Initial Commit

2026-03-16 14:38:46 +02:00
commit b8f7327a21
2327 changed files with 253610 additions and 0 deletions
@@ -0,0 +1,70 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests
+{
+    [TestFixture]
+    public class TestArrayPool : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void RunTest()
+        {
+            var pool = ArrayPool<string>.GetPool(2);
+
+            pool.Clear();
+            pool.ClearActiveCount();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+
+            var arr1 = pool.Spawn();
+
+            Assert.IsEqual(arr1.Length, 2);
+
+            arr1[0] = "asdf";
+            arr1[1] = "zbx";
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 1);
+
+            pool.Despawn(arr1);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+
+            var arr2 = pool.Spawn();
+
+            Assert.IsEqual(arr2.Length, 2);
+            Assert.IsNull(arr2[0]);
+            Assert.IsNull(arr2[1]);
+
+            Assert.IsEqual(arr2.Length, 2);
+            Assert.IsEqual(arr2, arr1);
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 1);
+
+            var arr3 = pool.Spawn();
+
+            Assert.IsNotEqual(arr2, arr3);
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+
+            pool.Despawn(arr3);
+            pool.Despawn(arr2);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 2);
+            Assert.IsEqual(pool.NumTotal, 2);
+
+            Assert.Throws(() => pool.Despawn(arr3));
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 33e25c55b70120c42a55e90dee543e4a
+timeCreated: 1537872724
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,141 @@
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests
+{
+    [TestFixture]
+    public class TestDisposeBlock : ZenjectUnitTestFixture
+    {
+        class Foo : IDisposable
+        {
+            public static readonly StaticMemoryPool<string, Foo> Pool =
+                new StaticMemoryPool<string, Foo>(OnSpawned, OnDespawned);
+
+            public void Dispose()
+            {
+                Pool.Despawn(this);
+            }
+
+            static void OnDespawned(Foo that)
+            {
+                that.Value = null;
+            }
+
+            static void OnSpawned(string value, Foo that)
+            {
+                that.Value = value;
+            }
+
+            public string Value
+            {
+                get; private set;
+            }
+        }
+
+        public class Bar : IDisposable
+        {
+            readonly Pool _pool;
+
+            public Bar(Pool pool)
+            {
+                _pool = pool;
+            }
+
+            public void Dispose()
+            {
+                _pool.Despawn(this);
+            }
+
+            public class Pool : MemoryPool<Bar>
+            {
+            }
+        }
+
+        public class Qux : IDisposable
+        {
+            public bool WasDisposed
+            {
+                get; private set;
+            }
+
+            public void Dispose()
+            {
+                WasDisposed = true;
+            }
+        }
+
+        [Test]
+        public void TestExceptions()
+        {
+            var qux1 = new Qux();
+            var qux2 = new Qux();
+
+            try
+            {
+                using (var block = DisposeBlock.Spawn())
+                {
+                    block.Add(qux1);
+                    block.Add(qux2);
+                    throw new Exception();
+                }
+            }
+            catch
+            {
+            }
+
+            Assert.That(qux1.WasDisposed);
+            Assert.That(qux2.WasDisposed);
+        }
+
+        [Test]
+        public void TestWithStaticMemoryPool()
+        {
+            var pool = Foo.Pool;
+
+            pool.Clear();
+
+            Assert.IsEqual(pool.NumTotal, 0);
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            using (var block = DisposeBlock.Spawn())
+            {
+                block.Spawn(pool, "asdf");
+
+                Assert.IsEqual(pool.NumTotal, 1);
+                Assert.IsEqual(pool.NumActive, 1);
+                Assert.IsEqual(pool.NumInactive, 0);
+            }
+
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 1);
+        }
+
+        [Test]
+        public void TestWithNormalMemoryPool()
+        {
+            Container.BindMemoryPool<Bar, Bar.Pool>();
+
+            var pool = Container.Resolve<Bar.Pool>();
+
+            Assert.IsEqual(pool.NumTotal, 0);
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            using (var block = DisposeBlock.Spawn())
+            {
+                block.Spawn(pool);
+
+                Assert.IsEqual(pool.NumTotal, 1);
+                Assert.IsEqual(pool.NumActive, 1);
+                Assert.IsEqual(pool.NumInactive, 0);
+            }
+
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 1);
+        }
+    }
+}
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: fd6b9542508dba54ba29e1316963417a
+timeCreated: 1527949568
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,93 @@
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromPoolableMemoryPoolOne : ZenjectUnitTestFixture
+    {
+        public class Foo : IPoolable<string, IMemoryPool>, IDisposable
+        {
+            IMemoryPool _pool;
+            string _data;
+            string _initialData;
+
+            public Foo(string initialData)
+            {
+                _initialData = initialData;
+                SetDefaults();
+            }
+
+            public string InitialData
+            {
+                get { return _initialData; }
+            }
+
+            public IMemoryPool Pool
+            {
+                get { return _pool; }
+            }
+
+            public string Data
+            {
+                get { return _data; }
+            }
+
+            void SetDefaults()
+            {
+                _pool = null;
+                _data = null;
+            }
+
+            public void Dispose()
+            {
+                _pool.Despawn(this);
+            }
+
+            public void OnDespawned()
+            {
+                _data = null;
+                _pool = null;
+                SetDefaults();
+            }
+
+            public void OnSpawned(string data, IMemoryPool pool)
+            {
+                _pool = pool;
+                _data = data;
+            }
+
+            public class Factory : PlaceholderFactory<string, Foo>
+            {
+            }
+        }
+
+        [Test]
+        public void Test1()
+        {
+            Container.BindFactory<string, Foo, Foo.Factory>().FromPoolableMemoryPool(x => x.WithInitialSize(2).WithArguments("blurg"));
+
+            var factory = Container.Resolve<Foo.Factory>();
+
+            var foo = factory.Create("asdf");
+
+            Assert.IsEqual(foo.InitialData, "blurg");
+
+            var pool = foo.Pool;
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 1);
+
+            Assert.IsEqual(foo.Data, "asdf");
+
+            foo.Dispose();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 2);
+            Assert.IsEqual(foo.Data, null);
+        }
+    }
+}
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 0290781678baa694491808cbbb4365b0
+timeCreated: 1528529859
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,84 @@
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromPoolableMemoryPoolSix : ZenjectUnitTestFixture
+    {
+        public class Foo : IPoolable<string, int, float, char, double, long, IMemoryPool>, IDisposable
+        {
+            IMemoryPool _pool;
+            string _data;
+
+            public Foo()
+            {
+                SetDefaults();
+            }
+
+            public IMemoryPool Pool
+            {
+                get { return _pool; }
+            }
+
+            public string Data
+            {
+                get { return _data; }
+            }
+
+            void SetDefaults()
+            {
+                _pool = null;
+                _data = null;
+            }
+
+            public void Dispose()
+            {
+                _pool.Despawn(this);
+            }
+
+            public void OnDespawned()
+            {
+                _data = null;
+                _pool = null;
+                SetDefaults();
+            }
+
+            public void OnSpawned(string p1, int p2, float p3, char p4, double p5, long p6, IMemoryPool pool)
+            {
+                _pool = pool;
+                _data = p1;
+            }
+
+            public class Factory : PlaceholderFactory<string, int, float, char, double, long, Foo>
+            {
+            }
+        }
+
+        [Test]
+        public void Test1()
+        {
+            Container.BindFactory<string, int, float, char, double, long, Foo, Foo.Factory>().FromPoolableMemoryPool(x => x.WithInitialSize(2));
+
+            var factory = Container.Resolve<Foo.Factory>();
+
+            var foo = factory.Create("asdf", 1, 1.0f, 'u', 1.0, 1L);
+            var pool = foo.Pool;
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 1);
+
+            Assert.IsEqual(foo.Data, "asdf");
+
+            foo.Dispose();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 2);
+            Assert.IsEqual(foo.Data, null);
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 098b4e9c9d112bc42866f5cff81842c0
+timeCreated: 1528529859
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,81 @@
+
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromPoolableMemoryPoolValidation
+    {
+        public class Bar
+        {
+        }
+
+        public class Foo : IPoolable<IMemoryPool>, IDisposable
+        {
+            IMemoryPool _pool;
+
+            public Foo(Bar bar)
+            {
+            }
+
+            public IMemoryPool Pool
+            {
+                get { return _pool; }
+            }
+
+            void SetDefaults()
+            {
+                _pool = null;
+            }
+
+            public void Dispose()
+            {
+                _pool.Despawn(this);
+            }
+
+            public void OnDespawned()
+            {
+                _pool = null;
+                SetDefaults();
+            }
+
+            public void OnSpawned(IMemoryPool pool)
+            {
+                _pool = pool;
+            }
+
+            public class Factory : PlaceholderFactory<Foo>
+            {
+            }
+        }
+
+        [Test]
+        public void TestFailure()
+        {
+            var container = new DiContainer(true);
+            container.Settings = new ZenjectSettings(
+                ValidationErrorResponses.Throw, RootResolveMethods.All);
+
+            container.BindFactory<Foo, Foo.Factory>().FromPoolableMemoryPool(x => x.WithInitialSize(2));
+
+            Assert.Throws(() => container.ResolveRoots());
+        }
+
+
+        [Test]
+        public void TestSuccess()
+        {
+            var container = new DiContainer(true);
+            container.Settings = new ZenjectSettings(
+                ValidationErrorResponses.Throw, RootResolveMethods.All);
+
+            container.Bind<Bar>().AsSingle();
+            container.BindFactory<Foo, Foo.Factory>().FromPoolableMemoryPool(x => x.WithInitialSize(2));
+
+            container.ResolveRoots();
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 327a53cf63cd4c04dbf831a038257783
+timeCreated: 1528530804
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,67 @@
+
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestFromPoolableMemoryPoolZero : ZenjectUnitTestFixture
+    {
+        public class Foo : IPoolable<IMemoryPool>, IDisposable
+        {
+            IMemoryPool _pool;
+
+            public IMemoryPool Pool
+            {
+                get { return _pool; }
+            }
+
+            void SetDefaults()
+            {
+                _pool = null;
+            }
+
+            public void Dispose()
+            {
+                _pool.Despawn(this);
+            }
+
+            public void OnDespawned()
+            {
+                _pool = null;
+                SetDefaults();
+            }
+
+            public void OnSpawned(IMemoryPool pool)
+            {
+                _pool = pool;
+            }
+
+            public class Factory : PlaceholderFactory<Foo>
+            {
+            }
+        }
+
+        [Test]
+        public void Test1()
+        {
+            Container.BindFactory<Foo, Foo.Factory>().FromPoolableMemoryPool(x => x.WithInitialSize(2).FromNew());
+
+            var factory = Container.Resolve<Foo.Factory>();
+
+            var foo = factory.Create();
+            var pool = foo.Pool;
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 1);
+
+            foo.Dispose();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 2);
+        }
+    }
+}
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ac0356e6e75c5604fbc522ae6ee4c252
+timeCreated: 1528529860
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,384 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+#pragma warning disable 219
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestMemoryPool0 : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestFactoryProperties()
+        {
+            Container.BindMemoryPool<Foo, Foo.Pool>();
+
+            var pool = Container.Resolve<Foo.Pool>();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            var foo = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(foo.ResetCount, 1);
+
+            pool.Despawn(foo);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(pool.NumInactive, 1);
+            Assert.IsEqual(foo.ResetCount, 1);
+
+            foo = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(foo.ResetCount, 2);
+
+            var foo2 = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(foo2.ResetCount, 1);
+
+            pool.Despawn(foo);
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 1);
+            Assert.IsEqual(foo.ResetCount, 2);
+
+            pool.Despawn(foo2);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 2);
+        }
+
+        [Test]
+        public void TestFactoryScopeDefault()
+        {
+            Container.BindMemoryPool<Foo, Foo.Pool>();
+
+            Assert.IsEqual(Container.Resolve<Foo.Pool>(), Container.Resolve<Foo.Pool>());
+        }
+
+        [Test]
+        public void TestFactoryScopeTransient()
+        {
+            Container.BindMemoryPool<Foo, Foo.Pool>().AsTransient();
+
+            Assert.IsNotEqual(Container.Resolve<Foo.Pool>(), Container.Resolve<Foo.Pool>());
+        }
+
+        [Test]
+        public void TestFactoryPropertiesDefault()
+        {
+            Container.BindMemoryPool<Foo>();
+
+            var pool = Container.Resolve<MemoryPool<Foo>>();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            var foo = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            pool.Despawn(foo);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(pool.NumInactive, 1);
+
+            foo = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            var foo2 = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            pool.Despawn(foo);
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 1);
+
+            pool.Despawn(foo2);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 2);
+        }
+
+        [Test]
+        public void TestExpandDouble()
+        {
+            Container.BindMemoryPool<Foo, Foo.Pool>().ExpandByDoubling();
+
+            var pool = Container.Resolve<Foo.Pool>();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            var foo = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            var foo2 = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            var foo3 = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 3);
+            Assert.IsEqual(pool.NumTotal, 4);
+            Assert.IsEqual(pool.NumInactive, 1);
+
+            pool.Despawn(foo2);
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 4);
+            Assert.IsEqual(pool.NumInactive, 2);
+
+            var foo4 = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 3);
+            Assert.IsEqual(pool.NumTotal, 4);
+            Assert.IsEqual(pool.NumInactive, 1);
+        }
+
+        [Test]
+        public void TestFixedSize()
+        {
+            Container.BindMemoryPool<Foo, Foo.Pool>().WithFixedSize(2);
+
+            var pool = Container.Resolve<Foo.Pool>();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 2);
+
+            var foo = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 1);
+
+            var foo2 = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            Assert.Throws<PoolExceededFixedSizeException>(() => pool.Spawn());
+        }
+
+        [Test]
+        public void TestInitialSize()
+        {
+            Container.BindMemoryPool<Foo, Foo.Pool>().WithInitialSize(5);
+
+            var pool = Container.Resolve<Foo.Pool>();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 5);
+        }
+
+        [Test]
+        public void TestExpandAndShrinkManually()
+        {
+            Container.BindMemoryPool<Foo, Foo.Pool>();
+
+            var pool = Container.Resolve<Foo.Pool>();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            pool.ExpandBy(2);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 2);
+
+            var foo = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 1);
+
+            pool.ExpandBy(3);
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 4);
+
+            var foo2 = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 3);
+
+            var foo3 = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 3);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 2);
+
+            pool.ExpandBy(1);
+
+            Assert.IsEqual(pool.NumActive, 3);
+            Assert.IsEqual(pool.NumTotal, 6);
+            Assert.IsEqual(pool.NumInactive, 3);
+
+            pool.Despawn(foo2);
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 6);
+            Assert.IsEqual(pool.NumInactive, 4);
+
+            var foo4 = pool.Spawn();
+
+            Assert.IsEqual(pool.NumActive, 3);
+            Assert.IsEqual(pool.NumTotal, 6);
+            Assert.IsEqual(pool.NumInactive, 3);
+
+            pool.ShrinkBy(1);
+
+            Assert.IsEqual(pool.NumActive, 3);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 2);
+
+            pool.Resize(6);
+
+            Assert.IsEqual(pool.NumActive, 3);
+            Assert.IsEqual(pool.NumTotal, 9);
+            Assert.IsEqual(pool.NumInactive, 6);
+
+            pool.Clear();
+
+            Assert.IsEqual(pool.NumActive, 3);
+            Assert.IsEqual(pool.NumTotal, 3);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            Assert.Throws(() => pool.Resize(-1));
+            Assert.Throws(() => pool.ShrinkBy(1));
+        }
+
+        [Test]
+        public void TestMaxSize()
+        {
+            Container.BindMemoryPool<Foo, Foo.Pool>().WithInitialSize(2).WithMaxSize(4);
+
+            var pool = Container.Resolve<Foo.Pool>();
+
+            var foos = new List<Foo>();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 2);
+
+            foos.Add(pool.Spawn());
+            foos.Add(pool.Spawn());
+            foos.Add(pool.Spawn());
+            foos.Add(pool.Spawn());
+            foos.Add(pool.Spawn());
+
+            Assert.IsEqual(pool.NumActive, 5);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            pool.Despawn(foos[0]);
+            pool.Despawn(foos[1]);
+            pool.Despawn(foos[2]);
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 3);
+
+            pool.Despawn(foos[3]);
+            pool.Despawn(foos[4]);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 4);
+            Assert.IsEqual(pool.NumInactive, 4);
+        }
+
+        class Bar
+        {
+            public class Pool : MemoryPool<Bar>
+            {
+            }
+        }
+
+        class Foo
+        {
+            public int ResetCount
+            {
+                get; private set;
+            }
+
+            public class Pool : MemoryPool<Foo>
+            {
+                protected override void OnSpawned(Foo foo)
+                {
+                    foo.ResetCount++;
+                }
+            }
+        }
+
+        [Test]
+        public void TestSubContainers()
+        {
+            Container.BindMemoryPool<Qux, Qux.Pool>()
+                .FromSubContainerResolve().ByMethod(InstallQux).NonLazy();
+
+            var pool = Container.Resolve<Qux.Pool>();
+            var qux = pool.Spawn();
+        }
+
+        void InstallQux(DiContainer subContainer)
+        {
+            subContainer.Bind<Qux>().AsSingle();
+        }
+
+        class Qux
+        {
+            public class Pool : MemoryPool<Qux>
+            {
+            }
+        }
+
+        [Test]
+        [ValidateOnly]
+        public void TestIds()
+        {
+            Container.BindMemoryPool<Foo, Foo.Pool>().WithId("foo").WithInitialSize(5);
+
+            var pool = Container.ResolveId<Foo.Pool>("foo");
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 325335e855a4c594480804dc3d0e8caa
+timeCreated: 1519832826
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,52 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+#pragma warning disable 219
+
+namespace Zenject.Tests.Bindings
+{
+    [TestFixture]
+    public class TestMemoryPoolCustomFactory : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestFromBinding()
+        {
+            Container.BindMemoryPool<Qux, Qux.Pool>().FromIFactory(b => b.To<CustomFactory>().AsCached());
+
+            var pool = Container.Resolve<Qux.Pool>();
+
+            var qux = pool.Spawn();
+
+            Assert.IsEqual(pool.NumTotal, 1);
+        }
+
+        [Test]
+        public void TestFromRuntime()
+        {
+            var settings = new MemoryPoolSettings(0, int.MaxValue, PoolExpandMethods.OneAtATime);
+
+            var pool = Container.Instantiate<Qux.Pool>(new object[] { settings, new CustomFactory() });
+
+            var qux = pool.Spawn();
+
+            Assert.IsEqual(pool.NumTotal, 1);
+        }
+
+        class CustomFactory : IFactory<Qux>
+        {
+            public Qux Create()
+            {
+                return new Qux();
+            }
+        }
+
+        class Qux
+        {
+            public class Pool : MemoryPool<Qux>
+            {
+            }
+        }
+    }
+}
+
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 8379f1a96bdcecb4e9cd40975f9c898d
+timeCreated: 1519832826
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,63 @@
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests
+{
+    [TestFixture]
+    public class TestPoolableStaticMemoryPool : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void RunTest()
+        {
+            var pool = Foo.Pool;
+
+            pool.Clear();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+
+            var foo = pool.Spawn("asdf");
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(foo.Data, "asdf");
+
+            foo.Dispose();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+            Assert.IsEqual(foo.Data, null);
+        }
+
+        public class Foo : IPoolable<string>, IDisposable
+        {
+            public static readonly PoolableStaticMemoryPool<string, Foo> Pool =
+                new PoolableStaticMemoryPool<string, Foo>();
+
+            public string Data
+            {
+                get; private set;
+            }
+
+            public void Dispose()
+            {
+                Pool.Despawn(this);
+            }
+
+            public void OnSpawned(string data)
+            {
+                Data = data;
+            }
+
+            public void OnDespawned()
+            {
+                Data = null;
+            }
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: f7ee5ff810de60d4ba6ac2e06aeb70ea
+timeCreated: 1528618262
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,254 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests
+{
+    [TestFixture]
+    public class TestStaticMemoryPool : ZenjectUnitTestFixture
+    {
+        [SetUp]
+        public void CommonInstall()
+        {
+            Container.Inject(this);
+        }
+
+        [Test]
+        public void RunTest()
+        {
+            var pool = Foo.Pool;
+
+            pool.Clear();
+            pool.ClearActiveCount();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+
+            var foo = pool.Spawn("asdf");
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 1);
+
+            Assert.IsEqual(foo.Value, "asdf");
+            pool.Despawn(foo);
+            Assert.IsNull(foo.Value);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+
+            var foo2 = pool.Spawn("zxcv");
+            Assert.That(ReferenceEquals(foo, foo2));
+            Assert.IsEqual(foo2.Value, "zxcv");
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 1);
+
+            var foo3 = pool.Spawn("bar");
+            Assert.That(!ReferenceEquals(foo2, foo3));
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+
+            pool.Despawn(foo3);
+            pool.Despawn(foo2);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 2);
+            Assert.IsEqual(pool.NumTotal, 2);
+
+            Assert.Throws(() => pool.Despawn(foo3));
+        }
+
+        [Test]
+        public void TestListPool()
+        {
+            var pool = ListPool<string>.Instance;
+
+            pool.Clear();
+            pool.ClearActiveCount();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+
+            var list = pool.Spawn();
+
+            list.Add("asdf");
+            list.Add("zbx");
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 1);
+
+            pool.Despawn(list);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+
+            var list2 = pool.Spawn();
+
+            Assert.IsEqual(list2.Count, 0);
+            Assert.IsEqual(list2, list);
+
+            Assert.IsEqual(pool.NumActive, 1);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 1);
+
+            var list3 = pool.Spawn();
+
+            Assert.IsNotEqual(list2, list3);
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+
+            pool.Despawn(list3);
+            pool.Despawn(list2);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 2);
+            Assert.IsEqual(pool.NumTotal, 2);
+
+            Assert.Throws(() => pool.Despawn(list3));
+        }
+
+        [Test]
+        public void TestPoolWrapper()
+        {
+            var pool = Foo.Pool;
+
+            pool.Clear();
+            pool.ClearActiveCount();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+
+            using (var block = DisposeBlock.Spawn())
+            {
+                block.Spawn(pool, "asdf");
+
+                Assert.IsEqual(pool.NumActive, 1);
+                Assert.IsEqual(pool.NumInactive, 0);
+                Assert.IsEqual(pool.NumTotal, 1);
+            }
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumInactive, 1);
+            Assert.IsEqual(pool.NumTotal, 1);
+        }
+
+        [Test]
+        public void TestResize()
+        {
+            var pool = Bar.Pool;
+
+            pool.Clear();
+            pool.ClearActiveCount();
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 0);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            pool.Resize(2);
+
+            Assert.IsEqual(pool.NumActive, 0);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 2);
+
+            var bars = new List<Bar>();
+
+            bars.Add(pool.Spawn());
+            bars.Add(pool.Spawn());
+            bars.Add(pool.Spawn());
+            bars.Add(pool.Spawn());
+            bars.Add(pool.Spawn());
+
+            Assert.IsEqual(pool.NumActive, 5);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            pool.Despawn(bars[0]);
+            pool.Despawn(bars[1]);
+            pool.Despawn(bars[2]);
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 3);
+
+            pool.ShrinkBy(1);
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 4);
+            Assert.IsEqual(pool.NumInactive, 2);
+
+            pool.ExpandBy(1);
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 5);
+            Assert.IsEqual(pool.NumInactive, 3);
+
+            pool.Resize(1);
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 3);
+            Assert.IsEqual(pool.NumInactive, 1);
+
+            pool.Clear();
+
+            Assert.IsEqual(pool.NumActive, 2);
+            Assert.IsEqual(pool.NumTotal, 2);
+            Assert.IsEqual(pool.NumInactive, 0);
+
+            Assert.Throws(() => pool.Resize(-1));
+            Assert.Throws(() => pool.ShrinkBy(1));
+        }
+
+        public class Bar
+        {
+            public static readonly StaticMemoryPool<Bar> Pool =
+                new StaticMemoryPool<Bar>(OnSpawned, OnDespawned);
+
+            static void OnSpawned(Bar that)
+            {
+            }
+
+            static void OnDespawned(Bar that)
+            {
+            }
+        }
+
+        public class Foo : IDisposable
+        {
+            public static readonly StaticMemoryPool<string, Foo> Pool =
+                new StaticMemoryPool<string, Foo>(OnSpawned, OnDespawned);
+
+            public string Value
+            {
+                get; private set;
+            }
+
+            public void Dispose()
+            {
+                Pool.Despawn(this);
+            }
+
+            static void OnSpawned(string value, Foo that)
+            {
+                that.Value = value;
+            }
+
+            static void OnDespawned(Foo that)
+            {
+                that.Value = null;
+            }
+        }
+    }
+}
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 554fc06f7ed876d479aa605f55099e02
+timeCreated: 1528024394
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: