com.wallstop-studios.dxmessaging 2.1.2 → 2.1.4

package/Tests/Runtime/Core/DxMessagingStaticStateTests.cs

@@ -0,0 +1,69 @@
+#if UNITY_2021_3_OR_NEWER
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System;
+    using System.Reflection;
+    using DxMessaging.Core;
+    using DxMessaging.Core.Helper;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Core.Messages;
+    using NUnit.Framework;
+
+    public sealed class DxMessagingStaticStateTests
+    {
+        [Test]
+        public void ResetRestoresDefaultStaticState()
+        {
+            DxMessagingStaticState.Reset();
+            IMessageBus baselineBus = MessageHandler.MessageBus;
+            MessageRegistrationHandle baselineHandle =
+                MessageRegistrationHandle.CreateMessageRegistrationHandle();
+
+            MessageRegistrationHandle.CreateMessageRegistrationHandle();
+            MessagingDebug.enabled = true;
+            MessagingDebug.LogFunction = (logLevel, message) => { };
+
+            IMessageBus.GlobalDiagnosticsTargets = DiagnosticsTarget.All;
+            IMessageBus.GlobalMessageBufferSize = 128;
+            IMessageBus.GlobalSequentialIndex = 7;
+
+            Type builderType = typeof(MessageRegistrationBuilder);
+            FieldInfo syntheticOwnerField = builderType.GetField(
+                "_syntheticOwnerCounter",
+                BindingFlags.NonPublic | BindingFlags.Static
+            );
+            Assert.IsNotNull(syntheticOwnerField);
+            syntheticOwnerField.SetValue(null, 3);
+
+            MessageCache<object> cache = new MessageCache<object>();
+            cache.GetOrAdd<DummyUntargetedMessage>();
+
+            MessageHandler.SetGlobalMessageBus(new MessageBus());
+
+            DxMessagingStaticState.Reset();
+
+            Assert.IsFalse(MessagingDebug.enabled);
+            Assert.IsNull(MessagingDebug.LogFunction);
+            Assert.AreEqual(DiagnosticsTarget.Off, IMessageBus.GlobalDiagnosticsTargets);
+            Assert.AreEqual(0, IMessageBus.GlobalMessageBufferSize);
+            Assert.AreEqual(-1, IMessageBus.GlobalSequentialIndex);
+
+            MessageRegistrationHandle resetHandle =
+                MessageRegistrationHandle.CreateMessageRegistrationHandle();
+            Assert.AreEqual(baselineHandle, resetHandle);
+
+            object syntheticOwnerValue = syntheticOwnerField.GetValue(null);
+            Assert.AreEqual(0, (int)syntheticOwnerValue);
+
+            Assert.AreEqual(0, MessageHelperIndexer.TotalMessages);
+            Assert.AreEqual(-1, MessageHelperIndexer<DummyUntargetedMessage>.SequentialId);
+            Assert.AreSame(MessageHandler.InitialGlobalMessageBus, MessageHandler.MessageBus);
+            Assert.AreSame(baselineBus, MessageHandler.MessageBus);
+
+            DxMessagingStaticState.Reset();
+        }
+
+        private struct DummyUntargetedMessage : IUntargetedMessage { }
+    }
+}
+#endif

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

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

package/Tests/Runtime/Core/Extensions/MessageBusExtensionsTests.cs

@@ -33,9 +33,7 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
             MessageHandler handler = new MessageHandler(new InstanceId(10), bus) { active = true };
             MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
             int count = 0;
-            _ = token.RegisterUntargeted<ClassUntargetedMessage>(
-                (ref ClassUntargetedMessage _) => count++
-            );
+            _ = token.RegisterUntargeted((ref ClassUntargetedMessage _) => count++);
             token.Enable();
 
             ClassUntargetedMessage message = new ClassUntargetedMessage();
