com.wallstop-studios.dxmessaging 1.0.0-rc8

package/Tests/Runtime/Core/RegistrationTests.cs

@@ -0,0 +1,1045 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using DxMessaging.Core;
+    using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.Messages;
+    using NUnit.Framework;
+    using Scripts.Components;
+    using Scripts.Messages;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+
+    public sealed class RegistrationTests : MessagingTestBase
+    {
+        private GameObject _test;
+        private EmptyMessageAwareComponent _component;
+        private MessageRegistrationToken _token;
+
+        [UnitySetUp]
+        public override IEnumerator UnitySetup()
+        {
+            IEnumerator baseEnumerator = base.UnitySetup();
+            while (baseEnumerator.MoveNext())
+            {
+                yield return baseEnumerator.Current;
+            }
+
+            _test = new(nameof(RegistrationTests), typeof(EmptyMessageAwareComponent));
+            _spawned.Add(_test);
+            _component = _test.GetComponent<EmptyMessageAwareComponent>();
+            _token = GetToken(_component);
+        }
+
+        [UnityTest]
+        public IEnumerator UntargetedNormal()
+        {
+            int count = 0;
+            void Handle(SimpleUntargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleUntargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterUntargeted<SimpleUntargetedMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitUntargeted();
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitUntargeted();
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitUntargeted();
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator UntargetedNoCopy()
+        {
+            int count = 0;
+            void Handle(ref SimpleUntargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleUntargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterUntargeted<SimpleUntargetedMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitUntargeted();
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitUntargeted();
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitUntargeted();
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator UntargetedPostProcessor()
+        {
+            int count = 0;
+            void Handle(ref SimpleUntargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleUntargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitUntargeted();
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitUntargeted();
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitUntargeted();
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator UntargetedInterceptor()
+        {
+            int count = 0;
+            bool Intercept(ref SimpleUntargetedMessage message)
+            {
+                ++count;
+                return true;
+            }
+
+            SimpleUntargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(Intercept), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitUntargeted();
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitUntargeted();
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitUntargeted();
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator GameObjectTargetedNormal()
+        {
+            int count = 0;
+            void Handle(SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterGameObjectTargeted<SimpleTargetedMessage>(_test, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator GameObjectTargetedNoCopy()
+        {
+            int count = 0;
+            void Handle(ref SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterGameObjectTargeted<SimpleTargetedMessage>(_test, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator GameObjectTargetedPostProcessor()
+        {
+            int count = 0;
+            void Handle(ref SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(_test, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator ComponentTargetedNormal()
+        {
+            int count = 0;
+            void Handle(SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterComponentTargeted<SimpleTargetedMessage>(_component, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator ComponentTargetedNoCopy()
+        {
+            int count = 0;
+            void Handle(ref SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterComponentTargeted<SimpleTargetedMessage>(_component, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator ComponentTargetedPostProcessor()
+        {
+            int count = 0;
+            void Handle(ref SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(_component, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator TargetedInterceptor()
+        {
+            int count = 0;
+            bool Intercept(ref InstanceId target, ref SimpleTargetedMessage message)
+            {
+                ++count;
+                return true;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterTargetedInterceptor<SimpleTargetedMessage>(Intercept), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator TargetedWithoutTargetingNormal()
+        {
+            int count = 0;
+            void Handle(InstanceId target, SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator TargetedWithoutTargetingNoCopy()
+        {
+            int count = 0;
+            void Handle(ref InstanceId target, ref SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator TargetedWithoutTargetingPostProcessorNormal()
+        {
+            int count = 0;
+            void Handle(InstanceId target, SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator TargetedWithoutTargetingPostProcessorNoCopy()
+        {
+            int count = 0;
+            void Handle(ref InstanceId target, ref SimpleTargetedMessage message)
+            {
+                ++count;
+            }
+
+            SimpleTargetedMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectTargeted(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectTargeted(_test);
+                    message.EmitComponentTargeted(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator GameObjectBroadcastNormal()
+        {
+            int count = 0;
+            void Handle(SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(_test, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectBroadcast(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectBroadcast(_test);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator GameObjectBroadcastNoCopy()
+        {
+            int count = 0;
+            void Handle(ref SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(_test, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectBroadcast(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectBroadcast(_test);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator GameObjectBroadcastPostProcessor()
+        {
+            int count = 0;
+            void Handle(ref SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(_test, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectBroadcast(_test);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitGameObjectBroadcast(_test);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator ComponentBroadcastNormal()
+        {
+            int count = 0;
+            void Handle(SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterComponentBroadcast<SimpleBroadcastMessage>(_component, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator ComponentBroadcastNoCopy()
+        {
+            int count = 0;
+            void Handle(ref SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterComponentBroadcast<SimpleBroadcastMessage>(_component, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator ComponentBroadcastPostProcessor()
+        {
+            int count = 0;
+            void Handle(ref SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(_component, Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator BroadcastInterceptor()
+        {
+            int count = 0;
+            bool Intercept(ref InstanceId target, ref SimpleBroadcastMessage message)
+            {
+                ++count;
+                return true;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterBroadcastInterceptor<SimpleBroadcastMessage>(Intercept), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator BroadcastWithoutSourceNormal()
+        {
+            int count = 0;
+            void Handle(InstanceId id, SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterBroadcastWithoutSource<SimpleBroadcastMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator BroadcastWithoutSourceNoCopy()
+        {
+            int count = 0;
+            void Handle(ref InstanceId id, ref SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterBroadcastWithoutSource<SimpleBroadcastMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator BroadcastWithoutSourcePostProcessorNormal()
+        {
+            int count = 0;
+            void Handle(InstanceId id, SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator BroadcastWithoutSourcePostProcessorNoCopy()
+        {
+            int count = 0;
+            void Handle(ref InstanceId id, ref SimpleBroadcastMessage message)
+            {
+                ++count;
+            }
+
+            SimpleBroadcastMessage message = new();
+            RunRegistrationTest(
+                token => token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(Handle), i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, count);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, count);
+                }, () =>
+                {
+                    message.EmitGameObjectBroadcast(_test);
+                    message.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, count);
+                }, () =>
+                {
+                    count = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator GlobalAcceptAllNormal()
+        {
+            int targetedCount = 0;
+            int broadcastCount = 0;
+            int untargetedCount = 0;
+
+            void HandleUntargeted(IUntargetedMessage message)
+            {
+                ++untargetedCount;
+            }
+
+            void HandleTargeted(InstanceId id, ITargetedMessage message)
+            {
+                ++targetedCount;
+            }
+
+            void HandleBroadcast(InstanceId id, IBroadcastMessage message)
+            {
+                ++broadcastCount;
+            }
+
+            SimpleUntargetedMessage untargetedMessage = new();
+            SimpleTargetedMessage targetedMessage = new();
+            SimpleBroadcastMessage broadcastMessage = new();
+            RunRegistrationTest(
+                token => token.RegisterGlobalAcceptAll(HandleUntargeted, HandleTargeted, HandleBroadcast), i =>
+                {
+                    Assert.AreEqual(i, targetedCount);
+                    Assert.AreEqual(i, broadcastCount);
+                    Assert.AreEqual(i, untargetedCount);
+                    untargetedMessage.EmitUntargeted();
+                    targetedMessage.EmitGameObjectTargeted(_test);
+                    broadcastMessage.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, targetedCount);
+                    Assert.AreEqual(i, broadcastCount);
+                    Assert.AreEqual(i, untargetedCount);
+                    untargetedMessage.EmitUntargeted();
+                    Assert.AreEqual(i, targetedCount);
+                    Assert.AreEqual(i, broadcastCount);
+                    Assert.AreEqual(i + 1, untargetedCount);
+                    targetedMessage.EmitGameObjectTargeted(_test);
+                    Assert.AreEqual(i + 1, targetedCount);
+                    Assert.AreEqual(i, broadcastCount);
+                    Assert.AreEqual(i + 1, untargetedCount);
+                    broadcastMessage.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, targetedCount);
+                    Assert.AreEqual(i + 1, broadcastCount);
+                    Assert.AreEqual(i + 1, untargetedCount);
+                }, () =>
+                {
+                    untargetedMessage.EmitUntargeted();
+                    targetedMessage.EmitGameObjectTargeted(_test);
+                    broadcastMessage.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, targetedCount);
+                    Assert.AreEqual(0, broadcastCount);
+                    Assert.AreEqual(0, untargetedCount);
+                }, () =>
+                {
+                    targetedCount = 0;
+                    broadcastCount = 0;
+                    untargetedCount = 0;
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator GlobalAcceptAllNoCopy()
+        {
+            int targetedCount = 0;
+            int broadcastCount = 0;
+            int untargetedCount = 0;
+
+            void HandleUntargeted(ref IUntargetedMessage message)
+            {
+                ++untargetedCount;
+            }
+
+            void HandleTargeted(ref InstanceId id, ref ITargetedMessage message)
+            {
+                ++targetedCount;
+            }
+
+            void HandleBroadcast(ref InstanceId id, ref IBroadcastMessage message)
+            {
+                ++broadcastCount;
+            }
+
+            SimpleUntargetedMessage untargetedMessage = new();
+            SimpleTargetedMessage targetedMessage = new();
+            SimpleBroadcastMessage broadcastMessage = new();
+            RunRegistrationTest(
+                token => token.RegisterGlobalAcceptAll(HandleUntargeted, HandleTargeted, HandleBroadcast), i =>
+                {
+                    Assert.AreEqual(i, targetedCount);
+                    Assert.AreEqual(i, broadcastCount);
+                    Assert.AreEqual(i, untargetedCount);
+                    untargetedMessage.EmitUntargeted();
+                    targetedMessage.EmitGameObjectTargeted(_test);
+                    broadcastMessage.EmitComponentBroadcast(_component);
+                }, i =>
+                {
+                    Assert.AreEqual(i, targetedCount);
+                    Assert.AreEqual(i, broadcastCount);
+                    Assert.AreEqual(i, untargetedCount);
+                    untargetedMessage.EmitUntargeted();
+                    Assert.AreEqual(i, targetedCount);
+                    Assert.AreEqual(i, broadcastCount);
+                    Assert.AreEqual(i + 1, untargetedCount);
+                    targetedMessage.EmitGameObjectTargeted(_test);
+                    Assert.AreEqual(i + 1, targetedCount);
+                    Assert.AreEqual(i, broadcastCount);
+                    Assert.AreEqual(i + 1, untargetedCount);
+                    broadcastMessage.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(i + 1, targetedCount);
+                    Assert.AreEqual(i + 1, broadcastCount);
+                    Assert.AreEqual(i + 1, untargetedCount);
+                }, () =>
+                {
+                    untargetedMessage.EmitUntargeted();
+                    targetedMessage.EmitGameObjectTargeted(_test);
+                    broadcastMessage.EmitComponentBroadcast(_component);
+                    Assert.AreEqual(0, targetedCount);
+                    Assert.AreEqual(0, broadcastCount);
+                    Assert.AreEqual(0, untargetedCount);
+                }, () =>
+                {
+                    targetedCount = 0;
+                    broadcastCount = 0;
+                    untargetedCount = 0;
+                });
+            yield break;
+        }
+
+        private void RunRegistrationTest(Func<MessageRegistrationToken, MessageRegistrationHandle> registration, Action<int> normalAssert, Action<int> removalAssert, Action finalAssert, Action reset)
+        {
+            HashSet<MessageRegistrationHandle> handles = new(_numRegistrations);
+            try
+            {
+                for (int i = 0; i < _numRegistrations; ++i)
+                {
+                    MessageRegistrationHandle handle = registration(_token);
+                    bool neverSeen = handles.Add(handle);
+                    Assert.IsTrue(neverSeen, "Handle {0} at count {1} was a duplicate.", handle, neverSeen);
+                }
+
+                for (int i = 0; i < 100; ++i)
+                {
+                    normalAssert(i);
+                }
+
+                reset();
+                int expected = 0;
+                foreach (MessageRegistrationHandle handle in handles.OrderBy(_ => _random.Next()).ToList())
+                {
+                    removalAssert(expected++);
+                    handles.Remove(handle);
+                    _token.RemoveRegistration(handle);
+                }
+
+                reset();
+                for (int i = 0; i < 100; ++i)
+                {
+                    finalAssert();
+                }
+            }
+            finally
+            {
+                foreach (MessageRegistrationHandle handle in handles)
+                {
+                    _token.RemoveRegistration(handle);
+                }
+            }
+        }
+    }
+}