Initial Commit

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 1d55b2694c783d147a989babca92c7bf
+folderAsset: yes
+timeCreated: 1461799712
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a25b85a8c5c0f2b42a1eec620b699e8a
+folderAsset: yes
+timeCreated: 1461711436
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestBindingInheritanceMethod.cs

@@ -0,0 +1,92 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Other
+{
+    [TestFixture]
+    public class TestBindingInheritanceMethod : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestNoCopy()
+        {
+            Container.Bind<Foo>().AsSingle();
+
+            var sub1 = Container.CreateSubContainer();
+
+            Assert.IsEqual(sub1.Resolve<Foo>(), Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestCopyIntoAll1()
+        {
+            Container.Bind<Foo>().AsSingle().CopyIntoAllSubContainers();
+
+            var sub1 = Container.CreateSubContainer();
+
+            Assert.IsNotEqual(sub1.Resolve<Foo>(), Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestCopyIntoAll2()
+        {
+            Container.Bind<IBar>().To<Bar>().FromResolve().CopyIntoAllSubContainers();
+            Container.Bind<Bar>().AsSingle();
+
+            var sub1 = Container.CreateSubContainer();
+
+            Assert.IsEqual(Container.ResolveAll<IBar>().Count, 1);
+            Assert.IsEqual(sub1.ResolveAll<IBar>().Count, 2);
+        }
+
+        [Test]
+        public void TestCopyDirect1()
+        {
+            Container.Bind<Foo>().AsSingle().CopyIntoDirectSubContainers();
+
+            var sub1 = Container.CreateSubContainer();
+            var sub2 = sub1.CreateSubContainer();
+
+            Assert.That(Container.HasBindingId(typeof(Foo), null, InjectSources.Local));
+            Assert.That(sub1.HasBindingId(typeof(Foo), null, InjectSources.Local));
+            Assert.That(!sub2.HasBindingId(typeof(Foo), null, InjectSources.Local));
+        }
+
+        [Test]
+        public void TestMoveDirect1()
+        {
+            Container.Bind<Foo>().AsSingle().MoveIntoDirectSubContainers();
+
+            var sub1 = Container.CreateSubContainer();
+            var sub2 = sub1.CreateSubContainer();
+
+            Assert.That(!Container.HasBindingId(typeof(Foo), null, InjectSources.Local));
+            Assert.That(sub1.HasBindingId(typeof(Foo), null, InjectSources.Local));
+            Assert.That(!sub2.HasBindingId(typeof(Foo), null, InjectSources.Local));
+        }
+
+        [Test]
+        public void TestMoveAll()
+        {
+            Container.Bind<Foo>().AsSingle().MoveIntoAllSubContainers();
+
+            var sub1 = Container.CreateSubContainer();
+            var sub2 = sub1.CreateSubContainer();
+
+            Assert.That(!Container.HasBindingId(typeof(Foo), null, InjectSources.Local));
+            Assert.That(sub1.HasBindingId(typeof(Foo), null, InjectSources.Local));
+            Assert.That(sub2.HasBindingId(typeof(Foo), null, InjectSources.Local));
+        }
+
+        public interface IBar
+        {
+        }
+
+        public class Foo
+        {
+        }
+
+        public class Bar : IBar
+        {
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestBindingInheritanceMethod.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 645589d2772852246ac2ea1fd8ee4f92
+timeCreated: 1519842213
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestConcreteIdentifier.cs

@@ -0,0 +1,47 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.BindFeatures
+{
+    [TestFixture]
+    public class TestConcreteIdentifier : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void Test1()
+        {
+            Container.Bind<IFoo>().To<Foo>().AsCached().WithConcreteId("asdf");
+            Container.Bind<IFoo>().To<Foo>().AsCached();
+
+            Container.BindInstance("a").When(x => Equals(x.ConcreteIdentifier, "asdf") && x.ObjectType == typeof(Foo));
+            Container.BindInstance("b").When(x => x.ConcreteIdentifier == null && x.ObjectType == typeof(Foo));
+
+            var foos = Container.ResolveAll<IFoo>();
+
+            Assert.IsEqual(foos[0].Value, "a");
+            Assert.IsEqual(foos[1].Value, "b");
+        }
+
+        interface IFoo
+        {
+            string Value
+            {
+                get;
+            }
+        }
+
+        class Foo : IFoo
+        {
+            public Foo(string data)
+            {
+                Value = data;
+            }
+
+            public string Value
+            {
+                get; private set;
+            }
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestConcreteIdentifier.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 51d298299a99e3247aa3cc0b5caa1c88
+timeCreated: 1523257672
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestIfNotBound.cs

@@ -0,0 +1,41 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.BindFeatures
+{
+    [TestFixture]
+    public class TestIfNotBound : ZenjectUnitTestFixture
+    {
+        interface IFoo
+        {
+        }
+
+        public class Foo1 : IFoo
+        {
+        }
+
+        public class Foo2 : IFoo
+        {
+        }
+
+        [Test]
+        public void Test1()
+        {
+            Container.Bind<IFoo>().To<Foo1>().AsSingle();
+            Container.Bind<IFoo>().To<Foo2>().AsSingle();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count, 2);
+        }
+
+        [Test]
+        public void Test2()
+        {
+            Container.Bind<IFoo>().To<Foo1>().AsSingle();
+            Container.Bind<IFoo>().To<Foo2>().AsSingle().IfNotBound();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count, 1);
+            Assert.IsType<Foo1>(Container.Resolve<IFoo>());
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestIfNotBound.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 0fa385d656ffb584d8326240eb19c9f3
+timeCreated: 1519798640
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestMoveIntoAllSubContainers.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 685a532a989c2f846b3fb97ea6c63b01
+timeCreated: 1519798640
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestMoveIntoDirectSubContainers.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 7a57b8b648dfde647b2cc4de6e9ea944
+timeCreated: 1519798640
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestMultipleContractTypes.cs

@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.BindFeatures
+{
+    [TestFixture]
+    public class TestMultipleContractTypes : ZenjectUnitTestFixture
+    {
+        class Test1
+        {
+        }
+
+        class Test2 : Test1
+        {
+        }
+
+        class Test3 : Test1
+        {
+        }
+
+        class TestImpl1
+        {
+            public List<Test1> tests;
+
+            public TestImpl1(List<Test1> tests)
+            {
+                this.tests = tests;
+            }
+        }
+
+        class TestImpl2
+        {
+            [Inject]
+            public List<Test1> tests = null;
+        }
+
+        [Test]
+        public void TestMultiBind1()
+        {
+            Container.Bind<Test1>().To<Test2>().AsSingle().NonLazy();
+            Container.Bind<Test1>().To<Test3>().AsSingle().NonLazy();
+            Container.Bind<TestImpl1>().AsSingle().NonLazy();
+
+            var test1 = Container.Resolve<TestImpl1>();
+
+            Assert.That(test1.tests.Count == 2);
+        }
+
+        [Test]
+        public void TestMultiBindListInjection()
+        {
+            Container.Bind<Test1>().To<Test2>().AsSingle().NonLazy();
+            Container.Bind<Test1>().To<Test3>().AsSingle().NonLazy();
+            Container.Bind<TestImpl2>().AsSingle().NonLazy();
+
+            var test = Container.Resolve<TestImpl2>();
+            Assert.That(test.tests.Count == 2);
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestMultipleContractTypes.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fb35253dbaabad84a815c3a9106cab8b
+timeCreated: 1461708055
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestMultipleContractTypes2.cs

@@ -0,0 +1,90 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.BindFeatures
+{
+    [TestFixture]
+    public class TestMultipleContractTypes2 : ZenjectUnitTestFixture
+    {
+        public class Bar
+        {
+        }
+
+        public interface IFoo
+        {
+        }
+
+        public interface IQux
+        {
+        }
+
+        public class Foo : IQux, IFoo
+        {
+        }
+
+        [Test]
+        public void Test1()
+        {
+            var types = new[]
+            {
+                typeof(Bar),
+                typeof(Foo)
+            };
+
+            Container.Bind(types).AsSingle().NonLazy();
+
+            Container.Resolve<Bar>();
+            Container.Resolve<Foo>();
+        }
+
+        [Test]
+        public void TestInterfaces()
+        {
+            Container.Bind<IFoo>().AsSingle().NonLazy();
+
+            Assert.Throws(() => Container.FlushBindings());
+        }
+
+        [Test]
+        public void TestAllInterfacesMistake()
+        {
+            Container.BindInterfacesTo<Foo>();
+
+            // Should require setting scope
+            Assert.Throws(() => Container.FlushBindings());
+        }
+
+        [Test]
+        public void TestAllInterfaces()
+        {
+            Container.BindInterfacesTo<Foo>().AsSingle().NonLazy();
+
+            Assert.IsNull(Container.TryResolve<Foo>());
+
+            Assert.IsNotNull(Container.Resolve<IFoo>());
+            Assert.IsNotNull(Container.Resolve<IQux>());
+        }
+
+        [Test]
+        public void TestAllInterfacesAndSelf()
+        {
+            Container.BindInterfacesAndSelfTo<Foo>().AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>());
+            Assert.IsNotNull(Container.Resolve<IFoo>());
+            Assert.IsNotNull(Container.Resolve<IQux>());
+        }
+
+        [Test]
+        public void TestAllInterfacesAndSelfMistake()
+        {
+            Container.BindInterfacesAndSelfTo<Foo>();
+
+            // Should require setting scope
+            Assert.Throws(() => Container.FlushBindings());
+        }
+    }
+}
+
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestMultipleContractTypes2.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b0c99e3d7ab1f7040b86e83fda23093b
+timeCreated: 1461708052
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestMultipleContractTypes3.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.BindFeatures
+{
+    [TestFixture]
+    public class TestMultipleContractTypes3 : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        class Test3 : Test0
+        {
+        }
+
+        class Test4 : Test0
+        {
+        }
+
+        class Test2
+        {
+            public Test0 test;
+
+            public Test2(Test0 test)
+            {
+                this.test = test;
+            }
+        }
+
+        class Test1
+        {
+            public List<Test0> test;
+
+            public Test1(List<Test0> test)
+            {
+                this.test = test;
+            }
+        }
+
+        [Test]
+        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>());
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestMultipleContractTypes3.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a3c5d33d617b5d74386818cd004d2f3d
+timeCreated: 1461708052
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestNonLazy.cs

@@ -0,0 +1,45 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestNonLazy : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void Test1()
+        {
+            Container.Bind<Foo>().AsSingle().NonLazy();
+
+            Assert.Throws(() => Container.ResolveRoots());
+        }
+
+        [Test]
+        public void Test2()
+        {
+            Container.Bind<Foo>().AsSingle();
+
+            Container.ResolveRoots();
+        }
+
+        [Test]
+        public void Test3()
+        {
+            Container.Bind<Foo>().AsSingle().NonLazy();
+            Container.Bind<Bar>().AsSingle();
+
+            Container.ResolveRoots();
+        }
+
+        public class Foo
+        {
+            public Foo(Bar bar)
+            {
+            }
+        }
+
+        public class Bar
+        {
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestNonLazy.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: bd8592ec897336d4fb55f476488dfb1c
+timeCreated: 1461708053
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestRebind.cs

@@ -0,0 +1,33 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.BindFeatures
+{
+    [TestFixture]
+    public class TestRebind : ZenjectUnitTestFixture
+    {
+        interface ITest
+        {
+        }
+
+        class Test2 : ITest
+        {
+        }
+
+        class Test3 : ITest
+        {
+        }
+
+        [Test]
+        public void Run()
+        {
+            Container.Bind<ITest>().To<Test2>().AsSingle();
+
+            Assert.That(Container.Resolve<ITest>() is Test2);
+
+            Container.Rebind<ITest>().To<Test3>().AsSingle();
+
+            Assert.That(Container.Resolve<ITest>() is Test3);
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestRebind.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 389794c3c2d66a24f9146f9071f398aa
+timeCreated: 1464374481
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestUnbind.cs

@@ -0,0 +1,62 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.BindFeatures
+{
+    [TestFixture]
+    public class TestUnbind : ZenjectUnitTestFixture
+    {
+        interface ITest
+        {
+        }
+
+        interface ITest2
+        {
+        }
+
+        class Test2 : ITest, ITest2
+        {
+        }
+
+        [Test]
+        public void Run()
+        {
+            Container.Bind<ITest>().To<Test2>().AsSingle();
+
+            Assert.IsNotNull(Container.Resolve<ITest>());
+
+            Container.Unbind<ITest>();
+
+            Assert.IsNull(Container.TryResolve<ITest>());
+        }
+
+        [Test]
+        public void TestUnbindInterfaces()
+        {
+            Container.BindInterfacesTo<Test2>().AsSingle();
+
+            Assert.IsNotNull(Container.Resolve<ITest>());
+            Assert.IsNotNull(Container.Resolve<ITest2>());
+
+            Container.UnbindInterfacesTo<Test2>();
+
+            Assert.IsNull(Container.TryResolve<ITest>());
+            Assert.IsNull(Container.TryResolve<ITest2>());
+        }
+
+        // Do we care about this?
+        //[Test]
+        public void TestUnbindAsSingle()
+        {
+            Container.Bind<ITest>().To<Test2>().AsSingle();
+
+            Container.Unbind<ITest>();
+
+            Assert.IsNull(Container.TryResolve<ITest>());
+
+            Container.Bind<ITest>().To<Test2>().AsSingle();
+
+            Assert.IsNotNull(Container.TryResolve<ITest>());
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestUnbind.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7bc1066beaa29be488a974f611aadf7f
+timeCreated: 1464374492
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestWithArguments.cs

@@ -0,0 +1,57 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.BindFeatures
+{
+    [TestFixture]
+    public class TestWithArguments : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void Test1()
+        {
+            Container.Bind<Foo>().AsTransient().WithArguments(3).NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>().Value, 3);
+        }
+
+        [Test]
+        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);
+        }
+
+        interface IFoo
+        {
+        }
+
+        class Foo : IFoo
+        {
+            public Foo(
+                int value,
+                [InjectOptional]
+                string value2)
+            {
+                Value = value;
+                Value2 = value2;
+            }
+
+            public int Value
+            {
+                get;
+                private set;
+            }
+
+            public string Value2
+            {
+                get;
+                private set;
+            }
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/BindFeatures/TestWithArguments.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a9729dccd0a5529458a8ef18263587ae
+timeCreated: 1461708052
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 12da5cd15bf088a46ba2934227c0334b
+folderAsset: yes
+timeCreated: 1461711435
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFrom.cs

@@ -0,0 +1,260 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFrom : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestSelfSingle()
+        {
+            Container.Bind<Foo>().AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>());
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestSelfSingleExplicit()
+        {
+            Container.Bind<Foo>().ToSelf().FromNew().AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>());
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestSelfTransient()
+        {
+            Container.Bind<Foo>().AsTransient().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>());
+            Assert.IsNotEqual(Container.Resolve<Foo>(), Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestSelfCached()
+        {
+            Container.Bind<Foo>().AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>());
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestConcreteSingle()
+        {
+            Container.Bind(typeof(Foo), typeof(IFoo)).To<Foo>().AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>());
+            Assert.IsNotNull(Container.Resolve<IFoo>());
+
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<Foo>());
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.Resolve<Foo>());
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.Resolve<IFoo>());
+        }
+
+        [Test]
+        public void TestConcreteTransient()
+        {
+            Container.Bind<IFoo>().To<Foo>().AsTransient().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<IFoo>());
+            Assert.IsNotEqual(Container.Resolve<IFoo>(), Container.Resolve<IFoo>());
+        }
+
+        [Test]
+        public void TestConcreteTransient2()
+        {
+            Container.Bind<IFoo>().To<Foo>().AsTransient().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<IFoo>());
+            Assert.IsNotEqual(Container.Resolve<IFoo>(), Container.Resolve<IFoo>());
+        }
+
+        [Test]
+        public void TestConcreteCached()
+        {
+            Container.Bind<Foo>().AsCached().NonLazy();
+            Container.Bind<IFoo>().To<Foo>().AsCached().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>());
+            Assert.IsNotNull(Container.Resolve<IFoo>());
+
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.Resolve<IFoo>());
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<Foo>());
+            Assert.IsNotEqual(Container.Resolve<IFoo>(), Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestDuplicateBindingsFail()
+        {
+            Container.Bind<Foo>().AsSingle();
+            Container.Bind<Foo>().AsSingle();
+
+            Assert.Throws(
+                () => Container.FlushBindings());
+        }
+
+        [Test]
+        public void TestConcreteMultipleTransient()
+        {
+            Container.Bind<IFoo>().To(typeof(Foo), typeof(Bar)).AsTransient().NonLazy();
+
+            var foos = Container.ResolveAll<IFoo>();
+
+            Assert.IsEqual(foos.Count, 2);
+            Assert.That(foos[0] is Foo);
+            Assert.That(foos[1] is Bar);
+
+            var foos2 = Container.ResolveAll<IFoo>();
+
+            Assert.IsNotEqual(foos[0], foos2[0]);
+            Assert.IsNotEqual(foos[1], foos2[1]);
+        }
+
+        [Test]
+        public void TestConcreteMultipleSingle()
+        {
+            Container.Bind<IFoo>().To(typeof(Foo), typeof(Bar)).AsSingle().NonLazy();
+
+            var foos = Container.ResolveAll<IFoo>();
+
+            Assert.IsEqual(foos.Count, 2);
+            Assert.That(foos[0] is Foo);
+            Assert.That(foos[1] is Bar);
+
+            var foos2 = Container.ResolveAll<IFoo>();
+
+            Assert.IsEqual(foos[0], foos2[0]);
+            Assert.IsEqual(foos[1], foos2[1]);
+        }
+
+        [Test]
+        public void TestMultipleBindingsSingleFail1()
+        {
+            Container.Bind(typeof(IFoo), typeof(IBar)).AsSingle();
+
+            Assert.Throws(() => Container.FlushBindings());
+        }
+
+        [Test]
+        public void TestMultipleBindingsSingleFail2()
+        {
+            Assert.Throws(() => Container.Bind(typeof(IFoo), typeof(IBar)).To<Qux>().AsSingle());
+        }
+
+        [Test]
+        public void TestMultipleBindingsSingle()
+        {
+            Container.Bind(typeof(IFoo), typeof(IBar)).To<Foo>().AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.Resolve<IBar>());
+            Assert.That(Container.Resolve<IFoo>() is Foo);
+        }
+
+        [Test]
+        public void TestMultipleBindingsTransient()
+        {
+            Container.Bind(typeof(IFoo), typeof(IBar)).To<Foo>().AsTransient().NonLazy();
+
+            Assert.That(Container.Resolve<IFoo>() is Foo);
+            Assert.That(Container.Resolve<IBar>() is Foo);
+
+            Assert.IsNotEqual(Container.Resolve<IFoo>(), Container.Resolve<IFoo>());
+            Assert.IsNotEqual(Container.Resolve<IFoo>(), Container.Resolve<IBar>());
+        }
+
+        [Test]
+        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>());
+        }
+
+        [Test]
+        public void TestMultipleBindingsConcreteMultipleSingle()
+        {
+            Container.Bind(typeof(IFoo), typeof(IBar))
+                .To(new List<Type> {typeof(Foo), typeof(Bar)}).AsSingle().NonLazy();
+
+            var foos = Container.ResolveAll<IFoo>();
+            var bars = Container.ResolveAll<IBar>();
+
+            Assert.IsEqual(foos.Count, 2);
+            Assert.IsEqual(bars.Count, 2);
+
+            Assert.That(foos[0] is Foo);
+            Assert.That(foos[1] is Bar);
+
+            Assert.IsEqual(foos[0], bars[0]);
+            Assert.IsEqual(foos[1], bars[1]);
+        }
+
+        [Test]
+        public void TestMultipleBindingsConcreteMultipleTransient()
+        {
+            Container.Bind(typeof(IFoo), typeof(IBar)).To(new List<Type> {typeof(Foo), typeof(Bar)}).AsTransient().NonLazy();
+
+            var foos = Container.ResolveAll<IFoo>();
+            var bars = Container.ResolveAll<IBar>();
+
+            Assert.IsEqual(foos.Count, 2);
+            Assert.IsEqual(bars.Count, 2);
+
+            Assert.That(foos[0] is Foo);
+            Assert.That(foos[1] is Bar);
+
+            Assert.IsNotEqual(foos[0], bars[0]);
+            Assert.IsNotEqual(foos[1], bars[1]);
+        }
+
+        [Test]
+        public void TestMultipleBindingsConcreteMultipleCached()
+        {
+            Container.Bind(typeof(IFoo), typeof(IBar)).To(new List<Type> {typeof(Foo), typeof(Bar)}).AsCached().NonLazy();
+            Container.Bind<Foo>().AsCached().NonLazy();
+            Container.Bind<Bar>().AsCached().NonLazy();
+
+            var foos = Container.ResolveAll<IFoo>();
+            var bars = Container.ResolveAll<IBar>();
+
+            Assert.IsEqual(foos.Count, 2);
+            Assert.IsEqual(bars.Count, 2);
+
+            Assert.That(foos[0] is Foo);
+            Assert.That(foos[1] is Bar);
+
+            Assert.IsEqual(foos[0], bars[0]);
+            Assert.IsEqual(foos[1], bars[1]);
+
+            Assert.IsNotEqual(foos[0], Container.Resolve<Foo>());
+            Assert.IsNotEqual(foos[1], Container.Resolve<Bar>());
+        }
+
+        interface IBar
+        {
+        }
+
+        interface IFoo
+        {
+        }
+
+        class Foo : IFoo, IBar
+        {
+        }
+
+        class Bar : IFoo, IBar
+        {
+        }
+
+        public class Qux
+        {
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFrom.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6a67145dedecd9947bb94c542f6474ae
+timeCreated: 1485738783
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromFactory.cs

@@ -0,0 +1,187 @@
+using System.Linq;
+using ModestTree;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromFactory : ZenjectUnitTestFixture
+    {
+        static Foo StaticFoo = new Foo();
+
+        [Test]
+        public void Test1()
+        {
+            FooFactory.InstanceCount = 0;
+
+            Container.Bind<Foo>().FromIFactory(b => b.To<FooFactory>().AsCached());
+
+            Assert.IsEqual(Container.Resolve<Foo>(), StaticFoo);
+
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+
+            Assert.IsEqual(FooFactory.InstanceCount, 1);
+        }
+
+        [Test]
+        public void TestOldVersion()
+        {
+            FooFactory.InstanceCount = 0;
+
+            Container.Bind<Foo>().FromFactory<FooFactory>();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), StaticFoo);
+
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+
+            Assert.IsEqual(FooFactory.InstanceCount, 1);
+        }
+
+        [Test]
+        public void TestMoveIntoSubcontainers()
+        {
+            FooFactory.InstanceCount = 0;
+
+            Container.Bind<Foo>().FromIFactory(b => b.To<FooFactory>().AsCached()).MoveIntoDirectSubContainers();
+
+            Assert.That(Container.AllContracts.Where(x => x.Type == typeof(IFactory<Foo>)).IsEmpty());
+
+            Assert.IsNull(Container.TryResolve<Foo>());
+
+            var subContainer = Container.CreateSubContainer();
+
+            Assert.IsEqual(subContainer.Resolve<Foo>(), StaticFoo);
+
+            Assert.That(subContainer.AllContracts.Where(x => x.Type == typeof(IFactory<Foo>)).Count() == 1);
+
+            subContainer.Resolve<Foo>();
+            subContainer.Resolve<Foo>();
+            subContainer.Resolve<Foo>();
+
+            Assert.IsEqual(FooFactory.InstanceCount, 1);
+        }
+
+        [Test]
+        public void Test2()
+        {
+            FooFactory.InstanceCount = 0;
+
+            Container.Bind<Foo>().FromIFactory(b => b.To<FooFactory>().AsTransient());
+
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+
+            Assert.IsEqual(FooFactory.InstanceCount, 3);
+        }
+
+        [Test]
+        public void Test3()
+        {
+            FooFactory.InstanceCount = 0;
+
+            Container.Bind<Foo>().FromIFactory(b => b.To<FooFactory>().AsTransient()).AsCached();
+
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+
+            Assert.IsEqual(FooFactory.InstanceCount, 1);
+        }
+
+        [Test]
+        public void TestConcreteSingle()
+        {
+            FooFactory.InstanceCount = 0;
+
+            Container.Bind<IFoo>().To<Foo>().FromIFactory(b => b.To<FooFactory>().AsCached()).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<IFoo>(), StaticFoo);
+
+            Container.Resolve<IFoo>();
+            Container.Resolve<IFoo>();
+            Container.Resolve<IFoo>();
+
+            Assert.IsEqual(FooFactory.InstanceCount, 1);
+        }
+
+        [Test]
+        public void TestSelfAndConcreteSingle()
+        {
+            FooFactory.InstanceCount = 0;
+
+            Container.Bind<Foo>().FromIFactory(b => b.To<FooFactory>().AsCached()).AsSingle().NonLazy();
+            Container.Bind<IFoo>().To<Foo>().FromResolve();
+
+            Assert.IsEqual(Container.Resolve<IFoo>(), StaticFoo);
+            Assert.IsEqual(Container.Resolve<Foo>(), StaticFoo);
+
+            Container.Resolve<IFoo>();
+            Container.Resolve<IFoo>();
+            Container.Resolve<IFoo>();
+
+            Assert.IsEqual(FooFactory.InstanceCount, 1);
+        }
+
+        [Test]
+        public void TestSelfCached()
+        {
+            FooFactory.InstanceCount = 0;
+
+            Container.Bind<Foo>().FromIFactory(b => b.To<FooFactory>().AsCached()).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), StaticFoo);
+
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+
+            Assert.IsEqual(FooFactory.InstanceCount, 1);
+        }
+
+        [Test]
+        public void TestConcreteCached()
+        {
+            FooFactory.InstanceCount = 0;
+
+            Container.Bind<IFoo>().To<Foo>().FromIFactory(b => b.To<FooFactory>().AsCached()).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<IFoo>(), StaticFoo);
+
+            Container.Resolve<IFoo>();
+            Container.Resolve<IFoo>();
+            Container.Resolve<IFoo>();
+
+            Assert.IsEqual(FooFactory.InstanceCount, 1);
+        }
+
+        class FooFactory : IFactory<Foo>
+        {
+            public static int InstanceCount;
+
+            public FooFactory()
+            {
+                InstanceCount++;
+            }
+
+            public Foo Create()
+            {
+                return StaticFoo;
+            }
+        }
+
+        interface IFoo
+        {
+        }
+
+        class Foo : IFoo
+        {
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromFactory.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d88c26093930ebe4c9c294ae22d12754
+timeCreated: 1485738788
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromGetter.cs

@@ -0,0 +1,117 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromGetter : ZenjectUnitTestFixture
+    {
+        [Test]
+        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);
+        }
+
+        [Test]
+        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>());
+        }
+
+        [Test]
+        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);
+        }
+
+        [Test]
+        public void TestInjectSource1()
+        {
+            Container.Bind<Foo>().AsCached();
+            Container.Bind<Foo>().AsCached();
+
+            var subContainer = Container.CreateSubContainer();
+            subContainer.Bind<Foo>().AsCached();
+
+            subContainer.Bind<Bar>().FromResolveAllGetter<Foo>(x => x.Bar);
+
+            Assert.IsEqual(subContainer.ResolveAll<Bar>().Count, 3);
+        }
+
+        [Test]
+        public void TestInjectSource2()
+        {
+            Container.Bind<Foo>().AsCached();
+            Container.Bind<Foo>().AsCached();
+
+            var subContainer = Container.CreateSubContainer();
+            subContainer.Bind<Foo>().AsCached();
+
+            subContainer.Bind<Bar>().FromResolveAllGetter<Foo>(null, x => x.Bar, InjectSources.Local);
+
+            Assert.IsEqual(subContainer.ResolveAll<Bar>().Count, 1);
+        }
+
+        [Test]
+        public void TestInjectSource3()
+        {
+            Container.Bind<Foo>().AsCached();
+            Container.Bind<Foo>().AsCached();
+
+            var subContainer = Container.CreateSubContainer();
+            subContainer.Bind<Foo>().AsCached();
+
+            subContainer.Bind<Bar>().FromResolveGetter<Foo>(null, x => x.Bar);
+
+            Assert.IsNotNull(subContainer.Resolve<Bar>());
+        }
+
+        [Test]
+        public void TestInjectSource4()
+        {
+            Container.Bind<Foo>().AsCached();
+
+            var subContainer = Container.CreateSubContainer();
+            subContainer.Bind<Foo>().AsCached();
+            subContainer.Bind<Foo>().AsCached();
+
+            subContainer.Bind<Bar>().FromResolveGetter<Foo>(null, x => x.Bar, InjectSources.Parent);
+
+            Assert.IsEqual(subContainer.ResolveAll<Bar>().Count, 1);
+        }
+
+        interface IBar
+        {
+        }
+
+        class Bar : IBar
+        {
+        }
+
+        class Foo
+        {
+            public Foo()
+            {
+                Bar = new Bar();
+            }
+
+            public Bar Bar
+            {
+                get; private set;
+            }
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromGetter.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 1d62dc62d45050143ae156ca7f735abf
+timeCreated: 1485738782
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromIFactory.cs

@@ -0,0 +1,61 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromIFactory : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void Test1()
+        {
+            Container.BindFactory<Foo, Foo.Factory>().WithId("foo1")
+                .FromIFactory(x => x.To<FooFactory>().AsCached().WithArguments("asdf"));
+
+            Container.BindFactory<Foo, Foo.Factory>().WithId("foo2")
+                .FromIFactory(x => x.To<FooFactory>().AsCached().WithArguments("zxcv"));
+
+            var factory1 = Container.ResolveId<Foo.Factory>("foo1");
+            var factory2 = Container.ResolveId<Foo.Factory>("foo2");
+
+            Assert.IsEqual(factory1.Create().Value, "asdf");
+            Assert.IsEqual(factory2.Create().Value, "zxcv");
+        }
+
+        public class Foo
+        {
+            public Foo(string value)
+            {
+                Value = value;
+            }
+
+            public string Value
+            {
+                get; private set;
+            }
+
+            public class Factory : PlaceholderFactory<Foo>
+            {
+            }
+        }
+
+        public class FooFactory : IFactory<Foo>
+        {
+            readonly string _value;
+            readonly DiContainer _container;
+
+            public FooFactory(
+                DiContainer container,
+                string value)
+            {
+                _value = value;
+                _container = container;
+            }
+
+            public Foo Create()
+            {
+                return _container.Instantiate<Foo>(new [] { _value });
+            }
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromIFactory.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 4dcea3c765b0e9149915042c669c1046
+timeCreated: 1520406909
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromIFactory2.cs

@@ -0,0 +1,74 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromIFactory2 : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void Test1()
+        {
+            Container.BindFactory<int, Foo, Foo.Factory>().WithId("foo1")
+                .FromIFactory(x => x.To<FooFactory>().AsCached().WithArguments("asdf"));
+
+            Container.BindFactory<int, Foo, Foo.Factory>().WithId("foo2")
+                .FromIFactory(x => x.To<FooFactory>().AsCached().WithArguments("zxcv"));
+
+            var factory1 = Container.ResolveId<Foo.Factory>("foo1");
+            var factory2 = Container.ResolveId<Foo.Factory>("foo2");
+
+            var foo1 = factory1.Create(5);
+            var foo2 = factory2.Create(2);
+
+            Assert.IsEqual(foo1.Value, "asdf");
+            Assert.IsEqual(foo1.Value2, 5);
+
+            Assert.IsEqual(foo2.Value, "zxcv");
+            Assert.IsEqual(foo2.Value2, 2);
+        }
+
+        public class Foo
+        {
+            public Foo(string value, int value2)
+            {
+                Value = value;
+                Value2 = value2;
+            }
+
+            public int Value2
+            {
+                get; private set;
+            }
+
+            public string Value
+            {
+                get; private set;
+            }
+
+            public class Factory : PlaceholderFactory<int, Foo>
+            {
+            }
+        }
+
+        public class FooFactory : IFactory<int, Foo>
+        {
+            readonly string _value;
+            readonly DiContainer _container;
+
+            public FooFactory(
+                DiContainer container,
+                string value)
+            {
+                _value = value;
+                _container = container;
+            }
+
+            public Foo Create(int value)
+            {
+                return _container.Instantiate<Foo>(new object [] { value, _value });
+            }
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromIFactory2.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 5f3553d18dec30b4eba317e9036f97dd
+timeCreated: 1520700394
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromInstance.cs

@@ -0,0 +1,52 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromInstance : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestTransient()
+        {
+            var foo = new Foo();
+
+            Container.Bind<IFoo>().FromInstance(foo).NonLazy();
+            Container.Bind<Foo>().FromInstance(foo).NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<IFoo>());
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        [Test]
+        public void TestSingle()
+        {
+            Container.Bind<Foo>().FromInstance(new Foo()).AsSingle().NonLazy();
+            Container.Bind<Foo>().AsSingle().NonLazy();
+
+            Assert.Throws(() => Container.FlushBindings());
+        }
+
+        // There's really no good reason to do this but it is part of the api
+        [Test]
+        public void TestCached()
+        {
+            var foo = new Foo();
+
+            Container.Bind<IFoo>().FromInstance(foo).AsSingle().NonLazy();
+            Container.Bind<Foo>().FromInstance(foo).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<IFoo>());
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        interface IFoo
+        {
+        }
+
+        class Foo : IFoo
+        {
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromInstance.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7bf907a08d456614db4e71411381f66a
+timeCreated: 1485738784
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromMethod.cs

@@ -0,0 +1,85 @@
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromMethod : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestSingle()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().FromMethod(ctx => foo).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        [Test]
+        public void TestTransient()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().FromMethod(ctx => foo).AsTransient().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        [Test]
+        public void TestCached()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().FromMethod(ctx => foo).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        Foo CreateFoo(InjectContext ctx)
+        {
+            return new Foo();
+        }
+
+        [Test]
+        public void TestTransient2()
+        {
+            int numCalls = 0;
+
+            Func<InjectContext, Foo> method = ctx =>
+            {
+                numCalls++;
+                return null;
+            };
+
+            Container.Bind<Foo>().FromMethod(method).AsTransient().NonLazy();
+            Container.Bind<IFoo>().To<Foo>().FromMethod(method).AsTransient().NonLazy();
+
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<IFoo>();
+
+            Assert.IsEqual(numCalls, 4);
+        }
+
+        [Test]
+        public void TestCached2()
+        {
+            Container.Bind(typeof(Foo), typeof(IFoo)).To<Foo>().FromMethod(ctx => new Foo()).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<Foo>());
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<IFoo>());
+        }
+
+        interface IFoo
+        {
+        }
+
+        class Foo : IFoo
+        {
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromMethod.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2f937d712d2be4042b394985b5b8f441
+timeCreated: 1485738782
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromMethodMultiple.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromMethodMultiple : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestSingle()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultiple(ctx => new[] { foo }).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        [Test]
+        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>().FromMethodMultiple(ctx => new[] { new Foo(), new Foo() }).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.ResolveAll<Foo>().Count, 2);
+        }
+
+        [Test]
+        public void TestMisc()
+        {
+            var foo1 = new Foo();
+            var foo2 = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultiple(ctx => new[] { foo1, foo2 });
+
+            var foos = Container.ResolveAll<Foo>();
+            Assert.IsEqual(foos[0], foo1);
+            Assert.IsEqual(foos[1], foo2);
+        }
+
+        [Test]
+        public void TestMisc2()
+        {
+            var foo1 = new Foo();
+            var foo2 = new Foo();
+            var foo3 = new Foo();
+            var foo4 = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultiple(ctx => new[] { foo1, foo2 });
+            Container.Bind<Foo>().FromMethodMultiple(ctx => new[] { foo3, foo4 });
+
+            var foos = Container.ResolveAll<Foo>();
+
+            Assert.IsEqual(foos[0], foo1);
+            Assert.IsEqual(foos[1], foo2);
+            Assert.IsEqual(foos[2], foo3);
+            Assert.IsEqual(foos[3], foo4);
+        }
+
+        [Test]
+        public void TestTransient()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultiple(ctx => new[] { foo }).AsTransient().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        [Test]
+        public void TestCached()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultiple(ctx => new[] { foo }).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        IEnumerable<Foo> CreateFoos(InjectContext ctx)
+        {
+            yield return new Foo();
+        }
+
+        [Test]
+        public void TestTransient2()
+        {
+            int numCalls = 0;
+
+            Func<InjectContext, IEnumerable<Foo>> method = ctx =>
+            {
+                numCalls++;
+                return new[] { new Foo() };
+            };
+
+            Container.Bind<Foo>().FromMethodMultiple(method).AsTransient().NonLazy();
+            Container.Bind<IFoo>().To<Foo>().FromMethodMultiple(method).AsTransient().NonLazy();
+
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<IFoo>();
+
+            Assert.IsEqual(numCalls, 4);
+        }
+
+        [Test]
+        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>());
+        }
+
+        interface IFoo
+        {
+        }
+
+        class Foo : IFoo
+        {
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromMethodMultiple.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fadc8263bac9f4941b06a03c82251f36
+timeCreated: 1485738789
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromMethodMultipleUntyped.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromMethodMultipleUntyped : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestSingle()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultipleUntyped(ctx => new[] { foo }).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        [Test]
+        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);
+        }
+
+        [Test]
+        public void TestMisc()
+        {
+            var foo1 = new Foo();
+            var foo2 = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultipleUntyped(ctx => new[] { foo1, foo2 });
+
+            var foos = Container.ResolveAll<Foo>();
+            Assert.IsEqual(foos[0], foo1);
+            Assert.IsEqual(foos[1], foo2);
+        }
+
+        [Test]
+        public void TestMisc2()
+        {
+            var foo1 = new Foo();
+            var foo2 = new Foo();
+            var foo3 = new Foo();
+            var foo4 = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultipleUntyped(ctx => new[] { foo1, foo2 });
+            Container.Bind<Foo>().FromMethodMultipleUntyped(ctx => new[] { foo3, foo4 });
+
+            var foos = Container.ResolveAll<Foo>();
+
+            Assert.IsEqual(foos[0], foo1);
+            Assert.IsEqual(foos[1], foo2);
+            Assert.IsEqual(foos[2], foo3);
+            Assert.IsEqual(foos[3], foo4);
+        }
+
+        [Test]
+        public void TestTransient()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultipleUntyped(ctx => new[] { foo }).AsTransient().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        [Test]
+        public void TestCached()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().FromMethodMultipleUntyped(ctx => new[] { foo }).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), foo);
+        }
+
+        IEnumerable<Foo> CreateFoos(InjectContext ctx)
+        {
+            yield return new Foo();
+        }
+
+        [Test]
+        public void TestTransient2()
+        {
+            int numCalls = 0;
+
+            Func<InjectContext, IEnumerable<object>> method = ctx =>
+            {
+                numCalls++;
+                return new[] { new Foo() };
+            };
+
+            Container.Bind<Foo>().FromMethodMultipleUntyped(method).AsTransient().NonLazy();
+            Container.Bind<IFoo>().To<Foo>().FromMethodMultipleUntyped(method).AsTransient().NonLazy();
+
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<Foo>();
+            Container.Resolve<IFoo>();
+
+            Assert.IsEqual(numCalls, 4);
+        }
+
+        [Test]
+        public void TestCached2()
+        {
+            Container.Bind(typeof(Foo), typeof(IFoo)).To<Foo>().FromMethodMultipleUntyped(ctx => new[] { new Foo() }).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<Foo>());
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<IFoo>());
+        }
+
+        interface IFoo
+        {
+        }
+
+        class Foo : IFoo
+        {
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromMethodMultipleUntyped.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c9c6a37cf443b134e91d0b7eb1c1532e
+timeCreated: 1529064998
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromResolve.cs

@@ -0,0 +1,207 @@
+using System.Linq;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromResolve : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestTransient()
+        {
+            var foo = new Foo();
+
+            Container.BindInstance(foo);
+            Container.Bind<IFoo>().To<Foo>().FromResolve();
+
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.Resolve<Foo>());
+            Assert.IsEqual(Container.Resolve<IFoo>(), foo);
+        }
+
+        [Test]
+        public void TestIdentifier()
+        {
+            var foo = new Foo();
+
+            Container.Bind<Foo>().WithId("foo").FromInstance(foo);
+            Container.Bind<IFoo>().To<Foo>().FromResolve("foo");
+
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.ResolveId<Foo>("foo"));
+            Assert.IsEqual(Container.Resolve<IFoo>(), foo);
+        }
+
+        [Test]
+        public void TestCached()
+        {
+            Container.Bind<Foo>().AsTransient();
+            Container.Bind<IFoo>().To<Foo>().FromResolve().AsCached();
+
+            Assert.IsNotEqual(Container.Resolve<Foo>(), Container.Resolve<Foo>());
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.Resolve<IFoo>());
+        }
+
+        [Test]
+        public void TestSingle()
+        {
+            var foo = new Foo();
+            Container.Bind<Foo>().FromInstance(foo);
+            Container.Bind<IFoo>().To<Foo>().FromResolve();
+
+            Assert.IsEqual(Container.Resolve<IFoo>(), foo);
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.Resolve<IFoo>());
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestNoMatch()
+        {
+            Container.Bind<IFoo>().To<Foo>().FromResolve();
+
+            Assert.Throws(() => Container.Resolve<IFoo>());
+        }
+
+        [Test]
+        public void TestSingleFailure()
+        {
+            Container.Bind<Foo>().AsCached();
+            Container.Bind<Foo>().AsCached();
+            Container.Bind<IFoo>().To<Foo>().FromResolve();
+
+            Assert.Throws(() => Container.Resolve<IFoo>());
+        }
+
+        [Test]
+        public void TestInfiniteLoop()
+        {
+            Container.Bind<IFoo>().To<IFoo>().FromResolve().AsSingle();
+
+            Assert.Throws(() => Container.Resolve<IFoo>());
+        }
+
+        [Test]
+        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);
+        }
+
+        [Test]
+        public void TestResolveManyTransient2()
+        {
+            Container.Bind<Foo>().AsTransient();
+            Container.Bind<Foo>().FromInstance(new Foo());
+
+            Container.Bind(typeof(IFoo), typeof(IBar)).To<Foo>().FromResolveAll();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count, 2);
+            Assert.IsEqual(Container.ResolveAll<IBar>().Count, 2);
+        }
+
+        [Test]
+        public void TestResolveManyCached()
+        {
+            Container.Bind<Foo>().AsTransient();
+            Container.Bind<Foo>().AsTransient();
+
+            Container.Bind<IFoo>().To<Foo>().FromResolveAll().AsCached();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count, 2);
+            Assert.That(Enumerable.SequenceEqual(Container.ResolveAll<IFoo>(), Container.ResolveAll<IFoo>()));
+        }
+
+        [Test]
+        public void TestResolveManyCached2()
+        {
+            Container.Bind<Foo>().AsTransient();
+            Container.Bind<Foo>().AsTransient();
+
+            Container.Bind(typeof(IFoo), typeof(IBar)).To<Foo>().FromResolveAll().AsCached();
+
+            Assert.IsEqual(Container.ResolveAll<IBar>().Count, 2);
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count, 2);
+            Assert.That(Enumerable.SequenceEqual(Container.ResolveAll<IFoo>().Cast<object>(), Container.ResolveAll<IBar>().Cast<object>()));
+        }
+
+        [Test]
+        public void TestResolveManyCached3()
+        {
+            Container.Bind<Foo>().AsTransient();
+            Container.Bind<Foo>().AsTransient();
+
+            Container.Bind<IFoo>().To<Foo>().FromResolveAll().AsCached();
+            Container.Bind<IBar>().To<Foo>().FromResolveAll().AsCached();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count, 2);
+            Assert.IsEqual(Container.ResolveAll<IBar>().Count, 2);
+            Assert.That(!Enumerable.SequenceEqual(Container.ResolveAll<IFoo>().Cast<object>(), Container.ResolveAll<IBar>().Cast<object>()));
+        }
+
+        [Test]
+        public void TestResolveSingleLocal()
+        {
+            var foo1 = new Foo();
+            var foo2 = new Foo();
+
+            Container.Bind<Foo>().FromInstance(foo1);
+
+            var subContainer = Container.CreateSubContainer();
+            subContainer.Bind<Foo>().FromInstance(foo2);
+
+            subContainer.Bind<IFoo>().To<Foo>().FromResolve();
+
+            Assert.IsEqual(subContainer.Resolve<IFoo>(), foo2);
+        }
+
+        [Test]
+        public void TestInjectSource1()
+        {
+            var foo1 = new Foo();
+            var foo2 = new Foo();
+
+            Container.Bind<Foo>().FromInstance(foo1);
+
+            var subContainer = Container.CreateSubContainer();
+            subContainer.Bind<Foo>().FromInstance(foo2);
+
+            subContainer.Bind<IFoo>().To<Foo>().FromResolve(null, InjectSources.Parent);
+
+            Assert.IsEqual(subContainer.Resolve<IFoo>(), foo1);
+        }
+
+        [Test]
+        public void TestInjectSource2()
+        {
+            var foo1 = new Foo();
+            var foo2 = new Foo();
+            var foo3 = new Foo();
+
+            Container.Bind<Foo>().FromInstance(foo1);
+
+            var subContainer = Container.CreateSubContainer();
+            subContainer.Bind<Foo>().FromInstance(foo2);
+            subContainer.Bind<Foo>().FromInstance(foo3);
+
+            subContainer.Bind<IFoo>().To<Foo>().FromResolveAll(null, InjectSources.Local);
+
+            Assert.Throws(() => subContainer.Resolve<IFoo>());
+            Assert.That(Enumerable.SequenceEqual(subContainer.ResolveAll<IFoo>(), new [] { foo2, foo3, }));
+        }
+
+        interface IBar
+        {
+        }
+
+        interface IFoo
+        {
+        }
+
+        class Foo : IFoo, IBar
+        {
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromResolve.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0b37e8adbb14af84ba212744b2bd2804
+timeCreated: 1485738781
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromSubContainerInstaller.cs

@@ -0,0 +1,124 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromSubContainerInstaller : ZenjectUnitTestFixture
+    {
+        [Test]
+        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>());
+        }
+
+        [Test]
+        public void TestInstallerSelfTransient()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve().ByInstaller<FooInstaller>().AsTransient().NonLazy();
+
+            var foo = Container.Resolve<Foo>();
+            Assert.IsNotNull(foo.Bar);
+            Assert.IsNotEqual(foo, Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestInstallerSelfCached()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve().ByInstaller<FooInstaller>().AsSingle().NonLazy();
+
+            var foo = Container.Resolve<Foo>();
+            Assert.IsNotNull(foo.Bar);
+            Assert.IsEqual(foo, Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestInstallerSelfSingleMultipleContracts()
+        {
+            Container.Bind(typeof(Foo), typeof(Bar)).FromSubContainerResolve().ByInstaller<FooInstaller>().AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>().Bar, Container.Resolve<Bar>());
+        }
+
+        [Test]
+        public void TestInstallerSelfCachedMultipleContracts()
+        {
+            Container.Bind(typeof(Foo), typeof(IFoo)).To<Foo>().FromSubContainerResolve().ByInstaller<FooInstaller>().AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<IFoo>());
+        }
+
+        [Test]
+        public void TestInstallerSelfSingleMultipleMatches()
+        {
+            Container.Bind<Qux>().FromSubContainerResolveAll().ByInstaller<FooInstaller>().AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.ResolveAll<Qux>().Count, 2);
+        }
+
+        [Test]
+        public void TestInstallerSelfIdentifiersFails()
+        {
+            Container.Bind<Gorp>().FromSubContainerResolve().ByInstaller<FooInstaller>().AsSingle().NonLazy();
+
+            Assert.Throws(() => Container.Resolve<Gorp>());
+        }
+
+        [Test]
+        public void TestInstallerSelfIdentifiers()
+        {
+            Container.Bind<Gorp>().FromSubContainerResolve("gorp").ByInstaller<FooInstaller>().AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Gorp>());
+        }
+
+        public class Gorp
+        {
+        }
+
+        public class Qux
+        {
+        }
+
+        public class Bar
+        {
+        }
+
+        public interface IFoo
+        {
+        }
+
+        public class Foo : IFoo
+        {
+            public Foo(Bar bar)
+            {
+                Bar = bar;
+            }
+
+            public Bar Bar
+            {
+                get;
+                private set;
+            }
+        }
+
+        class FooInstaller : Installer<FooInstaller>
+        {
+            public override void InstallBindings()
+            {
+                Container.Bind<Foo>().AsSingle();
+                Container.Bind<Bar>().AsSingle();
+
+                Container.Bind<Qux>().AsTransient();
+                Container.Bind<Qux>().FromInstance(new Qux());
+
+                Container.Bind<Gorp>().WithId("gorp").AsTransient();
+            }
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromSubContainerInstaller.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0d941aa49ba79854487ffabb59b0a24f
+timeCreated: 1485738781
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromSubContainerInstance.cs

@@ -0,0 +1,128 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromSubContainerInstance : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestInstallerSelfSingle()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve()
+                .ByInstance(CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>().Bar);
+        }
+
+        [Test]
+        public void TestInstallerSelfTransient()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve().ByInstance(
+                CreateFooSubContainer()).AsTransient().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>().Bar);
+        }
+
+        [Test]
+        public void TestInstallerSelfCached()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve()
+                .ByInstance(CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>().Bar);
+        }
+
+        [Test]
+        public void TestInstallerSelfSingleMultipleContracts()
+        {
+            Container.Bind(typeof(Foo), typeof(Bar)).FromSubContainerResolve()
+                .ByInstance(CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>().Bar, Container.Resolve<Bar>());
+        }
+
+        [Test]
+        public void TestInstallerSelfCachedMultipleContracts()
+        {
+            Container.Bind(typeof(Foo), typeof(IFoo)).To<Foo>().FromSubContainerResolve()
+                .ByInstance(CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>(), Container.Resolve<IFoo>());
+        }
+
+        [Test]
+        public void TestInstallerSelfSingleMultipleMatches()
+        {
+            Container.Bind<Qux>().FromSubContainerResolveAll()
+                .ByInstance(CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.ResolveAll<Qux>().Count, 2);
+        }
+
+        [Test]
+        public void TestInstallerSelfIdentifiersFails()
+        {
+            Container.Bind<Gorp>().FromSubContainerResolve()
+                .ByInstance(CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.Throws(() => Container.Resolve<Gorp>());
+        }
+
+        [Test]
+        public void TestInstallerSelfIdentifiers()
+        {
+            Container.Bind<Gorp>().FromSubContainerResolve("gorp")
+                .ByInstance(CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Gorp>());
+        }
+
+        public class Gorp
+        {
+        }
+
+        public class Qux
+        {
+        }
+
+        public class Bar
+        {
+        }
+
+        public interface IFoo
+        {
+        }
+
+        public class Foo : IFoo
+        {
+            public Foo(Bar bar)
+            {
+                Bar = bar;
+            }
+
+            public Bar Bar
+            {
+                get;
+                private set;
+            }
+        }
+
+        DiContainer CreateFooSubContainer()
+        {
+            var subContainer = new DiContainer();
+
+            subContainer.Bind<Foo>().AsSingle();
+            subContainer.Bind<Bar>().AsSingle();
+
+            subContainer.Bind<Qux>().AsTransient();
+            subContainer.Bind<Qux>().FromInstance(new Qux());
+
+            subContainer.Bind<Gorp>().WithId("gorp").AsTransient();
+
+            return subContainer;
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromSubContainerInstance.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 1435f07f5e446424ab1523f4aed91c0c
+timeCreated: 1535189469
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromSubContainerInstanceGetter.cs

@@ -0,0 +1,129 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromSubContainerInstanceGetter : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestInstallerSelfSingle()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve()
+                .ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>().Bar);
+        }
+
+        [Test]
+        public void TestInstallerSelfTransient()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve()
+                .ByInstanceGetter(ctx => CreateFooSubContainer()).AsTransient().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>().Bar);
+        }
+
+        [Test]
+        public void TestInstallerSelfCached()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve()
+                .ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo>().Bar);
+        }
+
+        [Test]
+        public void TestInstallerSelfSingleMultipleContracts()
+        {
+            Container.Bind(typeof(Foo), typeof(Bar)).FromSubContainerResolve()
+                .ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>().Bar, Container.Resolve<Bar>());
+        }
+
+        [Test]
+        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>());
+        }
+
+        [Test]
+        public void TestInstallerSelfSingleMultipleMatches()
+        {
+            Container.Bind<Qux>().FromSubContainerResolveAll()
+                .ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.ResolveAll<Qux>().Count, 2);
+        }
+
+        [Test]
+        public void TestInstallerSelfIdentifiersFails()
+        {
+            Container.Bind<Gorp>().FromSubContainerResolve()
+                .ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.Throws(() => Container.Resolve<Gorp>());
+        }
+
+        [Test]
+        public void TestInstallerSelfIdentifiers()
+        {
+            Container.Bind<Gorp>().FromSubContainerResolve("gorp")
+                .ByInstanceGetter(ctx => CreateFooSubContainer()).AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Gorp>());
+        }
+
+        public class Gorp
+        {
+        }
+
+        public class Qux
+        {
+        }
+
+        public class Bar
+        {
+        }
+
+        public interface IFoo
+        {
+        }
+
+        public class Foo : IFoo
+        {
+            public Foo(Bar bar)
+            {
+                Bar = bar;
+            }
+
+            public Bar Bar
+            {
+                get;
+                private set;
+            }
+        }
+
+        DiContainer CreateFooSubContainer()
+        {
+            var subContainer = new DiContainer();
+
+            subContainer.Bind<Foo>().AsSingle();
+            subContainer.Bind<Bar>().AsSingle();
+
+            subContainer.Bind<Qux>().AsTransient();
+            subContainer.Bind<Qux>().FromInstance(new Qux());
+
+            subContainer.Bind<Gorp>().WithId("gorp").AsTransient();
+
+            return subContainer;
+        }
+    }
+}
+
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromSubContainerInstanceGetter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 933792039e2b04441933af16ce414f05
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromSubContainerMethod.cs

@@ -0,0 +1,144 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromSubContainerMethod : ZenjectUnitTestFixture
+    {
+        [Test]
+        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>());
+        }
+
+        [Test]
+        public void TestMethodSelfTransient()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve().ByMethod(InstallFooFacade).AsTransient().NonLazy();
+
+            var foo = Container.Resolve<Foo>();
+            Assert.IsNotNull(foo.Bar);
+            Assert.IsNotEqual(foo, Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestDanglingBinding()
+        {
+            Container.Bind<Bar>().FromSubContainerResolve();
+
+            Assert.Throws(() => Container.Resolve<Bar>());
+        }
+
+        [Test]
+        public void TestMethodSelfCached()
+        {
+            Container.Bind<Foo>().FromSubContainerResolve().ByMethod(InstallFooFacade).AsSingle().NonLazy();
+
+            var foo = Container.Resolve<Foo>();
+            Assert.IsNotNull(foo.Bar);
+            Assert.IsEqual(foo, Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestMethodSelfCachedMultipleContracts()
+        {
+            Container.Bind(typeof(Foo), typeof(Bar)).FromSubContainerResolve().ByMethod(InstallFooFacade).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo>().Bar, Container.Resolve<Bar>());
+        }
+
+        [Test]
+        public void TestMethodConcreteSingle()
+        {
+            Container.Bind<IFoo>().To<Foo>().FromSubContainerResolve().ByMethod(InstallFooFacade).AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<IFoo>().Bar);
+        }
+
+        [Test]
+        public void TestMethodConcreteTransient()
+        {
+            Container.Bind<IFoo>().To<Foo>().FromSubContainerResolve().ByMethod(InstallFooFacade).AsTransient().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<IFoo>().Bar);
+        }
+
+        [Test]
+        public void TestMethodConcreteCached()
+        {
+            Container.Bind<IFoo>().To<Foo>()
+                .FromSubContainerResolve().ByMethod(InstallFooFacade).AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<IFoo>().Bar);
+        }
+
+        [Test]
+        public void TestMethodConcreteCachedMultipleContracts()
+        {
+            Container.Bind(typeof(Foo), typeof(IFoo)).To<Foo>().FromSubContainerResolve().ByMethod(InstallFooFacade).AsSingle().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<IFoo>(), Container.Resolve<Foo>());
+        }
+
+        [Test]
+        public void TestMethodSelfIdentifiersFails()
+        {
+            Container.Bind<Gorp>().FromSubContainerResolve().ByMethod(InstallFooFacade).AsSingle().NonLazy();
+
+            Assert.Throws(() => Container.Resolve<Gorp>());
+        }
+
+        [Test]
+        public void TestMethodSelfIdentifiers()
+        {
+            Container.Bind<Gorp>().FromSubContainerResolve("gorp").ByMethod(InstallFooFacade).AsSingle().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Gorp>());
+        }
+
+        public class Gorp
+        {
+        }
+
+        public class Bar
+        {
+        }
+
+        public interface IFoo
+        {
+            Bar Bar
+            {
+                get;
+            }
+        }
+
+        public class Foo : IFoo
+        {
+            public Foo(Bar bar)
+            {
+                Bar = bar;
+            }
+
+            public Bar Bar
+            {
+                get;
+                private set;
+            }
+        }
+
+        void InstallFooFacade(DiContainer container)
+        {
+            container.Bind<Foo>().AsSingle();
+            container.Bind<Bar>().AsSingle();
+
+            container.Bind<Gorp>().WithId("gorp").AsTransient();
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestFromSubContainerMethod.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0aca0ea3c3e68134886983eb884c26c0
+timeCreated: 1485738781
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestNonGeneric.cs

@@ -0,0 +1,57 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestNonGeneric : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void Test1()
+        {
+            Assert.Throws(() =>
+                Container.Bind(typeof(IFoo), typeof(IBar)).To(typeof(Foo)).AsCached());
+        }
+
+        [Test]
+        public void Test2()
+        {
+            Assert.Throws(() =>
+                Container.Bind<IFoo>().To(typeof(Bar)).AsCached());
+        }
+
+        [Test]
+        public void Test3()
+        {
+            Assert.Throws(() =>
+                Container.Bind(typeof(IFoo)).To(typeof(Bar), typeof(Foo)).AsCached());
+        }
+
+        [Test]
+        public void Test4()
+        {
+            // This case is more lenient and just ignores invalid bindings
+            Container.Bind(typeof(IFoo), typeof(IBar)).To(typeof(Foo), typeof(Bar)).AsCached();
+
+            Assert.IsNotNull(Container.Resolve<IFoo>());
+            Assert.IsNotNull(Container.Resolve<IBar>());
+        }
+
+        public interface IBar
+        {
+        }
+
+        public interface IFoo
+        {
+        }
+
+        public class Bar : IBar
+        {
+        }
+
+        public class Foo : IFoo
+        {
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestNonGeneric.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 304074b8e887c2945b28ba359d69b282
+timeCreated: 1521270889
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestWithKernel.cs

@@ -0,0 +1,150 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestWithKernel : ZenjectUnitTestFixture
+    {
+        static int GlobalInitializeCount;
+
+        public class Foo : IInitializable
+        {
+            public bool WasInitialized
+            {
+                get; private set;
+            }
+
+            public int InitializeCount
+            {
+                get; private set;
+            }
+
+            public void Initialize()
+            {
+                InitializeCount = ++GlobalInitializeCount;
+                WasInitialized = true;
+            }
+        }
+
+        public class FooFacade
+        {
+            [Inject]
+            public Foo Foo
+            {
+                get; private set;
+            }
+        }
+
+        public class FooInstaller : Installer<FooInstaller>
+        {
+            public override void InstallBindings()
+            {
+                InstallFoo(Container);
+            }
+        }
+
+        static void InstallFoo(DiContainer subContainer)
+        {
+            subContainer.Bind<FooFacade>().AsSingle();
+            subContainer.BindInterfacesAndSelfTo<Foo>().AsSingle();
+        }
+
+        [Test]
+        public void TestByInstaller()
+        {
+            Container.Bind<FooFacade>().FromSubContainerResolve()
+                .ByInstaller<FooInstaller>().WithKernel().AsSingle();
+
+            ZenjectManagersInstaller.Install(Container);
+            Container.ResolveRoots();
+
+            var facade = Container.Resolve<FooFacade>();
+
+            Assert.That(!facade.Foo.WasInitialized);
+            Container.Resolve<InitializableManager>().Initialize();
+            Assert.That(facade.Foo.WasInitialized);
+        }
+
+        [Test]
+        public void TestByMethod()
+        {
+            Container.Bind<FooFacade>().FromSubContainerResolve()
+                .ByMethod(InstallFoo).WithKernel().AsSingle();
+
+            ZenjectManagersInstaller.Install(Container);
+            Container.ResolveRoots();
+
+            var facade = Container.Resolve<FooFacade>();
+
+            Assert.That(!facade.Foo.WasInitialized);
+            Container.Resolve<InitializableManager>().Initialize();
+            Assert.That(facade.Foo.WasInitialized);
+        }
+
+        public class FooKernel : Kernel
+        {
+        }
+
+        public class Bar : IInitializable
+        {
+            public int InitializeCount
+            {
+                get; private set;
+            }
+
+            public void Initialize()
+            {
+                InitializeCount = ++GlobalInitializeCount;
+            }
+        }
+
+        [Test]
+        public void TestByInstallerCustomOrder()
+        {
+            GlobalInitializeCount = 0;
+
+            Container.BindInterfacesAndSelfTo<Bar>().AsSingle();
+            Container.Bind<FooFacade>().FromSubContainerResolve()
+                .ByInstaller<FooInstaller>().WithKernel<FooKernel>().AsSingle();
+
+            ZenjectManagersInstaller.Install(Container);
+            Container.ResolveRoots();
+
+            var facade = Container.Resolve<FooFacade>();
+
+            Assert.That(!facade.Foo.WasInitialized);
+            Container.Resolve<InitializableManager>().Initialize();
+            Assert.That(facade.Foo.WasInitialized);
+
+            Assert.IsEqual(Container.Resolve<Bar>().InitializeCount, 1);
+            Assert.IsEqual(facade.Foo.InitializeCount, 2);
+        }
+
+        [Test]
+        public void TestByInstallerCustomOrder2()
+        {
+            GlobalInitializeCount = 0;
+
+            Container.BindInterfacesAndSelfTo<Bar>().AsSingle();
+            Container.Bind<FooFacade>().FromSubContainerResolve()
+                .ByInstaller<FooInstaller>().WithKernel<FooKernel>().AsSingle();
+
+            Container.BindExecutionOrder<FooKernel>(-1);
+
+            ZenjectManagersInstaller.Install(Container);
+            Container.ResolveRoots();
+
+            var facade = Container.Resolve<FooFacade>();
+
+            Assert.That(!facade.Foo.WasInitialized);
+            Container.Resolve<InitializableManager>().Initialize();
+            Assert.That(facade.Foo.WasInitialized);
+
+            Assert.IsEqual(Container.Resolve<Bar>().InitializeCount, 2);
+            Assert.IsEqual(facade.Foo.InitializeCount, 1);
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Bindings/TestWithKernel.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: a2f3ac87f43046e4896f1a00fa6a847e
+timeCreated: 1535185352
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a01ea76b569d29e408de9e06455bc52f
+folderAsset: yes
+timeCreated: 1461711436
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsBasic.cs

@@ -0,0 +1,68 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Conditions
+{
+    [TestFixture]
+    public class TestConditionsBasic : ZenjectUnitTestFixture
+    {
+        public interface IFoo
+        {
+        }
+
+        class Foo1 : IFoo
+        {
+        }
+
+        class Foo2 : IFoo
+        {
+        }
+
+        class Bar1
+        {
+            public IFoo Foo;
+
+            public Bar1(IFoo foo)
+            {
+                Foo = foo;
+            }
+        }
+
+        class Bar2
+        {
+            public IFoo Foo;
+
+            public Bar2(IFoo foo)
+            {
+                Foo = foo;
+            }
+        }
+
+        [Test]
+        public void Test1()
+        {
+            Container.Bind<Bar1>().AsSingle().NonLazy();
+            Container.Bind<Bar2>().AsSingle().NonLazy();
+            Container.Bind<IFoo>().To<Foo1>().AsSingle().NonLazy();
+            Container.Bind<IFoo>().To<Foo2>().AsSingle().WhenInjectedInto<Bar2>().NonLazy();
+
+            Assert.IsNotEqual(
+                Container.Resolve<Bar1>().Foo, Container.Resolve<Bar2>().Foo);
+        }
+
+        [Test]
+        public void Test2()
+        {
+            Container.Bind<Bar1>().AsSingle().NonLazy();
+            Container.Bind<Bar2>().AsSingle().NonLazy();
+            Container.Bind<IFoo>().To<Foo1>().AsSingle().NonLazy();
+            Container.Bind<IFoo>().To<Foo2>().AsSingle().WhenNotInjectedInto<Bar1>().NonLazy();
+
+            Assert.IsNotEqual(
+                Container.Resolve<Bar1>().Foo, Container.Resolve<Bar2>().Foo);
+        }
+    }
+}
+
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsBasic.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6cb63718e40b7bd429fc93d4542aaf01
+timeCreated: 1461708051
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsComplex.cs

@@ -0,0 +1,40 @@
+using System.Linq;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Conditions
+{
+    [TestFixture]
+    public class TestConditionsComplex : ZenjectUnitTestFixture
+    {
+        class Foo
+        {
+        }
+
+        class Bar
+        {
+            public Foo Foo;
+
+            public Bar(Foo foo)
+            {
+                Foo = foo;
+            }
+        }
+
+        [Test]
+        public void TestCorrespondingIdentifiers()
+        {
+            var foo1 = new Foo();
+            var foo2 = new Foo();
+
+            Container.Bind<Bar>().WithId("Bar1").AsTransient().NonLazy();
+            Container.Bind<Bar>().WithId("Bar2").AsTransient().NonLazy();
+
+            Container.BindInstance(foo1).When(c => c.ParentContexts.Where(x => x.MemberType == typeof(Bar) && Equals(x.Identifier, "Bar1")).Any());
+            Container.BindInstance(foo2).When(c => c.ParentContexts.Where(x => x.MemberType == typeof(Bar) && Equals(x.Identifier, "Bar2")).Any());
+
+            Assert.IsEqual(Container.ResolveId<Bar>("Bar1").Foo, foo1);
+            Assert.IsEqual(Container.ResolveId<Bar>("Bar2").Foo, foo2);
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsComplex.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f34becbac266acf42a68abcd73423b00
+timeCreated: 1461708055
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsFieldName.cs

@@ -0,0 +1,55 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Conditions
+{
+    [TestFixture]
+    public class TestConditionsFieldName : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+
+        }
+
+        class Test1
+        {
+            public Test1(Test0 name1)
+            {
+            }
+        }
+
+        class Test2
+        {
+            public Test2(Test0 name2)
+            {
+            }
+        }
+
+        public override void Setup()
+        {
+            base.Setup();
+            Container.Bind<Test0>().AsSingle().When(r => r.MemberName == "name1");
+        }
+
+        [Test]
+        public void TestNameConditionError()
+        {
+            Container.Bind<Test2>().AsSingle().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test2>(); });
+        }
+
+        [Test]
+        public void TestNameConditionSuccess()
+        {
+            Container.Bind<Test1>().AsSingle().NonLazy();
+
+            var test1 = Container.Resolve<Test1>();
+
+            Assert.That(test1 != null);
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsFieldName.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6eacf4d3f8215d54dadba7ba02a91fbf
+timeCreated: 1461708051
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsIdentifier.cs

@@ -0,0 +1,144 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Conditions
+{
+    [TestFixture]
+    public class TestConditionsIdentifier : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        class Test1
+        {
+            public Test1(
+                [Inject(Id ="foo")]
+                Test0 name1)
+            {
+            }
+        }
+
+        class Test2
+        {
+            [Inject(Id ="foo")]
+            public Test0 name2 = null;
+        }
+
+        [Test]
+        public void TestUnspecifiedNameConstructorInjection()
+        {
+            Container.Bind<Test1>().AsTransient().NonLazy();
+            Container.Bind<Test0>().AsTransient().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test1>(); });
+        }
+
+        [Test]
+        public void TestUnspecifiedNameFieldInjection()
+        {
+            Container.Bind<Test1>().AsTransient().NonLazy();
+            Container.Bind<Test2>().AsTransient().NonLazy();
+
+            Container.Bind<Test0>().AsTransient().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test2>(); });
+        }
+
+        [Test]
+        public void TestSuccessConstructorInjectionString()
+        {
+            Container.Bind<Test1>().AsTransient().NonLazy();
+            Container.Bind<Test2>().AsTransient().NonLazy();
+
+            Container.Bind<Test0>().FromInstance(new Test0()).NonLazy();
+            Container.Bind<Test0>().WithId("foo").FromInstance(new Test0()).NonLazy();
+
+            // Should not throw exceptions
+            Container.Resolve<Test1>();
+
+            Assert.IsNotNull(Container.Resolve<Test1>());
+        }
+
+        [Test]
+        public void TestSuccessFieldInjectionString()
+        {
+            Container.Bind<Test1>().AsTransient().NonLazy();
+            Container.Bind<Test2>().AsTransient().NonLazy();
+
+            Container.Bind<Test0>().FromInstance(new Test0()).NonLazy();
+            Container.Bind<Test0>().WithId("foo").FromInstance(new Test0()).NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Test2>());
+        }
+
+        class Test3
+        {
+            public Test3(
+                [Inject(Id ="TestValue2")]
+                Test0 test0)
+            {
+            }
+        }
+
+        class Test4
+        {
+
+        }
+
+        [Test]
+        public void TestFailConstructorInjectionEnum()
+        {
+            Container.Bind<Test1>().AsTransient().NonLazy();
+            Container.Bind<Test2>().AsTransient().NonLazy();
+            Container.Bind<Test3>().AsTransient().NonLazy();
+
+            Container.Bind<Test0>().FromInstance(new Test0()).NonLazy();
+            Container.Bind<Test0>().WithId("TestValue1").FromInstance(new Test0()).NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test3>(); });
+        }
+
+        [Test]
+        public void TestSuccessConstructorInjectionEnum()
+        {
+            Container.Bind<Test3>().AsTransient().NonLazy();
+
+            Container.Bind<Test0>().FromInstance(new Test0()).NonLazy();
+            Container.Bind<Test0>().WithId("TestValue2").FromInstance(new Test0()).NonLazy();
+
+            // No exceptions
+            Container.Resolve<Test3>();
+
+            Assert.IsNotNull(Container.Resolve<Test3>());
+        }
+
+        [Test]
+        public void TestFailFieldInjectionEnum()
+        {
+            Container.Bind<Test1>().AsTransient().NonLazy();
+            Container.Bind<Test2>().AsTransient().NonLazy();
+            Container.Bind<Test3>().AsTransient().NonLazy();
+
+            Container.Bind<Test0>().FromInstance(new Test0()).NonLazy();
+            Container.Bind<Test0>().WithId("TestValue1").FromInstance(new Test0()).NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test3>(); });
+        }
+
+        [Test]
+        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>());
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsIdentifier.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a3c3d9696613b32448c9d67ce36945e8
+timeCreated: 1461708052
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsParents.cs

@@ -0,0 +1,131 @@
+using System.Linq;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Conditions
+{
+    [TestFixture]
+    public class TestConditionsParents : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        interface ITest1
+        {
+        }
+
+        class Test1 : ITest1
+        {
+            public Test0 test0;
+
+            public Test1(Test0 test0)
+            {
+                this.test0 = test0;
+            }
+        }
+
+        class Test2 : ITest1
+        {
+            public Test0 test0;
+
+            public Test2(Test0 test0)
+            {
+                this.test0 = test0;
+            }
+        }
+
+        class Test3 : ITest1
+        {
+            public Test1 test1;
+
+            public Test3(Test1 test1)
+            {
+                this.test1 = test1;
+            }
+        }
+
+        class Test4 : ITest1
+        {
+            public Test1 test1;
+
+            public Test4(Test1 test1)
+            {
+                this.test1 = test1;
+            }
+        }
+
+        [Test]
+        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>(); });
+        }
+
+        [Test]
+        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);
+        }
+
+        // Test using parents to look deeper up the heirarchy..
+        [Test]
+        public void TestCase3()
+        {
+            var t0a = new Test0();
+            var t0b = new Test0();
+
+            Container.Bind<Test3>().AsSingle();
+            Container.Bind<Test4>().AsSingle();
+            Container.Bind<Test1>().AsTransient();
+
+            Container.Bind<Test0>().FromInstance(t0a).When(c => c.AllObjectTypes.Contains(typeof(Test3)));
+            Container.Bind<Test0>().FromInstance(t0b).When(c => c.AllObjectTypes.Contains(typeof(Test4)));
+
+            var test3 = Container.Resolve<Test3>();
+
+            var test4 = Container.Resolve<Test4>();
+
+            Assert.That(ReferenceEquals(test3.test1.test0, t0a));
+            Assert.That(ReferenceEquals(test4.test1.test0, t0b));
+        }
+
+        [Test]
+        public void TestCase4()
+        {
+            Container.Bind<ITest1>().To<Test2>().AsSingle().NonLazy();
+            Container.Bind<Test0>().AsSingle().When(c => c.AllObjectTypes.Contains(typeof(ITest1)));
+
+            Assert.Throws(
+                delegate { Container.Resolve<ITest1>(); });
+        }
+
+        [Test]
+        public void TestCase5()
+        {
+            Container.Bind<ITest1>().To<Test2>().AsSingle().NonLazy();
+            Container.Bind<Test0>().AsSingle().When(c => c.AllObjectTypes.Contains(typeof(Test2)));
+
+            var test1 = Container.Resolve<ITest1>();
+            Assert.That(test1 != null);
+        }
+
+        [Test]
+        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);
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsParents.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 12290b4e2fc99dd4197a95555c4b7742
+timeCreated: 1461708048
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsTarget.cs

@@ -0,0 +1,54 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Conditions
+{
+    [TestFixture]
+    public class TestConditionsTarget : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        class Test1
+        {
+            public Test1(Test0 test)
+            {
+            }
+        }
+
+        class Test2
+        {
+            public Test2(Test0 test)
+            {
+            }
+        }
+
+        public override void Setup()
+        {
+            base.Setup();
+            Container.Bind<Test0>().AsSingle().When(r => r.ObjectType == typeof(Test2));
+        }
+
+        [Test]
+        public void TestTargetConditionError()
+        {
+            Container.Bind<Test1>().AsSingle().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test1>(); });
+        }
+
+        [Test]
+        public void TestTargetConditionSuccess()
+        {
+            Container.Bind<Test2>().AsSingle().NonLazy();
+
+            var test2 = Container.Resolve<Test2>();
+
+            Assert.That(test2 != null);
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsTarget.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fa53be31526be634795d3b724199e7ea
+timeCreated: 1461708055
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsTargetInstance.cs

@@ -0,0 +1,38 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Conditions
+{
+    [TestFixture]
+    public class TestConditionsTargetInstance : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        class Test1
+        {
+            [Inject]
+            public Test0 test0 = null;
+        }
+
+        Test1 _test1;
+
+        public override void Setup()
+        {
+            base.Setup();
+
+            _test1 = new Test1();
+            Container.Bind<Test0>().AsSingle().When(r => r.ObjectInstance == _test1);
+            Container.Bind<Test1>().FromInstance(_test1);
+        }
+
+        [Test]
+        public void TestTargetConditionError()
+        {
+            Container.Inject(_test1);
+
+            Assert.That(_test1.test0 != null);
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestConditionsTargetInstance.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0f79fbd0fa046ae429a33becfec16c75
+timeCreated: 1461708048
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestIdentifierTypes.cs

@@ -0,0 +1,119 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Conditions
+{
+    [TestFixture]
+    public class TestIdentifierTypes : ZenjectUnitTestFixture
+    {
+        class Foo
+        {
+        }
+
+        enum Things
+        {
+            Thing1,
+            Thing2
+        }
+
+        class Test0
+        {
+            public Test0(
+                [Inject(Id = "asdf")]
+                Foo foo)
+            {
+            }
+        }
+
+        [Test]
+        public void TestStringIdentifiers1()
+        {
+            Container.Bind<Foo>().AsTransient();
+            Container.Bind<Test0>().AsTransient();
+
+            Assert.Throws(() => Container.Resolve<Test0>());
+        }
+
+        [Test]
+        public void TestStringIdentifiers2()
+        {
+            Container.Bind<Foo>().WithId("asdf").AsTransient();
+            Container.Bind<Test0>().AsTransient();
+
+            Assert.IsNotNull(Container.Resolve<Test0>());
+        }
+
+        class Test1
+        {
+            public Test1(
+                [Inject(Id = 5)]
+                Foo foo)
+            {
+            }
+        }
+
+        [Test]
+        public void TestIntIdentifiers1()
+        {
+            Container.Bind<Foo>().AsTransient();
+            Container.Bind<Test1>().AsTransient();
+
+            Assert.Throws(() => Container.Resolve<Test1>());
+        }
+
+        [Test]
+        public void TestIntIdentifiers2()
+        {
+            Container.Bind<Foo>().WithId(4).AsTransient();
+            Container.Bind<Test1>().AsTransient();
+
+            Assert.Throws(() => Container.Resolve<Test1>());
+        }
+
+        [Test]
+        public void TestIntIdentifiers3()
+        {
+            Container.Bind<Foo>().WithId(5).AsTransient();
+            Container.Bind<Test1>().AsTransient();
+
+            Assert.IsNotNull(Container.Resolve<Test1>());
+        }
+
+        class Test2
+        {
+            public Test2(
+                [Inject(Id = Things.Thing1)]
+                Foo foo)
+            {
+            }
+        }
+
+        [Test]
+        public void TestEnumIdentifiers1()
+        {
+            Container.Bind<Foo>().AsTransient();
+            Container.Bind<Test2>().AsTransient();
+
+            Assert.Throws(() => Container.Resolve<Test2>());
+        }
+
+        [Test]
+        public void TestEnumIdentifiers2()
+        {
+            Container.Bind<Foo>().WithId(Things.Thing2).AsTransient();
+            Container.Bind<Test2>().AsTransient();
+
+            Assert.Throws(() => Container.Resolve<Test2>());
+        }
+
+        [Test]
+        public void TestEnumIdentifiers3()
+        {
+            Container.Bind<Foo>().WithId(Things.Thing1).AsTransient();
+            Container.Bind<Test2>().AsTransient();
+
+            Assert.IsNotNull(Container.Resolve<Test2>());
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestIdentifierTypes.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9bc24db5ed5a5d047af12bf9c81319bb
+timeCreated: 1537241991
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestIdentifiers.cs

@@ -0,0 +1,69 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Conditions
+{
+    [TestFixture]
+    public class TestIdentifiers : ZenjectUnitTestFixture
+    {
+        class Test0
+        {
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+            Container.Bind<Test0>().WithId("foo").AsTransient().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test0>(); });
+
+            Container.ResolveId<Test0>("foo");
+        }
+
+        [Test]
+        public void TestBasic2()
+        {
+            Container.Bind<Test0>().WithId("foo").AsSingle().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test0>(); });
+
+            Container.ResolveId<Test0>("foo");
+        }
+
+        [Test]
+        public void TestBasic3()
+        {
+            Container.Bind<Test0>().WithId("foo").FromMethod(ctx => new Test0()).NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test0>(); });
+
+            Container.ResolveId<Test0>("foo");
+        }
+
+        [Test]
+        public void TestBasic4()
+        {
+            Container.Bind<Test0>().WithId("foo").AsTransient().NonLazy();
+            Container.Bind<Test0>().WithId("foo").AsTransient().NonLazy();
+
+            Assert.Throws(
+                delegate { Container.Resolve<Test0>(); });
+
+            Assert.Throws(
+                delegate { Container.ResolveId<Test0>("foo"); });
+
+            Assert.IsEqual(Container.ResolveIdAll<Test0>("foo").Count, 2);
+        }
+
+        [Test]
+        public void TestFromMethodUntyped()
+        {
+            Container.Bind(typeof(Test0)).FromMethod(ctx => new Test0()).NonLazy();
+
+            Container.Resolve<Test0>();
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conditions/TestIdentifiers.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 644729bec6228dd46a175eab4d04637a
+timeCreated: 1461708051
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a06a3cca4f04a6245a9def6d9505c530
+folderAsset: yes
+timeCreated: 1462372161
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/Foo.cs

@@ -0,0 +1,40 @@
+#if !(UNITY_WSA && ENABLE_DOTNET)
+
+using System;
+
+namespace Zenject.Tests.Convention
+{
+    public class ConventionTestAttribute : Attribute
+    {
+        public ConventionTestAttribute(int num)
+        {
+            Num = num;
+        }
+
+        public int Num
+        {
+            get;
+            private set;
+        }
+    }
+
+    public interface IFoo
+    {
+    }
+
+    public class Foo1 : IFoo
+    {
+    }
+
+    [ConventionTest(0)]
+    public class Foo2 : IFoo
+    {
+    }
+
+    [ConventionTest(1)]
+    public class Foo3 : IFoo
+    {
+    }
+}
+
+#endif

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/Foo.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: df03d112f1cade745b9c6eb4344fc519
+timeCreated: 1462127518
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/FooMore.cs

@@ -0,0 +1,14 @@
+#if !(UNITY_WSA && ENABLE_DOTNET)
+
+namespace Zenject.Tests.Convention.NamespaceTest
+{
+    public class Bar
+    {
+    }
+
+    public class Foo4 : IFoo
+    {
+    }
+}
+
+#endif

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/FooMore.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d233b33d1863c004293dc5c5dbec63c9
+timeCreated: 1462127515
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/TestConvention.cs

@@ -0,0 +1,81 @@
+#if !(UNITY_WSA && ENABLE_DOTNET)
+
+using System.Linq;
+using ModestTree;
+using NUnit.Framework;
+using UnityEngine;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Convention
+{
+    [TestFixture]
+    public class TestConvention : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestDerivingFrom()
+        {
+            Container.Bind<IFoo>()
+                .To(x => x.AllTypes().DerivingFrom<IFoo>().FromThisAssembly()).AsTransient();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count(), 4);
+        }
+
+        [Test]
+        public void TestDerivingFrom2()
+        {
+            Container.Bind<IFoo>()
+                .To(x => x.AllTypes().DerivingFrom<IFoo>()).AsTransient();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count(), 4);
+        }
+
+        [Test]
+        public void TestMatchAll()
+        {
+            // Should automatically filter by contract types
+            Container.Bind<IFoo>().To(x => x.AllNonAbstractClasses()).AsTransient();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count(), 4);
+        }
+
+#if !NOT_UNITY3D
+        [Test]
+        public void TestDerivingFromFail()
+        {
+            Container.Bind<IFoo>()
+                .To(x => x.AllTypes().DerivingFrom<IFoo>().FromAssemblyContaining<Vector3>()).AsTransient();
+
+            Assert.That(Container.ResolveAll<IFoo>().IsEmpty());
+        }
+#endif
+
+        [Test]
+        public void TestAttributeFilter()
+        {
+            Container.Bind<IFoo>()
+                .To(x => x.AllTypes().WithAttribute<ConventionTestAttribute>()).AsTransient();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count(), 2);
+        }
+
+        [Test]
+        public void TestAttributeWhereFilter()
+        {
+            Container.Bind<IFoo>()
+                .To(x => x.AllTypes().WithAttributeWhere<ConventionTestAttribute>(a => a.Num == 1)).AsTransient();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count(), 1);
+        }
+
+        [Test]
+        public void TestInNamespace()
+        {
+            Container.Bind<IFoo>()
+                .To(x => x.AllTypes().DerivingFrom<IFoo>().InNamespace("Zenject.Tests.Convention.NamespaceTest")).AsTransient();
+
+            Assert.IsEqual(Container.ResolveAll<IFoo>().Count(), 1);
+        }
+    }
+}
+
+#endif

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/TestConvention.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 69363ffe277b0e84ea97667444992554
+timeCreated: 1462127494
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/TestConvention2.cs

@@ -0,0 +1,53 @@
+#if !(UNITY_WSA && ENABLE_DOTNET)
+
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Convention.Two
+{
+    [TestFixture]
+    public class TestConvention2
+    {
+        [Test]
+        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);
+        }
+
+        [Test]
+        public void TestBindAllInterfaces2()
+        {
+            var container = new DiContainer();
+
+            container.Bind(x => x.AllInterfaces())
+                .To(x => x.AllNonAbstractClasses().InNamespace("Zenject.Tests.Convention.Two")).AsTransient();
+
+            Assert.IsEqual(container.ResolveAll<IFoo>().Count, 2);
+            Assert.IsEqual(container.ResolveAll<IBar>().Count, 2);
+        }
+
+        public interface IFoo
+        {
+        }
+
+        public interface IBar
+        {
+        }
+
+        public class Foo : IFoo, IBar
+        {
+        }
+
+        public class Bar : IBar, IFoo
+        {
+        }
+    }
+}
+
+#endif
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/TestConvention2.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 37e019ec982c85046baf80bc37b38d11
+timeCreated: 1464576582
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/TestConventionNames.cs

@@ -0,0 +1,65 @@
+
+#if !(UNITY_WSA && ENABLE_DOTNET)
+
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Convention.Names
+{
+    [TestFixture]
+    public class TestConventionNames : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestWithSuffix()
+        {
+            Container.Bind<IController>()
+                .To(x => x.AllNonAbstractClasses().InNamespace("Zenject.Tests.Convention.Names").WithSuffix("Controller")).AsTransient();
+
+            Assert.That(Container.Resolve<IController>() is FooController);
+        }
+
+        [Test]
+        public void TestWithPrefix()
+        {
+            Container.Bind<IController>()
+                .To(x => x.AllTypes().InNamespace("Zenject.Tests.Convention.Names").WithPrefix("Controller")).AsTransient();
+
+            Assert.That(Container.Resolve<IController>() is ControllerBar);
+        }
+
+        [Test]
+        public void TestMatchingRegex()
+        {
+            Container.Bind<IController>()
+                .To(x => x.AllNonAbstractClasses().InNamespace("Zenject.Tests.Convention.Names").MatchingRegex("Controller$")).AsTransient();
+
+            Assert.That(Container.Resolve<IController>() is FooController);
+        }
+
+        interface IController
+        {
+        }
+
+        class FooController : IController
+        {
+        }
+
+        class ControllerBar : IController
+        {
+        }
+
+        class QuxControllerAsdf : IController
+        {
+        }
+
+        class IgnoredFooController
+        {
+        }
+
+        class ControllerBarIgnored
+        {
+        }
+    }
+}
+
+#endif

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Conventions/TestConventionNames.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a8a9ff36735244a47babe85319e21e38
+timeCreated: 1464576609
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: dc0d4125f5cf5cd45b5d13defb47da01
+folderAsset: yes
+timeCreated: 1461711436
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 5e3c408f00aae61468d936ac29f004d1
+folderAsset: yes
+timeCreated: 1461708047
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings/TestFactoryFrom0.cs

