describe("optional components", () => {
        describe("contains", () => {
          var group;

          beforeEach(() => {
            group = new ControlGroup(
                {
                  "required": new Control("requiredValue"),
                  "optional": new Control("optionalValue")
                },
                {"optional": false});
          });

          // rename contains into has
          it("should return false when the component is not included",
             () => { expect(group.contains("optional")).toEqual(false); })

              it("should return false when there is no component with the given name",
                 () => { expect(group.contains("something else")).toEqual(false); });

          it("should return true when the component is included", () => {
            expect(group.contains("required")).toEqual(true);

            group.include("optional");

            expect(group.contains("optional")).toEqual(true);
          });
        });

        it("should not include an inactive component into the group value", () => {
          var group = new ControlGroup(
              {"required": new Control("requiredValue"), "optional": new Control("optionalValue")},
              {"optional": false});

          expect(group.value).toEqual({"required": "requiredValue"});

          group.include("optional");

          expect(group.value).toEqual({"required": "requiredValue", "optional": "optionalValue"});
        });

        it("should not run Validators on an inactive component", () => {
          var group = new ControlGroup(
              {
                "required": new Control("requiredValue", Validators.required),
                "optional": new Control("", Validators.required)
              },
              {"optional": false});

          expect(group.valid).toEqual(true);

          group.include("optional");

          expect(group.valid).toEqual(false);
        });

        describe("valueChanges", () => {
          var g, c1, c2;

          beforeEach(() => {
            c1 = new Control("old1");
            c2 = new Control("old2");
            g = new ControlGroup({"one": c1, "two": c2}, {"two": true});
          });

          it("should fire an event after the value has been updated",
             inject([AsyncTestCompleter], (async) => {
               ObservableWrapper.subscribe(g.valueChanges, (value) => {
                 expect(g.value).toEqual({'one': 'new1', 'two': 'old2'});
                 expect(value).toEqual({'one': 'new1', 'two': 'old2'});
                 async.done();
               });
               c1.updateValue("new1");
             }));

          it("should fire an event after the control's observable fired an event",
             inject([AsyncTestCompleter], (async) => {
               var controlCallbackIsCalled = false;

               ObservableWrapper.subscribe(c1.valueChanges,
                                           (value) => { controlCallbackIsCalled = true; });

               ObservableWrapper.subscribe(g.valueChanges, (value) => {
                 expect(controlCallbackIsCalled).toBe(true);
                 async.done();
               });

               c1.updateValue("new1");
             }));

          it("should fire an event when a control is excluded",
             inject([AsyncTestCompleter], (async) => {
               ObservableWrapper.subscribe(g.valueChanges, (value) => {
                 expect(value).toEqual({'one': 'old1'});
                 async.done();
               });

               g.exclude("two");
             }));

//.........这里部分代码省略.........

export function main() {
  describe('router injectables', () => {
    var fakeDoc, el, testBindings;
    beforeEach(() => {
      fakeDoc = DOM.createHtmlDocument();
      el = DOM.createElement('app-cmp', fakeDoc);
      DOM.appendChild(fakeDoc.body, el);
      testBindings = [
        routerInjectables,
        bind(BrowserLocation)
            .toFactory(() => {
              var browserLocation = new DummyBrowserLocation();
              browserLocation.spy('pushState');
              return browserLocation;
            }),
        bind(DOCUMENT_TOKEN).toValue(fakeDoc)
      ];
    });

    it('should bootstrap a simple app', inject([AsyncTestCompleter], (async) => {
         bootstrap(AppCmp, testBindings)
             .then((applicationRef) => {
               var router = applicationRef.hostComponent.router;
               router.subscribe((_) => {
                 expect(el).toHaveText('outer { hello }');
                 expect(applicationRef.hostComponent.location.path()).toEqual('/');
                 async.done();
               });
             });
       }));

    it('should rethrow exceptions from component constructors',
       inject([AsyncTestCompleter], (async) => {
         bootstrap(BrokenAppCmp, testBindings)
             .then((applicationRef) => {
               var router = applicationRef.hostComponent.router;
               PromiseWrapper.catchError(router.navigate('/cause-error'), (error) => {
                 expect(el).toHaveText('outer { oh no }');
                 expect(error.message).toBe('oops!');
                 async.done();
               });
             });
       }));

    it('should bootstrap an app with a hierarchy', inject([AsyncTestCompleter], (async) => {
         bootstrap(HierarchyAppCmp, testBindings)
             .then((applicationRef) => {
               var router = applicationRef.hostComponent.router;
               router.subscribe((_) => {
                 expect(el).toHaveText('root { parent { hello } }');
                 expect(applicationRef.hostComponent.location.path()).toEqual('/parent/child');
                 async.done();
               });
               router.navigate('/parent/child');
             });
       }));

    it('should bootstrap an app with a custom app base href',
       inject([AsyncTestCompleter], (async) => {
         bootstrap(HierarchyAppCmp, [testBindings, bind(appBaseHrefToken).toValue('/my/app')])
             .then((applicationRef) => {
               var router = applicationRef.hostComponent.router;
               router.subscribe((_) => {
                 expect(el).toHaveText('root { parent { hello } }');
                 expect(applicationRef.hostComponent.location.path())
                     .toEqual('/my/app/parent/child');
                 async.done();
               });
               router.navigate('/parent/child');
             });
       }));

    // TODO: add a test in which the child component has bindings
  });
}

export function main() {
  describe("Form Model", () => {
    describe("Control", () => {
      describe("validator", () => {
        it("should run validator with the initial value", () => {
          var c = new Control("value", Validators.required);
          expect(c.valid).toEqual(true);
        });

        it("should rerun the validator when the value changes", () => {
          var c = new Control("value", Validators.required);
          c.updateValue(null);
          expect(c.valid).toEqual(false);
        });

        it("should return errors", () => {
          var c = new Control(null, Validators.required);
          expect(c.errors).toEqual({"required": true});
        });
      });

      describe("dirty", () => {
        it("should be false after creating a control", () => {
          var c = new Control("value");
          expect(c.dirty).toEqual(false);
        });

        it("should be true after changing the value of the control", () => {
          var c = new Control("value");
          c.markAsDirty();
          expect(c.dirty).toEqual(true);
        });
      });

      describe("updateValue", () => {
        var g, c;
        beforeEach(() => {
          c = new Control("oldValue");
          g = new ControlGroup({"one": c});
        });

        it("should update the value of the control", () => {
          c.updateValue("newValue");
          expect(c.value).toEqual("newValue");
        });

        it("should invoke onChange if it is present", () => {
          var onChange;
          c.registerOnChange((v) => onChange = ["invoked", v]);

          c.updateValue("newValue");

          expect(onChange).toEqual(["invoked", "newValue"]);
        });

        it("should update the parent", () => {
          c.updateValue("newValue");
          expect(g.value).toEqual({"one": "newValue"});
        });

        it("should not update the parent when explicitly specified", () => {
          c.updateValue("newValue", {onlySelf: true});
          expect(g.value).toEqual({"one": "oldValue"});
        });

        it("should fire an event", fakeAsync(() => {
             ObservableWrapper.subscribe(c.valueChanges,
                                         (value) => { expect(value).toEqual("newValue"); });

             c.updateValue("newValue");
             tick();
           }));

        it("should not fire an event when explicitly specified", fakeAsync(() => {
             ObservableWrapper.subscribe(c.valueChanges, (value) => { throw "Should not happen"; });

             c.updateValue("newValue", {emitEvent: false});

             tick();
           }));
      });

      describe("valueChanges", () => {
        var c;

        beforeEach(() => { c = new Control("old"); });

        it("should fire an event after the value has been updated",
           inject([AsyncTestCompleter], (async) => {
             ObservableWrapper.subscribe(c.valueChanges, (value) => {
               expect(c.value).toEqual('new');
               expect(value).toEqual('new');
               async.done();
             });
             c.updateValue("new");
           }));

        it("should return a cold observable", inject([AsyncTestCompleter], (async) => {
             c.updateValue("will be ignored");
             ObservableWrapper.subscribe(c.valueChanges, (value) => {
//.........这里部分代码省略.........

 describe('LightDom', function() {
   var lightDomView;
   beforeEach(() => {
     lightDomView = new FakeView();
   });
   describe("contentTags", () => {
     it("should collect content tags from element injectors", () => {
       var tag = new FakeContentTag(el('<script></script>'));
       var shadowDomView = new FakeView([tag]);
       var lightDom = new LightDom(lightDomView, shadowDomView, el("<div></div>"));
       expect(lightDom.contentTags()).toEqual([tag]);
     });
     it("should collect content tags from ViewContainers", () => {
       var tag = new FakeContentTag(el('<script></script>'));
       var vc = new FakeViewContainer(null, null, [new FakeView([tag])]);
       var shadowDomView = new FakeView([vc]);
       var lightDom = new LightDom(lightDomView, shadowDomView, el("<div></div>"));
       expect(lightDom.contentTags()).toEqual([tag]);
     });
   });
   describe("expandedDomNodes", () => {
     it("should contain root nodes", () => {
       var lightDomEl = el("<div><a></a></div>");
       var lightDom = new LightDom(lightDomView, new FakeView(), lightDomEl);
       expect(toHtml(lightDom.expandedDomNodes())).toEqual(["<a></a>"]);
     });
     it("should include view container nodes", () => {
       var lightDomEl = el("<div><template></template></div>");
       var lightDom = new LightDom(new FakeView([new FakeViewContainer(DOM.firstChild(lightDomEl), [el('<a></a>')])]), null, lightDomEl);
       expect(toHtml(lightDom.expandedDomNodes())).toEqual(["<a></a>"]);
     });
     it("should include content nodes", () => {
       var lightDomEl = el("<div><content></content></div>");
       var lightDom = new LightDom(new FakeView([new FakeContentTag(DOM.firstChild(lightDomEl), '', [el('<a></a>')])]), null, lightDomEl);
       expect(toHtml(lightDom.expandedDomNodes())).toEqual(["<a></a>"]);
     });
     it("should work when the element injector array contains nulls", () => {
       var lightDomEl = el("<div><a></a></div>");
       var lightDomView = new FakeView();
       var lightDom = new LightDom(lightDomView, new FakeView(), lightDomEl);
       expect(toHtml(lightDom.expandedDomNodes())).toEqual(["<a></a>"]);
     });
   });
   describe("redistribute", () => {
     it("should redistribute nodes between content tags with select property set", () => {
       var contentA = new FakeContentTag(null, "a");
       var contentB = new FakeContentTag(null, "b");
       var lightDomEl = el("<div><a>1</a><b>2</b><a>3</a></div>");
       var lightDom = new LightDom(lightDomView, new FakeView([contentA, contentB]), lightDomEl);
       lightDom.redistribute();
       expect(toHtml(contentA.nodes())).toEqual(["<a>1</a>", "<a>3</a>"]);
       expect(toHtml(contentB.nodes())).toEqual(["<b>2</b>"]);
     });
     it("should support wildcard content tags", () => {
       var wildcard = new FakeContentTag(null, '');
       var contentB = new FakeContentTag(null, "b");
       var lightDomEl = el("<div><a>1</a><b>2</b><a>3</a></div>");
       var lightDom = new LightDom(lightDomView, new FakeView([wildcard, contentB]), lightDomEl);
       lightDom.redistribute();
       expect(toHtml(wildcard.nodes())).toEqual(["<a>1</a>", "<b>2</b>", "<a>3</a>"]);
       expect(toHtml(contentB.nodes())).toEqual([]);
     });
   });
 });

  describe("ObservablePipe", () => {
    var emitter;
    var pipe;
    var ref;
    var message = new Object();

    beforeEach(() => {
      emitter = new EventEmitter();
      ref = new SpyChangeDetectorRef();
      pipe = new ObservablePipe(ref);
    });

    describe("supports", () => {
      it("should support observables", () => { expect(pipe.supports(emitter)).toBe(true); });

      it("should not support other objects", () => {
        expect(pipe.supports("string")).toBe(false);
        expect(pipe.supports(null)).toBe(false);
      });
    });

    describe("transform", () => {
      it("should return null when subscribing to an observable",
         () => { expect(pipe.transform(emitter)).toBe(null); });

      it("should return the latest available value wrapped",
         inject([AsyncTestCompleter], (async) => {
           pipe.transform(emitter);

           ObservableWrapper.callNext(emitter, message);

           TimerWrapper.setTimeout(() => {
             expect(pipe.transform(emitter)).toEqual(new WrappedValue(message));
             async.done();
           }, 0)
         }));


      it("should return same value when nothing has changed since the last call",
         inject([AsyncTestCompleter], (async) => {
           pipe.transform(emitter);
           ObservableWrapper.callNext(emitter, message);

           TimerWrapper.setTimeout(() => {
             pipe.transform(emitter);
             expect(pipe.transform(emitter)).toBe(message);
             async.done();
           }, 0)
         }));

      it("should dispose of the existing subscription when subscribing to a new observable",
         inject([AsyncTestCompleter], (async) => {
           pipe.transform(emitter);

           var newEmitter = new EventEmitter();
           expect(pipe.transform(newEmitter)).toBe(null);

           // this should not affect the pipe
           ObservableWrapper.callNext(emitter, message);

           TimerWrapper.setTimeout(() => {
             expect(pipe.transform(newEmitter)).toBe(null);
             async.done();
           }, 0)
         }));

      it("should request a change detection check upon receiving a new value",
         inject([AsyncTestCompleter], (async) => {
           pipe.transform(emitter);
           ObservableWrapper.callNext(emitter, message);

           TimerWrapper.setTimeout(() => {
             expect(ref.spy('requestCheck')).toHaveBeenCalled();
             async.done();
           }, 0)
         }));
    });

    describe("onDestroy", () => {
      it("should do nothing when no subscription",
         () => { expect(() => pipe.onDestroy()).not.toThrow(); });

      it("should dispose of the existing subscription", inject([AsyncTestCompleter], (async) => {
           pipe.transform(emitter);
           pipe.onDestroy();

           ObservableWrapper.callNext(emitter, message);

           TimerWrapper.setTimeout(() => {
             expect(pipe.transform(emitter)).toBe(null);
             async.done();
           }, 0)
         }));
    });
  });

  describe('ProtoViewBuilder', () => {
    var builder;
    var templateCloner;
    beforeEach(() => {
      templateCloner = new TemplateCloner(-1);
      builder =
          new ProtoViewBuilder(DOM.createTemplate(''), ViewType.EMBEDDED, ViewEncapsulation.NONE);
    });

    if (!IS_DART) {
      describe('verification of properties', () => {

        it('should throw for unknown properties', () => {
          builder.bindElement(el('<div/>')).bindProperty('unknownProperty', emptyExpr());
          expect(() => builder.build(new DomElementSchemaRegistry(), templateCloner))
              .toThrowError(
                  `Can't bind to 'unknownProperty' since it isn't a known property of the '<div>' element and there are no matching directives with a corresponding property`);
        });

        it('should allow unknown properties if a directive uses it', () => {
          var binder = builder.bindElement(el('<div/>'));
          binder.bindDirective(0).bindProperty('someDirProperty', emptyExpr(), 'directiveProperty');
          binder.bindProperty('directiveProperty', emptyExpr());
          expect(() => builder.build(new DomElementSchemaRegistry(), templateCloner)).not.toThrow();
        });

        it('should throw for unknown host properties even if another directive uses it', () => {
          var binder = builder.bindElement(el('<div/>'));
          binder.bindDirective(0).bindProperty('someDirProperty', emptyExpr(), 'someDirProperty');
          binder.bindDirective(1).bindHostProperty('someDirProperty', emptyExpr());
          expect(() => builder.build(new DomElementSchemaRegistry()))
              .toThrowError(
                  `Can't bind to 'someDirProperty' since it isn't a known property of the '<div>' element`);
        });

        it('should allow unknown properties on custom elements', () => {
          var binder = builder.bindElement(el('<some-custom/>'));
          binder.bindProperty('unknownProperty', emptyExpr());
          expect(() => builder.build(new DomElementSchemaRegistry(), templateCloner)).not.toThrow();
        });

        it('should throw for unknown properties on custom elements if there is an ng component', () => {
          var binder = builder.bindElement(el('<some-custom/>'));
          binder.bindProperty('unknownProperty', emptyExpr());
          binder.setComponentId('someComponent');
          expect(() => builder.build(new DomElementSchemaRegistry(), templateCloner))
              .toThrowError(
                  `Can't bind to 'unknownProperty' since it isn't a known property of the '<some-custom>' element and there are no matching directives with a corresponding property`);
        });

      });
    } else {
      describe('verification of properties', () => {

        // TODO(tbosch): This is just a temporary test that makes sure that the dart server and
        // dart browser is in sync. Change this to "not contains notifyBinding"
        // when https://github.com/angular/angular/issues/3019 is solved.
        it('should not throw for unknown properties', () => {
          builder.bindElement(el('<div/>')).bindProperty('unknownProperty', emptyExpr());
          expect(() => builder.build(new DomElementSchemaRegistry(), templateCloner)).not.toThrow();
        });

      });
    }

    describe('property normalization', () => {
      it('should normalize "innerHtml" to "innerHTML"', () => {
        builder.bindElement(el('<div/>')).bindProperty('innerHtml', emptyExpr());
        var pv = builder.build(new DomElementSchemaRegistry(), templateCloner);
        expect(pv.elementBinders[0].propertyBindings[0].property).toEqual('innerHTML');
      });

      it('should normalize "tabindex" to "tabIndex"', () => {
        builder.bindElement(el('<div/>')).bindProperty('tabindex', emptyExpr());
        var pv = builder.build(new DomElementSchemaRegistry(), templateCloner);
        expect(pv.elementBinders[0].propertyBindings[0].property).toEqual('tabIndex');
      });

      it('should normalize "readonly" to "readOnly"', () => {
        builder.bindElement(el('<input/>')).bindProperty('readonly', emptyExpr());
        var pv = builder.build(new DomElementSchemaRegistry(), templateCloner);
        expect(pv.elementBinders[0].propertyBindings[0].property).toEqual('readOnly');
      });

      it('should normalize "class" to "className"', () => {
        builder.bindElement(el('<div></div>')).bindProperty('class', emptyExpr());
        var pv = builder.build(new DomElementSchemaRegistry(), templateCloner);
        expect(pv.elementBinders[0].propertyBindings[0].property).toEqual('className');
      });
    });

    describe('property binding', () => {
      describe('types', () => {
        it('should detect property names', () => {
          builder.bindElement(el('<div/>')).bindProperty('tabindex', emptyExpr());
          var pv = builder.build(new DomElementSchemaRegistry(), templateCloner);
          expect(pv.elementBinders[0].propertyBindings[0].type)
              .toEqual(PropertyBindingType.PROPERTY);
        });

//.........这里部分代码省略.........

export function main() {
  describe('PropertyBindingParser', () => {
    function createPipeline(ignoreBindings = false, hasNestedProtoView = false) {
      return new CompilePipeline([new MockStep((parent, current, control) => {
        current.ignoreBindings = ignoreBindings;
        if (hasNestedProtoView) {
          current.bindElement().bindNestedProtoView(el('<template></template>'));
        }
      }), new PropertyBindingParser(new Parser(new Lexer()))]);
    }
    function process(element, ignoreBindings = false, hasNestedProtoView = false) {
      return ListWrapper.map(createPipeline(ignoreBindings, hasNestedProtoView).process(element), (compileElement) => compileElement.inheritedElementBinder);
    }
    it('should not parse bindings when ignoreBindings is true', () => {
      var results = process(el('<div [a]="b"></div>'), true);
      expect(results[0]).toEqual(null);
    });
    it('should detect [] syntax', () => {
      var results = process(el('<div [a]="b"></div>'));
      expect(MapWrapper.get(results[0].propertyBindings, 'a').source).toEqual('b');
    });
    it('should detect [] syntax only if an attribute name starts and ends with []', () => {
      expect(process(el('<div z[a]="b"></div>'))[0]).toBe(null);
      expect(process(el('<div [a]v="b"></div>'))[0]).toBe(null);
    });
    it('should detect bind- syntax', () => {
      var results = process(el('<div bind-a="b"></div>'));
      expect(MapWrapper.get(results[0].propertyBindings, 'a').source).toEqual('b');
    });
    it('should detect bind- syntax only if an attribute name starts with bind', () => {
      expect(process(el('<div _bind-a="b"></div>'))[0]).toEqual(null);
    });
    it('should detect interpolation syntax', () => {
      var results = process(el('<div a="{{b}}"></div>'));
      expect(MapWrapper.get(results[0].propertyBindings, 'a').source).toEqual('{{b}}');
    });
    it('should detect var- syntax', () => {
      var results = process(el('<template var-a="b"></template>'));
      expect(MapWrapper.get(results[0].variableBindings, 'b')).toEqual('a');
    });
    it('should store variable binding for a template element on the nestedProtoView', () => {
      var results = process(el('<template var-george="washington"></p>'), false, true);
      expect(results[0].variableBindings).toEqual(EMPTY_MAP);
      expect(MapWrapper.get(results[0].nestedProtoView.variableBindings, 'washington')).toEqual('george');
    });
    it('should store variable binding for a non-template element using shorthand syntax on the nestedProtoView', () => {
      var results = process(el('<template #george="washington"></template>'), false, true);
      expect(results[0].variableBindings).toEqual(EMPTY_MAP);
      expect(MapWrapper.get(results[0].nestedProtoView.variableBindings, 'washington')).toEqual('george');
    });
    it('should store variable binding for a non-template element', () => {
      var results = process(el('<p var-george="washington"></p>'));
      expect(MapWrapper.get(results[0].variableBindings, 'washington')).toEqual('george');
    });
    it('should store variable binding for a non-template element using shorthand syntax', () => {
      var results = process(el('<p #george="washington"></p>'));
      expect(MapWrapper.get(results[0].variableBindings, 'washington')).toEqual('george');
    });
    it('should store a variable binding with an implicit value', () => {
      var results = process(el('<p var-george></p>'));
      expect(MapWrapper.get(results[0].variableBindings, '\$implicit')).toEqual('george');
    });
    it('should store a variable binding with an implicit value using shorthand syntax', () => {
      var results = process(el('<p #george></p>'));
      expect(MapWrapper.get(results[0].variableBindings, '\$implicit')).toEqual('george');
    });
    it('should detect variable bindings only if an attribute name starts with #', () => {
      var results = process(el('<p b#george></p>'));
      expect(results[0]).toEqual(null);
    });
    it('should detect () syntax', () => {
      var results = process(el('<div (click)="b()"></div>'));
      expect(MapWrapper.get(results[0].eventBindings, 'click').source).toEqual('b()');
      results = process(el('<div (click[])="b()"></div>'));
      expect(MapWrapper.get(results[0].eventBindings, 'click[]').source).toEqual('b()');
    });
    it('should detect () syntax only if an attribute name starts and ends with ()', () => {
      expect(process(el('<div z(a)="b()"></div>'))[0]).toEqual(null);
      expect(process(el('<div (a)v="b()"></div>'))[0]).toEqual(null);
    });
    it('should parse event handlers using () syntax as actions', () => {
      var results = process(el('<div (click)="foo=bar"></div>'));
      expect(MapWrapper.get(results[0].eventBindings, 'click').source).toEqual('foo=bar');
    });
    it('should detect on- syntax', () => {
      var results = process(el('<div on-click="b()"></div>'));
      expect(MapWrapper.get(results[0].eventBindings, 'click').source).toEqual('b()');
    });
    it('should parse event handlers using on- syntax as actions', () => {
      var results = process(el('<div on-click="foo=bar"></div>'));
      expect(MapWrapper.get(results[0].eventBindings, 'click').source).toEqual('foo=bar');
    });
    it('should store bound properties as temporal attributes', () => {
      var results = createPipeline().process(el('<div bind-a="b" [c]="d"></div>'));
      expect(MapWrapper.get(results[0].attrs(), 'a')).toEqual('b');
      expect(MapWrapper.get(results[0].attrs(), 'c')).toEqual('d');
    });
    it('should store variables as temporal attributes', () => {
      var results = createPipeline().process(el('<div var-a="b" #c="d"></div>'));
      expect(MapWrapper.get(results[0].attrs(), 'a')).toEqual('b');
//.........这里部分代码省略.........

 describe("parseAction", () => {
   describe("basic expressions", () => {
     it('should parse numerical expressions', () => {
       expectEval("1").toEqual(1);
     });
     it('should parse strings', () => {
       expectEval("'1'").toEqual('1');
       expectEval('"1"').toEqual('1');
     });
     it('should parse null', () => {
       expectEval("null").toBe(null);
     });
     it('should parse unary - expressions', () => {
       expectEval("-1").toEqual(-1);
       expectEval("+1").toEqual(1);
     });
     it('should parse unary ! expressions', () => {
       expectEval("!true").toEqual(!true);
       expectEval("!!true").toEqual(!!true);
     });
     it('should parse multiplicative expressions', () => {
       expectEval("3*4/2%5").toEqual(3 * 4 / 2 % 5);
     });
     it('should parse additive expressions', () => {
       expectEval("3+6-2").toEqual(3 + 6 - 2);
     });
     it('should parse relational expressions', () => {
       expectEval("2<3").toEqual(2 < 3);
       expectEval("2>3").toEqual(2 > 3);
       expectEval("2<=2").toEqual(2 <= 2);
       expectEval("2>=2").toEqual(2 >= 2);
     });
     it('should parse equality expressions', () => {
       expectEval("2==3").toEqual(2 == 3);
       expectEval("2!=3").toEqual(2 != 3);
     });
     it('should parse logicalAND expressions', () => {
       expectEval("true&&true").toEqual(true && true);
       expectEval("true&&false").toEqual(true && false);
     });
     it('should parse logicalOR expressions', () => {
       expectEval("false||true").toEqual(false || true);
       expectEval("false||false").toEqual(false || false);
     });
     it('should short-circuit AND operator', () => {
       expectEval('false && a()', td(() => {
         throw "BOOM";
       })).toBe(false);
     });
     it('should short-circuit OR operator', () => {
       expectEval('true || a()', td(() => {
         throw "BOOM";
       })).toBe(true);
     });
     it('should evaluate grouped expressions', () => {
       expectEval("(1+2)*3").toEqual((1 + 2) * 3);
     });
     it('should parse an empty string', () => {
       expectEval('').toBeNull();
     });
   });
   describe("literals", () => {
     it('should evaluate array', () => {
       expectEval("[1][0]").toEqual(1);
       expectEval("[[1]][0][0]").toEqual(1);
       expectEval("[]").toEqual([]);
       expectEval("[].length").toEqual(0);
       expectEval("[1, 2].length").toEqual(2);
     });
     it('should evaluate map', () => {
       expectEval("{}").toEqual({});
       expectEval("{a:'b'}['a']").toEqual('b');
       expectEval("{'a':'b'}['a']").toEqual('b');
       expectEval("{\"a\":'b'}['a']").toEqual('b');
       expectEval("{\"a\":'b'}['a']").toEqual("b");
       expectEval("{}['a']").not.toBeDefined();
       expectEval("{\"a\":'b'}['invalid']").not.toBeDefined();
     });
     it('should only allow identifier, string, or keyword as map key', () => {
       expectEvalError('{(:0}').toThrowError(new RegExp('expected identifier, keyword, or string'));
       expectEvalError('{1234:0}').toThrowError(new RegExp('expected identifier, keyword, or string'));
     });
   });
   describe("member access", () => {
     it("should parse field access", () => {
       expectEval("a", td(999)).toEqual(999);
       expectEval("a.a", td(td(999))).toEqual(999);
     });
     it('should throw when accessing a field on null', () => {
       expectEvalError("a.a.a").toThrowError();
     });
     it('should only allow identifier or keyword as member names', () => {
       expectEvalError('x.(').toThrowError(new RegExp('identifier or keyword'));
       expectEvalError('x. 1234').toThrowError(new RegExp('identifier or keyword'));
       expectEvalError('x."foo"').toThrowError(new RegExp('identifier or keyword'));
     });
     it("should read a field from Locals", () => {
       var locals = new Locals(null, MapWrapper.createFromPairs([["key", "value"]]));
       expectEval("key", null, locals).toEqual("value");
     });
//.........这里部分代码省略.........

  describe('switch', () => {
    describe('switch value changes', () => {
      it('should switch amongst when values', inject([TestBed, AsyncTestCompleter], (tb, async) => {
           var template = '<div>' +
                          '<ul [ng-switch]="switchValue">' +
                          '<template [ng-switch-when]="\'a\'"><li>when a</li></template>' +
                          '<template [ng-switch-when]="\'b\'"><li>when b</li></template>' +
                          '</ul></div>';

           tb.createView(TestComponent, {html: template})
               .then((view) => {
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('');

                 view.context.switchValue = 'a';
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('when a');

                 view.context.switchValue = 'b';
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('when b');

                 async.done();
               });
         }));

      it('should switch amongst when values with fallback to default',
         inject([TestBed, AsyncTestCompleter], (tb, async) => {
           var template = '<div>' +
                          '<ul [ng-switch]="switchValue">' +
                          '<li template="ng-switch-when \'a\'">when a</li>' +
                          '<li template="ng-switch-default">when default</li>' +
                          '</ul></div>';

           tb.createView(TestComponent, {html: template})
               .then((view) => {
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('when default');

                 view.context.switchValue = 'a';
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('when a');

                 view.context.switchValue = 'b';
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('when default');

                 async.done();
               });
         }));

      it('should support multiple whens with the same value',
         inject([TestBed, AsyncTestCompleter], (tb, async) => {
           var template = '<div>' +
                          '<ul [ng-switch]="switchValue">' +
                          '<template [ng-switch-when]="\'a\'"><li>when a1;</li></template>' +
                          '<template [ng-switch-when]="\'b\'"><li>when b1;</li></template>' +
                          '<template [ng-switch-when]="\'a\'"><li>when a2;</li></template>' +
                          '<template [ng-switch-when]="\'b\'"><li>when b2;</li></template>' +
                          '<template [ng-switch-default]><li>when default1;</li></template>' +
                          '<template [ng-switch-default]><li>when default2;</li></template>' +
                          '</ul></div>';

           tb.createView(TestComponent, {html: template})
               .then((view) => {
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('when default1;when default2;');

                 view.context.switchValue = 'a';
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('when a1;when a2;');

                 view.context.switchValue = 'b';
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('when b1;when b2;');

                 async.done();
               });
         }));
    });

    describe('when values changes', () => {
      it('should switch amongst when values', inject([TestBed, AsyncTestCompleter], (tb, async) => {
           var template = '<div>' +
                          '<ul [ng-switch]="switchValue">' +
                          '<template [ng-switch-when]="when1"><li>when 1;</li></template>' +
                          '<template [ng-switch-when]="when2"><li>when 2;</li></template>' +
                          '<template [ng-switch-default]><li>when default;</li></template>' +
                          '</ul></div>';

           tb.createView(TestComponent, {html: template})
               .then((view) => {
                 view.context.when1 = 'a';
                 view.context.when2 = 'b';
                 view.context.switchValue = 'a';
                 view.detectChanges();
                 expect(DOM.getText(view.rootNodes[0])).toEqual('when 1;');

                 view.context.switchValue = 'b';
                 view.detectChanges();
//.........这里部分代码省略.........