Update the Angular/DI tests to latest from github.

third_party/pkg/di/test/main.dart

 @Injectables(const [
   ClassOne,
   CircularA,
   CircularB,
   MultipleConstructors,
   NumDependency,
   IntDependency,
   DoubleDependency,
   BoolDependency,
   StringDependency
@@ skipping 14 matching lines @@
  * generated. For testing purposes not all classes are marked with this
  * annotation, some classes are included in @Injectables at the top.
  */
 class Injectable {
   const 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()
 class MockEngine2 implements Engine {
   String id = 'mock-id-2';
 }
 
+class HiddenConstructor {
+  HiddenConstructor._();
+}
+
 @Injectable()
 class Car {
   Engine engine;
   Injector injector;
 
   Car(this.engine, this.injector);
 }
 
+class Lemon {
+  final engine;
+  final Injector injector;
+
+  Lemon(this.engine, this.injector);
+}
+
 class NumDependency {
   NumDependency(num value) {}
 }
 
 class IntDependency {
   IntDependency(int value) {}
 }
 
 class DoubleDependency {
   DoubleDependency(double value) {}
@@ skipping 16 matching lines @@
   CircularB(CircularA a) {}
 }
 
 typedef int CompareInt(int a, int b);
 
 int compareIntAsc(int a, int b) => b.compareTo(a);
 
 class WithTypeDefDependency {
   CompareInt compare;
 
-  WithTypeDefDependency(CompareInt c) {
-    compare = c;
-  }
+  WithTypeDefDependency(this.compare);
 }
 
 class MultipleConstructors {
   String instantiatedVia;
   MultipleConstructors() : instantiatedVia = 'default';
   MultipleConstructors.named() : instantiatedVia = 'named';
 }
 
 class InterfaceOne {
 }
 
 class ClassOne implements InterfaceOne {
   ClassOne(Log log) {
     log.add('ClassOne');
   }
 }
 
 @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 = [];
 
   add(String message) => log.add(message);
 }
 
 class EmulatedMockEngineFactory {
   call(Injector i) => new MockEngine();
 }
 
 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]);
 
 createInjectorSpec(String injectorName, InjectorFactory injectorFactory) {
 
   describe(injectorName, () {
 
     it('should instantiate a type', () {
       var injector = injectorFactory([new Module()..type(Engine)]);
@@ skipping 14 matching lines @@
 
     it('should resolve basic dependencies', () {
       var injector = injectorFactory([new Module()..type(Car)..type(Engine)]);
       var instance = injector.get(Car);
 
       expect(instance, instanceOf(Car));
       expect(instance.engine.id, toEqual('v8-id'));
     });
 
 
+    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);
 
       // injector is immutable
       // you can't load more modules once it's instantiated
       // (you can create a child injector)
       var injector = injectorFactory([module]);
       var instance = injector.get(Engine);
 
       expect(instance.id, toEqual('mock-id'));
@@ skipping 109 matching lines @@
     });
 
 
     it('should provide the injector as Injector', () {
       var injector = injectorFactory([]);
 
       expect(injector.get(Injector), toBe(injector));
     });
 
 
-    // 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]);
       var compare = injector.get(CompareInt);
 
       expect(compare(1, 2), toBe(1));
       expect(compare(5, 2), toBe(-1));
     });
 
 
-    // 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);
     });
 
 
     it('should instantiate via the default/unnamed constructor', () {
       var injector = injectorFactory([new Module()..type(MultipleConstructors)]);
       MultipleConstructors instance = injector.get(MultipleConstructors);
       expect(instance.instantiatedVia, 'default');
     });
 
     // CHILD INJECTORS
@@ skipping 184 matching lines @@
             NoProviderError,
             'No provider found for Car! (resolving Car)'
         ));
       });
 
     });
 
   });
 
 }
+
+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>());
+    });
+
+  });
+}