public void TestSelfCached() { Container.Bind <Foo>().AsSingle().NonLazy(); Assert.IsNotNull(Container.Resolve <Foo>()); Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <Foo>()); }
public void TestMultipleBindingsCached() { Container.Bind(typeof(IFoo), typeof(IBar)).To <Foo>().AsSingle().NonLazy(); Assert.IsEqual(Container.Resolve <IFoo>(), Container.Resolve <IFoo>()); Assert.IsEqual(Container.Resolve <IFoo>(), Container.Resolve <IBar>()); }
public void TestSelfSingleExplicit() { Container.Bind <Foo>().ToSelf().FromNew().AsSingle().NonLazy(); Assert.IsNotNull(Container.Resolve <Foo>()); Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <Foo>()); }
public void TestConcrete() { Container.BindFactory <IFoo, IFooFactory>() .To <Foo>().FromIFactory(b => b.To <CustomFooFactory>().AsCached()).NonLazy(); Assert.IsEqual(Container.Resolve <IFooFactory>().Create(), StaticFoo); }
// Test that tickables get called in the correct order public void TestOrder() { BindTickable <Tickable3>(2); BindTickable <Tickable1>(0); BindTickable <Tickable2>(1); var taskUpdater = _container.Resolve <TaskUpdater <ITickable> >(); var tick1 = _container.Resolve <Tickable1>(); var tick2 = _container.Resolve <Tickable2>(); var tick3 = _container.Resolve <Tickable3>(); int tickCount = 0; tick1.TickCalled += delegate { Assert.IsEqual(tickCount, 0); tickCount++; }; tick2.TickCalled += delegate { Assert.IsEqual(tickCount, 1); tickCount++; }; tick3.TickCalled += delegate { Assert.IsEqual(tickCount, 2); tickCount++; }; taskUpdater.UpdateAll(); }
public void Test1() { Container.BindFactory <string, Foo, Foo.Factory>().FromPoolableMemoryPool(x => x.WithInitialSize(2).WithArguments("blurg")); var factory = Container.Resolve <Foo.Factory>(); var foo = factory.Create("asdf"); Assert.IsEqual(foo.InitialData, "blurg"); var pool = foo.Pool; Assert.IsEqual(pool.NumActive, 1); Assert.IsEqual(pool.NumTotal, 2); Assert.IsEqual(pool.NumInactive, 1); Assert.IsEqual(foo.Data, "asdf"); foo.Dispose(); Assert.IsEqual(pool.NumActive, 0); Assert.IsEqual(pool.NumTotal, 2); Assert.IsEqual(pool.NumInactive, 2); Assert.IsEqual(foo.Data, null); }
public void TestInstallerSelfSingleMultipleContracts() { Container.Bind(typeof(Foo), typeof(Bar)).FromSubContainerResolve() .ByInstance(CreateFooSubContainer()).AsSingle().NonLazy(); Assert.IsEqual(Container.Resolve <Foo>().Bar, Container.Resolve <Bar>()); }
public void TestConcrete() { Container.BindFactory <string, IFoo, IFooFactory>() .To <Foo>().FromSubContainerResolve().ByInstaller <FooInstaller>().NonLazy(); Assert.IsEqual(Container.Resolve <IFooFactory>().Create("asdf").Value, "asdf"); }
public void TestConcrete() { Container.BindFactory <IFoo, IFooFactory>() .To <Foo>().FromSubContainerResolve().ByMethod(InstallFoo).NonLazy(); Assert.IsEqual(Container.Resolve <IFooFactory>().Create(), ConstFoo); }
public void TestDecoratorMethod() { SaveHandler.NumInstances = 0; SaveDecorator1.CallCount = 0; bool wasCalled = false; Container.Bind <ISaveHandler>().To <SaveHandler>().AsSingle(); Container.Decorate <ISaveHandler>() .With <SaveDecorator1>().FromMethod((x, h) => { wasCalled = true; return(new SaveDecorator1(h)); }); CallCounter = 1; Assert.That(!wasCalled); Assert.IsEqual(SaveHandler.NumInstances, 0); Assert.IsEqual(SaveDecorator1.CallCount, 0); Container.Resolve <ISaveHandler>().Save(); Assert.That(wasCalled); Assert.IsEqual(SaveHandler.NumInstances, 1); Assert.IsEqual(SaveDecorator1.CallCount, 1); }
public void Test1() { Container.Bind <IFoo>().To <Foo1>().AsSingle(); Container.Bind <IFoo>().To <Foo2>().AsSingle(); Assert.IsEqual(Container.ResolveAll <IFoo>().Count, 2); }
public void RunTest1() { Container.Bind <Test1>().AsSingle().NonLazy(); Container.Bind <int>().FromInstance(1).NonLazy(); Assert.IsEqual(Container.Resolve <Test1>().val, 1); }
public void TestCached2() { Container.Bind(typeof(Foo), typeof(IFoo)).To <Foo>().FromMethodMultiple(ctx => new[] { new Foo() }).AsSingle().NonLazy(); Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <Foo>()); Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <IFoo>()); }
public void TestInstallerSelfSingleMultipleMatches() { Container.Bind <Qux>().FromSubContainerResolveAll() .ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy(); Assert.IsEqual(Container.ResolveAll <Qux>().Count, 2); }
public void TestExplicitOrder() { Container.Bind <PoolableManager>().AsSingle(); Container.Bind <IPoolable>().To <Foo>().AsSingle(); Container.Bind <IPoolable>().To <Bar>().AsSingle(); Container.BindExecutionOrder <Foo>(2); Container.BindExecutionOrder <Bar>(1); var poolManager = Container.Resolve <PoolableManager>(); CallCount = 1; Foo.SpawnCallCount = 0; Foo.DespawnCallCount = 0; Bar.SpawnCallCount = 0; Bar.DespawnCallCount = 0; poolManager.TriggerOnSpawned(); Assert.IsEqual(Foo.SpawnCallCount, 2); Assert.IsEqual(Bar.SpawnCallCount, 1); Assert.IsEqual(Foo.DespawnCallCount, 0); Assert.IsEqual(Bar.DespawnCallCount, 0); poolManager.TriggerOnDespawned(); Assert.IsEqual(Foo.SpawnCallCount, 2); Assert.IsEqual(Bar.SpawnCallCount, 1); Assert.IsEqual(Foo.DespawnCallCount, 3); Assert.IsEqual(Bar.DespawnCallCount, 4); }
public void TestSelf() { Container.BindFactory <Foo, Foo.Factory>() .FromSubContainerResolve().ByInstaller <FooInstaller>().NonLazy(); Assert.IsEqual(Container.Resolve <Foo.Factory>().Create(), FooInstaller.Foo); }
public void TestInstallerSelfCachedMultipleContracts() { Container.Bind(typeof(Foo), typeof(IFoo)).To <Foo>().FromSubContainerResolve() .ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy(); Assert.IsEqual(Container.Resolve <Foo>(), Container.Resolve <IFoo>()); }
public void TestPrimitiveParamOptionalUsesExplicitDefault3() { Container.Bind <Test8_2>().AsSingle().NonLazy(); Container.BindInstance(2); Assert.IsEqual(Container.Resolve <Test8_2>().Val1, 2); }
public void TestCase2() { Test0 test0; Test1 test1; var subContainer = Container.CreateSubContainer(); var test0Local = new Test0(); subContainer.Bind <Test0>().FromInstance(test0Local); subContainer.Bind <Test1>().AsSingle(); test0 = subContainer.Resolve <Test0>(); Assert.IsEqual(test0Local, test0); test1 = subContainer.Resolve <Test1>(); Assert.Throws( delegate { Container.Resolve <Test0>(); }); Assert.Throws( delegate { Container.Resolve <Test1>(); }); Container.Bind <Test0>().AsSingle(); Container.Bind <Test1>().AsSingle(); Assert.That(Container.Resolve <Test0>() != test0); Assert.That(Container.Resolve <Test1>() != test1); }
public void TestSelf() { Container.BindFactory <string, Foo, Foo.Factory>() .FromSubContainerResolve().ByMethod(InstallFoo).NonLazy(); Assert.IsEqual(Container.Resolve <Foo.Factory>().Create("asdf").Value, "asdf"); }
public void Test2() { var foo = new Foo(); Container.BindMemoryPoolCustomInterface <Foo, Foo.Pool, Foo.IFooPool>().FromInstance(foo); Assert.IsEqual(Container.Resolve <Foo.IFooPool>().Spawn(), foo); }
public void TestCached() { var foo = new Foo(); Container.Bind <Foo>().FromMethodMultiple(ctx => new[] { foo }).AsSingle().NonLazy(); Assert.IsEqual(Container.Resolve <Foo>(), foo); }
public void Test1() { var foo = new Foo(); Container.BindFactoryCustomInterface <Foo, Foo.Factory, Foo.IFooFactory>().FromInstance(foo); Assert.IsEqual(Container.Resolve <Foo.IFooFactory>().Create(), foo); }
public void TestMultiple() { Container.Bind <Foo>().AsCached(); Container.Bind <Foo>().AsCached(); Container.Bind <Bar>().FromResolveAllGetter <Foo>(x => x.Bar).AsSingle(); Assert.IsEqual(Container.ResolveAll <Bar>().Count, 2); }
public void Test5() { Container.BindIFactory <string, int, char, long, double, IFooFive>().To <FooFive>(); var factory = Container.Resolve <IFactory <string, int, char, long, double, IFooFive> >(); Assert.IsEqual(factory.Create("asdf", 0, 'z', 2, 3.0).P1, "asdf"); }
public void Test2() { Container.BindIFactory <string, FooTwo>(); var factory = Container.Resolve <IFactory <string, FooTwo> >(); Assert.IsEqual(factory.Create("asdf").Value, "asdf"); }
public void TestTransient() { Container.Bind <Foo>().AsSingle(); Container.Bind <Bar>().FromResolveGetter <Foo>(x => x.Bar); Assert.IsNotNull(Container.Resolve <Bar>()); Assert.IsEqual(Container.Resolve <Bar>(), Container.Resolve <Foo>().Bar); }
public void TestSelf() { Container.Bind <Foo>().AsSingle().NonLazy(); Container.BindFactory <Bar, Bar.Factory>().FromResolveGetter <Foo>(x => x.Bar).NonLazy(); Assert.IsNotNull(Container.Resolve <Bar.Factory>().Create()); Assert.IsEqual(Container.Resolve <Bar.Factory>().Create(), Container.Resolve <Foo>().Bar); }
public void TestSelf() { var foo = new Foo(); Container.BindFactory <Foo, Foo.Factory>().FromInstance(foo).NonLazy(); Assert.IsEqual(Container.Resolve <Foo.Factory>().Create(), foo); }
public void TestCustomValidatable() { Container.BindInterfacesAndSelfTo <Loy>().AsSingle().NonLazy(); Container.ResolveRoots(); Assert.IsEqual(Container.Resolve <Loy>().CallCount, 1); }