public void TestSelfDependency()
{
if (Container.ChecksForCircularDependencies)
{
Container.Bind <Test7>().AsSingle();
Assert.Throws(() => Container.Instantiate <Test7>());
}
}
public void TestExpandManually()
{
Container.BindMemoryPool <Foo, Foo.Pool>();
var factory = Container.Resolve <Foo.Pool>();
Assert.IsEqual(factory.NumActive, 0);
Assert.IsEqual(factory.NumTotal, 0);
Assert.IsEqual(factory.NumInactive, 0);
factory.ExpandPoolBy(2);
Assert.IsEqual(factory.NumActive, 0);
Assert.IsEqual(factory.NumTotal, 2);
Assert.IsEqual(factory.NumInactive, 2);
var foo = factory.Spawn();
Assert.IsEqual(factory.NumActive, 1);
Assert.IsEqual(factory.NumTotal, 2);
Assert.IsEqual(factory.NumInactive, 1);
factory.ExpandPoolBy(3);
Assert.IsEqual(factory.NumActive, 1);
Assert.IsEqual(factory.NumTotal, 5);
Assert.IsEqual(factory.NumInactive, 4);
var foo2 = factory.Spawn();
Assert.IsEqual(factory.NumActive, 2);
Assert.IsEqual(factory.NumTotal, 5);
Assert.IsEqual(factory.NumInactive, 3);
var foo3 = factory.Spawn();
Assert.IsEqual(factory.NumActive, 3);
Assert.IsEqual(factory.NumTotal, 5);
Assert.IsEqual(factory.NumInactive, 2);
factory.ExpandPoolBy(1);
Assert.IsEqual(factory.NumActive, 3);
Assert.IsEqual(factory.NumTotal, 6);
Assert.IsEqual(factory.NumInactive, 3);
factory.Despawn(foo2);
Assert.IsEqual(factory.NumActive, 2);
Assert.IsEqual(factory.NumTotal, 6);
Assert.IsEqual(factory.NumInactive, 4);
var foo4 = factory.Spawn();
Assert.IsEqual(factory.NumActive, 3);
Assert.IsEqual(factory.NumTotal, 6);
Assert.IsEqual(factory.NumInactive, 3);
}
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 TestConcrete()
{
Container.BindFactory <string, int, string, float, int, IFoo, IFooFactory>().To <Foo>().NonLazy();
var ifoo = Container.Resolve <IFooFactory>().Create("asdf", 2, "a", 4.2f, 6);
Assert.IsNotNull(ifoo);
Assert.IsEqual(((Foo)ifoo).P1, "asdf");
}
public void TestOutsideObjectGraph2()
{
Container.Settings = new ZenjectSettings(
ValidationErrorResponses.Throw, RootResolveMethods.All);
Container.Bind <Bar>().AsSingle();
Assert.Throws(() => Container.ResolveRoots());
}
public void TestMethodSelfSingle()
{
Container.Bind <Foo>().FromSubContainerResolve().ByMethod(InstallFooFacade).AsSingle().NonLazy();
var foo = Container.Resolve <Foo>();
Assert.IsNotNull(foo.Bar);
Assert.IsEqual(foo, Container.Resolve <Foo>());
}
public void TestSuccessFieldInjectionEnum()
{
Container.Bind <Test4>().AsTransient().NonLazy();
Container.Bind <Test0>().FromInstance(new Test0()).NonLazy();
Container.Bind <Test0>().WithId("TestValue3").FromInstance(new Test0()).NonLazy();
Assert.IsNotNull(Container.Resolve <Test4>());
}
public IEnumerator Hides_After_Duration()
{
yield return(Shows_After_Duration());
_popup.Hide(null);
yield return(new WaitForSeconds(Duration));
Assert.IsEqual(Vector3.zero, _popup.transform.localScale);
}
public void TestInjectConstructorOfStruct()
{
Container.BindInstance("asdf");
Container.Bind <Test4>().AsSingle();
var test4 = Container.Instantiate <Test4>();
Assert.IsEqual(test4.Value, "asdf");
}
public void TestResolveManyTransient()
{
Container.Bind <Foo>().AsTransient();
Container.Bind <Foo>().FromInstance(new Foo());
Container.Bind <IFoo>().To <Foo>().FromResolveAll();
Assert.IsEqual(Container.ResolveAll <IFoo>().Count, 2);
}
public void TestCase6()
{
Container.Bind <ITest1>().To <Test2>().AsSingle().NonLazy();
Container.Bind <Test0>().AsSingle().When(c => c.AllObjectTypes.Where(x => typeof(ITest1).IsAssignableFrom(x)).Any());
var test1 = Container.Resolve <ITest1>();
Assert.That(test1 != null);
}
public void TestBindAllInterfacesSimple()
{
var container = new DiContainer();
container.Bind(x => x.AllInterfaces()).To <Foo>().AsTransient();
Assert.That(container.Resolve <IFoo>() is Foo);
Assert.That(container.Resolve <IBar>() is Foo);
}
public void TestParent3()
{
var rootContainer = new DiContainer();
rootContainer.Bind <Test0>().AsSingle();
rootContainer.Bind <Test2>().AsSingle();
Assert.Throws(() => rootContainer.Resolve <Test2>());
}
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 TestBasic2()
{
Container.Bind <Test0>().WithId("foo").AsSingle().NonLazy();
Assert.Throws(
delegate { Container.Resolve <Test0>(); });
Container.ResolveId <Test0>("foo");
}
public void TestConcrete()
{
Container.BindFactory <string, IFoo, IFooFactory>().To <Foo>().NonLazy();
var ifoo = Container.Resolve <IFooFactory>().Create("asdf");
Assert.IsNotNull(ifoo);
Assert.IsEqual(((Foo)ifoo).Value, "asdf");
}
public void TestCase2()
{
Container.Bind <Test1>().AsSingle().NonLazy();
Container.Bind <Test0>().AsSingle().When(c => c.AllObjectTypes.Contains(typeof(Test1)));
var test1 = Container.Resolve <Test1>();
Assert.That(test1 != null);
}
public void TestCaseBaseClassPropertyInjection()
{
Container.Bind <Test0>().AsSingle().NonLazy();
Container.Bind <Test2>().AsSingle().NonLazy();
var test1 = Container.Resolve <Test2>();
Assert.That(test1.GetVal() != null);
}
public void TestCase1()
{
Container.Bind <Test0>().To <Test1>().AsSingle();
Container.Bind <Test0>().To <Test2>().AsSingle();
List <Test0> many = Container.ResolveAll <Test0>();
Assert.That(many.Count == 2);
}
public void TestMultipleChooseLeastArguments()
{
Container.Bind <Bar>().AsSingle().NonLazy();
Container.Bind <Gorp>().AsSingle().NonLazy();
var gorp = Container.Resolve <Gorp>();
Assert.IsEqual(gorp.ChosenConstructor, 1);
}
public void TestOptional3()
{
Container.Bind <Gorp>().AsSingle();
var gorp = Container.Resolve <Gorp>();
object temp;
Assert.Throws(() => temp = gorp.Bar.Value);
}
public void TestIsDeclared1()
{
Container.DeclareSignal <FooSignal>();
Container.ResolveRoots();
var signalBus = Container.Resolve <SignalBus>();
Assert.That(signalBus.IsSignalDeclared <FooSignal>());
}
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 TestAllInterfaces()
{
Container.BindInterfacesTo <Foo>().AsSingle().NonLazy();
Assert.IsNull(Container.TryResolve <Foo>());
Assert.IsNotNull(Container.Resolve <IFoo>());
Assert.IsNotNull(Container.Resolve <IQux>());
}
public void TestNullValues()
{
Container.Bind <Foo>().AsSingle().WithArguments(3, (string)null);
var foo = Container.Resolve <Foo>();
Assert.IsEqual(foo.Value, 3);
Assert.IsEqual(foo.Value2, null);
}
public void TestInstallerSelfSingle()
{
Container.Bind <Foo>().FromSubContainerResolve().ByInstaller <FooInstaller>().AsSingle().NonLazy();
var foo = Container.Resolve <Foo>();
Assert.IsNotNull(foo.Bar);
Assert.IsEqual(foo, Container.Resolve <Foo>());
}
public void Run()
{
var foo = _fooFactory.Create();
foo.DoSomething();
var result = foo.GetTest();
Assert.IsNull(result);
}
public void TestSingle5()
{
// This is weird but consistent with how AsSingle is interpreted for other From types
// like FromSubcontainerResolve, FromComponentInPrefab, etc.
// The 'single' is really refering to the fact that it's a single resolve handler, not a
// single instance
Container.Bind <Foo>().FromMethodMultipleUntyped(ctx => new[] { new Foo(), new Foo() }).AsSingle().NonLazy();
Assert.IsEqual(Container.ResolveAll <Foo>().Count, 2);
}
public void Run()
{
Container.Bind <ITest>().To <Test2>().AsSingle();
Assert.IsNotNull(Container.Resolve <ITest>());
Container.Unbind <ITest>();
Assert.IsNull(Container.TryResolve <ITest>());
}
public void TestInitialSize()
{
Container.BindMemoryPool <Foo, Foo.Pool>().WithInitialSize(5);
var factory = Container.Resolve <Foo.Pool>();
Assert.IsEqual(factory.NumActive, 0);
Assert.IsEqual(factory.NumTotal, 5);
Assert.IsEqual(factory.NumInactive, 5);
}
