Update Project

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: