Update all Angular libs (run update_all.sh).

third_party/pkg/angular/test/directive/ng_model_select_spec.dart

 library input_select_spec;
 
 import '../_specs.dart';
 
 //TODO(misko): re-enabled disabled tests once we have forms.
 
 main() {
   describe('input-select', () {
 
     describe('ng-value', () {
       TestBed _;
-      beforeEach(inject((TestBed tb) => _ = tb));
+      beforeEach((TestBed tb) => _ = tb);
 
       it('should retrieve using ng-value', () {
         _.compile(
             '<select ng-model="robot" probe="p">'
               '<option ng-repeat="r in robots" ng-value="r">{{r.name}}</option>'
             '</select>');
         var r2d2 = {"name":"r2d2"};
         var c3p0 = {"name":"c3p0"};
         _.rootScope.context['robots'] = [ r2d2, c3p0 ];
         _.rootScope.apply();
@@ skipping 17 matching lines @@
         _.rootScope.apply();
         _.selectOption(_.rootElement, 'c3p0');
         expect(_.rootScope.context['robot']).toEqual([c3p0]);
 
         _.rootScope.context['robot'] = [r2d2];
         _.rootScope.apply();
         expect(_.rootScope.context['robot']).toEqual([r2d2]);
         expect(_.rootElement).toEqualSelect([['r2d2'], 'c3p0']);
       });
     });
-    
+
     TestBed _;
 
-    beforeEach(inject((TestBed tb) => _ = tb));
+    beforeEach((TestBed tb) => _ = tb);
 
     describe('select-one', () {
       it('should compile children of a select without a ngModel, but not create a model for it',
           () {
         _.compile(
             '<select>'
               '<option selected="true">{{a}}</option>'
               '<option value="">{{b}}</option>'
               '<option>C</option>'
             '</select>');
@@ skipping 21 matching lines @@
       it('should work with repeated value options', () {
         _.compile(
             '<select ng-model="robot" probe="p">'
               '<option ng-repeat="r in robots">{{r}}</option>'
             '</select>');
 
         _.rootScope.context['robots'] = ['c3p0', 'r2d2'];
         _.rootScope.context['robot'] = 'r2d2';
         _.rootScope.apply();
 
-        var select = _.rootScope.context['p'].directive(InputSelectDirective);
+        var select = _.rootScope.context['p'].directive(InputSelect);
         expect(_.rootElement).toEqualSelect(['c3p0', ['r2d2']]);
 
         _.rootElement.querySelectorAll('option')[0].selected = true;
         _.triggerEvent(_.rootElement, 'change');
 
 
         expect(_.rootElement).toEqualSelect([['c3p0'], 'r2d2']);
         expect(_.rootScope.context['robot']).toEqual('c3p0');
 
         _.rootScope.apply(() {
@@ skipping 39 matching lines @@
         it('should set the model to empty string when empty option is selected', () {
           _.rootScope.context['robot'] = 'x';
           _.compile(
               '<select ng-model="robot" probe="p">' +
                 '<option value="">--select--</option>' +
                 '<option value="x">robot x</option>' +
                 '<option value="y">robot y</option>' +
               '</select>');
           _.rootScope.apply();
 
-          var select = _.rootScope.context['p'].directive(InputSelectDirective);
+          var select = _.rootScope.context['p'].directive(InputSelect);
 
           expect(_.rootElement).toEqualSelect(['', ['x'], 'y']);
 
           _.selectOption(_.rootElement, '--select--');
 
           expect(_.rootElement).toEqualSelect([[''], 'x', 'y']);
           expect(_.rootScope.context['robot']).toEqual(null);
         });
 
         describe('interactions with repeated options', () {
           it('should select empty option when model is undefined', () {
             _.rootScope.context['robots'] = ['c3p0', 'r2d2'];
             _.compile(
                 '<select ng-model="robot">' +
                   '<option value="">--select--</option>' +
                   '<option ng-repeat="r in robots">{{r}}</option>' +
                 '</select>');
             _.rootScope.apply();
             expect(_.rootElement).toEqualSelect([[''], 'c3p0', 'r2d2']);
           });
 
           it('should set model to empty string when selected', () {
             _.rootScope.context['robots'] = ['c3p0', 'r2d2'];
             _.compile(
                 '<select ng-model="robot" probe="p">' +
                   '<option value="">--select--</option>' +
                   '<option ng-repeat="r in robots">{{r}}</option>' +
                 '</select>');
             _.rootScope.apply();
-            var select = _.rootScope.context['p'].directive(InputSelectDirective);
+            var select = _.rootScope.context['p'].directive(InputSelect);
 
             _.selectOption(_.rootElement, 'c3p0');
             expect(_.rootElement).toEqualSelect(['', ['c3p0'], 'r2d2']);
             expect( _.rootScope.context['robot']).toEqual('c3p0');
 
             _.selectOption(_.rootElement, '--select--');
 
             expect(_.rootElement).toEqualSelect([[''], 'c3p0', 'r2d2']);
             expect( _.rootScope.context['robot']).toEqual(null);
           });
@@ skipping 223 matching lines @@
         expect(_.rootElement).toEqualSelect([]);
         _.rootScope.context['attached'] = true;
         _.rootScope.apply();
         expect(_.rootElement).toEqualSelect(['a', ['b']]);
       });
     });
 
 
     describe('select from angular.js', () {
       TestBed _;
-      beforeEach(inject((TestBed tb) => _ = tb));
+      beforeEach((TestBed tb) => _ = tb);
 
       var scope, formElement, element;
 
       compile(html) {
         _.compile('<form name="form">' + html + '</form>');
         element = _.rootElement.querySelector('select');
         scope.apply();
       }
 
-      beforeEach(inject((Scope rootScope) {
+      beforeEach((Scope rootScope) {
         scope = rootScope;
         formElement = element = null;
-      }));
+      });
 
 
       afterEach(() {
         scope.destroy(); //disables unknown option work during destruction
       });
 
 
       describe('select-one', () {
 
         it('should compile children of a select without a ngModel, but not create a model for it',
@@ skipping 37 matching lines @@
           scope.apply(() {
             scope.context['selection'] = 'c';
           });
 
           element.value = 'c';
           _.triggerEvent(element, 'change');
           expect(log).toEqual('change:c;');
         });
 
 
-        xit('should require', () {
+        it('should require', () {
           compile(
-            '<select name="select" ng-model="selection" required ng-change="change()">' +
+            '<select name="select" ng-model="selection" probe="i" required ng-change="change()">' +
               '<option value=""></option>' +
               '<option value="c">C</option>' +
             '</select>');
 
+          var element = scope.context['i'].element;
+
+          scope.context['log'] = '';
           scope.context['change'] = () {
-            scope.log += 'change;';
+            scope.context['log'] += 'change;';
           };
 
           scope.apply(() {
             scope.context['log'] = '';
             scope.context['selection'] = 'c';
           });
 
-          expect(scope.context['form'].select.$error.required).toEqual(false);;
-          expect(element).toEqualValid();
-          expect(element).toEqualPristine();
+          expect(scope.context['form']['select'].hasErrorState('ng-required')).toEqual(false);
+          expect(scope.context['form']['select'].valid).toEqual(true);
+          expect(scope.context['form']['select'].pristine).toEqual(true);
 
           scope.apply(() {
             scope.context['selection'] = '';
           });
 
-          expect(scope.context['form'].select.$error.required).toEqual(true);;
-          expect(element).toEqualInvalid();
-          expect(element).toEqualPristine();
+          expect(scope.context['form']['select'].hasErrorState('ng-required')).toEqual(true);
+          expect(scope.context['form']['select'].invalid).toEqual(true);
+          expect(scope.context['form']['select'].pristine).toEqual(true);
           expect(scope.context['log']).toEqual('');
 
-          element[0].value = 'c';
+          element.value = 'c';
           _.triggerEvent(element, 'change');
-          expect(element).toEqualValid();
-          expect(element).toEqualDirty();
+          scope.apply();
+
+          expect(scope.context['form']['select'].valid).toEqual(true);
+          expect(scope.context['form']['select'].dirty).toEqual(true);
           expect(scope.context['log']).toEqual('change;');
         });
 
 
-        xit('should not be invalid if no require', () {
+        it('should not be invalid if no require', () {
           compile(
             '<select name="select" ng-model="selection">' +
               '<option value=""></option>' +
               '<option value="c">C</option>' +
             '</select>');
 
-          expect(element).toEqualValid();
-          expect(element).toEqualPristine();
+          expect(scope.context['form']['select'].valid).toEqual(true);
+          expect(scope.context['form']['select'].pristine).toEqual(true);
         });
 
 
         describe('empty option', () {
 
           it('should select the empty option when model is undefined', () {
             compile('<select ng-model="robot">' +
                       '<option value="">--select--</option>' +
                       '<option value="x">robot x</option>' +
                       '<option value="y">robot y</option>' +
@@ skipping 53 matching lines @@
             scope.context['selection'] = ['A'];
           });
           expect(element).toEqualSelect([['A'], 'B']);
 
           scope.apply(() {
             scope.context['selection'].add('B');
           });
           expect(element).toEqualSelect([['A'], ['B']]);
         });
 
-        xit('should require', () {
+        it('should require', () {
           compile(
-            '<select name="select"  ng-model="selection" multiple required>' +
+            '<select name="select" probe="i" ng-model="selection" multiple required>' +
               '<option>A</option>' +
               '<option>B</option>' +
             '</select>');
 
+          var element = scope.context['i'].element;
           scope.apply(() {
             scope.context['selection'] = [];
           });
 
-          expect(scope.context['form'].select.$error.required).toEqual(true);;
-          expect(element).toEqualInvalid();
-          expect(element).toEqualPristine();
+          expect(scope.context['form']['select'].hasErrorState('ng-required')).toEqual(true);
+          expect(scope.context['form']['select'].invalid).toEqual(true);
+          expect(scope.context['form']['select'].pristine).toEqual(true);
 
           scope.apply(() {
             scope.context['selection'] = ['A'];
           });
 
-          expect(element).toEqualValid();
-          expect(element).toEqualPristine();
+          expect(scope.context['form']['select'].valid).toEqual(true);
+          expect(scope.context['form']['select'].pristine).toEqual(true);
 
-          element[0].value = 'B';
+          element.value = 'B';
           _.triggerEvent(element, 'change');
-          expect(element).toEqualValid();
-          expect(element).toEqualDirty();
+
+          expect(scope.context['form']['select'].valid).toEqual(true);
+          expect(scope.context['form']['select'].dirty).toEqual(true);
         });
       });
 
 
       describe('ngOptions', () {
         createSelect(attrs, [blank, unknown, ngRepeat, text, ngValue]) {
           var html = '<select';
           attrs.forEach((key, value) {
             if (value is bool) {
               if (value != null) html += ' $key';
@@ skipping 196 matching lines @@
             expect(element).toEqualSelect([['A'], 'B']);
 
             scope.apply(() {
               scope.context['selected'] = scope.context['values'][1];
             });
 
             expect(element).toEqualSelect(['A', ['B']]);
           });
 
 
-          // TODO(misko): re-enable once we support group by
-          xit('should bind to scope value and group', () {
-            createSelect({
-              'ng-model': 'selected',
-              'ng-options': 'item.name group by item.group for item in values'
+          it('should bind to scope value and group', () {
+            var element = _.compile(
+                '<select ng-model="selected" probe="p">'
+                  '<optgroup label=\'{{ group["title"] }}\' ng-repeat="group in values">'
+                    '<option value=\'{{ item["val"] }}\' '
+                            'ng-repeat=\'item in group["items"]\'>{{ item["name"] }}</option>'
+                  '</optgroup>'
+                '</select>');
+
+            scope.apply(() {
+              scope.context['values'] = [
+                { 'title': 'first',  'items':
+                  [{ 'val':'a', 'name' : 'A' }, { 'val':'c', 'name' : 'C' } ]},
+                { 'title': 'second', 'items':
+                  [{ 'val':'b', 'name' : 'B' }, { 'val':'d', 'name' : 'D' } ]}
+              ];
+              scope.context['selected'] = scope.context['values'][1]['items'][0]['val'];
             });
 
-            scope.apply(() {
-              scope.context['values'] = [{'name': 'A'},
-                              {'name': 'B', group: 'first'},
-                              {'name': 'C', group: 'second'},
-                              {'name': 'D', group: 'first'},
-                              {'name': 'E', group: 'second'}];
-              scope.context['selected'] = scope.context['values'][3];
-            });
-
-            expect(element).toEqualSelect(['A', 'B', ['D'], 'C', 'E']);
+            expect(element).toEqualSelect(['a', 'c', ['b'], 'd']);
 
             var first = element.querySelectorAll('optgroup')[0];
             var b = first.querySelectorAll('option')[0];
             var d = first.querySelectorAll('option')[1];
-            expect(first.attr('label')).toEqual('first');
-            expect(b.text).toEqual('B');
-            expect(d.text).toEqual('D');
+            expect(first.getAttribute('label')).toEqual('first');
+            expect(b.text).toEqual('A');
+            expect(d.text).toEqual('C');
 
             var second = element.querySelectorAll('optgroup')[1];
             var c = second.querySelectorAll('option')[0];
             var e = second.querySelectorAll('option')[1];
-            expect(second.attr('label')).toEqual('second');
-            expect(c.text).toEqual('C');
-            expect(e.text).toEqual('E');
+            expect(second.getAttribute('label')).toEqual('second');
+            expect(c.text).toEqual('B');
+            expect(e.text).toEqual('D');
 
             scope.apply(() {
-              scope.context['selected'] = scope.context['values'][0];
+              scope.context['selected'] = scope.context['values'][0]['items'][1]['val'];
             });
 
-            expect(element.value).toEqual('0');
+            expect(element.value).toEqual('c');
           });
 
 
           it('should bind to scope value through experession', () {
             createSelect({'ng-model': 'selected'}, null, null, 'item in values', 'item.name', 'item.id');
 
             scope.apply(() {
               scope.context['values'] = [{'id': 10, 'name': 'A'}, {'id': 20, 'name': 'B'}];
               scope.context['selected'] = scope.context['values'][0]['id'];
             });
@@ skipping 312 matching lines @@
             }, true);
 
 
             scope.apply(() {
               scope.context['values'] = [{'name': 'A', 'id': 1}, {'name': 'B', 'id': 2}];
               scope.context['required'] = false;
             });
 
             element.value = '';
             _.triggerEvent(element, 'change');
-            expect(element).toEqualValid();
+            expect(element).toBeValid();
 
             scope.apply(() {
               scope.context['required'] = true;
             });
-            expect(element).toEqualInvalid();
+            expect(element).not.toBeValid();
 
             scope.apply(() {
               scope.context['value'] = scope.context['values'][0];
             });
-            expect(element).toEqualValid();
+            expect(element).toBeValid();
 
             element.value = '';
             _.triggerEvent(element, 'change');
-            expect(element).toEqualInvalid();
+            expect(element).not.toBeValid();
 
             scope.apply(() {
               scope.context['required'] = false;
             });
-            expect(element).toEqualValid();
+            expect(element).toBeValid();
           });
         });
       });
 
 
       describe('option', () {
 
         it('should populate value attribute on OPTION', () {
           compile('<select ng-model="x"><option selected>abc</option></select>');
           expect(element).toEqualSelect([['?'], 'abc']);
         });
 
         it('should ignore value if already exists', () {
           compile('<select ng-model="x"><option value="abc">xyz</option></select>');
           expect(element).toEqualSelect([['?'], 'abc']);
         });
 
         it('should set value even if self closing HTML', () {
           scope.context['x'] = 'hello';
           compile('<select ng-model="x"><option>hello</select>');
           expect(element).toEqualSelect([['hello']]);
         });
 
         it('should not blow up when option directive is found inside of a datalist',
             () {
-          _.compile('<div>' +
-                      '<datalist><option>some val</option></datalist>' +
-                      '<span>{{foo}}</span>' +
+          _.compile('<div>'
+                      '<datalist><option>some val</option></datalist>'
+                      '<span>{{foo}}</span>'
                     '</div>');
 
           _.rootScope.context['foo'] = 'success';
           _.rootScope.apply();
           expect(_.rootElement.querySelector('span').text).toEqual('success');
         });
       });
     });
   });
 }