com.wallstop-studios.dxmessaging 1.0.0-rc10

package/Tests/Runtime/Core/GlobalAcceptAllTests.cs

@@ -0,0 +1,169 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using DxMessaging.Core;
+    using Scripts.Components;
+    using System;
+    using System.Collections;
+    using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.Messages;
+    using NUnit.Framework;
+    using Scripts.Messages;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+
+    public sealed class GlobalAcceptAllTests : MessagingTestBase
+    {
+        private GameObject _test;
+
+        [UnitySetUp]
+        public override IEnumerator UnitySetup()
+        {
+            IEnumerator baseSetup = base.UnitySetup();
+            while (baseSetup.MoveNext())
+            {
+                yield return baseSetup.Current;
+            }
+
+            _test = new(nameof(GlobalAcceptAllTests), typeof(EmptyMessageAwareComponent));
+            _spawned.Add(_test);
+        }
+
+        [UnityTest]
+        public IEnumerator SimpleNormal()
+        {
+            int untargetedCount = 0;
+            int targetedCount = 0;
+            int broadcastCount = 0;
+
+            void HandleUntargeted(IUntargetedMessage message)
+            {
+                ++untargetedCount;
+            }
+
+            void HandleTargeted(InstanceId target, ITargetedMessage message)
+            {
+                ++targetedCount;
+            }
+
+            void HandleBroadcast(InstanceId source, IBroadcastMessage message)
+            {
+                ++broadcastCount;
+            }
+
+            SimpleUntargetedMessage untargetedMessage = new();
+            SimpleTargetedMessage targetedMessage = new();
+            SimpleBroadcastMessage broadcastMessage = new();
+            RunGlobalAcceptAllTest(
+                token => token.RegisterGlobalAcceptAll(HandleUntargeted, HandleTargeted, HandleBroadcast),
+                i =>
+                {
+                    Assert.AreEqual(i, untargetedCount);
+                    untargetedMessage.EmitUntargeted();
+                    Assert.AreEqual(i + 1, untargetedCount);
+                }, i =>
+                {
+                    Assert.AreEqual(i, targetedCount);
+                    if (_random.Next() % 2 == 0)
+                    {
+                        targetedMessage.EmitGameObjectTargeted(_test);
+                    }
+                    else
+                    {
+                        targetedMessage.EmitComponentTargeted(_test.transform);
+                    }
+
+                    Assert.AreEqual(i + 1, targetedCount);
+                }, i =>
+                {
+                    Assert.AreEqual(i, broadcastCount);
+                    if (_random.Next() % 2 == 0)
+                    {
+                        broadcastMessage.EmitGameObjectBroadcast(_test);
+                    }
+                    else
+                    {
+                        broadcastMessage.EmitComponentBroadcast(_test.transform);
+                    }
+
+                    Assert.AreEqual(i + 1, broadcastCount);
+                });
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator SimpleNoCopy()
+        {
+            int untargetedCount = 0;
+            int targetedCount = 0;
+            int broadcastCount = 0;
+
+            void HandleUntargeted(ref IUntargetedMessage message)
+            {
+                ++untargetedCount;
+            }
+
+            void HandleTargeted(ref InstanceId target, ref ITargetedMessage message)
+            {
+                ++targetedCount;
+            }
+
+            void HandleBroadcast(ref InstanceId source, ref IBroadcastMessage message)
+            {
+                ++broadcastCount;
+            }
+
+            SimpleUntargetedMessage untargetedMessage = new();
+            SimpleTargetedMessage targetedMessage = new();
+            SimpleBroadcastMessage broadcastMessage = new();
+            RunGlobalAcceptAllTest(
+                token => token.RegisterGlobalAcceptAll(HandleUntargeted, HandleTargeted, HandleBroadcast),
+                i =>
+                {
+                    Assert.AreEqual(i, untargetedCount);
+                    untargetedMessage.EmitUntargeted();
+                    Assert.AreEqual(i + 1, untargetedCount);
+                }, i =>
+                {
+                    Assert.AreEqual(i, targetedCount);
+                    if (_random.Next() % 2 == 0)
+                    {
+                        targetedMessage.EmitGameObjectTargeted(_test);
+                    }
+                    else
+                    {
+                        targetedMessage.EmitComponentTargeted(_test.transform);
+                    }
+
+                    Assert.AreEqual(i + 1, targetedCount);
+                }, i =>
+                {
+                    Assert.AreEqual(i, broadcastCount);
+                    if (_random.Next() % 2 == 0)
+                    {
+                        broadcastMessage.EmitGameObjectBroadcast(_test);
+                    }
+                    else
+                    {
+                        broadcastMessage.EmitComponentBroadcast(_test.transform);
+                    }
+
+                    Assert.AreEqual(i + 1, broadcastCount);
+                });
+            yield break;
+        }
+
+        private void RunGlobalAcceptAllTest(Action<MessageRegistrationToken> register, Action<int> untargeted, Action<int> targeted, Action<int> broadcast)
+        {
+            EmptyMessageAwareComponent component = _test.GetComponent<EmptyMessageAwareComponent>();
+            MessageRegistrationToken token = GetToken(component);
+
+            register(token);
+            for (int i = 0; i < 100; ++i)
+            {
+                untargeted(i);
+                targeted(i);
+                broadcast(i);
+            }
+        }
+    }
+}