@@ -52,9 +50,7 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
             MessageHandler handler = new MessageHandler(new InstanceId(20), bus) { active = true };
             MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
             int count = 0;
-            _ = token.RegisterUntargeted<StructUntargetedMessage>(
-                (ref StructUntargetedMessage _) => count++
-            );
+            _ = token.RegisterUntargeted((ref StructUntargetedMessage _) => count++);
             token.Enable();
 
             StructUntargetedMessage message = new StructUntargetedMessage(1);
@@ -73,7 +69,7 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
             StructInterceptedMessage intercepted = default;
             int postProcessCount = 0;
 
-            _ = bus.RegisterUntargetedInterceptor<StructInterceptedMessage>(
+            _ = bus.RegisterUntargetedInterceptor(
                 (ref StructInterceptedMessage msg) =>
                 {
                     msg.Value += 10;
@@ -81,11 +77,9 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
                 }
             );
 
-            _ = token.RegisterUntargeted<StructInterceptedMessage>(
-                (ref StructInterceptedMessage msg) => intercepted = msg
-            );
+            _ = token.RegisterUntargeted((ref StructInterceptedMessage msg) => intercepted = msg);
 
-            _ = token.RegisterUntargetedPostProcessor<StructInterceptedMessage>(
+            _ = token.RegisterUntargetedPostProcessor(
                 (ref StructInterceptedMessage _) => postProcessCount++
             );
 
@@ -108,9 +102,7 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
             MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
             int busSum = 0;
 
-            _ = token.RegisterUntargeted<StructUntargetedMessage>(
-                (ref StructUntargetedMessage msg) => busSum += msg.Value
-            );
+            _ = token.RegisterUntargeted((ref StructUntargetedMessage msg) => busSum += msg.Value);
 
             token.Enable();
 
@@ -132,7 +124,7 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
             MessageRegistrationToken token2 = MessageRegistrationToken.Create(handler2, bus);
             int messageSum = 0;
 
-            _ = token2.RegisterUntargeted<StructUntargetedMessage>(
+            _ = token2.RegisterUntargeted(
                 (ref StructUntargetedMessage msg) => messageSum += msg.Value
             );
 
@@ -158,10 +150,7 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
             MessageHandler handler = new MessageHandler(new InstanceId(30), bus) { active = true };
             MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
             int count = 0;
-            _ = token.RegisterTargeted<StructTargetedMessage>(
-                target,
-                (ref StructTargetedMessage _) => count++
-            );
+            _ = token.RegisterTargeted(target, (ref StructTargetedMessage _) => count++);
             token.Enable();
 
             StructTargetedMessage message = new StructTargetedMessage(5);
@@ -180,10 +169,7 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
             MessageHandler handler = new MessageHandler(new InstanceId(40), bus) { active = true };
             MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
             int count = 0;
-            _ = token.RegisterBroadcast<StructBroadcastMessage>(
-                source,
-                (ref StructBroadcastMessage _) => count++
-            );
+            _ = token.RegisterBroadcast(source, (ref StructBroadcastMessage _) => count++);
             token.Enable();
 
             StructBroadcastMessage message = new StructBroadcastMessage(7);
@@ -206,19 +192,14 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
             string broadcast = null;
             string untargeted = null;
 
-            _ = token.RegisterTargeted<StringMessage>(
-                target,
-                (ref StringMessage m) => targeted = m.message
-            );
+            _ = token.RegisterTargeted(target, (ref StringMessage m) => targeted = m.message);
 
-            _ = token.RegisterBroadcast<SourcedStringMessage>(
+            _ = token.RegisterBroadcast(
                 source,
                 (ref SourcedStringMessage m) => broadcast = m.message
             );
 
-            _ = token.RegisterUntargeted<GlobalStringMessage>(
-                (ref GlobalStringMessage m) => untargeted = m.message
-            );
+            _ = token.RegisterUntargeted((ref GlobalStringMessage m) => untargeted = m.message);
 
             token.Enable();