Revert revision 33053

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 {
-  final String id = 'v8-id';
+  String id = 'v8-id';
 }
 
 @Injectable()
 class MockEngine implements Engine {
-  final String id = 'mock-id';
+  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(this.compare);
+  WithTypeDefDependency(CompareInt c) {
+    compare = c;
+  }
 }
 
 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));
     });
 
 
-    it('should inject a typedef', () {
+    // Typedef injection is not supported in dart2js: http://dartbug.com/11612
+    xit('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));
     });
 
 
-    it('should throw an exception when injecting typedef without providing it', () {
+    // Typedef injection is not supported in dart2js: http://dartbug.com/11612
+    xit('should throw an exception when injecting typedef without providing it', () {
       var injector = injectorFactory([new Module()..type(WithTypeDefDependency)]);
 
       expect(() {
         injector.get(WithTypeDefDependency);
-      }, throws);
+      }, toThrow(NoProviderError, 'No provider found for CompareInt! '
+      '(resolving WithTypeDefDependency -> CompareInt)'));
     });
 
 
     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>());
-    });
-
-  });
-}