Update Project

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Injection/TestPostInjectCall.cs

@@ -0,0 +1,193 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestPostInjectCall : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        class Test1
+        {
+        }
+
+        class Test2
+        {
+        }
+
+        class Test3
+        {
+            public bool HasInitialized;
+            public bool HasInitialized2;
+
+            [Inject]
+            public Test1 test1 = null;
+
+            [Inject]
+            public Test0 test0 = null;
+
+            Test2 _test2;
+
+            public Test3(Test2 test2)
+            {
+                _test2 = test2;
+            }
+
+            [Inject]
+            public void Init()
+            {
+                Assert.That(!HasInitialized);
+                Assert.IsNotNull(test1);
+                Assert.IsNotNull(test0);
+                Assert.IsNotNull(_test2);
+                HasInitialized = true;
+            }
+
+            [Inject]
+            void TestPrivatePostInject()
+            {
+                HasInitialized2 = true;
+            }
+        }
+
+        [Test]
+        public void Test()
+        {
+            Container.Bind<Test0>().AsSingle().NonLazy();
+            Container.Bind<Test1>().AsSingle().NonLazy();
+            Container.Bind<Test2>().AsSingle().NonLazy();
+            Container.Bind<Test3>().AsSingle().NonLazy();
+
+            var test3 = Container.Resolve<Test3>();
+            Assert.That(test3.HasInitialized);
+            Assert.That(test3.HasInitialized2);
+        }
+
+        public class SimpleBase
+        {
+            public bool WasCalled;
+
+            [Inject]
+            void Init()
+            {
+                WasCalled = true;
+            }
+        }
+
+        public class SimpleDerived : SimpleBase
+        {
+        }
+
+        [Test]
+        public void TestPrivateBaseClassPostInject()
+        {
+            Container.Bind<SimpleBase>().To<SimpleDerived>().AsSingle().NonLazy();
+
+            var simple = Container.Resolve<SimpleBase>();
+
+            Assert.That(simple.WasCalled);
+        }
+
+        [Test]
+        public void TestInheritance()
+        {
+            Container.Bind<IFoo>().To<FooDerived>().AsSingle().NonLazy();
+
+            var foo = Container.Resolve<IFoo>();
+
+            Assert.That(((FooDerived)foo).WasDerivedCalled);
+            Assert.That(((FooBase)foo).WasBaseCalled);
+            Assert.That(((FooDerived)foo).WasDerivedCalled2);
+            Assert.That(((FooBase)foo).WasBaseCalled2);
+        }
+
+        [Test]
+        public void TestInheritanceOrder()
+        {
+            Container.Bind<IFoo>().To<FooDerived2>().AsSingle().NonLazy();
+
+            // base post inject methods should be called first
+            _initOrder = 0;
+            FooBase.BaseCallOrder = 0;
+            FooDerived.DerivedCallOrder = 0;
+            FooDerived2.Derived2CallOrder = 0;
+
+            Container.Resolve<IFoo>();
+
+            //Log.Info("FooBase.BaseCallOrder = {0}".Fmt(FooBase.BaseCallOrder));
+            //Log.Info("FooDerived.DerivedCallOrder = {0}".Fmt(FooDerived.DerivedCallOrder));
+
+            Assert.IsEqual(FooBase.BaseCallOrder, 0);
+            Assert.IsEqual(FooDerived.DerivedCallOrder, 1);
+            Assert.IsEqual(FooDerived2.Derived2CallOrder, 2);
+        }
+
+        static int _initOrder;
+
+        interface IFoo
+        {
+        }
+
+        class FooBase : IFoo
+        {
+            public bool WasBaseCalled;
+            public bool WasBaseCalled2;
+            public static int BaseCallOrder;
+
+            [Inject]
+            void TestBase()
+            {
+                Assert.That(!WasBaseCalled);
+                WasBaseCalled = true;
+                BaseCallOrder = _initOrder++;
+            }
+
+            [Inject]
+            public virtual void TestVirtual1()
+            {
+                Assert.That(!WasBaseCalled2);
+                WasBaseCalled2 = true;
+            }
+        }
+
+        class FooDerived : FooBase
+        {
+            public bool WasDerivedCalled;
+            public bool WasDerivedCalled2;
+            public static int DerivedCallOrder;
+
+            [Inject]
+            void TestDerived()
+            {
+                Assert.That(!WasDerivedCalled);
+                WasDerivedCalled = true;
+                DerivedCallOrder = _initOrder++;
+            }
+
+            public override void TestVirtual1()
+            {
+                base.TestVirtual1();
+                Assert.That(!WasDerivedCalled2);
+                WasDerivedCalled2 = true;
+            }
+        }
+
+        class FooDerived2 : FooDerived
+        {
+            public bool WasDerived2Called;
+            public static int Derived2CallOrder;
+
+            [Inject]
+            public void TestVirtual2()
+            {
+                Assert.That(!WasDerived2Called);
+                WasDerived2Called = true;
+                Derived2CallOrder = _initOrder++;
+            }
+        }
+    }
+}
+