@@ -0,0 +1,84 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFactoryFrom0 : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestSelf1()
+        {
+            Container.BindFactory<Foo, Foo.Factory>().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo.Factory>().Create());
+        }
+
+        [Test]
+        public void TestSelf2()
+        {
+            Container.BindFactory<Foo, Foo.Factory>().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo.Factory>().Create());
+        }
+
+        [Test]
+        public void TestSelf3()
+        {
+            Container.BindFactory<Foo, Foo.Factory>().FromNew().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<Foo.Factory>().Create());
+        }
+
+        [Test]
+        public void TestFactoryScopeDefault()
+        {
+            Container.BindFactory<Foo, Foo.Factory>();
+
+            Assert.IsEqual(Container.Resolve<Foo.Factory>(), Container.Resolve<Foo.Factory>());
+        }
+
+        [Test]
+        public void TestFactoryScopeTransient()
+        {
+            Container.BindFactory<Foo, Foo.Factory>().AsTransient();
+
+            Assert.IsNotEqual(Container.Resolve<Foo.Factory>(), Container.Resolve<Foo.Factory>());
+        }
+
+        [Test]
+        public void TestConcrete()
+        {
+            Container.BindFactory<IFoo, IFooFactory>().To<Foo>().NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<IFooFactory>().Create());
+
+            Assert.That(Container.Resolve<IFooFactory>().Create() is Foo);
+        }
+
+        [Test]
+        public void TestConcreteUntyped()
+        {
+            Container.BindFactory<IFoo, IFooFactory>().To(typeof(Foo)).NonLazy();
+
+            Assert.IsNotNull(Container.Resolve<IFooFactory>().Create());
+
+            Assert.That(Container.Resolve<IFooFactory>().Create() is Foo);
+        }
+
+        interface IFoo
+        {
+        }
+
+        class IFooFactory : PlaceholderFactory<IFoo>
+        {
+        }
+
+        class Foo : IFoo
+        {
+            public class Factory : PlaceholderFactory<Foo>
+            {
+            }
+        }
+    }
+}

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings/TestFactoryFrom0.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: cd589059f4c2ff341a25698a4a1673d9
+timeCreated: 1485738788
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings/TestFactoryFrom1.cs

@@ -0,0 +1,55 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFactoryFrom1 : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestSelf()
+        {
+            Container.BindFactory<string, Foo, Foo.Factory>().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo.Factory>().Create("asdf").Value, "asdf");
+        }
+
+        [Test]
+        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");
+        }
+
+        interface IFoo
+        {
+        }
+
+        class IFooFactory : PlaceholderFactory<string, IFoo>
+        {
+        }
+
+        class Foo : IFoo
+        {
+            public Foo(string value)
+            {
+                Value = value;
+            }
+
+            public string Value
+            {
+                get;
+                private set;
+            }
+
+            public class Factory : PlaceholderFactory<string, Foo>
+            {
+            }
+        }
+    }
+}
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings/TestFactoryFrom1.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2aeb922683e72ac4f9fd3806715e65df
+timeCreated: 1485738782
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings/TestFactoryFrom5.cs

@@ -0,0 +1,64 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFactoryFrom5 : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestSelf1()
+        {
+            Container.BindFactory<string, int, string, float, int, Foo, Foo.Factory>().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo.Factory>().Create("asdf", 2, "a", 4.2f, 6).P1, "asdf");
+        }
+
+        [Test]
+        public void TestSelf2()
+        {
+            Container.BindFactory<string, int, string, float, int, Foo, Foo.Factory>().NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo.Factory>().Create("asdf", 2, "a", 4.2f, 6).P1, "asdf");
+        }
+
+        [Test]
+        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");
+        }
+
+        interface IFoo
+        {
+        }
+
+        class IFooFactory : PlaceholderFactory<string, int, string, float, int, IFoo>
+        {
+        }
+
+        class Foo : IFoo
+        {
+            public Foo(string p1, int p2, string p3, float p4, int p5)
+            {
+                P1 = p1;
+            }
+
+            public string P1
+            {
+                get;
+                private set;
+            }
+
+            public class Factory : PlaceholderFactory<string, int, string, float, int, Foo>
+            {
+            }
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings/TestFactoryFrom5.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: db247dfbb1d6d284cae35a8f3ae55f17
+timeCreated: 1485738788
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings/TestFactoryFromFactory0.cs

@@ -0,0 +1,75 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFactoryFromFactory0 : ZenjectUnitTestFixture
+    {
+        static Foo StaticFoo = new Foo();
+
+        [Test]
+        public void TestSelf()
+        {
+            Container.BindFactory<Foo, Foo.Factory>().FromIFactory(b => b.To<CustomFooFactory>().AsCached()).NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo.Factory>().Create(), StaticFoo);
+        }
+
+        [Test]
+        public void TestConcrete()
+        {
+            Container.BindFactory<IFoo, IFooFactory>()
+                .To<Foo>().FromIFactory(b => b.To<CustomFooFactory>().AsCached()).NonLazy();
+
+            Assert.IsEqual(Container.Resolve<IFooFactory>().Create(), StaticFoo);
+        }
+
+        [Test]
+        public void TestFactoryValidation()
+        {
+            Container.BindFactory<IFoo, IFooFactory>()
+                .To<Foo>().FromIFactory(b => b.To<CustomFooFactoryWithValidate>().AsCached()).NonLazy();
+
+            Container.Resolve<IFooFactory>().Create();
+        }
+
+        class CustomFooFactoryWithValidate : IFactory<Foo>, IValidatable
+        {
+            public Foo Create()
+            {
+                return StaticFoo;
+            }
+
+            public void Validate()
+            {
+                throw Assert.CreateException("Test error");
+            }
+        }
+
+        class CustomFooFactory : IFactory<Foo>
+        {
+            public Foo Create()
+            {
+                return StaticFoo;
+            }
+        }
+
+        interface IFoo
+        {
+        }
+
+        class IFooFactory : PlaceholderFactory<IFoo>
+        {
+        }
+
+        class Foo : IFoo
+        {
+            public class Factory : PlaceholderFactory<Foo>
+            {
+            }
+        }
+    }
+}
+
+

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings/TestFactoryFromFactory0.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 1ccf6a6010280bd4c80cd60ddfc3251c
+timeCreated: 1485738782
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Zenject/OptionalExtras/UnitTests/Editor/Factories/Bindings/TestFactoryFromFactory1.cs

