Ejemplo n.º 1
0
        public void TestImplicitToSingleton()
        {
            //This succeeds if no error
            IInjectionBinding binding = new InjectionBinding(resolver).Bind <InjectableSuperClass> ().ToSingleton();

            factory.Get(binding);

            //Succeeds if throws error
            IInjectionBinding binding2     = new InjectionBinding(resolver).Bind <ISimpleInterface> ().ToSingleton();
            TestDelegate      testDelegate = delegate()
            {
                factory.Get(binding2);
            };
            InjectionException ex = Assert.Throws <InjectionException>(testDelegate);

            Assert.That(ex.type == InjectionExceptionType.NOT_INSTANTIABLE);

            //Succeeds if throws error
            IInjectionBinding binding3      = new InjectionBinding(resolver).Bind <AbstractClass> ().ToSingleton();
            TestDelegate      testDelegate2 = delegate()
            {
                factory.Get(binding3);
            };
            InjectionException ex2 = Assert.Throws <InjectionException>(testDelegate2);

            Assert.That(ex2.type == InjectionExceptionType.NOT_INSTANTIABLE);
        }
Ejemplo n.º 2
0
        public void TestUnbindNonexistentThrows()
        {
            TestDelegate testDelegate = delegate
            {
                commandBinder.Unbind <NoArgSignal>();
            };
            InjectionException ex = Assert.Throws <InjectionException>(testDelegate);

            Assert.AreEqual(ex.type, InjectionExceptionType.NULL_BINDING);
        }
Ejemplo n.º 3
0
 private void CheckNamedParameter(Type t)
 {
     if (ReflectionUtilities.IsAssignableFromIgnoreGeneric(typeof(Name <>), t))
     {
         var ex = new InjectionException("GetInstance() called on Name "
                                         + ReflectionUtilities.GetName(t)
                                         + " Did you mean to call GetNamedInstance() instead?");
         Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER);
     }
 }
Ejemplo n.º 4
0
        public void TestInjectionErrorFailureToProvideDependency()
        {
            TestDelegate testDelegate = delegate() {
                binder.GetInstance <InjectableSuperClass> ();
            };

            binder.Bind <InjectableSuperClass> ().To <InjectableSuperClass> ();
            InjectionException ex = Assert.Throws <InjectionException> (testDelegate);

            Assert.That(ex.type == InjectionExceptionType.NULL_BINDING);
        }
Ejemplo n.º 5
0
        public void TestCircularDependencies()
        {
            binder.Bind <CircularDependencyOne> ().To <CircularDependencyOne> ();
            binder.Bind <CircularDependencyTwo> ().To <CircularDependencyTwo> ();

            TestDelegate testDelegate = delegate()
            {
                binder.GetInstance <CircularDependencyOne>();
            };
            InjectionException ex = Assert.Throws <InjectionException>(testDelegate);

            Assert.That(ex.type == InjectionExceptionType.CIRCULAR_DEPENDENCY);
        }
Ejemplo n.º 6
0
        public void TestIllegalValueBinding()
        {
            MarkerClass illegalValue = new MarkerClass();

            Binder.BindingResolver resolver     = delegate(IBinding binding){};
            TestDelegate           testDelegate = delegate()
            {
                new InjectionBinding(resolver).Bind <InjectableSuperClass> ().To <InjectableDerivedClass> ().ToValue(illegalValue);
            };
            InjectionException ex =
                Assert.Throws <InjectionException> (testDelegate);

            Assert.That(ex.type == InjectionExceptionType.ILLEGAL_BINDING_VALUE);
        }
Ejemplo n.º 7
0
        public void TestDoesNotImplementTwo()
        {
            context.ScannedPackages = new string[] {
                "strange.unittests.annotated.testUnimplementedImplementsTag",
            };

            TestDelegate testDelegate = delegate
            {
                context.Start();
            };

            //We should be getting an exception here because the interface is not implemented
            InjectionException ex = Assert.Throws <InjectionException>(testDelegate);

            //make sure it's the right exception
            Assert.AreEqual(InjectionExceptionType.IMPLICIT_BINDING_TYPE_DOES_NOT_IMPLEMENT_DESIGNATED_INTERFACE, ex.type);
        }
Ejemplo n.º 8
0
        public void TestRemoveDependency()
        {
            binder.Bind <InjectableSuperClass> ().To <InjectableSuperClass> ();
            binder.Bind <int> ().ToValue(42);
            InjectableSuperClass testValueBeforeUnbinding = binder.GetInstance <InjectableSuperClass> () as InjectableSuperClass;

            Assert.IsNotNull(testValueBeforeUnbinding);
            Assert.That(testValueBeforeUnbinding.intValue == 42);

            binder.Unbind <int> ();

            TestDelegate testDelegate = delegate() {
                binder.GetInstance <InjectableSuperClass> ();
            };

            InjectionException ex = Assert.Throws <InjectionException> (testDelegate);

            Assert.That(ex.type == InjectionExceptionType.NULL_BINDING);
        }
Ejemplo n.º 9
0
        public object InjectFromPlan(InjectionPlan plan)
        {
            if (!plan.IsFeasible())
            {
                var ex = new InjectionException("Cannot inject " + plan.GetNode().GetFullName() + ": "
                                                + plan.ToCantInjectString());
                Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER);
            }

            if (plan.IsAmbiguous())
            {
                var ex = new InjectionException("Cannot inject " + plan.GetNode().GetFullName() + " "
                                                + plan.ToCantInjectString());
                Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER);
            }

            if (plan is InjectionFuturePlan)
            {
                InjectionFuturePlan fut = (InjectionFuturePlan)plan;
                INode  node             = fut.GetNode();
                string key = node.GetFullName();
                try
                {
                    Type t        = null;
                    Type nodeType = classHierarchy.ClassForName(node.GetFullName());

                    if (node is IClassNode)
                    {
                        t = nodeType;
                    }
                    else if (node is INamedParameterNode)
                    {
                        var nn = (INamedParameterNode)node;
                        t = classHierarchy.ClassForName(nn.GetFullArgName());
                        if (nn.IsSet())
                        {
                            t = typeof(ISet <>).MakeGenericType(new Type[] { t });
                        }
                    }
                    else
                    {
                        var ex = new ApplicationException("Unexpected node type. Wanted ClassNode or NamedParameterNode.  Got: " + node);
                        Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER);
                    }

                    // Java - InjectionFuture<?> ret = new InjectionFuture<>(this, javaNamespace.classForName(fut.getNode().getFullName()));
                    // C# - InjectionFuture<object> ret = new InjectionFutureImpl<object>(this, classHierarchy.ClassForName(fut.GetNode().GetFullName()));
                    // We cannot simply create an object from generic with object as <T>
                    // typeof(InjectionFutureImpl<>).MakeGenericType(t) will get the InjectionFutureImpl generic Type with <T> as t
                    // for ClassNode, t is the Type of the class, for NamedParameterNode, t is the Type of the argument
                    // we then use reflection to invoke the constructor
                    // To retain generic argument information??
                    Type injectionFuture          = typeof(InjectionFutureImpl <>).MakeGenericType(t);
                    var  constructor              = injectionFuture.GetConstructor(new Type[] { typeof(IInjector), typeof(Type) });
                    IInjectionFuture <object> ret = (IInjectionFuture <object>)constructor.Invoke(new object[] { this, nodeType });

                    pendingFutures.Add(ret);
                    return(ret);
                }
                catch (TypeLoadException e)
                {
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new InjectionException("Could not get class for " + key), LOGGER);
                }
            }
            else if (plan.GetNode() is IClassNode && null != GetCachedInstance((IClassNode)plan.GetNode()))
            {
                return(GetCachedInstance((IClassNode)plan.GetNode()));
            }
            else if (plan is CsInstance)
            {
                // TODO: Must be named parameter node.  Check.
                // throw new IllegalStateException("Instance from plan not in Injector's set of instances?!?");
                return(((CsInstance)plan).instance);
            }
            else if (plan is Constructor)
            {
                Constructor     constructor = (Constructor)plan;
                object[]        args        = new object[constructor.GetArgs().Length];
                InjectionPlan[] argPlans    = constructor.GetArgs();

                for (int i = 0; i < argPlans.Length; i++)
                {
                    args[i] = InjectFromPlan(argPlans[i]);
                }

                try
                {
                    concurrentModificationGuard = true;
                    object ret = null;
                    try
                    {
                        IConstructorDef def = (IConstructorDef)constructor.GetConstructorDef();
                        ConstructorInfo c   = GetConstructor(def);

                        if (aspect != null)
                        {
                            ret = aspect.Inject(def, c, args);
                        }
                        else
                        {
                            ret = c.Invoke(args);
                        }
                    }
                    catch (ArgumentException e)
                    {
                        Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
                        StringBuilder sb = new StringBuilder("Internal Tang error?  Could not call constructor " + constructor.GetConstructorDef() + " with arguments [");
                        foreach (object o in args)
                        {
                            sb.Append("\n\t" + o);
                        }
                        sb.Append("]");
                        Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException(sb.ToString(), e), LOGGER);
                    }
                    if (ret is IExternalConstructor <object> )
                    {
                        ret = ((IExternalConstructor <object>)ret).NewInstance();
                    }
                    instances.Add(constructor.GetNode(), ret);
                    return(ret);
                }
                catch (TargetInvocationException e)
                {
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new InjectionException("Could not invoke constructor: " + plan, e), LOGGER);
                }
                finally
                {
                    concurrentModificationGuard = false;
                }
            }
            else if (plan is Subplan)
            {
                Subplan ambiguous = (Subplan)plan;
                return(InjectFromPlan(ambiguous.GetDelegatedPlan()));
            }
            else if (plan is SetInjectionPlan)
            {
                SetInjectionPlan setPlan   = (SetInjectionPlan)plan;
                INode            n         = setPlan.GetNode();
                string           typeOfSet = null;

                // TODO: This doesn't work for sets of generics (e.g., Set<Foo<int>>
                // because GetFullName and GetFullArgName strip generic info).
                if (n is INamedParameterNode)
                {
                    INamedParameterNode np = (INamedParameterNode)n;
                    typeOfSet = np.GetFullArgName();
                }
                else if (n is IClassNode)
                {
                    typeOfSet = n.GetFullName();
                }
                else
                {
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ApplicationException("Unknown node type :" + n.ToString()), LOGGER);
                }

                Type t = classHierarchy.ClassForName(typeOfSet);

                // MakeGenericType(t = int: MonotonicHashSet<> -> MonotonicHashSet<int>
                // Get constructor: MonotonicHashSet<int> -> public MonotonicHashSet<int>() { ... }
                // Invoke: public MonotonicHashSet<int> -> new MonotonicHashSet<int>()
                object ret = typeof(MonotonicHashSet <>).MakeGenericType(t).GetConstructor(new Type[] { }).Invoke(new object[] { }); // (this, classHierarchy.ClassForName(fut.GetNode().GetFullName()));

                MethodInfo mf = ret.GetType().GetMethod("Add");

                foreach (InjectionPlan subplan in setPlan.GetEntryPlans())
                {
                    // ret.Add(InjectFromPlan(subplan));
                    mf.Invoke(ret, new object[] { InjectFromPlan(subplan) });
                }
                return(ret);
            }
            else if (plan is ListInjectionPlan)
            {
                ListInjectionPlan listPlan   = (ListInjectionPlan)plan;
                INode             n          = listPlan.GetNode();
                string            typeOfList = null;

                if (n is INamedParameterNode)
                {
                    INamedParameterNode np = (INamedParameterNode)n;
                    typeOfList = np.GetFullArgName();
                }
                else if (n is IClassNode)
                {
                    typeOfList = n.GetFullName();
                }
                else
                {
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ApplicationException("Unknown node type :" + n.ToString()), LOGGER);
                }

                Type   t   = classHierarchy.ClassForName(typeOfList);
                object ret = typeof(List <>).MakeGenericType(t).GetConstructor(new Type[] { }).Invoke(new object[] { });

                MethodInfo mf = ret.GetType().GetMethod("Add");

                foreach (InjectionPlan subplan in listPlan.GetEntryPlans())
                {
                    mf.Invoke(ret, new object[] { InjectFromPlan(subplan) });
                }
                return(ret);
            }
            else
            {
                Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Unknown plan type: " + plan), LOGGER);
            }
            return(null); // should never reach here
        }