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();
}