@@ -0,0 +1,64 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFactoryFromFactory1 : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestSelf()
+        {
+            Container.BindFactory<string, Foo, Foo.Factory>().FromIFactory(b => b.To<CustomFooFactory>().AsCached()).NonLazy();
+
+            Assert.IsEqual(Container.Resolve<Foo.Factory>().Create("asdf").Value, "asdf");
+        }
+
+        [Test]
+        public void TestConcrete()
+        {
+            Container.BindFactory<string, IFoo, IFooFactory>().To<Foo>().FromIFactory(b => b.To<CustomFooFactory>().AsCached()).NonLazy();
+
+            Assert.IsEqual(Container.Resolve<IFooFactory>().Create("asdf").Value, "asdf");
+        }
+
+        class CustomFooFactory : IFactory<string, Foo>
+        {
+            public Foo Create(string value)
+            {
+                return new Foo(value);
+            }
+        }
+
+        interface IFoo
+        {
+            string Value
+            {
+                get;
+            }
+        }
+
+        class IFooFactory : PlaceholderFactory<string, IFoo>
+        {
+        }
+
+        class Foo : IFoo
+        {
+            public Foo(string value)
+            {
+                Value = value;
+            }
+
+            public string Value
+            {
+                get;
+                private set;
+            }
+
+            public class Factory : PlaceholderFactory<string, Foo>
+            {
+            }
+        }
+    }
+}
+