Initial Commit

2026-03-16 14:38:46 +02:00
commit b8f7327a21
2327 changed files with 253610 additions and 0 deletions
@@ -0,0 +1,153 @@
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Signals
+{
+    [TestFixture]
+    public class TestAsyncSignals : ZenjectUnitTestFixture
+    {
+        static int CallCount;
+
+        [Inject]
+        SignalBus _signalBus = null;
+
+        [Inject]
+        Receiver1 _receiver1 = null;
+
+        [Inject]
+        Receiver2 _receiver2 = null;
+
+        [Inject]
+        TickableManager _tickManager = null;
+
+        [InjectOptional]
+        Foo _foo = null;
+
+        public override void Setup()
+        {
+            base.Setup();
+
+            SignalBusInstaller.Install(Container);
+            ZenjectManagersInstaller.Install(Container);
+        }
+
+        [Test]
+        public void TestBasicAsync()
+        {
+            Container.DeclareSignal<Signal1>().RunAsync();
+            Container.DeclareSignal<Signal2>().RunAsync();
+
+            Container.Bind<Receiver1>().AsSingle();
+            Container.Bind<Receiver2>().AsSingle();
+
+            Container.BindSignal<Signal1>().ToMethod<Receiver1>(x => x.OnSignal).FromResolve();
+            Container.BindSignal<Signal2>().ToMethod<Receiver2>(x => x.OnSignal).FromResolve();
+
+            Container.ResolveRoots();
+            Container.Resolve<InitializableManager>().Initialize();
+
+            Container.Inject(this);
+
+            CallCount = 1;
+            _receiver1.CallIndex = 0;
+            _receiver2.CallIndex = 0;
+
+            _signalBus.Fire<Signal1>();
+            _signalBus.Fire<Signal2>();
+
+            Assert.IsEqual(_receiver1.CallIndex, 0);
+            Assert.IsEqual(_receiver2.CallIndex, 0);
+
+            _tickManager.Update();
+
+            Assert.IsEqual(_receiver1.CallIndex, 1);
+            Assert.IsEqual(_receiver2.CallIndex, 2);
+        }
+
+        [Test]
+        public void TestTickPriority()
+        {
+            Container.DeclareSignal<Signal1>().WithTickPriority(1);
+            Container.DeclareSignal<Signal2>().WithTickPriority(-4);
+
+            Container.BindInterfacesAndSelfTo<Foo>().AsSingle();
+
+            Container.Bind<Receiver1>().AsSingle();
+            Container.Bind<Receiver2>().AsSingle();
+
+            Container.BindSignal<Signal1>().ToMethod<Receiver1>(x => x.OnSignal).FromResolve();
+            Container.BindSignal<Signal2>().ToMethod<Receiver2>(x => x.OnSignal).FromResolve();
+
+            Container.ResolveRoots();
+            Container.Resolve<InitializableManager>().Initialize();
+
+            Container.Inject(this);
+
+            CallCount = 1;
+            _receiver1.CallIndex = 0;
+            _receiver2.CallIndex = 0;
+            _foo.CallIndex = 0;
+
+            _signalBus.Fire<Signal1>();
+            _signalBus.Fire<Signal2>();
+
+            Assert.IsEqual(_receiver1.CallIndex, 0);
+            Assert.IsEqual(_receiver2.CallIndex, 0);
+            Assert.IsEqual(_foo.CallIndex, 0);
+
+            _tickManager.Update();
+
+            Assert.IsEqual(_receiver2.CallIndex, 1);
+            Assert.IsEqual(_foo.CallIndex, 2);
+            Assert.IsEqual(_receiver1.CallIndex, 3);
+        }
+
+        public class Foo : ITickable
+        {
+            public int CallIndex
+            {
+                get; set;
+            }
+
+            public void Tick()
+            {
+                CallIndex = CallCount++;
+            }
+        }
+
+        public class Signal1
+        {
+        }
+
+        public class Signal2
+        {
+        }
+
+        public class Receiver1
+        {
+            public int CallIndex
+            {
+                get; set;
+            }
+
+            public void OnSignal()
+            {
+                CallIndex = CallCount++;
+            }
+        }
+
+        public class Receiver2
+        {
+            public int CallIndex
+            {
+                get; set;
+            }
+
+            public void OnSignal()
+            {
+                CallIndex = CallCount++;
+            }
+        }
+    }
+}
+
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ae6347214d2fec34faa73c79172f642d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -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
+        {
+        }
+    }
+}
+
+
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 907fe89581f70f64e88ceda5022ffdd6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,149 @@
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Signals
+{
+    [TestFixture]
+    public class TestSignalIdentifiers : ZenjectUnitTestFixture
+    {
+        [SetUp]
+        public void CommonInstall()
+        {
+            SignalBusInstaller.Install(Container);
+        }
+
+        [Test]
+        public void TestMissingDeclaration()
+        {
+            var signalBus = Container.Resolve<SignalBus>();
+
+            Assert.Throws(() => signalBus.FireId<FooSignal>("asdf"));
+        }
+
+        [Test]
+        public void TestSubscribeAndUnsubscribe()
+        {
+            var signalId = "asdf";
+
+            Container.DeclareSignal<FooSignal>().WithId(signalId);
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            bool received = false;
+
+            Action callback = () => received = true;
+            signalBus.SubscribeId<FooSignal>(signalId, callback);
+
+            Assert.Throws(() => signalBus.Subscribe<FooSignal>(callback));
+
+            Assert.That(!received);
+            signalBus.FireId<FooSignal>(signalId);
+            Assert.That(received);
+
+            Assert.Throws(() => signalBus.Fire<FooSignal>());
+            Assert.Throws(() => signalBus.FireId<FooSignal>("asdfz"));
+
+            received = false;
+            signalBus.FireId<FooSignal>(signalId);
+            Assert.That(received);
+
+            signalBus.UnsubscribeId<FooSignal>(signalId, callback);
+
+            received = false;
+            signalBus.FireId<FooSignal>(signalId);
+            Assert.That(!received);
+        }
+
+        [Test]
+        public void TestIncompleteBinding()
+        {
+            Container.DeclareSignal<FooSignal>().WithId("asdf");
+            Container.BindSignal<FooSignal>().WithId("asdf");
+
+            Assert.Throws(() => Container.FlushBindings());
+        }
+
+        [Test]
+        public void TestBindWithoutDeclaration()
+        {
+            Container.BindSignal<FooSignal>().WithId("asdf").ToMethod(() => {});
+
+            Assert.Throws(() => Container.ResolveRoots());
+        }
+
+        [Test]
+        public void TestStaticMethodHandler()
+        {
+            Container.DeclareSignal<FooSignal>().WithId("asdf");
+
+            bool received = false;
+
+            Container.BindSignal<FooSignal>().WithId("asdf").ToMethod(() => received = true);
+            Container.ResolveRoots();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            Assert.That(!received);
+            signalBus.FireId<FooSignal>("asdf");
+            Assert.That(received);
+        }
+
+        [Test]
+        public void TestStaticMethodHandlerWithArgs()
+        {
+            Container.DeclareSignal<FooSignal>().WithId("asdf");
+
+            FooSignal received = null;
+
+            Container.BindSignal<FooSignal>().WithId("asdf").ToMethod(x => received = x);
+            Container.ResolveRoots();
+
+            var signalBus = Container.Resolve<SignalBus>();
+            var sent = new FooSignal();
+
+            Assert.IsNull(received);
+            signalBus.FireId("asdf", sent);
+            Assert.IsEqual(received, sent);
+        }
+
+        [Test]
+        public void TestInstanceMethodHandler()
+        {
+            Container.DeclareSignal<FooSignal>().WithId("asdf");
+
+            var qux = new Qux();
+            Container.BindSignal<FooSignal>().WithId("asdf")
+                .ToMethod<Qux>(x => x.OnFoo).From(b => b.FromInstance(qux));
+            Container.ResolveRoots();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            Assert.That(!qux.HasRecievedSignal);
+            signalBus.FireId<FooSignal>("asdf");
+            Assert.That(qux.HasRecievedSignal);
+        }
+
+        public class Qux
+        {
+            public void OnFoo()
+            {
+                HasRecievedSignal = true;
+            }
+
+            public bool HasRecievedSignal
+            {
+                get; private set;
+            }
+        }
+
+        public class FooSignal
+        {
+        }
+
+        public class Foo
+        {
+        }
+    }
+}
+
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 858c963bb28d506418f719d41e989e33
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,51 @@
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Signals
+{
+    public class FooSignal
+    {
+    }
+
+    [TestFixture]
+    public class TestSignalRuntimeDeclaration : ZenjectUnitTestFixture
+    {
+        [SetUp]
+        public void InstallCommon()
+        {
+            SignalBusInstaller.Install(Container);
+            Container.Inject(this);
+        }
+
+        [Inject]
+        SignalBus _signalBus = null;
+
+        [Test]
+        public void TestMissingDeclaration()
+        {
+            Assert.Throws(() => _signalBus.Fire(new FooSignal()));
+        }
+
+        [Test]
+        public void TestFireSuccess()
+        {
+            _signalBus.DeclareSignal<FooSignal>();
+            _signalBus.Fire(new FooSignal());
+        }
+
+        [Test]
+        public void TestIdentifierMissing()
+        {
+            _signalBus.DeclareSignal<FooSignal>();
+            Assert.Throws(() => _signalBus.FireId("asdf", new FooSignal()));
+        }
+
+        [Test]
+        public void TestIdentifier()
+        {
+            _signalBus.DeclareSignal<FooSignal>("asdf");
+            _signalBus.FireId("asdf", new FooSignal());
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d126648ba38c37f4bbd46176fd19e72a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,124 @@
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Signals
+{
+    [TestFixture]
+    public class TestSignals1 : ZenjectUnitTestFixture
+    {
+        [Test]
+        public void TestMissingDeclaration()
+        {
+            SignalBusInstaller.Install(Container);
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            Assert.Throws(() => signalBus.Fire<FooSignal>());
+        }
+
+        [Test]
+        public void TestSubscribeAndUnsubscribe()
+        {
+            SignalBusInstaller.Install(Container);
+
+            Container.DeclareSignal<FooSignal>();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            bool received = false;
+
+            Action callback = () => received = true;
+            signalBus.Subscribe<FooSignal>(callback);
+
+            Assert.That(!received);
+            signalBus.Fire<FooSignal>();
+            Assert.That(received);
+
+            received = false;
+            signalBus.Fire<FooSignal>();
+            Assert.That(received);
+
+            signalBus.Unsubscribe<FooSignal>(callback);
+
+            received = false;
+            signalBus.Fire<FooSignal>();
+            Assert.That(!received);
+        }
+
+        [Test]
+        public void TestWithArgs()
+        {
+            SignalBusInstaller.Install(Container);
+
+            Container.DeclareSignal<FooSignal>();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            FooSignal received = null;
+
+            signalBus.Subscribe<FooSignal>(x => received = x);
+
+            var sent = new FooSignal();
+
+            signalBus.Fire(sent);
+
+            Assert.IsEqual(received, sent);
+        }
+
+        [Test]
+        public void TestUnsubscribeWithoutSubscribe()
+        {
+            SignalBusInstaller.Install(Container);
+
+            Container.DeclareSignal<FooSignal>();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            Action callback = () => {};
+
+            Assert.Throws(() => signalBus.Unsubscribe<FooSignal>(callback));
+
+            signalBus.TryUnsubscribe<FooSignal>(callback);
+
+            signalBus.Subscribe<FooSignal>(callback);
+            signalBus.Unsubscribe<FooSignal>(callback);
+        }
+
+        [Test]
+        public void TestUntypedSubscribe()
+        {
+            SignalBusInstaller.Install(Container);
+
+            Container.DeclareSignal<FooSignal>();
+            Container.DeclareSignal<BarSignal>();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            object received = null;
+
+            signalBus.Subscribe(typeof(FooSignal), x =>
+                {
+                    Assert.That(x is FooSignal);
+                    received = x;
+                });
+
+            var data = new FooSignal();
+
+            signalBus.Fire(data);
+
+            Assert.IsEqual(received, data);
+
+            signalBus.Fire(new BarSignal());
+        }
+
+        public class FooSignal
+        {
+        }
+
+        public class BarSignal
+        {
+            public string Value;
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5d50d2db331ed4b46b395d73e2032024
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,242 @@
+using System;
+using NUnit.Framework;
+using Assert = ModestTree.Assert;
+
+namespace Zenject.Tests.Signals
+{
+    [TestFixture]
+    public class TestSignalsAdvanced : ZenjectUnitTestFixture
+    {
+        [SetUp]
+        public void CommonInstall()
+        {
+            ZenjectManagersInstaller.Install(Container);
+            SignalBusInstaller.Install(Container);
+            Container.Inject(this);
+        }
+
+        [Test]
+        public void TestSubscribeDeterministicOrder()
+        {
+            Container.DeclareSignal<FooSignal>();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            int count = 1;
+
+            int order1 = 0;
+            Action handler1 = () => order1 = count++;
+
+            int order2 = 0;
+            Action handler2 = () => order2 = count++;
+
+            int order3 = 0;
+            Action handler3 = () => order3 = count++;
+
+            signalBus.Subscribe<FooSignal>(handler1);
+            signalBus.Subscribe<FooSignal>(handler2);
+            signalBus.Subscribe<FooSignal>(handler3);
+
+            signalBus.Fire<FooSignal>();
+
+            Assert.IsEqual(order1, 1);
+            Assert.IsEqual(order2, 2);
+            Assert.IsEqual(order3, 3);
+        }
+
+        [Test]
+        public void TestSubscribeUnsubscribeInsideHandler()
+        {
+            Container.DeclareSignal<FooSignal>();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            bool received = false;
+
+            Action handler2 = () => received = true;
+
+            Action handler = () =>
+            {
+                signalBus.Subscribe<FooSignal>(handler2);
+            };
+
+            Action handler3 = () =>
+            {
+                signalBus.Unsubscribe<FooSignal>(handler2);
+            };
+
+            signalBus.Subscribe<FooSignal>(handler);
+
+            Assert.That(!received);
+            signalBus.Fire<FooSignal>();
+            Assert.That(!received);
+            // handler2 is subscribed now
+
+            signalBus.Unsubscribe<FooSignal>(handler);
+
+            Assert.That(!received);
+            signalBus.Fire<FooSignal>();
+            Assert.That(received);
+            received = false;
+
+            signalBus.Subscribe<FooSignal>(handler3);
+            Assert.That(!received);
+            signalBus.Fire<FooSignal>();
+            // Should be called before handler 3 so should receive it
+            Assert.That(received);
+            received = false;
+            signalBus.Unsubscribe<FooSignal>(handler3);
+
+            Assert.That(!received);
+            signalBus.Fire<FooSignal>();
+            Assert.That(!received);
+            received = false;
+
+            Assert.IsEqual(signalBus.NumSubscribers, 0);
+
+            // Now test unsubscribing ourself in our own handler
+
+            Action handler4 = null;
+            handler4 = () =>
+            {
+                received = true;
+                signalBus.Unsubscribe<FooSignal>(handler4);
+            };
+            signalBus.Subscribe<FooSignal>(handler4);
+
+            Assert.That(!received);
+            signalBus.Fire<FooSignal>();
+            Assert.That(received);
+            received = false;
+
+            signalBus.Fire<FooSignal>();
+            Assert.That(!received);
+        }
+
+        [Test]
+        public void TestSubcontainers1()
+        {
+            Container.DeclareSignal<FooSignal>();
+
+            var signalBus1 = Container.Resolve<SignalBus>();
+
+            var subContainer = Container.CreateSubContainer();
+
+            var signalBus2 = subContainer.Resolve<SignalBus>();
+
+            bool received = false;
+            Action callback = () => received = true;
+
+            signalBus2.Subscribe<FooSignal>(callback);
+
+            Assert.That(!received);
+            signalBus1.Fire<FooSignal>();
+            Assert.That(received);
+
+            subContainer.Resolve<DisposableManager>().LateDispose();
+
+            // Signal should unregister automatically when the subcontainer is disposed
+            received = false;
+            signalBus1.Fire<FooSignal>();
+            Assert.That(!received);
+        }
+
+        [Test]
+        public void TestSignalDeclarationSettingsRequireHandlerMissing()
+        {
+            Container.DeclareSignal<FooSignal>();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            signalBus.Fire<FooSignal>();
+        }
+
+        [Test]
+        public void TestSignalDeclarationSettingsRequireHandler()
+        {
+            Container.DeclareSignal<FooSignal>().RequireSubscriber();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            Assert.Throws(() => signalBus.Fire<FooSignal>());
+        }
+
+        [Test]
+        public void TestSignalDeclarationSettingsRunAsync1()
+        {
+            Container.DeclareSignal<FooSignal>().RunAsync();
+            Container.ResolveRoots();
+            Container.Resolve<InitializableManager>().Initialize();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            bool received = false;
+            signalBus.Subscribe<FooSignal>(() => received = true);
+
+            Assert.That(!received);
+            signalBus.Fire<FooSignal>();
+            Assert.That(!received);
+
+            Container.Resolve<TickableManager>().Update();
+            Assert.That(received);
+        }
+
+        [Test]
+        public void TestIsDeclared1()
+        {
+            Container.DeclareSignal<FooSignal>();
+            Container.ResolveRoots();
+
+            var signalBus = Container.Resolve<SignalBus>();
+            Assert.That(signalBus.IsSignalDeclared<FooSignal>());
+        }
+
+        [Test]
+        public void TestIsDeclared2()
+        {
+            Container.ResolveRoots();
+
+            var signalBus = Container.Resolve<SignalBus>();
+            Assert.That(!signalBus.IsSignalDeclared<FooSignal>());
+        }
+
+        [Test]
+        public void TestSignalDeclarationSettingsRunAsync2()
+        {
+            Container.DeclareSignal<FooSignal>().RunAsync();
+            Container.ResolveRoots();
+            Container.Resolve<InitializableManager>().Initialize();
+
+            var signalBus = Container.Resolve<SignalBus>();
+
+            int callCount = 0;
+
+            Action handler = () =>
+            {
+                callCount++;
+                signalBus.Fire<FooSignal>();
+            };
+
+            signalBus.Subscribe<FooSignal>(handler);
+
+            Assert.IsEqual(callCount, 0);
+            signalBus.Fire<FooSignal>();
+            Assert.IsEqual(callCount, 0);
+
+            Container.Resolve<TickableManager>().Update();
+            Assert.IsEqual(callCount, 1);
+            Container.Resolve<TickableManager>().Update();
+            Assert.IsEqual(callCount, 2);
+        }
+
+        public class FooSignal
+        {
+        }
+
+        public class BarSignal
+        {
+            public string Value;
+        }
+    }
+}
+
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a29fed4f37865b6499168681c2fc1460
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: