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 Injectable {
-  const Injectable();
+class InjectableTest {
+  const InjectableTest();
 }
 
 // just some classes for testing
-@Injectable()
+@InjectableTest()
 class Engine {
   final String id = 'v8-id';
 }
 
 @Injectable()
 class MockEngine implements Engine {
   final String id = 'mock-id';
 }
 
-@Injectable()
+@InjectableTest()
 class MockEngine2 implements Engine {
   String id = 'mock-id-2';
 }
 
 class HiddenConstructor {
   HiddenConstructor._();
 }
 
-@Injectable()
+@InjectableTest()
+class TurboEngine implements Engine {
+  String id = 'turbo-engine-id';
+}
+
+@InjectableTest()
+class BrokenOldEngine implements Engine {
+  String id = 'broken-old-engine-id';
+}
+
+@InjectableTest()
 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');
   }
 }
 
-@Injectable()
+@InjectableTest()
 class ParameterizedType<T1, T2> {
   ParameterizedType();
 }
 
-@Injectable()
+@InjectableTest()
 class ParameterizedDependency {
   final ParameterizedType<bool, int> _p;
   ParameterizedDependency(this._p);
 }
 
-@Injectable()
+@InjectableTest()
 class GenericParameterizedDependency {
   final ParameterizedType _p;
   GenericParameterizedDependency(this._p);
 }
 
-@Injectable()
+@InjectableTest()
 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)'));
+      }, 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'));
     });
 
 
+    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: [Engine]);
+      var child = parent.createChild([], forceNewInstances: [new Key(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: [Engine]);
+      var child = parent.createChild([], forceNewInstances: [new Key(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 injector = injectorFactory([
+      var rootInjector = injectorFactory([]);
+      var injector = rootInjector.createChild([
           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)));
+    });
+  });
+}