Initial Commit

2026-03-16 14:38:46 +02:00
commit b8f7327a21
2327 changed files with 253610 additions and 0 deletions
@@ -0,0 +1,321 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestAllInjectionTypes : ZenjectUnitTestFixture
+    {
+        static int InjectCounter;
+
+        [Test]
+        // Test all variations of injection
+        public void TestCase1()
+        {
+            Container.Bind<Test0>().FromInstance(new Test0()).NonLazy();
+            Container.Bind<IFoo>().To<FooDerived>().AsSingle().NonLazy();
+
+            InjectCounter = 1;
+
+            var foo = Container.Resolve<IFoo>();
+
+            Assert.That(foo.DidPostInjectBase);
+            Assert.That(foo.DidPostInjectDerived);
+
+            Assert.IsEqual(foo.BaseTypePropertyInjectCount, 1);
+            Assert.IsEqual(foo.DerivedTypePropertyInjectCount, 2);
+
+            Assert.IsEqual(foo.BaseTypeMethodInjectCount, 3);
+            Assert.IsEqual(foo.DerivedTypeMethodInjectCount, 4);
+        }
+
+        class Test0
+        {
+        }
+
+        interface IFoo
+        {
+            bool DidPostInjectBase
+            {
+                get;
+            }
+
+            bool DidPostInjectDerived
+            {
+                get;
+            }
+
+            int BaseTypePropertyInjectCount
+            {
+                get;
+            }
+
+            int DerivedTypePropertyInjectCount
+            {
+                get;
+            }
+
+            int BaseTypeMethodInjectCount
+            {
+                get;
+            }
+
+            int DerivedTypeMethodInjectCount
+            {
+                get;
+            }
+        }
+
+        abstract class FooBase : IFoo
+        {
+            bool _didPostInjectBase;
+
+            [Inject]
+            public static Test0 BaseStaticFieldPublic = null;
+
+            [Inject]
+            static Test0 BaseStaticFieldPrivate = null;
+
+            [Inject]
+            protected static Test0 BaseStaticFieldProtected = null;
+
+            [Inject]
+            public static Test0 BaseStaticPropertyPublic
+            {
+                get;
+                set;
+            }
+
+            [Inject]
+            static Test0 BaseStaticPropertyPrivate
+            {
+                get;
+                set;
+            }
+
+            [Inject]
+            protected static Test0 BaseStaticPropertyProtected
+            {
+                get;
+                set;
+            }
+
+            // Instance
+            [Inject]
+            public Test0 BaseFieldPublic = null;
+
+            [Inject]
+            Test0 BaseFieldPrivate = null;
+
+            [Inject]
+            protected readonly Test0 BaseFieldProtected = null;
+
+            Test0 _basePropertyPublicValue = null;
+
+            [Inject]
+            public Test0 BasePropertyPublic
+            {
+                get { return _basePropertyPublicValue; }
+                set
+                {
+                    BaseTypePropertyInjectCount = InjectCounter++;
+                    _basePropertyPublicValue = value;
+                }
+            }
+
+            [Inject]
+            Test0 BasePropertyPrivate
+            {
+                get;
+                set;
+            }
+
+            [Inject]
+            protected Test0 BasePropertyProtected
+            {
+                get;
+                set;
+            }
+
+            [Inject]
+            public void PostInjectBase()
+            {
+                Assert.IsNull(BaseStaticFieldPublic);
+                Assert.IsNull(BaseStaticFieldPrivate);
+                Assert.IsNull(BaseStaticFieldProtected);
+                Assert.IsNull(BaseStaticPropertyPublic);
+                Assert.IsNull(BaseStaticPropertyPrivate);
+                Assert.IsNull(BaseStaticPropertyProtected);
+
+                Assert.IsNotNull(BaseFieldPublic);
+                Assert.IsNotNull(BaseFieldPrivate);
+                Assert.IsNotNull(BaseFieldProtected);
+                Assert.IsNotNull(BasePropertyPublic);
+                Assert.IsNotNull(BasePropertyPrivate);
+                Assert.IsNotNull(BasePropertyProtected);
+
+                BaseTypeMethodInjectCount = InjectCounter++;
+
+                _didPostInjectBase = true;
+            }
+
+            public bool DidPostInjectBase
+            {
+                get
+                {
+                    return _didPostInjectBase;
+                }
+            }
+
+            public abstract bool DidPostInjectDerived
+            {
+                get;
+            }
+
+            public int BaseTypePropertyInjectCount
+            {
+                get; set;
+            }
+
+            public int BaseTypeMethodInjectCount
+            {
+                get; set;
+            }
+
+            public abstract int DerivedTypeMethodInjectCount
+            {
+                get;
+            }
+
+            public abstract int DerivedTypePropertyInjectCount
+            {
+                get;
+            }
+        }
+
+        class FooDerived : FooBase
+        {
+            public bool _didPostInject;
+            public Test0 ConstructorParam;
+
+            public override bool DidPostInjectDerived
+            {
+                get
+                {
+                    return _didPostInject;
+                }
+            }
+
+            [Inject]
+            public static Test0 DerivedStaticFieldPublic = null;
+
+            [Inject]
+            static Test0 DerivedStaticFieldPrivate = null;
+
+            [Inject]
+            protected static Test0 DerivedStaticFieldProtected = null;
+
+            [Inject]
+            public static Test0 DerivedStaticPropertyPublic
+            {
+                get;
+                set;
+            }
+
+            [Inject]
+            static Test0 DerivedStaticPropertyPrivate
+            {
+                get;
+                set;
+            }
+
+            [Inject]
+            protected static Test0 DerivedStaticPropertyProtected
+            {
+                get;
+                set;
+            }
+
+            // Instance
+            public FooDerived(Test0 param)
+            {
+                ConstructorParam = param;
+            }
+
+            [Inject]
+            public void PostInject()
+            {
+                Assert.IsNull(DerivedStaticFieldPublic);
+                Assert.IsNull(DerivedStaticFieldPrivate);
+                Assert.IsNull(DerivedStaticFieldProtected);
+                Assert.IsNull(DerivedStaticPropertyPublic);
+                Assert.IsNull(DerivedStaticPropertyPrivate);
+                Assert.IsNull(DerivedStaticPropertyProtected);
+
+                Assert.IsNotNull(DerivedFieldPublic);
+                Assert.IsNotNull(DerivedFieldPrivate);
+                Assert.IsNotNull(DerivedFieldProtected);
+                Assert.IsNotNull(DerivedPropertyPublic);
+                Assert.IsNotNull(DerivedPropertyPrivate);
+                Assert.IsNotNull(DerivedPropertyProtected);
+                Assert.IsNotNull(ConstructorParam);
+
+                _derivedTypeMethodInjectCount = InjectCounter++;
+
+                _didPostInject = true;
+            }
+
+            [Inject]
+            public Test0 DerivedFieldPublic = null;
+
+            [Inject]
+            Test0 DerivedFieldPrivate = null;
+
+            [Inject]
+            protected Test0 DerivedFieldProtected = null;
+
+            Test0 _derivedPropertyPublicValue;
+
+            [Inject]
+            public Test0 DerivedPropertyPublic
+            {
+                get { return _derivedPropertyPublicValue; }
+                set
+                {
+                    _derivedTypePropertyInjectCount = InjectCounter++;
+                    _derivedPropertyPublicValue = value;
+                }
+            }
+
+            [Inject]
+            Test0 DerivedPropertyPrivate
+            {
+                get;
+                set;
+            }
+
+            [Inject]
+            protected Test0 DerivedPropertyProtected
+            {
+                get;
+                set;
+            }
+
+            int _derivedTypeMethodInjectCount;
+
+            public override int DerivedTypeMethodInjectCount
+            {
+                get { return _derivedTypeMethodInjectCount; }
+            }
+
+            int _derivedTypePropertyInjectCount;
+
+            public override int DerivedTypePropertyInjectCount
+            {
+                get { return _derivedTypePropertyInjectCount; }
+            }
+        }
+    }
+}
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9fe16f0cbfec7754e85378cb23b97b89
+timeCreated: 1461708052
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,44 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestBaseClassPropertyInjection : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        class Test3
+        {
+        }
+
+        class Test1 : Test3
+        {
+            [Inject] protected Test0 val = null;
+
+            public Test0 GetVal()
+            {
+                return val;
+            }
+        }
+
+        class Test2 : Test1
+        {
+        }
+
+        [Test]
+        public void TestCaseBaseClassPropertyInjection()
+        {
+            Container.Bind<Test0>().AsSingle().NonLazy();
+            Container.Bind<Test2>().AsSingle().NonLazy();
+
+            var test1 = Container.Resolve<Test2>();
+
+            Assert.That(test1.GetVal() != null);
+        }
+    }
+}
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 444583e94b8faf74c823354f8352eb23
+timeCreated: 1461708050
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,155 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestCircularDependencies : ZenjectUnitTestFixture
+    {
+        class Test1
+        {
+            public static int CreateCount;
+
+            [Inject]
+            public Test2 Other = null;
+
+            public Test1()
+            {
+                CreateCount++;
+            }
+        }
+
+        class Test2
+        {
+            public static int CreateCount;
+
+            [Inject]
+            public Test1 Other = null;
+
+            public Test2()
+            {
+                CreateCount++;
+            }
+        }
+
+        [Test]
+        public void TestFields()
+        {
+            Test2.CreateCount = 0;
+            Test1.CreateCount = 0;
+
+            Container.Bind<Test1>().AsSingle();
+            Container.Bind<Test2>().AsSingle();
+
+            var test1 = Container.Resolve<Test1>();
+            var test2 = Container.Resolve<Test2>();
+
+            Assert.IsEqual(Test2.CreateCount, 1);
+            Assert.IsEqual(Test1.CreateCount, 1);
+            Assert.IsEqual(test1.Other, test2);
+            Assert.IsEqual(test2.Other, test1);
+        }
+
+        class Test3
+        {
+            public static int CreateCount;
+
+            public Test4 Other;
+
+            public Test3()
+            {
+                CreateCount++;
+            }
+
+            [Inject]
+            public void Initialize(Test4 other)
+            {
+                Other = other;
+            }
+        }
+
+        class Test4
+        {
+            public static int CreateCount;
+
+            public Test3 Other;
+
+            public Test4()
+            {
+                CreateCount++;
+            }
+
+            [Inject]
+            public void Initialize(Test3 other)
+            {
+                Other = other;
+            }
+        }
+
+        [Test]
+        public void TestPostInject()
+        {
+            Test4.CreateCount = 0;
+            Test3.CreateCount = 0;
+
+            Container.Bind<Test3>().AsSingle();
+            Container.Bind<Test4>().AsSingle();
+
+            var test1 = Container.Resolve<Test3>();
+            var test2 = Container.Resolve<Test4>();
+
+            Assert.IsEqual(Test4.CreateCount, 1);
+            Assert.IsEqual(Test3.CreateCount, 1);
+            Assert.IsEqual(test1.Other, test2);
+            Assert.IsEqual(test2.Other, test1);
+        }
+
+        class Test5
+        {
+            public Test5(Test6 Other)
+            {
+                Assert.IsNotNull(Other);
+            }
+        }
+
+        class Test6
+        {
+            public Test6(Test5 other)
+            {
+                Assert.IsNotNull(other);
+            }
+        }
+
+        [Test]
+        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>());
+            }
+        }
+
+        class Test7
+        {
+            public Test7(Test7 other)
+            {
+            }
+        }
+
+        [Test]
+        public void TestSelfDependency()
+        {
+            if (Container.ChecksForCircularDependencies)
+            {
+                Container.Bind<Test7>().AsSingle();
+                Assert.Throws(() => Container.Instantiate<Test7>());
+            }
+        }
+    }
+}
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d00c81151702f6b4fa1d0400acf83a51
+timeCreated: 1461708053
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,99 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestConstructorInjection : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestResolve()
+        {
+            Container.Bind<Foo>().AsSingle().NonLazy();
+            Container.Bind<Bar>().AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestInstantiate()
+        {
+            Container.Bind<Foo>().AsSingle();
+            Assert.IsNotNull(Container.Instantiate<Foo>(new object[] { new Bar() }));
+        }
+
+        [Test]
+        public void TestMultipleWithOneTagged()
+        {
+            Container.Bind<Bar>().AsSingle().NonLazy();
+            Container.Bind<Qux>().AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Qux>());
+        }
+
+        [Test]
+        public void TestMultipleChooseLeastArguments()
+        {
+            Container.Bind<Bar>().AsSingle().NonLazy();
+            Container.Bind<Gorp>().AsSingle().NonLazy();
+
+            var gorp = Container.Resolve<Gorp>();
+
+            Assert.IsEqual(gorp.ChosenConstructor, 1);
+        }
+
+        class Bar
+        {
+        }
+
+        class Foo
+        {
+            public Foo(Bar bar)
+            {
+                Bar = bar;
+            }
+
+            public Bar Bar
+            {
+                get; private set;
+            }
+        }
+
+        class Qux
+        {
+            public Qux()
+            {
+            }
+
+            [Inject]
+            public Qux(Bar val)
+            {
+            }
+        }
+
+        class Gorp
+        {
+            public Gorp()
+            {
+                ChosenConstructor = 1;
+            }
+
+            public Gorp(Bar val)
+            {
+                ChosenConstructor = 2;
+            }
+
+            public Gorp(string p1, int p2)
+            {
+                ChosenConstructor = 3;
+            }
+
+            public int ChosenConstructor
+            {
+                get; private set;
+            }
+        }
+    }
+}
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6c6aad7bc2fa9c0428a8cc8b7670445d
+timeCreated: 1461708051
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,63 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestConstructorInjectionOptional : ZenjectUnitTestFixture
+    {
+        class Test1
+        {
+        }
+
+        class Test2
+        {
+            public Test1 val;
+
+            public Test2(Test1 val = null)
+            {
+                this.val = val;
+            }
+        }
+
+        class Test3
+        {
+            public Test1 val;
+
+            public Test3(Test1 val)
+            {
+                this.val = val;
+            }
+        }
+
+        [Test]
+        public void TestCase1()
+        {
+            Container.Bind<Test2>().AsSingle().NonLazy();
+
+            var test1 = Container.Resolve<Test2>();
+
+            Assert.That(test1.val == null);
+        }
+
+        [Test]
+        public void TestCase2()
+        {
+            Container.Bind<Test3>().AsSingle();
+
+            Assert.Throws(() => Container.Instantiate<Test3>());
+        }
+
+        [Test]
+        public void TestConstructByFactory()
+        {
+            Container.Bind<Test2>().AsSingle();
+
+            var test1 = Container.Instantiate<Test2>();
+
+            Assert.That(test1.val == null);
+        }
+    }
+}
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ccdd61e6305aade43b64f0c488a7f126
+timeCreated: 1461708053
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,34 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestDuplicateInjection : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        class Test1
+        {
+            public Test1(Test0 test1)
+            {
+            }
+        }
+
+        [Test]
+        public void TestCaseDuplicateInjection()
+        {
+            Container.Bind<Test0>().AsCached();
+            Container.Bind<Test0>().AsCached();
+
+            Container.Bind<Test1>().AsSingle();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test1>(); });
+        }
+    }
+}
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 68ac954686ff2e04699f2ceefd89a402
+timeCreated: 1461708051
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,149 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestInjectSources
+    {
+        class Test0
+        {
+        }
+
+        class Test1
+        {
+            public Test0 val;
+
+            public Test1(
+                [InjectLocal]
+                Test0 val)
+            {
+                this.val = val;
+            }
+        }
+
+        class Test2
+        {
+            public Test0 val;
+
+            public Test2(
+                [Inject(Source = InjectSources.Parent)]
+                Test0 val)
+            {
+                this.val = val;
+            }
+        }
+
+        class Test3
+        {
+            public Test0 val;
+
+            public Test3(
+                [Inject(Source = InjectSources.AnyParent)]
+                Test0 val)
+            {
+                this.val = val;
+            }
+        }
+
+        class Test4
+        {
+            public Test0 val;
+
+            public Test4(
+                [Inject(Source = InjectSources.Any)]
+                Test0 val)
+            {
+                this.val = val;
+            }
+        }
+
+        [Test]
+        public void TestAny()
+        {
+            var rootContainer = new DiContainer();
+            var sub1 = rootContainer.CreateSubContainer();
+
+            rootContainer.Bind<Test0>().AsSingle();
+            sub1.Bind<Test4>().AsSingle();
+
+            Assert.IsNotNull(sub1.Resolve<Test4>());
+        }
+
+        [Test]
+        public void TestLocal1()
+        {
+            var rootContainer = new DiContainer();
+            var sub1 = rootContainer.CreateSubContainer();
+
+            rootContainer.Bind<Test0>().AsSingle();
+            sub1.Bind<Test1>().AsSingle();
+
+            Assert.Throws(() => sub1.Resolve<Test1>());
+        }
+
+        [Test]
+        public void TestLocal2()
+        {
+            var rootContainer = new DiContainer();
+            var sub1 = rootContainer.CreateSubContainer();
+
+            sub1.Bind<Test0>().AsSingle();
+            sub1.Bind<Test1>().AsSingle();
+
+            Assert.IsNotNull(sub1.Resolve<Test1>());
+        }
+
+        [Test]
+        public void TestParent1()
+        {
+            var rootContainer = new DiContainer();
+            var sub1 = rootContainer.CreateSubContainer();
+
+            rootContainer.Bind<Test0>().AsSingle();
+            sub1.Bind<Test2>().AsSingle();
+
+            Assert.IsNotNull(sub1.Resolve<Test2>());
+        }
+
+        [Test]
+        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>());
+        }
+
+        [Test]
+        public void TestParent3()
+        {
+            var rootContainer = new DiContainer();
+
+            rootContainer.Bind<Test0>().AsSingle();
+            rootContainer.Bind<Test2>().AsSingle();
+
+            Assert.Throws(() => rootContainer.Resolve<Test2>());
+        }
+
+        [Test]
+        public void TestParentAny1()
+        {
+            var rootContainer = new DiContainer();
+            var sub1 = rootContainer.CreateSubContainer();
+            var sub2 = sub1.CreateSubContainer();
+
+            rootContainer.Bind<Test0>().AsSingle();
+            sub2.Bind<Test3>().AsSingle();
+
+            Assert.IsNotNull(sub2.Resolve<Test3>());
+        }
+    }
+}
+
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a991a1d50d39d334b846e0ad5cd511e7
+timeCreated: 1461708052
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,121 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestListInjection : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestConstructor1()
+        {
+            BindListItems();
+            Container.Bind<Test1>().AsSingle();
+            TestListItems(Container.Resolve<Test1>().Values);
+        }
+
+        [Test]
+        public void TestField1()
+        {
+            BindListItems();
+            Container.Bind<Test3>().AsSingle();
+            TestListItems(Container.Resolve<Test3>().Values);
+        }
+
+        [Test]
+        public void TestIList()
+        {
+            BindListItems();
+            Container.Bind<Test2>().AsSingle();
+            TestListItems(Container.Resolve<Test2>().Values.ToList());
+        }
+
+        [Test]
+        public void TestIEnumerable()
+        {
+            BindListItems();
+            Container.Bind<Test4>().AsSingle();
+            TestListItems(Container.Resolve<Test4>().Values.ToList());
+        }
+
+        [Test]
+        public void TestArrays()
+        {
+            BindListItems();
+            Container.Bind<Test5>().AsSingle();
+            TestListItems(Container.Resolve<Test5>().Values.ToList());
+        }
+
+        void BindListItems()
+        {
+            Container.BindInstance("foo");
+            Container.BindInstance("bar");
+        }
+
+        void TestListItems(List<string> values)
+        {
+            Assert.IsEqual(values[0], "foo");
+            Assert.IsEqual(values[1], "bar");
+        }
+
+        class Test1
+        {
+            public Test1(List<string> values)
+            {
+                Values = values;
+            }
+
+            public List<string> Values
+            {
+                get; private set;
+            }
+        }
+
+        class Test3
+        {
+            [Inject]
+            public List<string> Values = null;
+        }
+
+        class Test2
+        {
+            public Test2(IList<string> values)
+            {
+                Values = values;
+            }
+
+            public IList<string> Values
+            {
+                get; private set;
+            }
+        }
+
+        class Test4
+        {
+            public Test4(IEnumerable<string> values)
+            {
+                Values = values;
+            }
+
+            public IEnumerable<string> Values
+            {
+                get; private set;
+            }
+        }
+
+        class Test5
+        {
+            public Test5(string[] values)
+            {
+                Values = values;
+            }
+
+            public string[] Values
+            {
+                get; private set;
+            }
+        }
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d5b86b3c904d43145a9afbd7f8a0cb13
+timeCreated: 1461708054
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,48 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestNullableValues : ZenjectUnitTestFixture
+    {
+        class Test1
+        {
+            public int? val;
+
+            public Test1(int? val)
+            {
+                this.val = val;
+            }
+        }
+
+        class Test2
+        {
+            public int? val;
+
+            public Test2(
+                [InjectOptional]
+                int? val)
+            {
+                this.val = val;
+            }
+        }
+
+        [Test]
+        public void RunTest1()
+        {
+            Container.Bind<Test1>().AsSingle().NonLazy();
+            Container.Bind<int>().FromInstance(1).NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Test1>().val, 1);
+        }
+
+        [Test]
+        public void RunTest2()
+        {
+            Container.Bind<Test2>().AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Test2>().val, null);
+        }
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9adcc99fb99e8954c84b0f32060eeead
+timeCreated: 1461708052
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,46 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestParameters : ZenjectUnitTestFixture
+    {
+        class Test1
+        {
+            public int f1;
+            public int f2;
+
+            public Test1(int f1, int f2)
+            {
+                this.f1 = f1;
+                this.f2 = f2;
+            }
+        }
+
+        [Test]
+        public void TestExtraParametersSameType()
+        {
+            var test1 = Container.Instantiate<Test1>(new object[] { 5, 10 });
+
+            Assert.That(test1 != null);
+            Assert.That(test1.f1 == 5 && test1.f2 == 10);
+
+            var test2 = Container.Instantiate<Test1>(new object[] { 10, 5 });
+
+            Assert.That(test2 != null);
+            Assert.That(test2.f1 == 10 && test2.f2 == 5);
+        }
+
+        [Test]
+        public void TestMissingParameterThrows()
+        {
+            Container.Bind<Test1>().AsTransient().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test1>(); });
+        }
+    }
+}
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c571947a83e2460438d98aff825f6de2
+timeCreated: 1461708053
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -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++;
+            }
+        }
+    }
+}
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b471b20538748df4a8932877aa7bd2f9
+timeCreated: 1461708053
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,59 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestPostInjectParameters : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        class Test1
+        {
+        }
+
+        class Test2
+        {
+        }
+
+        class Test3
+        {
+            public bool HasInitialized;
+
+            public Test0 test0;
+
+            [Inject]
+            public Test1 test1 = null;
+
+            [Inject]
+            public void Init(
+                Test0 test0,
+                [InjectOptional]
+                Test2 test2)
+            {
+                Assert.That(!HasInitialized);
+                Assert.IsNotNull(test1);
+                Assert.IsNull(test2);
+                Assert.IsNull(this.test0);
+                this.test0 = test0;
+                HasInitialized = true;
+            }
+        }
+
+        [Test]
+        public void Test()
+        {
+            Container.Bind<Test1>().AsSingle().NonLazy();
+            Container.Bind<Test3>().AsSingle().NonLazy();
+
+            Container.Bind<Test0>().AsSingle().NonLazy();
+
+            var test3 = Container.Resolve<Test3>();
+
+            Assert.That(test3.HasInitialized);
+            Assert.IsNotNull(test3.test0);
+        }
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b2d41ccbf61026c45872ce060cd81b70
+timeCreated: 1461708053
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,48 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestPropertyInjection : ZenjectUnitTestFixture
+    {
+        class Test1
+        {
+        }
+
+        class Test2
+        {
+            [Inject]
+            public Test1 val2 { get; private set; }
+
+            [Inject]
+            Test1 val4 { get; set; }
+
+            public Test1 GetVal4()
+            {
+                return val4;
+            }
+        }
+
+        [Test]
+        public void TestPublicPrivate()
+        {
+            var test1 = new Test1();
+
+            Container.Bind<Test2>().AsSingle().NonLazy();
+            Container.Bind<Test1>().FromInstance(test1).NonLazy();
+
+            var test2 = Container.Resolve<Test2>();
+
+            Assert.IsEqual(test2.val2, test1);
+            Assert.IsEqual(test2.GetVal4(), test1);
+        }
+
+        [Test]
+        public void TestCase2()
+        {
+        }
+    }
+}
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e73445afb1e143e4d83dccc220517a72
+timeCreated: 1461708054
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,89 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestStructInjection : ZenjectUnitTestFixture
+    {
+        struct Test1
+        {
+        }
+
+        class Test2
+        {
+            public Test2(Test1 t1)
+            {
+            }
+        }
+
+        [Test]
+        public void TestInjectStructIntoClass()
+        {
+            Container.Bind<Test1>().FromInstance(new Test1()).NonLazy();
+            Container.Bind<Test2>().AsSingle().NonLazy();
+
+            Container.ResolveRoots();
+
+            var t2 = Container.Resolve<Test2>();
+
+            Assert.That(t2 != null);
+        }
+
+        struct Test3
+        {
+            [Inject]
+#pragma warning disable 649
+            public int ValueField;
+#pragma warning restore 649
+
+            [Inject]
+            public string ValueProperty
+            {
+                get; private set;
+            }
+
+            public float ValueConstructor
+            {
+                get; private set;
+            }
+        }
+
+        [Test]
+        public void TestInjectFieldsOfStruct()
+        {
+            Container.BindInstance("asdf");
+            Container.BindInstance(5);
+            Container.Bind<Test3>().AsSingle();
+
+            var test3 = Container.Instantiate<Test3>();
+
+            Assert.IsEqual(test3.ValueProperty, "asdf");
+            Assert.IsEqual(test3.ValueField, 5);
+        }
+
+        struct Test4
+        {
+            public Test4(string value)
+            {
+                Value = value;
+            }
+
+            public string Value
+            {
+                get; private set;
+            }
+        }
+
+        [Test]
+        public void TestInjectConstructorOfStruct()
+        {
+            Container.BindInstance("asdf");
+            Container.Bind<Test4>().AsSingle();
+
+            var test4 = Container.Instantiate<Test4>();
+
+            Assert.IsEqual(test4.Value, "asdf");
+        }
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 99836272f6c39824ebe35524b96e67cd
+timeCreated: 1461708052
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,217 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Injection
+{
+    [TestFixture]
+    public class TestTestOptional : ZenjectUnitTestFixture
+    {
+        class Test1
+        {
+        }
+
+        class Test2
+        {
+            [Inject]
+            public Test1 val1 = null;
+        }
+
+        class Test3
+        {
+            [InjectOptional]
+            public Test1 val1 = null;
+        }
+
+        class Test0
+        {
+            [InjectOptional]
+            public int Val1 = 5;
+        }
+
+        [Test]
+        public void TestFieldRequired()
+        {
+            Container.Bind<Test2>().AsSingle().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test2>(); });
+        }
+
+        [Test]
+        public void TestFieldOptional()
+        {
+            Container.Bind<Test3>().AsSingle().NonLazy();
+
+            var test = Container.Resolve<Test3>();
+            Assert.That(test.val1 == null);
+        }
+
+        [Test]
+        public void TestFieldOptional2()
+        {
+            Container.Bind<Test3>().AsSingle().NonLazy();
+
+            var test1 = new Test1();
+            Container.Bind<Test1>().FromInstance(test1).NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Test3>().val1, test1);
+        }
+
+        [Test]
+        public void TestFieldOptional3()
+        {
+            Container.Bind<Test0>().AsTransient().NonLazy();
+
+            // Should not redefine the hard coded value in this case
+            Assert.IsEqual(Container.Resolve<Test0>().Val1, 5);
+
+            Container.Bind<int>().FromInstance(3).NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Test0>().Val1, 3);
+        }
+
+        class Test4
+        {
+            public Test4(Test1 val1)
+            {
+            }
+        }
+
+        class Test5
+        {
+            public Test1 Val1;
+
+            public Test5(
+                [InjectOptional]
+                Test1 val1)
+            {
+                Val1 = val1;
+            }
+        }
+
+        [Test]
+        public void TestParameterRequired()
+        {
+            Container.Bind<Test4>().AsSingle().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test4>(); });
+        }
+
+        [Test]
+        public void TestParameterOptional()
+        {
+            Container.Bind<Test5>().AsSingle().NonLazy();
+
+            var test = Container.Resolve<Test5>();
+            Assert.That(test.Val1 == null);
+        }
+
+        class Test6
+        {
+            public Test6(Test2 test2)
+            {
+            }
+        }
+
+        [Test]
+        public void TestChildDependencyOptional()
+        {
+            Container.Bind<Test6>().AsSingle().NonLazy();
+            Container.Bind<Test2>().AsSingle().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test6>(); });
+        }
+
+        class Test7
+        {
+            public int Val1;
+
+            public Test7(
+                [InjectOptional]
+                int val1)
+            {
+                Val1 = val1;
+            }
+        }
+
+        [Test]
+        public void TestPrimitiveParamOptionalUsesDefault()
+        {
+            Container.Bind<Test7>().AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Test7>().Val1, 0);
+        }
+
+        class Test8
+        {
+            public int Val1;
+
+            public Test8(
+                [InjectOptional]
+                int val1 = 5)
+            {
+                Val1 = val1;
+            }
+        }
+
+        [Test]
+        public void TestPrimitiveParamOptionalUsesExplicitDefault()
+        {
+            Container.Bind<Test8>().AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Test8>().Val1, 5);
+        }
+
+        class Test8_2
+        {
+            public int Val1;
+
+            public Test8_2(int val1 = 5)
+            {
+                Val1 = val1;
+            }
+        }
+
+        [Test]
+        public void TestPrimitiveParamOptionalUsesExplicitDefault2()
+        {
+            Container.Bind<Test8_2>().AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Test8_2>().Val1, 5);
+        }
+
+        [Test]
+        public void TestPrimitiveParamOptionalUsesExplicitDefault3()
+        {
+            Container.Bind<Test8_2>().AsSingle().NonLazy();
+            Container.BindInstance(2);
+
+            Assert.IsEqual(Container.Resolve<Test8_2>().Val1, 2);
+        }
+
+        class Test9
+        {
+            public int? Val1;
+
+            public Test9(
+                [InjectOptional]
+                int? val1)
+            {
+                Val1 = val1;
+            }
+        }
+
+        [Test]
+        public void TestPrimitiveParamOptionalNullable()
+        {
+            Container.Bind<Test9>().AsSingle().NonLazy();
+
+            Assert.That(!Container.Resolve<Test9>().Val1.HasValue);
+        }
+    }
+}
+
+
+
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 731e8a7c5222176449a38890b363d0b5
+timeCreated: 1461708051
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: