com.wallstop-studios.dxmessaging 2.0.0-rc27.3 → 2.0.0

package/Tests/Runtime/Core/UntargetedPrefreezeTests.cs

@@ -0,0 +1,116 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using DxMessaging.Core;
+    using DxMessaging.Core.Helper;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Tests.Runtime.Scripts.Messages;
+    using NUnit.Framework;
+
+    public sealed class UntargetedPrefreezeTests
+    {
+        [Test]
+        public void PrefreezeRunsOncePerEmission()
+        {
+            MessageHandler handler = new(new InstanceId(123)) { active = true };
+            MessageBus messageBus = new();
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, messageBus);
+
+            int postProcessCount = 0;
+            _ = token.RegisterUntargeted<SimpleUntargetedMessage>(
+                (ref SimpleUntargetedMessage _) => { }
+            );
+            _ = token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(
+                (ref SimpleUntargetedMessage _) => postProcessCount++,
+                priority: 0
+            );
+
+            token.Enable();
+
+            object cache = GetUntargetedPostProcessingFastCache(
+                handler,
+                messageBus,
+                typeof(SimpleUntargetedMessage),
+                priority: 0
+            );
+
+            SimpleUntargetedMessage message = new();
+            messageBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(1, postProcessCount);
+            Assert.AreEqual(1, GetPrefreezeInvocationCount(cache));
+
+            messageBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(2, postProcessCount);
+            Assert.AreEqual(2, GetPrefreezeInvocationCount(cache));
+
+            token.Disable();
+        }
+
+        private static object GetUntargetedPostProcessingFastCache(
+            MessageHandler handler,
+            MessageBus messageBus,
+            Type messageType,
+            int priority
+        )
+        {
+            FieldInfo handlersField = typeof(MessageHandler).GetField(
+                "_handlersByTypeByMessageBus",
+                BindingFlags.NonPublic | BindingFlags.Instance
+            );
+            Assert.IsNotNull(handlersField);
+            var handlersByBus = (List<MessageCache<object>>)handlersField.GetValue(handler);
+            Assert.IsNotNull(handlersByBus);
+
+            MessageCache<object> cacheByType = handlersByBus[
+                messageBus.RegisteredGlobalSequentialIndex
+            ];
+            MethodInfo getOrAddMethod = typeof(MessageCache<object>)
+                .GetMethod(nameof(MessageCache<object>.GetOrAdd))
+                ?.MakeGenericMethod(messageType);
+            Assert.IsNotNull(getOrAddMethod);
+
+            object typedHandler = getOrAddMethod.Invoke(cacheByType, null);
+            Assert.IsNotNull(typedHandler);
+
+            FieldInfo fastHandlersField = typedHandler
+                .GetType()
+                .GetField(
+                    "_untargetedPostProcessingFastHandlers",
+                    BindingFlags.NonPublic | BindingFlags.Instance
+                );
+            Assert.IsNotNull(fastHandlersField);
+
+            object fastHandlers = fastHandlersField.GetValue(typedHandler);
+            Assert.IsNotNull(fastHandlers);
+
+            return GetDictionaryValue(fastHandlers, priority);
+        }
+
+        private static object GetDictionaryValue(object dictionary, int key)
+        {
+            MethodInfo tryGetValue = dictionary
+                .GetType()
+                .GetMethod("TryGetValue", BindingFlags.Public | BindingFlags.Instance);
+            Assert.IsNotNull(tryGetValue);
+
+            object[] args = { key, null };
+            bool found = (bool)tryGetValue.Invoke(dictionary, args);
+            Assert.IsTrue(found, $"Failed to locate cache for priority {key}.");
+            return args[1];
+        }
+
+        private static int GetPrefreezeInvocationCount(object handlerCache)
+        {
+            FieldInfo countField = handlerCache
+                .GetType()
+                .GetField(
+                    "prefreezeInvocationCount",
+                    BindingFlags.NonPublic | BindingFlags.Instance
+                );
+            Assert.IsNotNull(countField);
+            return (int)countField.GetValue(handlerCache);
+        }
+    }
+}

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

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

package/Tests/Runtime/Scripts/Components/ReflexiveReceiverComponent.cs

@@ -0,0 +1,14 @@
+namespace DxMessaging.Tests.Runtime.Scripts.Components
+{
+    using UnityEngine;
+
+    public sealed class ReflexiveReceiverComponent : MonoBehaviour
+    {
+        public int InvocationCount { get; private set; }
+
+        public void OnReflexive()
+        {
+            InvocationCount++;
+        }
+    }
+}

package/Tests/Runtime/Scripts/Components/ReflexiveReceiverComponent.cs.meta

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.dxmessaging",
-  "version": "2.0.0-rc27.3",
+  "version": "2.0.0",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",