public void TestAllInterfacesAndSelfMistake()
{
Container.BindInterfacesAndSelfTo <Foo>();
// Should require setting scope
Assert.Throws(() => Container.FlushBindings());
}
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 TestEnumIdentifiers2()
{
Container.Bind <Foo>().WithId(Things.Thing2).AsTransient();
Container.Bind <Test2>().AsTransient();
Assert.Throws(() => Container.Resolve <Test2>());
}
public void TestInstallerSelfIdentifiersFails()
{
Container.Bind <Gorp>().FromSubContainerResolve()
.ByInstance(CreateFooSubContainer()).AsSingle().NonLazy();
Assert.Throws(() => Container.Resolve <Gorp>());
}
public void TestSingle()
{
Container.Bind <Foo>().FromInstance(new Foo()).AsSingle().NonLazy();
Container.Bind <Foo>().AsSingle().NonLazy();
Assert.Throws(() => Container.FlushBindings());
}
public void TestUnspecifiedNameConstructorInjection()
{
Container.Bind <Test1>().AsTransient().NonLazy();
Container.Bind <Test0>().AsTransient().NonLazy();
Assert.Throws(
delegate { Container.Resolve <Test1>(); });
}
public void TestSingleFailure()
{
Container.Bind <Foo>().AsCached();
Container.Bind <Foo>().AsCached();
Container.Bind <Bar>().FromResolveGetter <Foo>(x => x.Bar).AsSingle();
Assert.Throws(() => Container.Resolve <Bar>());
}
public void Test2Error()
{
Container.BindIFactory <FooTwo>();
var factory = Container.Resolve <IFactory <FooTwo> >();
Assert.Throws(() => factory.Create());
}
public void TestThrows()
{
Container.Bind <Foo1>().AsSingle();
Container.Bind <Bar1>().AsSingle();
Assert.Throws(() => Container.Resolve <Foo1>());
Assert.Throws(() => Container.Resolve <Bar1>());
}
public void TestCase1()
{
Container.Bind <Test1>().AsSingle().NonLazy();
Container.Bind <Test0>().AsSingle().When(c => c.AllObjectTypes.Contains(typeof(Test2)));
Assert.Throws(
delegate { Container.Resolve <Test1>(); });
}
public void TestDuplicateBindingsFail()
{
Container.Bind <Foo>().AsSingle();
Container.Bind <Foo>().AsSingle();
Assert.Throws(
() => Container.FlushBindings());
}
public void TestChildDependencyOptional()
{
Container.Bind <Test6>().AsSingle().NonLazy();
Container.Bind <Test2>().AsSingle().NonLazy();
Assert.Throws(
delegate { Container.Resolve <Test6>(); });
}
public void TestValidationErrorThrows()
{
Container.Settings = new UniDiSettings(ValidationErrorResponses.Throw);
Container.Bind <Bar>().AsSingle().NonLazy();
Assert.Throws(() => Container.ResolveRoots());
}
public void TestFail2()
{
Container.Bind <ISaveHandler>().To <SaveHandler>().FromResolve(Guid.NewGuid()).AsSingle();
Container.Decorate <ISaveHandler>().With <SaveDecorator1>();
Container.Bind <Foo>().AsSingle().NonLazy();
Assert.Throws(() => Container.ResolveRoots());
}
public void TestSingleFailure()
{
Container.Bind <Foo>().AsCached();
Container.Bind <Foo>().AsCached();
Container.Bind <IFoo>().To <Foo>().FromResolve();
Assert.Throws(() => Container.Resolve <IFoo>());
}
public void TestSelfDependency()
{
if (Container.ChecksForCircularDependencies)
{
Container.Bind <Test7>().AsSingle();
Assert.Throws(() => Container.Instantiate <Test7>());
}
}
public void RunTest()
{
var pool = ArrayPool <string> .GetPool(2);
pool.Clear();
pool.ClearActiveCount();
Assert.IsEqual(pool.NumActive, 0);
Assert.IsEqual(pool.NumInactive, 0);
Assert.IsEqual(pool.NumTotal, 0);
var arr1 = pool.Spawn();
Assert.IsEqual(arr1.Length, 2);
arr1[0] = "asdf";
arr1[1] = "zbx";
Assert.IsEqual(pool.NumActive, 1);
Assert.IsEqual(pool.NumInactive, 0);
Assert.IsEqual(pool.NumTotal, 1);
pool.Despawn(arr1);
Assert.IsEqual(pool.NumActive, 0);
Assert.IsEqual(pool.NumInactive, 1);
Assert.IsEqual(pool.NumTotal, 1);
var arr2 = pool.Spawn();
Assert.IsEqual(arr2.Length, 2);
Assert.IsNull(arr2[0]);
Assert.IsNull(arr2[1]);
Assert.IsEqual(arr2.Length, 2);
Assert.IsEqual(arr2, arr1);
Assert.IsEqual(pool.NumActive, 1);
Assert.IsEqual(pool.NumInactive, 0);
Assert.IsEqual(pool.NumTotal, 1);
var arr3 = pool.Spawn();
Assert.IsNotEqual(arr2, arr3);
Assert.IsEqual(pool.NumActive, 2);
Assert.IsEqual(pool.NumInactive, 0);
Assert.IsEqual(pool.NumTotal, 2);
pool.Despawn(arr3);
pool.Despawn(arr2);
Assert.IsEqual(pool.NumActive, 0);
Assert.IsEqual(pool.NumInactive, 2);
Assert.IsEqual(pool.NumTotal, 2);
Assert.Throws(() => pool.Despawn(arr3));
}
public void TestOutsideObjectGraph2()
{
Container.Settings = new UniDiSettings(
ValidationErrorResponses.Throw, RootResolveMethods.All);
Container.Bind <Bar>().AsSingle();
Assert.Throws(() => Container.ResolveRoots());
}
public void TestBasic3()
{
Container.Bind <Test0>().WithId("foo").FromMethod(ctx => new Test0()).NonLazy();
Assert.Throws(
delegate { Container.Resolve <Test0>(); });
Container.ResolveId <Test0>("foo");
}
public void TestMultiBind2()
{
// Multi-binds should not map to single-binds
Container.Bind <Test0>().To <Test3>().AsSingle().NonLazy();
Container.Bind <Test0>().To <Test4>().AsSingle().NonLazy();
Container.Bind <Test2>().AsSingle().NonLazy();
Assert.Throws(() => Container.Resolve <Test2>());
}
public void TestParent3()
{
var rootContainer = new DiContainer();
rootContainer.Bind <Test0>().AsSingle();
rootContainer.Bind <Test2>().AsSingle();
Assert.Throws(() => rootContainer.Resolve <Test2>());
}
public void TestOptional3()
{
Container.Bind <Gorp>().AsSingle();
var gorp = Container.Resolve <Gorp>();
object temp;
Assert.Throws(() => temp = gorp.Bar.Value);
}
public void TestBasic2()
{
Container.Bind <Test0>().WithId("foo").AsSingle().NonLazy();
Assert.Throws(
delegate { Container.Resolve <Test0>(); });
Container.ResolveId <Test0>("foo");
}
public void TestCaseDuplicateInjection()
{
Container.Bind <Test0>().AsCached();
Container.Bind <Test0>().AsCached();
Container.Bind <Test1>().AsSingle();
Assert.Throws(
delegate { Container.Resolve <Test1>(); });
}
public void TestLocal1()
{
var rootContainer = new DiContainer();
var sub1 = rootContainer.CreateSubContainer();
rootContainer.Bind <Test0>().AsSingle();
sub1.Bind <Test1>().AsSingle();
Assert.Throws(() => sub1.Resolve <Test1>());
}
public void TestParent2()
{
var rootContainer = new DiContainer();
var sub1 = rootContainer.CreateSubContainer();
var sub2 = sub1.CreateSubContainer();
rootContainer.Bind <Test0>().AsSingle();
sub2.Bind <Test2>().AsSingle();
Assert.Throws(() => sub2.Resolve <Test2>());
}
public void TestConstructorInject()
{
if (Container.ChecksForCircularDependencies)
{
Container.Bind <Test5>().AsSingle().NonLazy();
Container.Bind <Test6>().AsSingle().NonLazy();
Assert.Throws(() => Container.Resolve <Test5>());
Assert.Throws(() => Container.Resolve <Test6>());
}
}
public void TestFailure()
{
var container = new DiContainer(true);
container.Settings = new UniDiSettings(
ValidationErrorResponses.Throw, RootResolveMethods.All);
container.BindFactory <Foo, Foo.Factory>().FromPoolableMemoryPool(x => x.WithInitialSize(2));
Assert.Throws(() => container.ResolveRoots());
}
public void TestSubContainerMethodFailure()
{
Container.Bind <Qux>().FromSubContainerResolve().ByMethod(
container =>
{
container.Bind <Qux>().AsSingle();
container.Bind <Bar>().AsSingle();
})
.AsSingle();
Assert.Throws(() => Container.ResolveRoots());
}
public void TestIsRemoved()
{
var subContainer = Container.CreateSubContainer();
var test1 = new Test0();
subContainer.Bind <Test0>().FromInstance(test1);
Assert.That(ReferenceEquals(test1, subContainer.Resolve <Test0>()));
Assert.Throws(
delegate { Container.Resolve <Test0>(); });
}
