com.wallstop-studios.dxmessaging 2.1.7 → 2.1.9

package/Tests/Runtime/Core/NominalTests.cs

@@ -1,1738 +0,0 @@
-#if UNITY_2021_3_OR_NEWER
-namespace DxMessaging.Tests.Runtime.Core
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using DxMessaging.Core;
-    using DxMessaging.Core.Extensions;
-    using DxMessaging.Core.MessageBus;
-    using DxMessaging.Core.Messages;
-    using NUnit.Framework;
-    using Scripts.Components;
-    using Scripts.Messages;
-    using UnityEngine;
-    using UnityEngine.TestTools;
-    using Object = UnityEngine.Object;
-
-    public sealed class NominalTests : MessagingTestBase
-    {
-        [UnityTest]
-        public IEnumerator Nominal()
-        {
-            GameObject test = new(nameof(Nominal), typeof(SimpleMessageAwareComponent));
-            _spawned.Add(test);
-            GameObject nonTest = new("Non-Test", typeof(SimpleMessageAwareComponent));
-            _spawned.Add(nonTest);
-
-            SimpleMessageAwareComponent firstComponent =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            int untargetedWorks = 0;
-            int targetedWorks = 0;
-            int targetedWithoutTargetingWorks = 0;
-            int broadcastWorks = 0;
-            int broadcastWithoutSourceWorks = 0;
-            Dictionary<object, int> componentTargetedWorks = new();
-            Dictionary<object, int> componentBroadcastWorks = new();
-
-            SetupComponent(firstComponent);
-
-            // Generate non-component targeted methods
-            SimpleUntargetedMessage untargetedMessage = new();
-            untargetedMessage.EmitUntargeted();
-            Assert.AreEqual(1, untargetedWorks);
-            Assert.AreEqual(0, targetedWorks);
-            Assert.AreEqual(0, broadcastWorks);
-            Assert.AreEqual(0, componentTargetedWorks.Count);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(0, targetedWithoutTargetingWorks);
-            Assert.AreEqual(0, broadcastWithoutSourceWorks);
-
-            untargetedMessage.EmitUntargeted();
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(0, targetedWorks);
-            Assert.AreEqual(0, broadcastWorks);
-            Assert.AreEqual(0, componentTargetedWorks.Count);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(0, targetedWithoutTargetingWorks);
-            Assert.AreEqual(0, broadcastWithoutSourceWorks);
-
-            SimpleTargetedMessage targetedMessage = new();
-            targetedMessage.EmitGameObjectTargeted(test);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(1, targetedWorks);
-            Assert.AreEqual(0, broadcastWorks);
-            Assert.AreEqual(0, componentTargetedWorks.Count);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(1, targetedWithoutTargetingWorks);
-            Assert.AreEqual(0, broadcastWithoutSourceWorks);
-
-            SimpleBroadcastMessage broadcastMessage = new();
-            broadcastMessage.EmitGameObjectBroadcast(test);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(1, targetedWorks);
-            Assert.AreEqual(1, broadcastWorks);
-            Assert.AreEqual(0, componentTargetedWorks.Count);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(1, targetedWithoutTargetingWorks);
-            Assert.AreEqual(1, broadcastWithoutSourceWorks);
-
-            yield return null;
-
-            /*
-            If we add a second component, our Untargeted, GameObjectTargeted,
-            and GameObjectBroadcast receivers will be called *twice* for each
-            message emission, once per component.
-         */
-            SimpleMessageAwareComponent secondComponent =
-                test.AddComponent<SimpleMessageAwareComponent>();
-            SetupComponent(secondComponent);
-
-            // Targeted
-            targetedMessage.EmitGameObjectTargeted(test);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(1, broadcastWorks);
-            Assert.AreEqual(0, componentTargetedWorks.Count);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(3, targetedWithoutTargetingWorks);
-            Assert.AreEqual(1, broadcastWithoutSourceWorks);
-
-            targetedMessage.EmitGameObjectTargeted(nonTest);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(1, broadcastWorks);
-            Assert.AreEqual(0, componentTargetedWorks.Count);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(5, targetedWithoutTargetingWorks);
-            Assert.AreEqual(1, broadcastWithoutSourceWorks);
-
-            // Component Targeted
-            targetedMessage.EmitComponentTargeted(firstComponent);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(1, broadcastWorks);
-            Assert.AreEqual(1, componentTargetedWorks.Count);
-            Assert.AreEqual(1, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(7, targetedWithoutTargetingWorks);
-            Assert.AreEqual(1, broadcastWithoutSourceWorks);
-
-            targetedMessage.EmitComponentTargeted(secondComponent);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(1, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(1, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(1, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(9, targetedWithoutTargetingWorks);
-            Assert.AreEqual(1, broadcastWithoutSourceWorks);
-
-            targetedMessage.EmitComponentTargeted(firstComponent);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(1, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(2, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(1, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(11, targetedWithoutTargetingWorks);
-            Assert.AreEqual(1, broadcastWithoutSourceWorks);
-
-            targetedMessage.EmitComponentTargeted(secondComponent);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(1, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(2, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(2, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(13, targetedWithoutTargetingWorks);
-            Assert.AreEqual(1, broadcastWithoutSourceWorks);
-
-            // Broadcast
-            broadcastMessage.EmitGameObjectBroadcast(nonTest);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(1, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(2, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(2, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(13, targetedWithoutTargetingWorks);
-            Assert.AreEqual(3, broadcastWithoutSourceWorks);
-
-            broadcastMessage.EmitGameObjectBroadcast(test);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(3, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(2, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(2, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(0, componentBroadcastWorks.Count);
-            Assert.AreEqual(13, targetedWithoutTargetingWorks);
-            Assert.AreEqual(5, broadcastWithoutSourceWorks);
-
-            // Component Broadcast
-            broadcastMessage.EmitComponentBroadcast(firstComponent);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(3, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(2, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(2, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(1, componentBroadcastWorks.Count);
-            Assert.AreEqual(1, componentBroadcastWorks[firstComponent]);
-            Assert.AreEqual(13, targetedWithoutTargetingWorks);
-            Assert.AreEqual(7, broadcastWithoutSourceWorks);
-
-            broadcastMessage.EmitComponentBroadcast(secondComponent);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(3, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(2, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(2, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(2, componentBroadcastWorks.Count);
-            Assert.AreEqual(1, componentBroadcastWorks[firstComponent]);
-            Assert.AreEqual(1, componentBroadcastWorks[secondComponent]);
-            Assert.AreEqual(13, targetedWithoutTargetingWorks);
-            Assert.AreEqual(9, broadcastWithoutSourceWorks);
-
-            broadcastMessage.EmitComponentBroadcast(firstComponent);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(3, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(2, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(2, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(2, componentBroadcastWorks.Count);
-            Assert.AreEqual(2, componentBroadcastWorks[firstComponent]);
-            Assert.AreEqual(1, componentBroadcastWorks[secondComponent]);
-            Assert.AreEqual(13, targetedWithoutTargetingWorks);
-            Assert.AreEqual(11, broadcastWithoutSourceWorks);
-
-            broadcastMessage.EmitComponentBroadcast(secondComponent);
-            Assert.AreEqual(2, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(3, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(2, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(2, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(2, componentBroadcastWorks.Count);
-            Assert.AreEqual(2, componentBroadcastWorks[firstComponent]);
-            Assert.AreEqual(2, componentBroadcastWorks[secondComponent]);
-            Assert.AreEqual(13, targetedWithoutTargetingWorks);
-            Assert.AreEqual(13, broadcastWithoutSourceWorks);
-
-            // Finally, re-emit the targeted message - it should be received by both components
-            untargetedMessage.EmitUntargeted();
-            Assert.AreEqual(4, untargetedWorks);
-            Assert.AreEqual(3, targetedWorks);
-            Assert.AreEqual(3, broadcastWorks);
-            Assert.AreEqual(2, componentTargetedWorks.Count);
-            Assert.AreEqual(2, componentTargetedWorks[firstComponent]);
-            Assert.AreEqual(2, componentTargetedWorks[secondComponent]);
-            Assert.AreEqual(2, componentBroadcastWorks.Count);
-            Assert.AreEqual(2, componentBroadcastWorks[firstComponent]);
-            Assert.AreEqual(2, componentBroadcastWorks[secondComponent]);
-            Assert.AreEqual(13, targetedWithoutTargetingWorks);
-            Assert.AreEqual(13, broadcastWithoutSourceWorks);
-            yield break;
-
-            void SetupComponent(SimpleMessageAwareComponent toSetup)
-            {
-                toSetup.untargetedHandler = () => ++untargetedWorks;
-                toSetup.targetedHandler = () => ++targetedWorks;
-                toSetup.targetedWithoutTargetingHandler = () => ++targetedWithoutTargetingWorks;
-                toSetup.broadcastHandler = () => ++broadcastWorks;
-                toSetup.broadcastWithoutSourceHandler = () => ++broadcastWithoutSourceWorks;
-                toSetup.componentTargetedHandler = () =>
-                {
-                    int existing = componentTargetedWorks.GetValueOrDefault(toSetup, 0);
-
-                    componentTargetedWorks[toSetup] = ++existing;
-                };
-                toSetup.componentBroadcastHandler = () =>
-                {
-                    int existing = componentBroadcastWorks.GetValueOrDefault(toSetup, 0);
-
-                    componentBroadcastWorks[toSetup] = ++existing;
-                };
-            }
-        }
-
-        [UnityTest]
-        public IEnumerator Lifetime()
-        {
-            IMessageBus messageBus = MessageHandler.MessageBus;
-            Assert.IsNotNull(messageBus);
-
-            GameObject test = new(nameof(Lifetime), typeof(SimpleMessageAwareComponent));
-            _spawned.Add(test);
-
-            SimpleMessageAwareComponent firstComponent =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            // One for the untargeted message, one for the targeted without targeting, one for broadcast without source
-            Assert.AreEqual(3, messageBus.RegisteredUntargeted);
-            // One for the game object, one for each targeted message type (simple + complex)
-            Assert.AreEqual(4, messageBus.RegisteredTargeted);
-            Assert.AreEqual(2, messageBus.RegisteredBroadcast);
-
-            yield return null;
-
-            SimpleMessageAwareComponent secondComponent =
-                test.AddComponent<SimpleMessageAwareComponent>();
-            Assert.AreEqual(3, messageBus.RegisteredUntargeted);
-            // One for the game object, one for the first component, one for the second component = 3
-            Assert.AreEqual(6, messageBus.RegisteredTargeted);
-            Assert.AreEqual(3, messageBus.RegisteredBroadcast);
-
-            secondComponent.enabled = false;
-            yield return null;
-
-            // 3 - one component (disabled)
-            Assert.AreEqual(3, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(4, messageBus.RegisteredTargeted);
-            Assert.AreEqual(2, messageBus.RegisteredBroadcast);
-
-            firstComponent.enabled = false;
-            yield return null;
-
-            // No active scripts, no active handlers
-            Assert.AreEqual(0, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(0, messageBus.RegisteredTargeted);
-            Assert.AreEqual(0, messageBus.RegisteredBroadcast);
-
-            test.SetActive(false);
-            yield return null;
-
-            Assert.AreEqual(0, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(0, messageBus.RegisteredTargeted);
-            Assert.AreEqual(0, messageBus.RegisteredBroadcast);
-
-            firstComponent.enabled = true;
-            yield return null;
-
-            // Game object is still disabled - shouldn't have active child scripts
-            Assert.AreEqual(0, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(0, messageBus.RegisteredTargeted);
-            Assert.AreEqual(0, messageBus.RegisteredBroadcast);
-
-            test.SetActive(true);
-            yield return null;
-
-            Assert.AreEqual(3, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(4, messageBus.RegisteredTargeted);
-            Assert.AreEqual(2, messageBus.RegisteredBroadcast);
-
-            Object.Destroy(firstComponent);
-            yield return null;
-
-            Assert.AreEqual(0, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(0, messageBus.RegisteredTargeted);
-            Assert.AreEqual(0, messageBus.RegisteredBroadcast);
-
-            secondComponent.enabled = true;
-            yield return null;
-
-            Assert.AreEqual(3, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(4, messageBus.RegisteredTargeted);
-            Assert.AreEqual(2, messageBus.RegisteredBroadcast);
-
-            Object.Destroy(test);
-            yield return null;
-
-            Assert.AreEqual(0, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(0, messageBus.RegisteredTargeted);
-            Assert.AreEqual(0, messageBus.RegisteredBroadcast);
-        }
-
-        [UnityTest]
-        public IEnumerator NonMessagingObjects()
-        {
-            IMessageBus messageBus = MessageHandler.MessageBus;
-            Assert.IsNotNull(messageBus);
-
-            GameObject test1 = new("NonMessaging1");
-            _spawned.Add(test1);
-
-            Assert.AreEqual(0, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(0, messageBus.RegisteredTargeted);
-            Assert.AreEqual(0, messageBus.RegisteredBroadcast);
-
-            GameObject test2 = new("NonMessaging1", typeof(SpriteRenderer), typeof(MessageHandler));
-            _spawned.Add(test2);
-
-            Assert.AreEqual(0, messageBus.RegisteredUntargeted);
-            Assert.AreEqual(0, messageBus.RegisteredTargeted);
-            Assert.AreEqual(0, messageBus.RegisteredBroadcast);
-            yield break;
-        }
-
-        [UnityTest]
-        public IEnumerator DedupedRegistration()
-        {
-            GameObject test = new(nameof(DedupedRegistration), typeof(SimpleMessageAwareComponent));
-            _spawned.Add(test);
-
-            SimpleMessageAwareComponent component =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            int unTargetedCount = 0;
-            int targetedCount = 0;
-            int broadcastCount = 0;
-            int componentTargetedCount = 0;
-            int componentBroadcastCount = 0;
-            component.untargetedHandler = () => ++unTargetedCount;
-            component.targetedHandler = () => ++targetedCount;
-            component.broadcastHandler = () => ++broadcastCount;
-            component.componentTargetedHandler = () => ++componentTargetedCount;
-            component.componentBroadcastHandler = () => ++componentBroadcastCount;
-
-            MessageRegistrationToken token = GetToken(component);
-            HashSet<MessageRegistrationHandle> handles = new();
-            try
-            {
-                IEnumerator TestLifecycle(
-                    Action emitMessage,
-                    MessageRegistrationHandle handle,
-                    Func<int> count
-                )
-                {
-                    _ = handles.Add(handle);
-                    emitMessage();
-                    Assert.AreEqual(1, count());
-
-                    component.enabled = false;
-                    yield return null;
-
-                    emitMessage();
-                    Assert.AreEqual(1, count());
-                    emitMessage();
-                    Assert.AreEqual(1, count());
-                    component.enabled = true;
-                    yield return null;
-
-                    emitMessage();
-                    Assert.AreEqual(2, count());
-
-                    _ = handles.Remove(handle);
-                    token.RemoveRegistration(handle);
-
-                    emitMessage();
-                    // The existing handler should have picked it up
-                    Assert.AreEqual(3, count());
-
-                    emitMessage();
-                    // The existing handler should have picked it up
-                    Assert.AreEqual(4, count());
-                }
-
-                // Untargeted
-                SimpleUntargetedMessage untargetedMessage = new();
-                MessageRegistrationHandle untargetedHandle =
-                    token.RegisterUntargeted<SimpleUntargetedMessage>(
-                        component.HandleSimpleUntargetedMessage
-                    );
-                IEnumerator untargetedLifecycle = TestLifecycle(
-                    () => untargetedMessage.EmitUntargeted(),
-                    untargetedHandle,
-                    () => unTargetedCount
-                );
-                while (untargetedLifecycle.MoveNext())
-                {
-                    yield return untargetedLifecycle.Current;
-                }
-
-                // Targeted
-                MessageRegistrationHandle targetedHandle =
-                    token.RegisterGameObjectTargeted<SimpleTargetedMessage>(
-                        test,
-                        component.HandleSimpleTargetedMessage
-                    );
-                SimpleTargetedMessage targetedMessage = new();
-                IEnumerator targetedLifecycle = TestLifecycle(
-                    () => targetedMessage.EmitGameObjectTargeted(test),
-                    targetedHandle,
-                    () => targetedCount
-                );
-                while (targetedLifecycle.MoveNext())
-                {
-                    yield return targetedLifecycle.Current;
-                }
-
-                // Broadcast
-                MessageRegistrationHandle broadcastHandle =
-                    token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                        test,
-                        component.HandleSimpleBroadcastMessage
-                    );
-                SimpleBroadcastMessage broadcastMessage = new();
-                IEnumerator broadcastLifecycle = TestLifecycle(
-                    () => broadcastMessage.EmitGameObjectBroadcast(test),
-                    broadcastHandle,
-                    () => broadcastCount
-                );
-                while (broadcastLifecycle.MoveNext())
-                {
-                    yield return broadcastLifecycle.Current;
-                }
-
-                // Component Targeted
-                MessageRegistrationHandle componentTargetedHandle =
-                    token.RegisterComponentTargeted<SimpleTargetedMessage>(
-                        component,
-                        component.HandleSimpleComponentTargetedMessage
-                    );
-                IEnumerator componentTargetedLifecycle = TestLifecycle(
-                    () => targetedMessage.EmitComponentTargeted(component),
-                    componentTargetedHandle,
-                    () => componentTargetedCount
-                );
-                while (componentTargetedLifecycle.MoveNext())
-                {
-                    yield return componentTargetedLifecycle.Current;
-                }
-
-                // Component Broadcast
-                MessageRegistrationHandle componentBroadcastHandle =
-                    token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                        test,
-                        component.HandleSimpleBroadcastMessage
-                    );
-                IEnumerator componentBroadcastLifecycle = TestLifecycle(
-                    () => broadcastMessage.EmitComponentBroadcast(component),
-                    componentBroadcastHandle,
-                    () => componentBroadcastCount
-                );
-                while (componentBroadcastLifecycle.MoveNext())
-                {
-                    yield return componentBroadcastLifecycle.Current;
-                }
-            }
-            finally
-            {
-                foreach (MessageRegistrationHandle handle in handles)
-                {
-                    token.RemoveRegistration(handle);
-                }
-            }
-        }
-
-        [UnityTest]
-        public IEnumerator Interceptors()
-        {
-            GameObject test = new(nameof(Interceptors), typeof(SimpleMessageAwareComponent));
-            _spawned.Add(test);
-
-            SimpleMessageAwareComponent component =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            int unTargetedCount = 0;
-            int targetedCount = 0;
-            int broadcastCount = 0;
-            int componentTargetedCount = 0;
-            int componentBroadcastCount = 0;
-            component.untargetedHandler = () => ++unTargetedCount;
-            component.targetedHandler = () => ++targetedCount;
-            component.broadcastHandler = () => ++broadcastCount;
-            component.componentTargetedHandler = () => ++componentTargetedCount;
-            component.componentBroadcastHandler = () => ++componentBroadcastCount;
-
-            MessageRegistrationToken token = GetToken(component);
-            HashSet<MessageRegistrationHandle> handles = new();
-            try
-            {
-                bool allowed = true;
-
-                bool UntargetedInterceptor(ref SimpleUntargetedMessage message)
-                {
-                    return allowed;
-                }
-
-                bool TargetedInterceptor(ref InstanceId target, ref SimpleTargetedMessage message)
-                {
-                    return allowed;
-                }
-
-                bool BroadcastInterceptor(ref InstanceId source, ref SimpleBroadcastMessage message)
-                {
-                    return allowed;
-                }
-
-                // Double register to ensure no bugs
-                MessageRegistrationHandle untargetedInterceptor1 =
-                    token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(
-                        UntargetedInterceptor
-                    );
-                handles.Add(untargetedInterceptor1);
-                MessageRegistrationHandle untargetedInterceptor2 =
-                    token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(
-                        UntargetedInterceptor
-                    );
-                handles.Add(untargetedInterceptor2);
-                MessageRegistrationHandle targetedInterceptor1 =
-                    token.RegisterTargetedInterceptor<SimpleTargetedMessage>(TargetedInterceptor);
-                handles.Add(targetedInterceptor1);
-                MessageRegistrationHandle targetedInterceptor2 =
-                    token.RegisterTargetedInterceptor<SimpleTargetedMessage>(TargetedInterceptor);
-                handles.Add(targetedInterceptor2);
-                MessageRegistrationHandle broadcastInterceptor1 =
-                    token.RegisterBroadcastInterceptor<SimpleBroadcastMessage>(
-                        BroadcastInterceptor
-                    );
-                handles.Add(broadcastInterceptor1);
-                MessageRegistrationHandle broadcastInterceptor2 =
-                    token.RegisterBroadcastInterceptor<SimpleBroadcastMessage>(
-                        BroadcastInterceptor
-                    );
-                handles.Add(broadcastInterceptor2);
-
-                void RunTest(Action emitMessage, Func<int> count)
-                {
-                    allowed = true;
-                    emitMessage();
-                    Assert.AreEqual(1, count());
-                    allowed = false;
-                    emitMessage();
-                    Assert.AreEqual(1, count());
-                    emitMessage();
-                    Assert.AreEqual(1, count());
-                    allowed = true;
-                    emitMessage();
-                    Assert.AreEqual(2, count());
-                    emitMessage();
-                    Assert.AreEqual(3, count());
-                    allowed = false;
-                    emitMessage();
-                    Assert.AreEqual(3, count());
-                }
-
-                SimpleUntargetedMessage untargetedMessage = new();
-                RunTest(() => untargetedMessage.EmitUntargeted(), () => unTargetedCount);
-                SimpleTargetedMessage targetedMessage = new();
-                RunTest(() => targetedMessage.EmitGameObjectTargeted(test), () => targetedCount);
-                RunTest(
-                    () => targetedMessage.EmitComponentTargeted(component),
-                    () => componentTargetedCount
-                );
-                SimpleBroadcastMessage broadcastMessage = new();
-                RunTest(() => broadcastMessage.EmitGameObjectBroadcast(test), () => broadcastCount);
-                RunTest(
-                    () => broadcastMessage.EmitComponentBroadcast(component),
-                    () => componentBroadcastCount
-                );
-            }
-            finally
-            {
-                foreach (MessageRegistrationHandle handle in handles)
-                {
-                    token.RemoveRegistration(handle);
-                }
-            }
-
-            yield break;
-        }
-
-        [UnityTest]
-        public IEnumerator PostProcessors()
-        {
-            GameObject test = new(nameof(PostProcessors), typeof(SimpleMessageAwareComponent));
-            _spawned.Add(test);
-
-            SimpleMessageAwareComponent component =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            int unTargetedCount = 0;
-            int targetedCount = 0;
-            int broadcastCount = 0;
-            int componentTargetedCount = 0;
-            int componentBroadcastCount = 0;
-            int expectedTargetedWithoutTargetingCount = 0;
-            int expectedBroadcastWithoutSourceCount = 0;
-            int? lastSeenUntargetedCount = null;
-            int? lastSeenTargetedCount = null;
-            int? lastSeenComponentTargetedCount = null;
-            int? lastSeenBroadcastCount = null;
-            int? lastSeenComponentBroadcastCount = null;
-            component.untargetedHandler = () => ++unTargetedCount;
-            component.targetedHandler = () =>
-            {
-                ++targetedCount;
-                ++expectedTargetedWithoutTargetingCount;
-            };
-            component.broadcastHandler = () =>
-            {
-                ++broadcastCount;
-                ++expectedBroadcastWithoutSourceCount;
-            };
-            component.componentTargetedHandler = () =>
-            {
-                ++componentTargetedCount;
-                ++expectedTargetedWithoutTargetingCount;
-            };
-            component.componentBroadcastHandler = () =>
-            {
-                ++componentBroadcastCount;
-                ++expectedBroadcastWithoutSourceCount;
-            };
-
-            MessageRegistrationToken token = GetToken(component);
-            HashSet<MessageRegistrationHandle> handles = new();
-            try
-            {
-                void UntargetedPostProcessor(ref SimpleUntargetedMessage message)
-                {
-                    if (lastSeenUntargetedCount == null)
-                    {
-                        lastSeenUntargetedCount = unTargetedCount;
-                        return;
-                    }
-
-                    Assert.AreEqual(lastSeenUntargetedCount + 1, unTargetedCount);
-                    lastSeenUntargetedCount = unTargetedCount;
-                }
-
-                void GameObjectTargetedPostProcessor(ref SimpleTargetedMessage message)
-                {
-                    if (lastSeenTargetedCount == null)
-                    {
-                        return;
-                    }
-
-                    Assert.AreEqual(lastSeenTargetedCount + 1, targetedCount);
-                }
-
-                void ComponentTargetedPostProcessor(ref SimpleTargetedMessage message)
-                {
-                    if (lastSeenComponentTargetedCount == null)
-                    {
-                        return;
-                    }
-
-                    Assert.AreEqual(lastSeenComponentTargetedCount + 1, componentTargetedCount);
-                }
-
-                void TargetedWithoutTargetingPostProcessor(
-                    ref InstanceId target,
-                    ref SimpleTargetedMessage message
-                )
-                {
-                    switch (target.Object)
-                    {
-                        case GameObject _:
-                        {
-                            if (lastSeenTargetedCount != null)
-                            {
-                                Assert.AreEqual(lastSeenTargetedCount + 1, targetedCount);
-                            }
-
-                            lastSeenTargetedCount = targetedCount;
-                            break;
-                        }
-                        case Component _:
-                        {
-                            if (lastSeenComponentTargetedCount != null)
-                            {
-                                Assert.AreEqual(
-                                    lastSeenComponentTargetedCount + 1,
-                                    componentTargetedCount
-                                );
-                            }
-
-                            lastSeenComponentTargetedCount = componentTargetedCount;
-                            break;
-                        }
-                        default:
-                            Assert.Fail("Unexpected Object type - {0}.", target.Object?.GetType());
-                            break;
-                    }
-
-                    Assert.AreEqual(
-                        expectedTargetedWithoutTargetingCount,
-                        targetedCount + componentTargetedCount
-                    );
-                }
-
-                void GameObjectBroadcastPostProcessor(ref SimpleBroadcastMessage message)
-                {
-                    if (lastSeenBroadcastCount == null)
-                    {
-                        return;
-                    }
-
-                    Assert.AreEqual(lastSeenBroadcastCount + 1, broadcastCount);
-                }
-
-                void ComponentBroadcastPostProcessor(ref SimpleBroadcastMessage message)
-                {
-                    if (lastSeenComponentBroadcastCount == null)
-                    {
-                        return;
-                    }
-
-                    Assert.AreEqual(lastSeenComponentBroadcastCount + 1, componentBroadcastCount);
-                }
-
-                void BroadcastWithoutSourcePostProcessor(
-                    ref InstanceId source,
-                    ref SimpleBroadcastMessage message
-                )
-                {
-                    switch (source.Object)
-                    {
-                        case GameObject _:
-                        {
-                            if (lastSeenBroadcastCount != null)
-                            {
-                                Assert.AreEqual(lastSeenBroadcastCount + 1, broadcastCount);
-                            }
-
-                            lastSeenBroadcastCount = broadcastCount;
-                            break;
-                        }
-                        case Component _:
-                        {
-                            if (lastSeenComponentBroadcastCount != null)
-                            {
-                                Assert.AreEqual(
-                                    lastSeenComponentBroadcastCount + 1,
-                                    componentBroadcastCount
-                                );
-                            }
-
-                            lastSeenComponentBroadcastCount = componentBroadcastCount;
-                            break;
-                        }
-                        default:
-                            Assert.Fail("Unexpected Object type - {0}.", source.Object?.GetType());
-                            break;
-                    }
-
-                    Assert.AreEqual(
-                        expectedBroadcastWithoutSourceCount,
-                        broadcastCount + componentBroadcastCount
-                    );
-                }
-
-                MessageRegistrationHandle untargetedPostProcessor =
-                    token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(
-                        UntargetedPostProcessor
-                    );
-                handles.Add(untargetedPostProcessor);
-                MessageRegistrationHandle gameObjectTargetedPostProcessor =
-                    token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(
-                        test,
-                        GameObjectTargetedPostProcessor
-                    );
-                handles.Add(gameObjectTargetedPostProcessor);
-                MessageRegistrationHandle componentTargetedPostProcessor =
-                    token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(
-                        component,
-                        ComponentTargetedPostProcessor
-                    );
-                handles.Add(componentTargetedPostProcessor);
-                MessageRegistrationHandle targetedWithoutTargetingPostProcessor =
-                    token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(
-                        TargetedWithoutTargetingPostProcessor
-                    );
-                handles.Add(targetedWithoutTargetingPostProcessor);
-                MessageRegistrationHandle gameObjectBroadcastPostProcessor =
-                    token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(
-                        test,
-                        GameObjectBroadcastPostProcessor
-                    );
-                handles.Add(gameObjectBroadcastPostProcessor);
-                MessageRegistrationHandle componentBroadcastPostProcessor =
-                    token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(
-                        component,
-                        ComponentBroadcastPostProcessor
-                    );
-                handles.Add(componentBroadcastPostProcessor);
-                MessageRegistrationHandle broadcastWithoutSourcePostProcessor =
-                    token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(
-                        BroadcastWithoutSourcePostProcessor
-                    );
-                handles.Add(broadcastWithoutSourcePostProcessor);
-
-                void RunTest(Action emitMessage, Func<int> count)
-                {
-                    Assert.AreEqual(0, count());
-                    component.enabled = true;
-                    emitMessage();
-                    Assert.AreEqual(1, count());
-                    component.enabled = false;
-                    emitMessage();
-                    Assert.AreEqual(1, count());
-                    emitMessage();
-                    Assert.AreEqual(1, count());
-                    component.enabled = true;
-                    emitMessage();
-                    Assert.AreEqual(2, count());
-                    emitMessage();
-                    Assert.AreEqual(3, count());
-                    component.enabled = false;
-                    emitMessage();
-                    Assert.AreEqual(3, count());
-                }
-
-                SimpleUntargetedMessage untargetedMessage = new();
-                RunTest(() => untargetedMessage.EmitUntargeted(), () => unTargetedCount);
-                SimpleTargetedMessage targetedMessage = new();
-                RunTest(() => targetedMessage.EmitGameObjectTargeted(test), () => targetedCount);
-                RunTest(
-                    () => targetedMessage.EmitComponentTargeted(component),
-                    () => componentTargetedCount
-                );
-                SimpleBroadcastMessage broadcastMessage = new();
-                RunTest(() => broadcastMessage.EmitGameObjectBroadcast(test), () => broadcastCount);
-                RunTest(
-                    () => broadcastMessage.EmitComponentBroadcast(component),
-                    () => componentBroadcastCount
-                );
-            }
-            finally
-            {
-                foreach (MessageRegistrationHandle handle in handles)
-                {
-                    token.RemoveRegistration(handle);
-                }
-            }
-
-            yield break;
-        }
-
-        [UnityTest]
-        public IEnumerator InstanceId()
-        {
-            GameObject test = new(nameof(InstanceId), typeof(SimpleMessageAwareComponent));
-            _spawned.Add(test);
-
-            // Message-aware instance ids
-            SimpleMessageAwareComponent component =
-                test.GetComponent<SimpleMessageAwareComponent>();
-            Assert.AreEqual((InstanceId)test, (InstanceId)test);
-            Assert.AreEqual((InstanceId)component, (InstanceId)component);
-            Assert.AreNotEqual((InstanceId)test, (InstanceId)component);
-            Assert.AreNotEqual((InstanceId)component, (InstanceId)test);
-
-            // Non-message-aware instance ids
-            GameObject test2 = new(nameof(InstanceId) + " - 2");
-            _spawned.Add(test2);
-            Assert.AreNotEqual((InstanceId)test2, (InstanceId)test2.transform);
-            Assert.AreNotEqual((InstanceId)test2.transform, (InstanceId)test2);
-
-            // Null checks
-            bool caught = false;
-            try
-            {
-                _ = (InstanceId)(GameObject)null;
-            }
-            catch
-            {
-                caught = true;
-            }
-
-            Assert.IsTrue(caught);
-
-            caught = false;
-            try
-            {
-                _ = (InstanceId)(Component)null;
-            }
-            catch
-            {
-                caught = true;
-            }
-
-            Assert.IsTrue(caught);
-            yield break;
-        }
-
-        [UnityTest]
-        public IEnumerator GlobalAcceptAll()
-        {
-            GameObject test = new(nameof(GlobalAcceptAll), typeof(SimpleMessageAwareComponent));
-            _spawned.Add(test);
-            SimpleMessageAwareComponent component =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            MessageRegistrationToken token = GetToken(component);
-
-            int untargetedCount = 0;
-            int targetedCount = 0;
-            int broadcastCount = 0;
-            int fastUntargetedCount = 0;
-            int fastTargetedCount = 0;
-            int fastBroadcastCount = 0;
-
-            HashSet<MessageRegistrationHandle> handles = new();
-            try
-            {
-                MessageRegistrationHandle firstHandle = token.RegisterGlobalAcceptAll(
-                    HandleUntargeted,
-                    HandleTargeted,
-                    HandleBroadcast
-                );
-                _ = handles.Add(firstHandle);
-
-                // Untargeted
-                SimpleUntargetedMessage untargetedMessage = new();
-                untargetedMessage.EmitUntargeted();
-                Assert.AreEqual(1, untargetedCount);
-                Assert.AreEqual(0, targetedCount);
-                Assert.AreEqual(0, broadcastCount);
-                Assert.AreEqual(0, fastUntargetedCount);
-                Assert.AreEqual(0, fastTargetedCount);
-                Assert.AreEqual(0, fastBroadcastCount);
-                untargetedMessage.EmitUntargeted();
-                Assert.AreEqual(2, untargetedCount);
-                Assert.AreEqual(0, targetedCount);
-                Assert.AreEqual(0, broadcastCount);
-                Assert.AreEqual(0, fastUntargetedCount);
-                Assert.AreEqual(0, fastTargetedCount);
-                Assert.AreEqual(0, fastBroadcastCount);
-
-                // Targeted
-                SimpleTargetedMessage targetedMessage = new();
-                targetedMessage.EmitGameObjectTargeted(test);
-                Assert.AreEqual(2, untargetedCount);
-                Assert.AreEqual(1, targetedCount);
-                Assert.AreEqual(0, broadcastCount);
-                Assert.AreEqual(0, fastUntargetedCount);
-                Assert.AreEqual(0, fastTargetedCount);
-                Assert.AreEqual(0, fastBroadcastCount);
-                targetedMessage.EmitComponentTargeted(component);
-                Assert.AreEqual(2, untargetedCount);
-                Assert.AreEqual(2, targetedCount);
-                Assert.AreEqual(0, broadcastCount);
-                Assert.AreEqual(0, fastUntargetedCount);
-                Assert.AreEqual(0, fastTargetedCount);
-                Assert.AreEqual(0, fastBroadcastCount);
-
-                // Broadcast
-                SimpleBroadcastMessage broadcastMessage = new();
-                broadcastMessage.EmitGameObjectBroadcast(test);
-                Assert.AreEqual(2, untargetedCount);
-                Assert.AreEqual(2, targetedCount);
-                Assert.AreEqual(1, broadcastCount);
-                Assert.AreEqual(0, fastUntargetedCount);
-                Assert.AreEqual(0, fastTargetedCount);
-                Assert.AreEqual(0, fastBroadcastCount);
-                broadcastMessage.EmitComponentBroadcast(component);
-                Assert.AreEqual(2, untargetedCount);
-                Assert.AreEqual(2, targetedCount);
-                Assert.AreEqual(2, broadcastCount);
-                Assert.AreEqual(0, fastUntargetedCount);
-                Assert.AreEqual(0, fastTargetedCount);
-                Assert.AreEqual(0, fastBroadcastCount);
-
-                component.enabled = false;
-                int noMatchingCount = 0;
-                Action<LogLevel, string> previousLog = MessagingDebug.LogFunction;
-                try
-                {
-                    MessagingDebug.LogFunction = (_, logMessage) =>
-                    {
-                        if (logMessage.Contains("matching"))
-                        {
-                            ++noMatchingCount;
-                        }
-                    };
-                    untargetedMessage.EmitUntargeted();
-                    Assert.AreEqual(1, noMatchingCount);
-                    targetedMessage.EmitGameObjectTargeted(test);
-                    Assert.AreEqual(2, noMatchingCount);
-                    targetedMessage.EmitComponentTargeted(component);
-                    Assert.AreEqual(3, noMatchingCount);
-                    broadcastMessage.EmitGameObjectBroadcast(test);
-                    Assert.AreEqual(4, noMatchingCount);
-                    broadcastMessage.EmitComponentBroadcast(component);
-                    Assert.AreEqual(5, noMatchingCount);
-                }
-                finally
-                {
-                    MessagingDebug.LogFunction = previousLog;
-                }
-
-                Assert.AreEqual(2, untargetedCount);
-                Assert.AreEqual(2, targetedCount);
-                Assert.AreEqual(2, broadcastCount);
-                Assert.AreEqual(0, fastUntargetedCount);
-                Assert.AreEqual(0, fastTargetedCount);
-                Assert.AreEqual(0, fastBroadcastCount);
-
-                component.enabled = true;
-                MessageRegistrationHandle secondHandle = token.RegisterGlobalAcceptAll(
-                    HandleUntargeted,
-                    HandleTargeted,
-                    HandleBroadcast
-                );
-                _ = handles.Add(secondHandle);
-                untargetedMessage.EmitUntargeted();
-                targetedMessage.EmitGameObjectTargeted(test);
-                targetedMessage.EmitComponentTargeted(component);
-                broadcastMessage.EmitGameObjectBroadcast(test);
-                broadcastMessage.EmitComponentBroadcast(component);
-                Assert.AreEqual(3, untargetedCount);
-                Assert.AreEqual(4, targetedCount);
-                Assert.AreEqual(4, broadcastCount);
-                Assert.AreEqual(0, fastUntargetedCount);
-                Assert.AreEqual(0, fastTargetedCount);
-                Assert.AreEqual(0, fastBroadcastCount);
-
-                MessageRegistrationHandle thirdHandle = token.RegisterGlobalAcceptAll(
-                    HandleFastUntargeted,
-                    HandleFastTargeted,
-                    HandleFastBroadcast
-                );
-                _ = handles.Add(thirdHandle);
-                untargetedMessage.EmitUntargeted();
-                targetedMessage.EmitGameObjectTargeted(test);
-                targetedMessage.EmitComponentTargeted(component);
-                broadcastMessage.EmitGameObjectBroadcast(test);
-                broadcastMessage.EmitComponentBroadcast(component);
-                Assert.AreEqual(4, untargetedCount);
-                Assert.AreEqual(6, targetedCount);
-                Assert.AreEqual(6, broadcastCount);
-                Assert.AreEqual(1, fastUntargetedCount);
-                Assert.AreEqual(2, fastTargetedCount);
-                Assert.AreEqual(2, fastBroadcastCount);
-
-                MessageRegistrationHandle fourthHandle = token.RegisterGlobalAcceptAll(
-                    HandleFastUntargeted,
-                    HandleFastTargeted,
-                    HandleFastBroadcast
-                );
-                _ = handles.Add(fourthHandle);
-                untargetedMessage.EmitUntargeted();
-                targetedMessage.EmitGameObjectTargeted(test);
-                targetedMessage.EmitComponentTargeted(component);
-                broadcastMessage.EmitGameObjectBroadcast(test);
-                broadcastMessage.EmitComponentBroadcast(component);
-                Assert.AreEqual(5, untargetedCount);
-                Assert.AreEqual(8, targetedCount);
-                Assert.AreEqual(8, broadcastCount);
-                Assert.AreEqual(2, fastUntargetedCount);
-                Assert.AreEqual(4, fastTargetedCount);
-                Assert.AreEqual(4, fastBroadcastCount);
-            }
-            finally
-            {
-                foreach (MessageRegistrationHandle handle in handles)
-                {
-                    token.RemoveRegistration(handle);
-                }
-            }
-
-            yield break;
-
-            void HandleUntargeted(IUntargetedMessage message)
-            {
-                ++untargetedCount;
-            }
-
-            void HandleFastUntargeted(ref IUntargetedMessage message)
-            {
-                ++fastUntargetedCount;
-            }
-
-            void HandleTargeted(InstanceId target, ITargetedMessage message)
-            {
-                ++targetedCount;
-            }
-
-            void HandleFastTargeted(ref InstanceId target, ref ITargetedMessage message)
-            {
-                ++fastTargetedCount;
-            }
-
-            void HandleBroadcast(InstanceId source, IBroadcastMessage message)
-            {
-                ++broadcastCount;
-            }
-
-            void HandleFastBroadcast(ref InstanceId source, ref IBroadcastMessage message)
-            {
-                ++fastBroadcastCount;
-            }
-        }
-
-        [UnityTest]
-        public IEnumerator InterceptorOrder()
-        {
-            GameObject test = new(nameof(InterceptorOrder), typeof(SimpleMessageAwareComponent));
-            _spawned.Add(test);
-
-            SimpleMessageAwareComponent component =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            bool seen = false;
-            component.untargetedHandler = () =>
-            {
-                // ReSharper disable once AccessToModifiedClosure
-                Assert.IsFalse(seen);
-                seen = true;
-            };
-
-            MessageRegistrationToken token = GetToken(component);
-            HashSet<MessageRegistrationHandle> handles = new();
-            try
-            {
-                int seenCount = 0;
-
-                bool UntargetedInterceptorFirstPriority(ref SimpleUntargetedMessage message)
-                {
-                    return seenCount++ % 3 == 0;
-                }
-
-                bool UntargetedInterceptorSecondPriority(ref SimpleUntargetedMessage message)
-                {
-                    return seenCount++ % 3 == 1;
-                }
-
-                bool UntargetedInterceptorThirdPriority(ref SimpleUntargetedMessage message)
-                {
-                    return seenCount++ % 3 == 2;
-                }
-
-                int interceptorRunCount = 0;
-
-                bool UntargetedInterceptorFourthPriority(ref SimpleUntargetedMessage message)
-                {
-                    // We should be running close to first and last
-                    if (++interceptorRunCount % 2 == 0)
-                    {
-                        return seenCount % 3 == 0;
-                    }
-
-                    return true;
-                }
-
-                MessageRegistrationHandle secondInterceptor =
-                    token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(
-                        UntargetedInterceptorSecondPriority,
-                        100
-                    );
-                _ = handles.Add(secondInterceptor);
-                MessageRegistrationHandle thirdInterceptor =
-                    token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(
-                        UntargetedInterceptorThirdPriority,
-                        101
-                    );
-                _ = handles.Add(thirdInterceptor);
-                MessageRegistrationHandle firstInterceptor =
-                    token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(
-                        UntargetedInterceptorFirstPriority,
-                        -1
-                    );
-                _ = handles.Add(firstInterceptor);
-                MessageRegistrationHandle fourthInterceptorFirstPriority =
-                    token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(
-                        UntargetedInterceptorFourthPriority,
-                        -1
-                    );
-                _ = handles.Add(fourthInterceptorFirstPriority);
-                MessageRegistrationHandle fourthInterceptorSecondPriority =
-                    token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(
-                        UntargetedInterceptorFourthPriority,
-                        102
-                    );
-                _ = handles.Add(fourthInterceptorSecondPriority);
-
-                SimpleUntargetedMessage message = new();
-                message.EmitUntargeted();
-                Assert.IsTrue(seen);
-                Assert.AreEqual(2, interceptorRunCount);
-                seen = false;
-
-                message.EmitUntargeted();
-                Assert.IsTrue(seen);
-                Assert.AreEqual(4, interceptorRunCount);
-                seen = false;
-
-                MessageRegistrationHandle doubleRegistrationOne =
-                    token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(
-                        UntargetedInterceptorFirstPriority,
-                        -1
-                    );
-                _ = handles.Add(doubleRegistrationOne);
-                message.EmitUntargeted();
-                Assert.IsTrue(seen);
-                Assert.AreEqual(6, interceptorRunCount);
-                seen = false;
-
-                _ = handles.Remove(firstInterceptor);
-                token.RemoveRegistration(firstInterceptor);
-                message.EmitUntargeted();
-                Assert.IsTrue(seen);
-                Assert.AreEqual(8, interceptorRunCount);
-                seen = false;
-
-                // Double remove
-                token.RemoveRegistration(firstInterceptor);
-                token.RemoveRegistration(firstInterceptor);
-                message.EmitUntargeted();
-                Assert.IsTrue(seen);
-                Assert.AreEqual(10, interceptorRunCount);
-            }
-            finally
-            {
-                foreach (MessageRegistrationHandle handle in handles)
-                {
-                    token.RemoveRegistration(handle);
-                }
-            }
-
-            yield break;
-        }
-
-        [UnityTest]
-        public IEnumerator UntargetedRemoveOrder()
-        {
-            GameObject test = new(
-                nameof(UntargetedRemoveOrder),
-                typeof(SimpleMessageAwareComponent)
-            );
-            _spawned.Add(test);
-
-            SimpleMessageAwareComponent component =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            MessageRegistrationToken token = GetToken(component);
-
-            int callCount = 0;
-            int fastCallCount = 0;
-
-            SimpleUntargetedMessage message = new();
-            int expectedCallCount = 0;
-            Run(
-                () => new[] { token.RegisterUntargeted<SimpleUntargetedMessage>(HandleUntargeted) },
-                () => message.EmitUntargeted(),
-                () =>
-                {
-                    Assert.AreEqual(++expectedCallCount, callCount);
-                    Assert.AreEqual(0, fastCallCount);
-                },
-                () =>
-                {
-                    Assert.AreEqual(expectedCallCount, callCount);
-                    Assert.AreEqual(0, fastCallCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            expectedCallCount = 0;
-            Run(
-                () =>
-                    new[]
-                    {
-                        token.RegisterUntargeted<SimpleUntargetedMessage>(HandleFastUntargeted),
-                    },
-                () => message.EmitUntargeted(),
-                () =>
-                {
-                    Assert.AreEqual(++expectedCallCount, fastCallCount);
-                    Assert.AreEqual(0, callCount);
-                },
-                () =>
-                {
-                    Assert.AreEqual(expectedCallCount, fastCallCount);
-                    Assert.AreEqual(0, callCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            fastCallCount = 0;
-            Run(
-                () =>
-                {
-                    return new[]
-                    {
-                        token.RegisterUntargeted<SimpleUntargetedMessage>(HandleFastUntargeted),
-                        token.RegisterUntargeted<SimpleUntargetedMessage>(HandleUntargeted),
-                    };
-                },
-                () => message.EmitUntargeted(),
-                () => { },
-                () =>
-                {
-                    Assert.AreNotEqual(callCount, fastCallCount);
-                },
-                token
-            );
-
-            yield break;
-
-            void HandleUntargeted(SimpleUntargetedMessage message)
-            {
-                ++callCount;
-            }
-
-            void HandleFastUntargeted(ref SimpleUntargetedMessage message)
-            {
-                ++fastCallCount;
-            }
-        }
-
-        [UnityTest]
-        public IEnumerator TargetedRemoveOrder()
-        {
-            GameObject test = new(nameof(TargetedRemoveOrder), typeof(SimpleMessageAwareComponent));
-            _spawned.Add(test);
-
-            SimpleMessageAwareComponent component =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            MessageRegistrationToken token = GetToken(component);
-
-            int callCount = 0;
-            int fastCallCount = 0;
-
-            SimpleTargetedMessage message = new();
-            int expectedCallCount = 0;
-            Run(
-                () =>
-                    new[]
-                    {
-                        token.RegisterGameObjectTargeted<SimpleTargetedMessage>(
-                            test,
-                            HandleTargeted
-                        ),
-                    },
-                () =>
-                {
-                    message.EmitComponentTargeted(component);
-                    message.EmitGameObjectTargeted(test);
-                },
-                () =>
-                {
-                    Assert.AreEqual(++expectedCallCount, callCount);
-                    Assert.AreEqual(0, fastCallCount);
-                },
-                () =>
-                {
-                    Assert.AreEqual(expectedCallCount, callCount);
-                    Assert.AreEqual(0, fastCallCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            expectedCallCount = 0;
-            Run(
-                () =>
-                    new[]
-                    {
-                        token.RegisterGameObjectTargeted<SimpleTargetedMessage>(
-                            test,
-                            HandleFastTargeted
-                        ),
-                    },
-                () =>
-                {
-                    message.EmitComponentTargeted(component);
-                    message.EmitGameObjectTargeted(test);
-                },
-                () =>
-                {
-                    Assert.AreEqual(++expectedCallCount, fastCallCount);
-                    Assert.AreEqual(0, callCount);
-                },
-                () =>
-                {
-                    Assert.AreEqual(expectedCallCount, fastCallCount);
-                    Assert.AreEqual(0, callCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            fastCallCount = 0;
-            Run(
-                () =>
-                {
-                    return new[]
-                    {
-                        token.RegisterGameObjectTargeted<SimpleTargetedMessage>(
-                            test,
-                            HandleFastTargeted
-                        ),
-                        token.RegisterGameObjectTargeted<SimpleTargetedMessage>(
-                            test,
-                            HandleTargeted
-                        ),
-                    };
-                },
-                () =>
-                {
-                    message.EmitComponentTargeted(component);
-                    message.EmitGameObjectTargeted(test);
-                },
-                () => { },
-                () =>
-                {
-                    Assert.AreNotEqual(callCount, fastCallCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            fastCallCount = 0;
-            Run(
-                () =>
-                {
-                    return new[]
-                    {
-                        token.RegisterComponentTargeted<SimpleTargetedMessage>(
-                            component,
-                            HandleFastTargeted
-                        ),
-                        token.RegisterGameObjectTargeted<SimpleTargetedMessage>(
-                            test,
-                            HandleTargeted
-                        ),
-                    };
-                },
-                () =>
-                {
-                    message.EmitComponentTargeted(component);
-                    message.EmitGameObjectTargeted(test);
-                },
-                () => { },
-                () =>
-                {
-                    Assert.AreNotEqual(callCount, fastCallCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            fastCallCount = 0;
-            Run(
-                () =>
-                {
-                    return new[]
-                    {
-                        token.RegisterComponentTargeted<SimpleTargetedMessage>(
-                            component,
-                            HandleFastTargeted
-                        ),
-                        token.RegisterComponentTargeted<SimpleTargetedMessage>(
-                            component,
-                            HandleTargeted
-                        ),
-                    };
-                },
-                () =>
-                {
-                    message.EmitComponentTargeted(component);
-                    message.EmitGameObjectTargeted(test);
-                },
-                () => { },
-                () =>
-                {
-                    Assert.AreNotEqual(callCount, fastCallCount);
-                },
-                token
-            );
-
-            yield break;
-
-            void HandleTargeted(SimpleTargetedMessage message)
-            {
-                ++callCount;
-            }
-
-            void HandleFastTargeted(ref SimpleTargetedMessage message)
-            {
-                ++fastCallCount;
-            }
-        }
-
-        [UnityTest]
-        public IEnumerator BroadcastRemoveOrder()
-        {
-            GameObject test = new(
-                nameof(BroadcastRemoveOrder),
-                typeof(SimpleMessageAwareComponent)
-            );
-            _spawned.Add(test);
-
-            SimpleMessageAwareComponent component =
-                test.GetComponent<SimpleMessageAwareComponent>();
-
-            MessageRegistrationToken token = GetToken(component);
-            int callCount = 0;
-            int fastCallCount = 0;
-
-            SimpleBroadcastMessage message = new();
-            int expectedCallCount = 0;
-            Run(
-                () =>
-                    new[]
-                    {
-                        token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                            test,
-                            HandleBroadcast
-                        ),
-                    },
-                () =>
-                {
-                    message.EmitComponentBroadcast(component);
-                    message.EmitGameObjectBroadcast(test);
-                },
-                () =>
-                {
-                    Assert.AreEqual(++expectedCallCount, callCount);
-                    Assert.AreEqual(0, fastCallCount);
-                },
-                () =>
-                {
-                    Assert.AreEqual(expectedCallCount, callCount);
-                    Assert.AreEqual(0, fastCallCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            expectedCallCount = 0;
-            Run(
-                () =>
-                    new[]
-                    {
-                        token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                            test,
-                            HandleFastBroadcast
-                        ),
-                    },
-                () =>
-                {
-                    message.EmitComponentBroadcast(component);
-                    message.EmitGameObjectBroadcast(test);
-                },
-                () =>
-                {
-                    Assert.AreEqual(++expectedCallCount, fastCallCount);
-                    Assert.AreEqual(0, callCount);
-                },
-                () =>
-                {
-                    Assert.AreEqual(expectedCallCount, fastCallCount);
-                    Assert.AreEqual(0, callCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            fastCallCount = 0;
-            Run(
-                () =>
-                {
-                    return new[]
-                    {
-                        token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                            test,
-                            HandleFastBroadcast
-                        ),
-                        token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                            test,
-                            HandleBroadcast
-                        ),
-                    };
-                },
-                () =>
-                {
-                    message.EmitComponentBroadcast(component);
-                    message.EmitGameObjectBroadcast(test);
-                },
-                () => { },
-                () =>
-                {
-                    Assert.AreNotEqual(callCount, fastCallCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            fastCallCount = 0;
-            Run(
-                () =>
-                {
-                    return new[]
-                    {
-                        token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                            test,
-                            HandleFastBroadcast
-                        ),
-                        token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                            test,
-                            HandleBroadcast
-                        ),
-                    };
-                },
-                () =>
-                {
-                    message.EmitComponentBroadcast(component);
-                    message.EmitGameObjectBroadcast(test);
-                },
-                () => { },
-                () =>
-                {
-                    Assert.AreNotEqual(callCount, fastCallCount);
-                },
-                token
-            );
-
-            callCount = 0;
-            fastCallCount = 0;
-            Run(
-                () =>
-                {
-                    return new[]
-                    {
-                        token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                            test,
-                            HandleFastBroadcast
-                        ),
-                        token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
-                            test,
-                            HandleBroadcast
-                        ),
-                    };
-                },
-                () =>
-                {
-                    message.EmitComponentBroadcast(component);
-                    message.EmitGameObjectBroadcast(test);
-                },
-                () => { },
-                () =>
-                {
-                    Assert.AreNotEqual(callCount, fastCallCount);
-                },
-                token
-            );
-
-            yield break;
-
-            void HandleBroadcast(SimpleBroadcastMessage message)
-            {
-                ++callCount;
-            }
-
-            void HandleFastBroadcast(ref SimpleBroadcastMessage message)
-            {
-                ++fastCallCount;
-            }
-        }
-    }
-}
-
-#endif