package/Tests/Runtime/Core/GlobalAcceptAllTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bb71a31296155514799b53b4cb57f60f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Core/MessagingTestBase.cs

@@ -0,0 +1,164 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Core;
+    using NUnit.Framework;
+    using System.Collections.Generic;
+    using UnityEngine;
+    using Unity;
+    using System.Collections;
+    using System.Diagnostics;
+    using System.Linq;
+    using System.Reflection;
+    using System;
+    using UnityEngine.TestTools;
+    using Debug = UnityEngine.Debug;
+    using Object = UnityEngine.Object;
+    using Random = System.Random;
+
+    public abstract class MessagingTestBase
+    {
+        protected int _numRegistrations;
+        protected readonly List<GameObject> _spawned = new();
+        protected readonly Random _random = new();
+
+        [SetUp]
+        public virtual void Setup()
+        {
+            MessagingDebug.LogFunction = (level, message) =>
+            {
+                switch (level)
+                {
+                    case LogLevel.Debug:
+                    case LogLevel.Info:
+                        Debug.Log(message);
+                        return;
+                    case LogLevel.Warn:
+                        Debug.LogWarning(message);
+                        return;
+                    case LogLevel.Error:
+                        Debug.LogError(message);
+                        return;
+                }
+            };
+            MessageBus messageBus = MessageHandler.MessageBus;
+            Assert.IsNotNull(messageBus);
+            messageBus.Log.Enabled = true;
+            _numRegistrations = 150;
+        }
+
+        [TearDown]
+        public virtual void Cleanup()
+        {
+            foreach (GameObject spawned in _spawned)
+            {
+                if (spawned == null)
+                {
+                    continue;
+                }
+
+                Object.Destroy(spawned);
+            }
+
+            _spawned.Clear();
+        }
+
+        [UnitySetUp]
+        public virtual IEnumerator UnitySetup()
+        {
+            return WaitUntilMessageHandlerIsFresh();
+        }
+
+        protected void Run(Func<IEnumerable<MessageRegistrationHandle>> register, Action emit, Action assert, Action finalAssert, MessageRegistrationToken token, bool synchronizeDeregistrations = false)
+        {
+            HashSet<MessageRegistrationHandle> handles = new();
+            try
+            {
+                List<List<MessageRegistrationHandle>> indexedRegistrations = new(_numRegistrations);
+                for (int i = 0; i < _numRegistrations; ++i)
+                {
+                    List<MessageRegistrationHandle> registrations = register().ToList();
+                    foreach (MessageRegistrationHandle handle in registrations)
+                    {
+                        handles.Add(handle);
+                    }
+
+                    indexedRegistrations.Add(registrations);
+                }
+
+                if (synchronizeDeregistrations)
+                {
+                    foreach (int index in Enumerable.Range(0, indexedRegistrations.Count).OrderBy(_ => _random.Next()))
+                    {
+                        emit();
+                        assert();
+                        foreach (MessageRegistrationHandle handle in indexedRegistrations[index])
+                        {
+                            handles.Remove(handle);
+                            token.RemoveRegistration(handle);
+                        }
+                    }
+                }
+                else
+                {
+                    foreach (MessageRegistrationHandle handle in handles.OrderBy(_ => _random.Next()).ToList())
+                    {
+                        emit();
+                        assert();
+                        handles.Remove(handle);
+                        token.RemoveRegistration(handle);
+                    }
+                }
+
+                emit();
+                finalAssert();
+                emit();
+                finalAssert();
+            }
+            finally
+            {
+                foreach (MessageRegistrationHandle handle in handles)
+                {
+                    token.RemoveRegistration(handle);
+                }
+            }
+        }
+
+        protected MessageRegistrationToken GetToken(MessageAwareComponent component)
+        {
+            // Reach inside and grab the token
+            FieldInfo field = typeof(MessageAwareComponent).GetField(
+                "_messageRegistrationToken", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+            Assert.IsNotNull(field);
+            MessageRegistrationToken token = field.GetValue(component) as MessageRegistrationToken;
+            Assert.IsNotNull(token);
+            return token;
+        }
+
+        protected IEnumerator WaitUntilMessageHandlerIsFresh()
+        {
+            Setup();
+            MessageBus messageBus = MessageHandler.MessageBus;
+            Assert.IsNotNull(messageBus);
+
+            Stopwatch timer = Stopwatch.StartNew();
+
+            bool IsStale()
+            {
+                return messageBus.RegisteredUntargeted != 0 || messageBus.RegisteredTargeted != 0 ||
+                       messageBus.RegisteredBroadcast != 0;
+            }
+
+            while (IsStale() && timer.Elapsed < TimeSpan.FromSeconds(2.5))
+            {
+                yield return null;
+            }
+
+            Assert.IsFalse(
+                IsStale(),
+                "MessageHandler had {0} Untargeted registrations, {1} Targeted registrations, {2} Broadcast registrations. Registration log: {3}.",
+                messageBus.RegisteredUntargeted, messageBus.RegisteredTargeted, messageBus.RegisteredBroadcast,
+                messageBus.Log);
+        }
+    }
+}

package/Tests/Runtime/Core/MessagingTestBase.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7535cc8753fc96548b025f5407a513eb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: