Revert "Update all Angular libs (run update_all.sh)."

third_party/pkg/di/test/main.dart

 @Injectables(const [
   ClassOne,
   CircularA,
   CircularB,
   MultipleConstructors,
   NumDependency,
   IntDependency,
   DoubleDependency,
   BoolDependency,
   StringDependency
 ])
 library di.tests;
 
 import 'fixed-unittest.dart';
 import 'package:di/di.dart';
 import 'package:di/dynamic_injector.dart';
 import 'package:di/static_injector.dart';
 import 'package:di/annotations.dart';
 
-import 'test_annotations.dart';
 // Generated file. Run ../test_tf_gen.sh.
 import 'type_factories_gen.dart' as type_factories_gen;
 
 /**
  * Annotation used to mark classes for which static type factory must be
  * generated. For testing purposes not all classes are marked with this
  * annotation, some classes are included in @Injectables at the top.
  */
-class InjectableTest {
-  const InjectableTest();
+class Injectable {
+  const Injectable();
 }
 
 // just some classes for testing
-@InjectableTest()
+@Injectable()
 class Engine {
   final String id = 'v8-id';
 }
 
 @Injectable()
 class MockEngine implements Engine {
   final String id = 'mock-id';
 }
 
-@InjectableTest()
+@Injectable()
 class MockEngine2 implements Engine {
   String id = 'mock-id-2';
 }
 
 class HiddenConstructor {
   HiddenConstructor._();
 }
 
-@InjectableTest()
-class TurboEngine implements Engine {
-  String id = 'turbo-engine-id';
-}
-
-@InjectableTest()
-class BrokenOldEngine implements Engine {
-  String id = 'broken-old-engine-id';
-}
-
-@InjectableTest()
+@Injectable()
 class Car {
   Engine engine;
   Injector injector;
 
   Car(this.engine, this.injector);
 }
 
 class Lemon {
   final engine;
   final Injector injector;
 
   Lemon(this.engine, this.injector);
 }
 
-@InjectableTest()
-class Porsche {
-  Engine engine;
-  Injector injector;
-
-  Porsche(@Turbo() this.engine, this.injector);
-}
-
 class NumDependency {
   NumDependency(num value) {}
 }
 
 class IntDependency {
   IntDependency(int value) {}
 }
 
 class DoubleDependency {
   DoubleDependency(double value) {}
@@ skipping 34 matching lines @@
 
 class InterfaceOne {
 }
 
 class ClassOne implements InterfaceOne {
   ClassOne(Log log) {
     log.add('ClassOne');
   }
 }
 
-@InjectableTest()
+@Injectable()
 class ParameterizedType<T1, T2> {
   ParameterizedType();
 }
 
-@InjectableTest()
+@Injectable()
 class ParameterizedDependency {
   final ParameterizedType<bool, int> _p;
   ParameterizedDependency(this._p);
 }
 
-@InjectableTest()
+@Injectable()
 class GenericParameterizedDependency {
   final ParameterizedType _p;
   GenericParameterizedDependency(this._p);
 }
 
-@InjectableTest()
+@Injectable()
 class Log {
   var log = [];
 
   add(String message) => log.add(message);
 }
 
-@InjectableTest()
-class AnnotatedPrimitiveDependency {
-  String strValue;
-  AnnotatedPrimitiveDependency(@Turbo() this.strValue);
-}
-
 class EmulatedMockEngineFactory {
   call(Injector i) => new MockEngine();
 }
 
-bool throwOnceShouldThrow = true;
-@InjectableTest()
-class ThrowOnce {
-  ThrowOnce() {
-    if (throwOnceShouldThrow) {
-      throwOnceShouldThrow = false;
-      throw ["ThrowOnce"];
-    }
-  }
-}
-
 void main() {
   createInjectorSpec('DynamicInjector',
       (modules, [name]) => new DynamicInjector(modules: modules, name: name));
 
   createInjectorSpec('StaticInjector',
       (modules, [name]) => new StaticInjector(modules: modules, name: name,
           typeFactories: type_factories_gen.typeFactories));
 
   dynamicInjectorTest();
   staticInjectorTest();
-  createKeySpec();
 }
 
 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)]);
       var instance = injector.get(Engine);
 
       expect(instance, instanceOf(Engine));
       expect(instance.id, toEqual('v8-id'));
     });
 
-    it('should instantiate an annotated type', () {
-      var injector = injectorFactory([new Module()
-          ..type(Engine, withAnnotation: Turbo, implementedBy: TurboEngine)
-          ..value(Car, new Engine())
-      ]);
-      var instance = injector.getByKey(new Key(Engine, Turbo));
-
-      expect(instance, instanceOf(TurboEngine));
-      expect(instance.id, toEqual('turbo-engine-id'));
-    });
-
     it('should fail if no binding is found', () {
       var injector = injectorFactory([]);
       expect(() {
         injector.get(Engine);
       }, toThrow(NoProviderError, 'No provider found for Engine! '
       '(resolving Engine)'));
     });
 
 
     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 resolve complex dependencies', () {
-      var injector = injectorFactory([new Module()
-            ..type(Porsche)
-            ..type(TurboEngine)
-            ..type(Engine, withAnnotation: Turbo, implementedBy: TurboEngine)
-      ]);
-      var instance = injector.get(Porsche);
-
-      expect(instance, instanceOf(Porsche));
-      expect(instance.engine.id, toEqual('turbo-engine-id'));
-    });
-
-    it('should resolve annotated primitive type', () {
-      var injector = injectorFactory([new Module()
-            ..type(AnnotatedPrimitiveDependency)
-            ..value(String, 'Worked!', withAnnotation: Turbo)
-      ]);
-      var instance = injector.get(AnnotatedPrimitiveDependency);
-
-      expect(instance, instanceOf(AnnotatedPrimitiveDependency));
-      expect(instance.strValue, toEqual('Worked!'));
-    });
 
     it('should inject generic parameterized types', () {
       var injector = injectorFactory([new Module()
             ..type(ParameterizedType)
             ..type(GenericParameterizedDependency)
       ]);
       expect(injector.get(GenericParameterizedDependency),
           new isInstanceOf<GenericParameterizedDependency>());
     });
 
@@ skipping 112 matching lines @@
       '(resolving BoolDependency -> bool)'));
 
       expect(() {
         injector.get(StringDependency);
       }, toThrow(NoProviderError, 'Cannot inject a primitive type of String! '
       '(resolving StringDependency -> String)'));
     });
 
 
     it('should throw an exception when circular dependency', () {
-      var injector = injectorFactory([new Module()..type(CircularA)
-                                        ..type(CircularB)]);
+      var injector = injectorFactory([new Module()..type(CircularA)..type(CircularB)]);
 
       expect(() {
         injector.get(CircularA);
-      }, toThrow(CircularDependencyError, 'Cannot resolve a circular '
-          'dependency! (resolving CircularA -> CircularB -> CircularA'));
-    });
-
-    it('should throw an exception when circular dependency in factory', () {
-      var injector = injectorFactory([new Module()
-          ..factory(CircularA, (i) => i.get(CircularA))
-      ]);
-
-      expect(() {
-        injector.get(CircularA);
-      }, toThrow(CircularDependencyError, 'Cannot resolve a '
-          'circular dependency! (resolving CircularA -> CircularA'));
+      }, toThrow(CircularDependencyError, 'Cannot resolve a circular dependency! '
+          '(resolving CircularA -> '
+      'CircularB -> CircularA)'));
     });
 
 
