public void BuildUpTest() { SimpleContainer c = new SimpleContainer(); var singletonC = new C(); var singletonD = new D(); c.RegisterType <A>(false); c.RegisterType <B>(false); c.RegisterInstance <C>(singletonC); c.RegisterInstance <D>(singletonD); // obiekt theA SKĄDŚ pochodzi, ale nie z kontenera A theA = new A(); theA.TheC = new C(); // ma jakieś C theA.setD(new D()); // ma jakieś D Assert.AreNotEqual(singletonC, theA.TheC); Assert.AreNotEqual(singletonD, theA.getD()); // wstrzykuje do theA zależności przez właściwości i metody c.BuildUp(theA); Assert.AreEqual(singletonC, theA.TheC); Assert.AreEqual(singletonD, theA.getD()); }
public void ReturnSameInstanceWhenInstanceRegistered() { SimpleContainer c = new SimpleContainer(); IFoo foo1 = new Foo(); c.RegisterInstance <IFoo>(foo1); IFoo foo2 = c.Resolve <IFoo>(); IFoo foo3 = c.Resolve <IFoo>(); Assert.Equal(foo1, foo2); Assert.Equal(foo1, foo1); c.RegisterType <IBar, Bar>(false); IBar b1 = c.Resolve <IBar>(); IBar b2 = new Bar(); c.RegisterInstance <IBar>(b2); IBar b3 = c.Resolve <IBar>(); Assert.NotEqual(b1, b3); Assert.Equal(typeof(Bar), b1.GetType()); c.RegisterType <IBar, BarNew>(false); IBar b4 = c.Resolve <IBar>(); Assert.Equal(typeof(BarNew), b4.GetType()); }
public void CreatesInstancesOfRegisteredTypes() { container.RegisterType <ExampleClass>(false); var instance = container.Resolve <ExampleClass>(); Assert.IsNotNull(instance); Assert.IsTrue(instance is ExampleClass); }
public void DependencyContructor() { var c = new SimpleContainer(); c.RegisterType<ITypeToResolveWithConstructorParams, ConcreteTypeWithDependencyConstructorAttr>(); c.RegisterType<ITypeToResolve, ConcreteType>(); var foo = c.Resolve<ITypeToResolveWithConstructorParams>(); Assert.IsNotNull(foo.Arg1); Assert.IsNull(foo.Arg2); }
public void ResolveObjectWithConstructorParams() { var container = new SimpleContainer(); container.RegisterType<ITypeToResolve, ConcreteType>(); container.RegisterType<ITypeToResolveWithConstructorParams, ConcreteTypeWithConstructorParams>(); var instance = container.Resolve<ITypeToResolveWithConstructorParams>(); Assert.IsInstanceOfType(instance, typeof(ConcreteTypeWithConstructorParams)); }
public void shouldOverrideAfterSecondRegister() { SimpleContainer simpleContainer = new SimpleContainer(); simpleContainer.RegisterType <IFoo, FooImpl>(false); simpleContainer.RegisterType <IFoo, FooImpl2>(false); IFoo f = simpleContainer.Resolve <IFoo>(); Assert.IsInstanceOfType(f, typeof(FooImpl2)); }
public void TestMultipleResolving() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Interface, AbstractClassImplementingInterface>(false); container.RegisterType <AbstractClassImplementingInterface, ClassInheritsAbstractClass>(false); container.RegisterType <ClassInheritsAbstractClass, ClassInheritsClass>(false); var object1 = container.Resolve <Interface>(); Assert.AreEqual(object1.GetType(), typeof(ClassInheritsClass)); }
public void TestRegisteringSingletonAfterInterfaceAreEqual() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Interface, ClassInheritsAbstractClass>(false); container.RegisterType <ClassInheritsAbstractClass>(true); var object1 = container.Resolve <Interface>(); var object2 = container.Resolve <Interface>(); Assert.AreEqual(object1, object2); }
public void RegistringRegistredTypeCLassCreation() { SimpleContainer c = new SimpleContainer(); c.RegisterType <Foo, Bar>(false); c.RegisterType <Bar, FooBar>(false); Foo foobar = c.Resolve <Foo>(); Assert.IsInstanceOfType(foobar, typeof(FooBar)); }
public void ResolveObjectWithConstructorParams() { var container = new SimpleContainer(); container.RegisterType <ITypeToResolve, ConcreteType>(); container.RegisterType <ITypeToResolveWithConstructorParams, ConcreteTypeWithConstructorParams>(); var instance = container.Resolve <ITypeToResolveWithConstructorParams>(); Assert.IsInstanceOfType(instance, typeof(ConcreteTypeWithConstructorParams)); }
public void DependencyContructor() { var c = new SimpleContainer(); c.RegisterType <ITypeToResolveWithConstructorParams, ConcreteTypeWithDependencyConstructorAttr>(); c.RegisterType <ITypeToResolve, ConcreteType>(); var foo = c.Resolve <ITypeToResolveWithConstructorParams>(); Assert.IsNotNull(foo.Arg1); Assert.IsNull(foo.Arg2); }
public void TestMultipleResolvingAllSingletons() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Interface, AbstractClassImplementingInterface>(true); container.RegisterType <AbstractClassImplementingInterface, ClassInheritsAbstractClass>(true); container.RegisterType <ClassInheritsAbstractClass, ClassInheritsClass>(true); var object1 = container.Resolve <Interface>(); var object2 = container.Resolve <Interface>(); Assert.AreEqual(object1, object2); }
public void BaseClassChangeCreation() { SimpleContainer c = new SimpleContainer(); c.RegisterType <Foo, Bar>(false); Foo bar = c.Resolve <Foo>(); c.RegisterType <Foo, Bar2>(false); Foo bar2 = c.Resolve <Foo>(); Assert.IsInstanceOfType(bar, typeof(Bar)); Assert.IsInstanceOfType(bar2, typeof(Bar2)); }
public void TestMultipleResolvingNoEmptyConstructorThrowError() { SimpleContainer container = new SimpleContainer(); Assert.ThrowsException <MissingMethodException>(() => { container.RegisterType <Interface, AbstractClassImplementingInterface>(false); container.RegisterType <AbstractClassImplementingInterface, ClassInheritsAbstractClass>(false); container.RegisterType <ClassInheritsAbstractClass, ClassNoEmptyConstructorInheritsAbstractClass>(false); var object1 = container.Resolve <Interface>(); }); }
public void TestChangingRegisterType() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Interface, ClassInheritsAbstractClass>(false); var object1 = container.Resolve <Interface>(); container.RegisterType <Interface, ClassInheritsClass>(false); var object2 = container.Resolve <Interface>(); Assert.AreEqual(object1.GetType(), typeof(ClassInheritsAbstractClass)); Assert.AreEqual(object2.GetType(), typeof(ClassInheritsClass)); }
public void ReturnOverwritedRegister() { SimpleContainer c = new SimpleContainer(); c.RegisterType <IBar, Bar>(false); IBar b1 = c.Resolve <IBar>(); Assert.Equal(typeof(Bar), b1.GetType()); c.RegisterType <IBar, BarNew>(false); IBar b2 = c.Resolve <IBar>(); Assert.Equal(typeof(BarNew), b2.GetType()); }
public void Inherit() { SimpleContainer sc = new SimpleContainer(); sc.RegisterType <IFoo, Foo>(false); IFoo f1 = sc.ResolveNoParams <IFoo>(); Assert.IsInstanceOfType(f1, typeof(Foo)); sc.RegisterType <IFoo, Moo>(false); IFoo f2 = sc.ResolveNoParams <IFoo>(); Assert.IsInstanceOfType(f2, typeof(Moo)); }
public void RegisterTypeAfterInstance() { SimpleContainer container = new SimpleContainer(); ITest instance = new A(); container.RegisterInstance<ITest>(instance); ITest obj1 = container.Resolve<ITest>(); container.RegisterType<ITest, A>(false); ITest obj2 = container.Resolve<ITest>(); Assert.AreNotSame(obj1, obj2); Assert.AreEqual(obj1.Value(), obj2.Value()); container.RegisterType<ITest, B>(false); ITest obj3 = container.Resolve<ITest>(); Assert.AreNotEqual(obj1.Value(), obj3.Value()); }
public void TestChangeInterfaceType() { var container = new SimpleContainer(); container.RegisterType <IBar, Bar3>(false); var bar1 = container.Resolve <IBar>(); container.RegisterType <IBar, Bar4>(false); var bar2 = container.Resolve <IBar>(); Assert.IsInstanceOf(typeof(Bar3), bar1); Assert.IsInstanceOf(typeof(Bar4), bar2); }
public void RegisterNonSingletonAfterSingleton() { SimpleContainer c = new SimpleContainer(); c.RegisterType <Baz>(true); Baz baz1 = c.Resolve <Baz>(); c.RegisterType <Baz>(false); Baz baz2 = c.Resolve <Baz>(); Baz baz3 = c.Resolve <Baz>(); Assert.AreNotEqual(baz2, baz1); Assert.AreNotEqual(baz3, baz2); }
public void TestDifferentInstance() { SimpleContainer c = new SimpleContainer(); c.RegisterType <IFoo, Foo>(false); IFoo f = c.Resolve <IFoo>(); // f ma typ Foo c.RegisterType <IFoo, Bar>(false); IFoo g = c.Resolve <IFoo>(); // g ma typ Bar Assert.IsInstanceOf(typeof(Foo), f); Assert.IsInstanceOf(typeof(Bar), g); }
public void TestChangeAbstractType() { var container = new SimpleContainer(); container.RegisterType <AbstractBar, Bar1>(false); var bar1 = container.Resolve <AbstractBar>(); container.RegisterType <AbstractBar, Bar2>(false); var bar2 = container.Resolve <AbstractBar>(); Assert.IsInstanceOf(typeof(Bar1), bar1); Assert.IsInstanceOf(typeof(Bar2), bar2); }
public void TestConstructorWithManyDifferentParametersProperlyCreateObject() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Interface, ClassInheritsAbstractClass>(false); var object1 = container.Resolve <ConstructorRequireManyDifferentParameters>(); }
public void ReturnSameInstanceWhenSingletonIsTrue() { SimpleContainer c = new SimpleContainer(); c.RegisterType <Foo>(true); Foo f1 = c.Resolve <Foo>(); Foo f2 = c.Resolve <Foo>(); Assert.Equal(f1, f2); c.RegisterType <IBar, Bar>(true); IBar b1 = c.Resolve <IBar>(); IBar b2 = c.Resolve <IBar>(); Assert.Equal(b1, b2); }
public void ResolveTwiceIFooTest() { SimpleContainer c = new SimpleContainer(); // Register IFoo as Foo c.RegisterType <IFoo, Foo>(); IFoo foo = c.Resolve <IFoo>(); Assert.True(foo is Foo); // Re-register IFoo as Foo2 c.RegisterType <IFoo, Foo2>(); IFoo foo2 = c.Resolve <IFoo>(); Assert.True(foo2 is Foo2); }
//[Timeout(1000)] public void CyclicDependencyNested() { var c = new SimpleContainer(); c.RegisterType <ITypeToResolve, ConcreteWithCyclicDependency>(); c.Resolve <ITypeToResolve>(); }
public void TestManySameLengthConstructorsProperlyCreateObject() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Interface, ClassInheritsAbstractClass>(false); var object1 = container.Resolve <ManySameLengthConstructors>(); }
public void TestLongestConstrucotIsUsed() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Interface, ClassInheritsAbstractClass>(false); var object1 = container.Resolve <ManyConstructorsOnlyLongestConstructorDoesntThrowException>(); }
public void CyclicDependencySimple() { var c = new SimpleContainer(); c.RegisterType<ITypeToResolve, ConcreteWithSimpleCyclicDependency>(); c.Resolve<ITypeToResolve>(); }
public void OverridingNormalTypes() { SimpleContainer c = new SimpleContainer(); c.RegisterType <Foo, Foo2>(false); var o1 = c.Resolve <Foo>(); Assert.IsTrue(o1 is Foo2); c.RegisterType <Foo, Foo3>(false); var o2 = c.Resolve <Foo>(); Assert.IsTrue(o2 is Foo3); Assert.AreNotEqual(o1, o2); }
public void ResolvableSecondConstructor() { var c = new SimpleContainer(); c.RegisterType<ITypeToResolve, ConcreteType>(); var instance = c.Resolve<ConcreteWithResolvableSecondConstructor>(); Assert.IsNotNull(instance.Arg1); }
public void RecursiveImplementation() { SimpleContainer container = new SimpleContainer(); container.RegisterType<ITest, A>(false); ITest objA = container.Resolve<ITest>(); Assert.IsNotNull(objA); Assert.AreEqual(objA.Value(), 1); container.RegisterType<A,B>(false); ITest objB = container.Resolve<ITest>(); Assert.IsNotNull(objB); Assert.AreEqual(objB.Value(), 2); }
public void ImplementedInterface() { SimpleContainer container = new SimpleContainer(); container.RegisterType<ITest, B>(true); ITest obj = container.Resolve<ITest>(); Assert.IsNotNull(obj); Assert.AreEqual(obj.Value(), 2); }
public void NotSingleton() { SimpleContainer container = new SimpleContainer(); container.RegisterType<A>(false); A obj1 = container.Resolve<A>(); A obj2 = container.Resolve<A>(); Assert.AreNotSame(obj1, obj2); }
public void ResolveConcreteTypeSingleton() { var container = new SimpleContainer(); container.RegisterType<ConcreteType>(); var instance = container.Resolve<ConcreteType>(); Assert.AreSame(container.Resolve<ConcreteType>(), instance); }
public void DefaultSingletonCreation() { var container = new SimpleContainer(); container.RegisterType<ITypeToResolve, ConcreteType>(); var instance = container.Resolve<ITypeToResolve>(); Assert.AreSame(container.Resolve<ITypeToResolve>(), instance); }
public void ResolveConcreteTypeTransient() { var container = new SimpleContainer(); container.RegisterType<ConcreteType>(false); var instance = container.Resolve<ConcreteType>(); Assert.AreNotSame(container.Resolve<ConcreteType>(), instance); }
public void ResolveObjectWithInterface() { var container = new SimpleContainer(); container.RegisterType<ITypeToResolve, ConcreteType>(); var instance = container.Resolve<ITypeToResolve>(); Assert.IsInstanceOfType(instance, typeof(ConcreteType)); }
static void Main(string[] args) { SimpleContainer container = new SimpleContainer(); container.RegisterType<Testing>( false ); Testing t1 = container.Resolve<Testing>(); t1.foo(); TestingSingleton t2, t3; container.RegisterType<TestingSingleton>( true ); t2 = container.Resolve<TestingSingleton>(); t3 = container.Resolve<TestingSingleton>(); Console.WriteLine( t2 == t3 ); IFoo t4, t5; container.RegisterType<IFoo, TestingWithInterface>( false ); t4 = container.Resolve<IFoo>(); t4.foo(); container.RegisterType<IFoo, TestingWithInterface2>( false ); t5 = container.Resolve<IFoo>(); t5.foo(); Console.ReadKey(); }