Update the Angular/DI tests to latest from github.

third_party/pkg/di/test/main.dart

Index: third_party/pkg/di/test/main.dart
diff --git a/third_party/pkg/di/test/main.dart b/third_party/pkg/di/test/main.dart
index 4233a35357e4e2be7587f06806e8e5f322b87bcc..0ebb3057ffe1077e4039dab28280342aa4474ffa 100644
--- a/third_party/pkg/di/test/main.dart
+++ b/third_party/pkg/di/test/main.dart
@@ -32,12 +32,12 @@ class Injectable {
 // just some classes for testing
 @Injectable()
 class Engine {
-  String id = 'v8-id';
+  final String id = 'v8-id';
 }
 
 @Injectable()
 class MockEngine implements Engine {
-  String id = 'mock-id';
+  final String id = 'mock-id';
 }
 
 @Injectable()
@@ -45,6 +45,10 @@ class MockEngine2 implements Engine {
   String id = 'mock-id-2';
 }
 
+class HiddenConstructor {
+  HiddenConstructor._();
+}
+
 @Injectable()
 class Car {
   Engine engine;
@@ -53,6 +57,13 @@ class Car {
   Car(this.engine, this.injector);
 }
 
+class Lemon {
+  final engine;
+  final Injector injector;
+
+  Lemon(this.engine, this.injector);
+}
+
 class NumDependency {
   NumDependency(num value) {}
 }
@@ -89,9 +100,7 @@ int compareIntAsc(int a, int b) => b.compareTo(a);
 class WithTypeDefDependency {
   CompareInt compare;
 
-  WithTypeDefDependency(CompareInt c) {
-    compare = c;
-  }
+  WithTypeDefDependency(this.compare);
 }
 
 class MultipleConstructors {
@@ -110,6 +119,23 @@ class ClassOne implements InterfaceOne {
 }
 
 @Injectable()
+class ParameterizedType<T1, T2> {
+  ParameterizedType();
+}
+
+@Injectable()
+class ParameterizedDependency {
+  final ParameterizedType<bool, int> _p;
+  ParameterizedDependency(this._p);
+}
+
+@Injectable()
+class GenericParameterizedDependency {
+  final ParameterizedType _p;
+  GenericParameterizedDependency(this._p);
+}
+
+@Injectable()
 class Log {
   var log = [];
 
@@ -124,12 +150,12 @@ void main() {
   createInjectorSpec('DynamicInjector',
       (modules, [name]) => new DynamicInjector(modules: modules, name: name));
 
-  // Initialize generated type factories.
-  type_factories_gen.main();
-
   createInjectorSpec('StaticInjector',
       (modules, [name]) => new StaticInjector(modules: modules, name: name,
           typeFactories: type_factories_gen.typeFactories));
+
+  dynamicInjectorTest();
+  staticInjectorTest();
 }
 
 typedef Injector InjectorFactory(List<Module> modules, [String name]);
@@ -164,6 +190,25 @@ createInjectorSpec(String injectorName, InjectorFactory injectorFactory) {
     });
 
 
+    it('should inject generic parameterized types', () {
+      var injector = injectorFactory([new Module()
+            ..type(ParameterizedType)
+            ..type(GenericParameterizedDependency)
+      ]);
+      expect(injector.get(GenericParameterizedDependency),
+          new isInstanceOf<GenericParameterizedDependency>());
+    });
+
+
+    xit('should error while resolving parameterized types', () {
+      var injector = injectorFactory([new Module()
+            ..type(ParameterizedType)
+            ..type(ParameterizedDependency)
+      ]);
+      expect(() => injector.get(ParameterizedDependency), throws);
+    });
+
+
     it('should allow modules and overriding providers', () {
       var module = new Module()..type(Engine, implementedBy: MockEngine);
 
@@ -293,8 +338,7 @@ createInjectorSpec(String injectorName, InjectorFactory injectorFactory) {
     });
 
 
-    // Typedef injection is not supported in dart2js: http://dartbug.com/11612
-    xit('should inject a typedef', () {
+    it('should inject a typedef', () {
       var module = new Module()..value(CompareInt, compareIntAsc);
 
       var injector = injectorFactory([module]);
@@ -305,14 +349,12 @@ createInjectorSpec(String injectorName, InjectorFactory injectorFactory) {
     });
 
 
-    // Typedef injection is not supported in dart2js: http://dartbug.com/11612
-    xit('should throw an exception when injecting typedef without providing it', () {
+    it('should throw an exception when injecting typedef without providing it', () {
       var injector = injectorFactory([new Module()..type(WithTypeDefDependency)]);
 
       expect(() {
         injector.get(WithTypeDefDependency);
-      }, toThrow(NoProviderError, 'No provider found for CompareInt! '
-      '(resolving WithTypeDefDependency -> CompareInt)'));
+      }, throws);
     });
 
 
@@ -517,3 +559,134 @@ createInjectorSpec(String injectorName, InjectorFactory injectorFactory) {
   });
 
 }
+
+void dynamicInjectorTest() {
+  describe('DynamicInjector', () {
+
+    it('should throw a comprehensible error message on untyped argument', () {
+      var module = new Module()..type(Lemon)..type(Engine);
+      var injector = new DynamicInjector(modules : [module]);
+
+      expect(() {
+        injector.get(Lemon);
+      }, toThrow(NoProviderError, "The 'engine' parameter must be typed "
+          "(resolving Lemon)"));
+    });
+
+    it('should throw a comprehensible error message when no default constructor found', () {
+      var module = new Module()..type(HiddenConstructor);
+      var injector = new DynamicInjector(modules: [module]);
+
+      expect(() {
+        injector.get(HiddenConstructor);
+      }, toThrow(NoProviderError, startsWith('Unable to find default '
+          'constructor for HiddenConstructor. Make sure class has a '
+          'default constructor.')));
+    });
+
+  });
+}
+
+void staticInjectorTest() {
+  describe('StaticInjector', () {
+
+    it('should use type factories passed in the constructor', () {
+      var module = new Module()
+          ..type(Engine);
+      var injector = new StaticInjector(modules: [module], typeFactories: {
+        Engine: (f) => new Engine()
+      });
+
+      var engine;
+      expect(() {
+        engine = injector.get(Engine);
+      }, isNot(throws));
+      expect(engine, new isInstanceOf<Engine>());
+    });
+
+    it('should use type factories passes in one module', () {
+      var module = new Module()
+          ..type(Engine)
+          ..typeFactories = {
+            Engine: (f) => new Engine()
+          };
+      var injector = new StaticInjector(modules: [module]);
+
+      var engine;
+      expect(() {
+        engine = injector.get(Engine);
+      }, isNot(throws));
+      expect(engine, new isInstanceOf<Engine>());
+    });
+
+    it('should use type factories passes in many modules', () {
+      var module1 = new Module()
+          ..type(Engine)
+          ..typeFactories = {
+            Engine: (f) => new Engine()
+          };
+      var module2 = new Module()
+          ..type(Car)
+          ..typeFactories = {
+            Car: (f) => new Car(f(Engine), f(Injector))
+          };
+
+      var injector = new StaticInjector(modules: [module1, module2]);
+
+      var engine;
+      expect(() {
+        engine = injector.get(Car);
+      }, isNot(throws));
+      expect(engine, new isInstanceOf<Car>());
+    });
+
+    it('should use type factories passes in hierarchical module', () {
+      var module = new Module()
+          ..type(Engine)
+          ..typeFactories = {
+            Engine: (f) => new Engine()
+          };
+
+      module.install(new Module()
+         ..type(Car)
+         ..typeFactories = {
+            Car: (f) => new Car(f(Engine), f(Injector))
+         });
+
+      var injector = new StaticInjector(modules: [module]);
+
+      var engine;
+      expect(() {
+        engine = injector.get(Car);
+      }, isNot(throws));
+      expect(engine, new isInstanceOf<Car>());
+    });
+
+    it('should find type factories from parent injector', () {
+      var module1 = new Module()
+          ..type(Engine)
+          ..typeFactories = {
+            Engine: (f) => new Engine()
+          };
+      var module2 = new Module()
+          ..type(Car)
+          ..typeFactories = {
+            Car: (f) => new Car(f(Engine), f(Injector))
+          };
+
+      var rootInjector = new StaticInjector(modules: [module1]);
+      var childInjector = rootInjector.createChild([module2]);
+
+      expect(() {
+        rootInjector.get(Car);
+      }, throws);
+
+      var engine;
+      expect(() {
+        engine = childInjector.get(Car);
+      }, isNot(throws));
+      expect(engine, new isInstanceOf<Car>());
+    });
+
+  });
+}