describe('Promise', () => {
      it('should run asynchronous code', fakeAsync(() => {
           var thenRan = false;
           PromiseWrapper.resolve(null).then((_) => { thenRan = true; });

           expect(thenRan).toEqual(false);

           flushMicrotasks();
           expect(thenRan).toEqual(true);
         }));

      it('should run chained thens', fakeAsync(() => {
           var log = new Log();

           PromiseWrapper.resolve(null).then((_) => log.add(1)).then((_) => log.add(2));

           expect(log.result()).toEqual('');

           flushMicrotasks();
           expect(log.result()).toEqual('1; 2');
         }));

      it('should run Promise created in Promise', fakeAsync(() => {
           var log = new Log();

           PromiseWrapper.resolve(null).then((_) => {
             log.add(1);
             PromiseWrapper.resolve(null).then((_) => log.add(2));
           });

           expect(log.result()).toEqual('');

           flushMicrotasks();
           expect(log.result()).toEqual('1; 2');
         }));

      // TODO(vicb): check why this doesn't work in JS - linked to open issues on GH ?
      xit('should complain if the test throws an exception during async calls', () => {
        expect(() => {
          fakeAsync(() => {
            PromiseWrapper.resolve(null).then((_) => { throw new BaseException('async'); });
            flushMicrotasks();
          })();
        }).toThrowError('async');
      });

      it('should complain if a test throws an exception', () => {
        expect(() => {
          fakeAsync(() => { throw new BaseException('sync'); })();
        }).toThrowError('sync');
      });

    });

  describe('run', () => {
    it('should return the body return value from run',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         macroTask(() => { expect(_zone.run(() => { return 6; })).toEqual(6); });

         macroTask(() => { async.done(); });
       }), testTimeout);

    it('should call onUnstable and onMicrotaskEmpty',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         runNgZoneNoLog(() => macroTask(_log.fn('run')));
         macroTask(() => {
           expect(_log.result()).toEqual('onUnstable; run; onMicrotaskEmpty; onStable');
           async.done();
         });
       }), testTimeout);

    it('should call onStable once at the end of event',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         // The test is set up in a way that causes the zone loop to run onMicrotaskEmpty twice
         // then verified that onStable is only called once at the end

         runNgZoneNoLog(() => macroTask(_log.fn('run')));

         var times = 0;
         ObservableWrapper.subscribe(_zone.onMicrotaskEmpty, (_) => {
           times++;
           _log.add(`onMicrotaskEmpty ${times}`);
           if (times < 2) {
             // Scheduling a microtask causes a second digest
             runNgZoneNoLog(() => { scheduleMicroTask(() => {}); });
           }
         });

         macroTask(() => {
           expect(_log.result())
               .toEqual(
                   'onUnstable; run; onMicrotaskEmpty; onMicrotaskEmpty 1; ' +
                   'onMicrotaskEmpty; onMicrotaskEmpty 2; onStable');
           async.done();
         }, resultTimer);
       }), testTimeout);

    it('should call standalone onStable',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         runNgZoneNoLog(() => macroTask(_log.fn('run')));

         macroTask(() => {
           expect(_log.result()).toEqual('onUnstable; run; onMicrotaskEmpty; onStable');
           async.done();
         }, resultTimer);
       }), testTimeout);

    xit('should run subscriber listeners in the subscription zone (outside)',
        inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
          // Each subscriber fires a microtask outside the Angular zone. The test
          // then verifies that those microtasks do not cause additional digests.

          var turnStart = false;
          ObservableWrapper.subscribe(_zone.onUnstable, (_) => {
            if (turnStart) throw 'Should not call this more than once';
            _log.add('onUnstable');
            scheduleMicroTask(() => {});
            turnStart = true;
          });

          var turnDone = false;
          ObservableWrapper.subscribe(_zone.onMicrotaskEmpty, (_) => {
            if (turnDone) throw 'Should not call this more than once';
            _log.add('onMicrotaskEmpty');
            scheduleMicroTask(() => {});
            turnDone = true;
          });

          var eventDone = false;
          ObservableWrapper.subscribe(_zone.onStable, (_) => {
            if (eventDone) throw 'Should not call this more than once';
            _log.add('onStable');
            scheduleMicroTask(() => {});
            eventDone = true;
          });

          macroTask(() => { _zone.run(_log.fn('run')); });

          macroTask(() => {
            expect(_log.result()).toEqual('onUnstable; run; onMicrotaskEmpty; onStable');
            async.done();
          }, resultTimer);
        }), testTimeout);

    it('should run subscriber listeners in the subscription zone (inside)',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         runNgZoneNoLog(() => macroTask(_log.fn('run')));

         // the only practical use-case to run a callback inside the zone is
         // change detection after "onMicrotaskEmpty". That's the only case tested.
         var turnDone = false;
         ObservableWrapper.subscribe(_zone.onMicrotaskEmpty, (_) => {
           _log.add('onMyMicrotaskEmpty');
           if (turnDone) return;
//.........这里部分代码省略.........

  describe('MockBackend', () => {

    var backend: MockBackend;
    var sampleRequest1: Request;
    var sampleResponse1: Response;
    var sampleRequest2: Request;
    var sampleResponse2: Response;

    beforeEach(() => {
      var injector = ReflectiveInjector.resolveAndCreate(
          [provide(ResponseOptions, {useClass: BaseResponseOptions}), MockBackend]);
      backend = injector.get(MockBackend);
      var base = new BaseRequestOptions();
      sampleRequest1 = new Request(base.merge(new RequestOptions({url: 'https://google.com'})));
      sampleResponse1 = new Response(new ResponseOptions({body: 'response1'}));
      sampleRequest2 = new Request(base.merge(new RequestOptions({url: 'https://google.com'})));
      sampleResponse2 = new Response(new ResponseOptions({body: 'response2'}));
    });

    it('should create a new MockBackend', () => {expect(backend).toBeAnInstanceOf(MockBackend)});

    it('should create a new MockConnection',
       () => {expect(backend.createConnection(sampleRequest1)).toBeAnInstanceOf(MockConnection)});

    it('should create a new connection and allow subscription', () => {
      let connection: MockConnection = backend.createConnection(sampleRequest1);
      connection.response.subscribe(() => {});
    });

    it('should allow responding after subscription',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         let connection: MockConnection = backend.createConnection(sampleRequest1);
         connection.response.subscribe(() => { async.done(); });
         connection.mockRespond(sampleResponse1);
       }));

    it('should allow subscribing after responding',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         let connection: MockConnection = backend.createConnection(sampleRequest1);
         connection.mockRespond(sampleResponse1);
         connection.response.subscribe(() => { async.done(); });
       }));

    it('should allow responding after subscription with an error',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         let connection: MockConnection = backend.createConnection(sampleRequest1);
         connection.response.subscribe(null, () => { async.done(); });
         connection.mockError(new Error('nope'));
       }));

    it('should not throw when there are no unresolved requests',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         let connection: MockConnection = backend.createConnection(sampleRequest1);
         connection.response.subscribe(() => { async.done(); });
         connection.mockRespond(sampleResponse1);
         backend.verifyNoPendingRequests();
       }));

    xit('should throw when there are unresolved requests',
        inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
          let connection: MockConnection = backend.createConnection(sampleRequest1);
          connection.response.subscribe(() => { async.done(); });
          backend.verifyNoPendingRequests();
        }));

    it('should work when requests are resolved out of order',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         let connection1: MockConnection = backend.createConnection(sampleRequest1);
         let connection2: MockConnection = backend.createConnection(sampleRequest1);
         connection1.response.subscribe(() => { async.done(); });
         connection2.response.subscribe(() => {});
         connection2.mockRespond(sampleResponse1);
         connection1.mockRespond(sampleResponse1);
         backend.verifyNoPendingRequests();
       }));

    xit('should allow double subscribing',
        inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
          let responses: Response[] = [sampleResponse1, sampleResponse2];
          backend.connections.subscribe((c: MockConnection) => c.mockRespond(responses.shift()));
          let responseObservable: ReplaySubject<Response> =
              backend.createConnection(sampleRequest1).response;
          responseObservable.subscribe(res => expect(res.text()).toBe('response1'));
          responseObservable.subscribe(res => expect(res.text()).toBe('response2'), null,
                                       async.done);
        }));

    // TODO(robwormald): readyStates are leaving?
    it('should allow resolution of requests manually', () => {
      let connection1: MockConnection = backend.createConnection(sampleRequest1);
      let connection2: MockConnection = backend.createConnection(sampleRequest1);
      connection1.response.subscribe(() => {});
      connection2.response.subscribe(() => {});
      backend.resolveAllConnections();
      backend.verifyNoPendingRequests();
    });
  });