-    it('should recover from errors', () {
-      var injector = injectorFactory([new Module()..type(ThrowOnce)]);
-      throwOnceShouldThrow = true;
-
-      var caught = false;
-      try {
-        injector.get(ThrowOnce);
-      } catch (e, s) {
-        caught = true;
-        expect(injector.get(ThrowOnce), not(toEqual(null)));
-      }
-      expect(caught, toEqual(true));
-    });
-
-
     it('should provide the injector as Injector', () {
       var injector = injectorFactory([]);
 
       expect(injector.get(Injector), toBe(injector));
     });
 
 
     it('should inject a typedef', () {
       var module = new Module()..value(CompareInt, compareIntAsc);
 
@@ skipping 32 matching lines @@
 
       expect(abcFromParent.id, toEqual('v8-id'));
       expect(abcFromChild.id, toEqual('mock-id'));
     });
 
 
     it('should enumerate across children', () {
       var parent = injectorFactory([new Module()..type(Engine)]);
       var child = parent.createChild([new Module()..type(MockEngine)]);
 
-      expect(parent.types, unorderedEquals(new Set.from(
-          [Engine, Injector])));
-      expect(child.types, unorderedEquals(new Set.from(
-          [Engine, MockEngine, Injector])));
+      expect(parent.types, unorderedEquals(new Set.from([Engine, Injector])));
+      expect(child.types, unorderedEquals(new Set.from([Engine, MockEngine, Injector])));
     });
 
 
     it('should inject instance from parent if not provided in child', () {
       var module = new Module()..type(Car);
 
       var parent = injectorFactory([new Module()..type(Car)..type(Engine)]);
       var child = parent.createChild([module]);
 
       var complexFromParent = parent.get(Car);
@@ skipping 20 matching lines @@
       expect(complexFromChild, toBe(complexFromParent));
       expect(complexFromChild.engine, toBe(abcFromParent));
       expect(complexFromChild.engine, not(toBe(abcFromChild)));
     });
 
 
     it('should force new instance in child even if already instantiated in parent', () {
       var parent = injectorFactory([new Module()..type(Engine)]);
       var abcAlreadyInParent = parent.get(Engine);
 
-      var child = parent.createChild([], forceNewInstances: [new Key(Engine)]);
+      var child = parent.createChild([], forceNewInstances: [Engine]);
       var abcFromChild = child.get(Engine);
 
       expect(abcFromChild, not(toBe(abcAlreadyInParent)));
     });
 
 
     it('should force new instance in child using provider from grand parent', () {
       var module = new Module()..type(Engine, implementedBy: MockEngine);
 
       var grandParent = injectorFactory([module]);
       var parent = grandParent.createChild([]);
-      var child = parent.createChild([], forceNewInstances: [new Key(Engine)]);
+      var child = parent.createChild([], forceNewInstances: [Engine]);
 
       var abcFromGrandParent = grandParent.get(Engine);
       var abcFromChild = child.get(Engine);
 
       expect(abcFromChild.id, toEqual(('mock-id')));
       expect(abcFromChild, not(toBe(abcFromGrandParent)));
     });
 
 
     it('should provide child injector as Injector', () {
@@ skipping 11 matching lines @@
 
 
     it('should set the child injector name', () {
       var injector = injectorFactory([], 'foo');
       var childInjector = injector.createChild(null, name: 'bar');
       expect(childInjector.name, 'bar');
     });
 
 
     it('should instantiate class only once (Issue #18)', () {
-      var rootInjector = injectorFactory([]);
-      var injector = rootInjector.createChild([
+      var injector = injectorFactory([
           new Module()
             ..type(Log)
             ..type(ClassOne)
             ..factory(InterfaceOne, (i) => i.get(ClassOne))
       ]);
 
       expect(injector.get(InterfaceOne), same(injector.get(ClassOne)));
       expect(injector.get(Log).log.join(' '), 'ClassOne');
     });
 
 
+    describe('creation strategy', () {
+
+      it('should get called for instance creation', () {
+
+        List creationLog = [];
+        dynamic creation(Injector requesting, Injector defining, factory) {
+          creationLog.add([requesting, defining]);
+          return factory();
+        }
+
+        var parentModule = new Module()
+          ..type(Engine, implementedBy: MockEngine, creation: creation)
+          ..type(Car, creation: creation);
+
+        var parentInjector = injectorFactory([parentModule]);
+        var childInjector = parentInjector.createChild([]);
+        childInjector.get(Car);
+        expect(creationLog, [
+          [childInjector, parentInjector],
+          [childInjector, parentInjector]
+        ]);
+      });
+
+      it('should be able to prevent instantiation', () {
+
+        List creationLog = [];
+        dynamic creation(Injector requesting, Injector defining, factory) {
+          throw 'not allowing';
+        }
+
+        var module = new Module()
+          ..type(Engine, implementedBy: MockEngine, creation: creation);
+        var injector = injectorFactory([module]);
+        expect(() {
+          injector.get(Engine);
+        }, throwsA('not allowing'));
+      });
+    });
+
+
     describe('visiblity', () {
 
       it('should hide instances', () {
 
         var rootMock = new MockEngine();
         var childMock = new MockEngine();
 
         var parentModule = new Module()
           ..value(Engine, rootMock);
         var childModule = new Module()
@@ skipping 43 matching lines @@
       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.')));
     });
 
-    it('should inject parameters into function and invoke it', () {
-      var module = new Module()
-          ..type(Engine);
-      var id;
-      var injector = new DynamicInjector(modules: [module]);
-      injector.invoke((Engine e) => id = e.id);
-      expect(id, equals('v8-id'));
-    });
-
-    it('should inject annotated parameters into function and invoke it', () {
-      var module = new Module()
-          ..type(Engine, withAnnotation: Turbo, implementedBy: TurboEngine);
-      var id;
-      var injector = new DynamicInjector(modules: [module]);
-      injector.invoke((@Turbo() Engine e) => id = e.id);
-      expect(id, equals('turbo-engine-id'));
-    });
-
   });
 }
 
 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: {
@@ skipping 86 matching lines @@
 
       var engine;
       expect(() {
         engine = childInjector.get(Car);
       }, isNot(throws));
       expect(engine, new isInstanceOf<Car>());
     });
 
   });
 }
-
-createKeySpec() {
-  describe('Key', () {
-    it('should be equal to another key if type is the same', () {
-      Key k1 = new Key(Car);
-      Key k2 = new Key(Car);
-      expect(k1, equals(k2));
-      expect(k1.hashCode,  equals(k2.hashCode));
-    });
-
-    it('should be equal to another key if type and annotation are the same', () {
-      Key k1 = new Key(Car, Turbo);
-      Key k2 = new Key(Car, Turbo);
-      expect(k1, equals(k2));
-      expect(k1.hashCode,  equals(k2.hashCode));
-    });
-
-    it('should not be equal to another key if types are different', () {
-      Key k1 = new Key(Car);
-      Key k2 = new Key(Porsche);
-      expect(k1, not(equals(k2)));
-      expect(k1.hashCode, not(equals(k2.hashCode)));
-    });
-
-    it('should not be equal to another key if annotations are different', () {
-      Key k1 = new Key(Car, Turbo);
-      Key k2 = new Key(Car, Old);
-      expect(k1, not(equals(k2)));
-      expect(k1.hashCode, not(equals(k2.hashCode)));
-    });
-
-    it('should not be equal to another key if type is different and annotation'
-        ' is same', () {
-      Key k1 = new Key(Engine, Old);
-      Key k2 = new Key(Car, Old);
-      expect(k1, not(equals(k2)));
-      expect(k1.hashCode, not(equals(k2.hashCode)));
-    });
-  });
-}