Initial Commit

2026-03-16 14:38:46 +02:00
commit b8f7327a21
2327 changed files with 253610 additions and 0 deletions
@@ -0,0 +1,163 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Signals
+{
+    [TestFixture]
+    public class TestBindSignal : ZenjectUnitTestFixture
+    {
+        [SetUp]
+        public void CommonInstall()
+        {
+            SignalBusInstaller.Install(Container);
+            Container.Inject(this);
+        }
+
+        [Test]
+        public void TestIncompleteBinding()
+        {
+            Container.DeclareSignal<FooSignal>();
+            Container.BindSignal<FooSignal>();
+
+            Assert.Throws(() => Container.FlushBindings());
+        }
+
+        [Test]
+        public void TestBindWithoutDeclaration()
+        {
+            Container.BindSignal<FooSignal>().ToMethod(() => {});
+
+            Assert.Throws(() => Container.ResolveRoots());
+        }
+
+        [Test]
+        public void TestStaticMethodHandler()
+        {
+            Container.DeclareSignal<FooSignal>();
+
+            bool received = false;
+
+            Container.BindSignal<FooSignal>().ToMethod(() => received = true);
+            Container.ResolveRoots();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            Assert.That(!received);
+            signalBus.Fire<FooSignal>();
+            Assert.That(received);
+        }
+
+        [Test]
+        public void TestStaticMethodHandlerWithArgs()
+        {
+            Container.DeclareSignal<FooSignal>();
+
+            FooSignal received = null;
+
+            Container.BindSignal<FooSignal>().ToMethod(x => received = x);
+            Container.ResolveRoots();
+
+            var signalBus = Container.Resolve<SignalBus>();
+            var sent = new FooSignal();
+
+            Assert.IsNull(received);
+            signalBus.Fire(sent);
+            Assert.IsEqual(received, sent);
+        }
+
+        [Test]
+        public void TestInstanceMethodHandler()
+        {
+            Container.DeclareSignal<FooSignal>();
+
+            var qux = new Qux();
+            Container.BindSignal<FooSignal>()
+                .ToMethod<Qux>(x => x.OnFoo).From(b => b.FromInstance(qux));
+            Container.ResolveRoots();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            Assert.That(!qux.HasRecievedSignal);
+            signalBus.Fire<FooSignal>();
+            Assert.That(qux.HasRecievedSignal);
+        }
+
+        [Test]
+        public void TestInstanceMethodHandler2()
+        {
+            Container.DeclareSignal<FooSignal>();
+
+            var gorp = new Gorp();
+            Container.BindSignal<FooSignal>()
+                .ToMethod<Gorp>(x => x.OnFoo).From(b => b.FromInstance(gorp));
+            Container.ResolveRoots();
+
+            var signalBus = Container.Resolve<SignalBus>();
+            var sent = new FooSignal();
+
+            Assert.IsNull(gorp.ReceivedValue);
+            signalBus.Fire(sent);
+            Assert.IsEqual(gorp.ReceivedValue, sent);
+        }
+
+        [Test]
+        public void TestMoveIntoDirectSubContainers()
+        {
+            Container.DeclareSignal<FooSignal>();
+
+            var gorp = new Gorp();
+
+            Container.BindSignal<FooSignal>()
+                .ToMethod<Gorp>(x => x.OnFoo).From(b => b.FromInstance(gorp)).MoveIntoDirectSubContainers();
+            Container.ResolveRoots();
+
+            var signalBus1 = Container.Resolve<SignalBus>();
+            var sent = new FooSignal();
+
+            Assert.IsNull(gorp.ReceivedValue);
+            signalBus1.Fire(sent);
+            Assert.IsNull(gorp.ReceivedValue);
+
+            var subContainer = Container.CreateSubContainer();
+            subContainer.ResolveRoots();
+
+            var signalBus2 = Container.Resolve<SignalBus>();
+
+            Assert.IsNull(gorp.ReceivedValue);
+            signalBus2.Fire(sent);
+            Assert.IsEqual(gorp.ReceivedValue, sent);
+        }
+
+        public class Qux
+        {
+            public void OnFoo()
+            {
+                HasRecievedSignal = true;
+            }
+
+            public bool HasRecievedSignal
+            {
+                get; private set;
+            }
+        }
+
+        public class Gorp
+        {
+            public void OnFoo(FooSignal foo)
+            {
+                ReceivedValue = foo;
+            }
+
+            public FooSignal ReceivedValue
+            {
+                get; private set;
+            }
+        }
+
+        public class FooSignal
+        {
+        }
+    }
+}
+
+