describe('some component', () => {
  xit('has a test', () => { throw 'This test will not run.'; });
  it('has another test', () => {
                             // This test will run.
                         });
});

//.........这里部分代码省略.........
          '<div i18n><div attr="value">zero<div>one</div></div><div>two</div></div>', 'someurl');
      expect(res.messages).toEqual([new Message(
          '<ph name="e0">zero<ph name="e2">one</ph></ph><ph name="e4">two</ph>', null, null)]);
    });

    it('should handle html content with interpolation', () => {
      let res =
          extractor.extract('<div i18n><div>zero{{a}}<div>{{b}}</div></div></div>', 'someurl');
      expect(res.messages).toEqual([new Message(
          '<ph name="e0"><ph name="t1">zero<ph name="0"/></ph><ph name="e2"><ph name="t3"><ph name="0"/></ph></ph></ph>',
          null, null)]);
    });

    it('should extract from nested elements', () => {
      let res = extractor.extract(
          '<div title="message1" i18n-title="meaning1|desc1"><div i18n="meaning2|desc2">message2</div></div>',
          'someurl');
      expect(res.messages).toEqual([
        new Message('message2', 'meaning2', 'desc2'), new Message('message1', 'meaning1', 'desc1')
      ]);
    });

    it('should extract messages from attributes in i18n blocks', () => {
      let res = extractor.extract(
          '<div i18n><div attr="value" i18n-attr="meaning|desc">message</div></div>', 'someurl');
      expect(res.messages).toEqual([
        new Message('<ph name="e0">message</ph>', null, null),
        new Message('value', 'meaning', 'desc')
      ]);
    });

    // TODO(vicb) - this should be extracted to a single message
    // see https://github.com/angular/angular/issues/9067
    xit('should extract messages from expansion forms', () => {
      let res = extractor.extract(
          `
        <div>
          {messages.length, plural,
             =0 {You have <b>no</b> messages}
             =1 {You have one message}
             other {You have messages}
          }
        </div>`,
          'someurl');

      expect(res.messages).toEqual([
        new Message('You have <ph name="e1">no</ph> messages', 'plural_=0', null),
        new Message('You have one message', 'plural_=1', null),
        new Message('You have messages', 'plural_other', null),
      ]);
    });

    it('should remove duplicate messages', () => {
      let res = extractor.extract(
          `
         <!-- i18n: meaning|desc1 -->message<!-- /i18n -->
         <!-- i18n: meaning|desc2 -->message<!-- /i18n -->`,
          'someUrl');

      expect(removeDuplicates(res.messages)).toEqual([
        new Message('message', 'meaning', 'desc1'),
      ]);
    });

    describe('implicit translation', () => {
      it('should extract from elements', () => {