com.wallstop-studios.dxmessaging 2.1.7 → 2.1.8

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

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

package/Tests/Runtime/Core/CyclicBufferTests.cs

@@ -1,343 +0,0 @@
-#if UNITY_2021_3_OR_NEWER
-namespace DxMessaging.Tests.Runtime.Core
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using DxMessaging.Core.DataStructure;
-    using NUnit.Framework;
-
-    public sealed class CyclicBufferTests
-    {
-        [Test]
-        public void AddAndOverwritePreservesChronology()
-        {
-            CyclicBuffer<int> buf = new(3) { 0, 1, 2 };
-
-            Assert.AreEqual(
-                3,
-                buf.Count,
-                "Count should reflect number of elements added up to capacity."
-            );
-            Assert.AreEqual(0, buf[0], "Oldest element should be at index 0 before wrap.");
-            Assert.AreEqual(1, buf[1], "Next element should be index 1.");
-            Assert.AreEqual(2, buf[2], "Newest element should be index 2 before wrap.");
-
-            // Overwrite oldest
-            buf.Add(3);
-            Assert.AreEqual(3, buf.Count, "Count should not grow beyond capacity.");
-            Assert.AreEqual(1, buf[0], "After overwrite, oldest is dropped.");
-            Assert.AreEqual(2, buf[1], "Element order should advance by one.");
-            Assert.AreEqual(3, buf[2], "Newest written value should be last.");
-
-            // Remove middle element
-            bool removed = buf.Remove(2);
-            Assert.IsTrue(removed, "Remove should return true when element existed.");
-            Assert.AreEqual(2, buf.Count, "Count should decrease after remove.");
-            Assert.AreEqual(1, buf[0], "Remaining first element should be unchanged.");
-            Assert.AreEqual(3, buf[1], "Remaining second element should be next in order.");
-        }
-
-        [Test]
-        public void ResizeTruncatesOrExtends()
-        {
-            CyclicBuffer<int> buf = new(5);
-            for (int i = 0; i < 5; ++i)
-            {
-                buf.Add(i);
-            }
-            Assert.AreEqual(5, buf.Count, "Filled buffer should have full count.");
-
-            // Shrink: oldest entries should be truncated
-            buf.Resize(3);
-            Assert.AreEqual(3, buf.Count, "Count should reflect new capacity after shrink.");
-            Assert.AreEqual(2, buf[0], "Shrink should retain most recent entries and drop oldest.");
-            Assert.AreEqual(3, buf[1], "Remaining order should be preserved (middle).");
-            Assert.AreEqual(4, buf[2], "Remaining order should be preserved (newest).");
-
-            // Grow: capacity increases, order stays
-            buf.Resize(6);
-            Assert.AreEqual(3, buf.Count, "Growing capacity should not change current count.");
-            Assert.AreEqual(2, buf[0], "Growing capacity should not alter order (first).");
-            Assert.AreEqual(3, buf[1], "Growing capacity should not alter order (second).");
-            Assert.AreEqual(4, buf[2], "Growing capacity should not alter order (third).");
-        }
-
-        [Test]
-        [TestCase(0, 5, 0, Description = "Zero capacity discards all items")]
-        [TestCase(1, 5, 1, Description = "Capacity 1 keeps only most recent")]
-        [TestCase(3, 5, 3, Description = "Capacity 3 keeps 3 most recent of 5")]
-        [TestCase(5, 5, 5, Description = "Capacity equals item count")]
-        [TestCase(10, 5, 5, Description = "Capacity larger than items")]
-        public void CapacityBehaviorDataDriven(int capacity, int itemsToAdd, int expectedCount)
-        {
-            CyclicBuffer<int> buffer = new(capacity);
-            for (int i = 0; i < itemsToAdd; ++i)
-            {
-                buffer.Add(i);
-            }
-
-            Assert.AreEqual(
-                expectedCount,
-                buffer.Count,
-                $"Buffer with capacity {capacity} after adding {itemsToAdd} items."
-            );
-
-            // Verify the most recent items are retained (if any)
-            if (expectedCount > 0)
-            {
-                int expectedNewest = itemsToAdd - 1;
-                Assert.AreEqual(
-                    expectedNewest,
-                    buffer[expectedCount - 1],
-                    "Most recent item should be preserved."
-                );
-            }
-        }
-
-        [Test]
-        [TestCase(
-            new[] { 1, 2, 3 },
-            1,
-            new[] { 2, 3 },
-            Description = "Remove first element by value"
-        )]
-        [TestCase(
-            new[] { 1, 2, 3 },
-            2,
-            new[] { 1, 3 },
-            Description = "Remove middle element by value"
-        )]
-        [TestCase(
-            new[] { 1, 2, 3 },
-            3,
-            new[] { 1, 2 },
-            Description = "Remove last element by value"
-        )]
-        [TestCase(
-            new[] { 1, 2, 3 },
-            99,
-            new[] { 1, 2, 3 },
-            Description = "Remove non-existent element"
-        )]
-        [TestCase(new[] { 1 }, 1, new int[0], Description = "Remove only element")]
-        public void RemoveBehaviorDataDriven(int[] initial, int toRemove, int[] expected)
-        {
-            CyclicBuffer<int> buffer = new(initial.Length, initial);
-            bool wasRemoved = buffer.Remove(toRemove);
-
-            bool shouldHaveBeenRemoved = initial.Contains(toRemove);
-            Assert.AreEqual(
-                shouldHaveBeenRemoved,
-                wasRemoved,
-                $"Remove({toRemove}) should return {shouldHaveBeenRemoved} for initial buffer [{string.Join(", ", initial)}]."
-            );
-
-            Assert.AreEqual(
-                expected.Length,
-                buffer.Count,
-                $"Count after Remove({toRemove}) from [{string.Join(", ", initial)}] should be {expected.Length}, but was {buffer.Count}."
-            );
-
-            int[] actual = buffer.ToArray();
-            CollectionAssert.AreEqual(
-                expected,
-                actual,
-                $"After Remove({toRemove}) from [{string.Join(", ", initial)}], expected [{string.Join(", ", expected)}] but got [{string.Join(", ", actual)}]."
-            );
-        }
-
-        [Test]
-        [TestCase(
-            new[] { 1, 2, 2, 3 },
-            2,
-            new[] { 1, 2, 3 },
-            Description = "Remove first occurrence of duplicate"
-        )]
-        [TestCase(
-            new[] { 2, 2, 2 },
-            2,
-            new[] { 2, 2 },
-            Description = "Remove first of all duplicates"
-        )]
-        [TestCase(
-            new[] { 1, 1, 1 },
-            1,
-            new[] { 1, 1 },
-            Description = "Remove first of identical elements"
-        )]
-        public void RemoveDuplicatesBehavior(int[] initial, int toRemove, int[] expected)
-        {
-            CyclicBuffer<int> buffer = new(initial.Length, initial);
-            bool wasRemoved = buffer.Remove(toRemove);
-
-            Assert.IsTrue(
-                wasRemoved,
-                $"Remove({toRemove}) should return true when element exists in [{string.Join(", ", initial)}]."
-            );
-
-            Assert.AreEqual(
-                expected.Length,
-                buffer.Count,
-                $"Count after Remove({toRemove}) from [{string.Join(", ", initial)}] should be {expected.Length}, but was {buffer.Count}."
-            );
-
-            int[] actual = buffer.ToArray();
-            CollectionAssert.AreEqual(
-                expected,
-                actual,
-                $"After Remove({toRemove}) from [{string.Join(", ", initial)}], expected [{string.Join(", ", expected)}] but got [{string.Join(", ", actual)}]."
-            );
-        }
-
-        [Test]
-        public void RemoveFromEmptyBuffer()
-        {
-            CyclicBuffer<int> buffer = new(5);
-            bool wasRemoved = buffer.Remove(1);
-            Assert.IsFalse(wasRemoved, "Remove from empty buffer should return false");
-            Assert.AreEqual(0, buffer.Count, "Count should remain 0");
-        }
-
-        [Test]
-        [TestCase(2, new[] { 3, 4 }, Description = "Remove first element from wrapped buffer")]
-        [TestCase(3, new[] { 2, 4 }, Description = "Remove middle element from wrapped buffer")]
-        [TestCase(4, new[] { 2, 3 }, Description = "Remove last element from wrapped buffer")]
-        public void RemoveFromWrappedBuffer(int toRemove, int[] expected)
-        {
-            // Create a buffer that has wrapped around
-            CyclicBuffer<int> buffer = new(3)
-            {
-                1,
-                2,
-                3,
-                // Buffer is now [1, 2, 3], full
-                4,
-            };
-            // Buffer has wrapped, now contains [2, 3, 4] logically
-
-            int[] beforeRemove = buffer.ToArray();
-            Assert.AreEqual(
-                new[] { 2, 3, 4 },
-                beforeRemove,
-                $"Before remove, wrapped buffer should be [2, 3, 4] but was [{string.Join(", ", beforeRemove)}]."
-            );
-
-            bool wasRemoved = buffer.Remove(toRemove);
-            Assert.IsTrue(
-                wasRemoved,
-                $"Remove({toRemove}) should return true for wrapped buffer containing {toRemove}."
-            );
-
-            int[] afterRemove = buffer.ToArray();
-            Assert.AreEqual(
-                expected.Length,
-                buffer.Count,
-                $"Count after Remove({toRemove}) from wrapped buffer should be {expected.Length}, but was {buffer.Count}."
-            );
-            CollectionAssert.AreEqual(
-                expected,
-                afterRemove,
-                $"After Remove({toRemove}) from wrapped buffer [2, 3, 4], expected [{string.Join(", ", expected)}] but got [{string.Join(", ", afterRemove)}]."
-            );
-        }
-
-        [Test]
-        public void RemoveWithCustomComparer()
-        {
-            // Case-insensitive string comparer
-            CyclicBuffer<string> buffer = new(5) { "Apple", "Banana", "Cherry" };
-
-            // Should find and remove "BANANA" using case-insensitive comparison
-            bool wasRemoved = buffer.Remove("BANANA", StringComparer.OrdinalIgnoreCase);
-            Assert.IsTrue(
-                wasRemoved,
-                "Remove with case-insensitive comparer should find 'BANANA' matching 'Banana'."
-            );
-
-            string[] afterRemove = buffer.ToArray();
-            Assert.AreEqual(2, buffer.Count, "Count should be 2 after removal.");
-            CollectionAssert.AreEqual(
-                new[] { "Apple", "Cherry" },
-                afterRemove,
-                $"After Remove('BANANA') with case-insensitive comparer, expected ['Apple', 'Cherry'] but got [{string.Join(", ", afterRemove)}]."
-            );
-
-            // Should NOT find "banana" using default (case-sensitive) comparison
-            buffer.Add("Durian");
-            wasRemoved = buffer.Remove("APPLE"); // default comparer is case-sensitive
-            Assert.IsFalse(
-                wasRemoved,
-                "Remove with default comparer should NOT find 'APPLE' when buffer contains 'Apple'."
-            );
-            Assert.AreEqual(3, buffer.Count, "Count should remain 3 when element not found.");
-        }
-
-        [Test]
-        public void SequentialRemoves()
-        {
-            CyclicBuffer<int> buffer = new(5, new[] { 1, 2, 3, 4, 5 });
-
-            Assert.IsTrue(buffer.Remove(2), "First remove should succeed");
-            CollectionAssert.AreEqual(new[] { 1, 3, 4, 5 }, buffer.ToArray(), "After first remove");
-
-            Assert.IsTrue(buffer.Remove(4), "Second remove should succeed");
-            CollectionAssert.AreEqual(new[] { 1, 3, 5 }, buffer.ToArray(), "After second remove");
-
-            Assert.IsTrue(buffer.Remove(1), "Third remove should succeed");
-            CollectionAssert.AreEqual(new[] { 3, 5 }, buffer.ToArray(), "After third remove");
-
-            Assert.AreEqual(2, buffer.Count, "Final count should be 2");
-        }
-
-        [Test]
-        public void WrappedBufferEnumerationConsistencyAfterRemove()
-        {
-            // Create a wrapped buffer
-            CyclicBuffer<int> buffer = new(3)
-            {
-                1,
-                2,
-                3,
-                4, // Now wrapped: [2, 3, 4]
-            };
-
-            buffer.Remove(3); // Remove middle: should be [2, 4]
-
-            // Verify ToArray() and foreach enumeration give same results
-            int[] fromToArray = buffer.ToArray();
-            List<int> fromEnumeration = new();
-            foreach (int item in buffer)
-            {
-                fromEnumeration.Add(item);
-            }
-
-            CollectionAssert.AreEqual(
-                new[] { 2, 4 },
-                fromToArray,
-                "ToArray() should return [2, 4]"
-            );
-            CollectionAssert.AreEqual(
-                fromToArray,
-                fromEnumeration.ToArray(),
-                "Enumeration should match ToArray()"
-            );
-        }
-
-        [Test]
-        public void ZeroCapacityBufferIsEmpty()
-        {
-            CyclicBuffer<int> buffer = new(0)
-            {
-                // Add multiple items - all should be silently discarded
-                1,
-                2,
-                3,
-            };
-
-            Assert.AreEqual(0, buffer.Capacity, "Capacity should remain 0.");
-            Assert.AreEqual(0, buffer.Count, "Count should remain 0.");
-        }
-    }
-}
-#endif

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

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

package/Tests/Runtime/Core/DefaultBusFallbackTests.cs

@@ -1,336 +0,0 @@
-#if UNITY_2021_3_OR_NEWER
-namespace DxMessaging.Tests.Runtime.Core
-{
-    using System.Collections;
-    using System.Collections.Generic;
-    using DxMessaging.Core;
-    using DxMessaging.Core.Extensions;
-    using DxMessaging.Core.MessageBus;
-    using DxMessaging.Tests.Runtime.Scripts.Components;
-    using DxMessaging.Tests.Runtime.Scripts.Messages;
-    using DxMessaging.Unity;
-    using NUnit.Framework;
-    using UnityEngine;
-    using UnityEngine.TestTools;
-
-    public sealed class DefaultBusFallbackTests : MessagingTestBase
-    {
-        private readonly List<MessageRegistrationHandle> _handles = new();
-        private readonly List<MessageRegistrationToken> _tokens = new();
-
-        [TearDown]
-        public void TearDown()
-        {
-            foreach (MessageRegistrationToken token in _tokens)
-            {
-                foreach (MessageRegistrationHandle handle in _handles)
-                {
-                    token.RemoveRegistration(handle);
-                }
-                token.Disable();
-            }
-
-            _handles.Clear();
-            _tokens.Clear();
-        }
-
-        [Test]
-        public void HandlerUsesInjectedDefaultBusWhenTokenOmitsBus()
-        {
-            MessageBus customBus = new();
-            MessageHandler handler = new(new InstanceId(42), customBus) { active = true };
-            MessageRegistrationToken token = MessageRegistrationToken.Create(handler);
-            _tokens.Add(token);
-
-            int callCount = 0;
-            MessageRegistrationHandle handle = token.RegisterUntargeted<SimpleUntargetedMessage>(
-                _ => ++callCount
-            );
-            _handles.Add(handle);
-
-            token.Enable();
-
-            SimpleUntargetedMessage message = new();
-            message.EmitUntargeted(customBus);
-            Assert.AreEqual(
-                1,
-                callCount,
-                "Handler should observe messages emitted through its injected bus."
-            );
-
-            message.EmitUntargeted();
-            Assert.AreEqual(
-                1,
-                callCount,
-                "Handler should remain isolated from the global bus when using an injected default."
-            );
-        }
-
-        [Test]
-        public void HandlerUsesInjectedDefaultBusForTargetedMessages()
-        {
-            MessageBus customBus = new();
-            MessageHandler handler = new(new InstanceId(99), customBus) { active = true };
-            MessageRegistrationToken token = MessageRegistrationToken.Create(handler);
-            _tokens.Add(token);
-
-            InstanceId target = new(1234);
-            int callCount = 0;
-            MessageRegistrationHandle handle = token.RegisterTargeted<SimpleTargetedMessage>(
-                target,
-                _ => ++callCount
-            );
-            _handles.Add(handle);
-
-            token.Enable();
-
-            SimpleTargetedMessage message = new();
-            message.EmitTargeted(target, customBus);
-            Assert.AreEqual(
-                1,
-                callCount,
-                "Targeted handlers should fire when messages emit on the injected bus."
-            );
-
-            message.EmitTargeted(target);
-            Assert.AreEqual(
-                1,
-                callCount,
-                "Targeted handler should ignore global bus emissions when a default bus is injected."
-            );
-        }
-
-        [Test]
-        public void HandlerUsesInjectedDefaultBusForBroadcastMessages()
-        {
-            MessageBus customBus = new();
-            MessageHandler handler = new(new InstanceId(1337), customBus) { active = true };
-            MessageRegistrationToken token = MessageRegistrationToken.Create(handler);
-            _tokens.Add(token);
-
-            int callCount = 0;
-            MessageRegistrationHandle handle = token.RegisterBroadcastWithoutSource(
-                (ref InstanceId _, ref SimpleBroadcastMessage _) => ++callCount
-            );
-            _handles.Add(handle);
-
-            token.Enable();
-
-            SimpleBroadcastMessage message = new();
-            InstanceId source = new(777);
-            message.EmitBroadcast(source, customBus);
-            Assert.AreEqual(
-                1,
-                callCount,
-                "Broadcast handlers should observe emissions on the injected bus."
-            );
-
-            message.EmitBroadcast(source);
-            Assert.AreEqual(
-                1,
-                callCount,
-                "Broadcast handler should remain isolated from global emissions when using an injected default bus."
-            );
-        }
-
-        [UnityTest]
-        public IEnumerator MessagingComponentConfigureRebindsExistingHandlerToCustomBus()
-        {
-            MessageBus customBus = new();
-            GameObject go = new(
-                nameof(MessagingComponentConfigureRebindsExistingHandlerToCustomBus),
-                typeof(MessagingComponent),
-                typeof(ManualListenerComponent)
-            );
-            _spawned.Add(go);
-
-            MessagingComponent messagingComponent = go.GetComponent<MessagingComponent>();
-            messagingComponent.Configure(customBus, MessageBusRebindMode.RebindActive);
-
-            ManualListenerComponent listener = go.GetComponent<ManualListenerComponent>();
-            MessageRegistrationToken token = listener.RequestToken(messagingComponent);
-            _tokens.Add(token);
-
-            int callCount = 0;
-            MessageRegistrationHandle handle = token.RegisterUntargeted<SimpleUntargetedMessage>(
-                _ => ++callCount
-            );
-            _handles.Add(handle);
-            token.Enable();
-
-            SimpleUntargetedMessage message = new();
-            message.EmitUntargeted(customBus);
-            Assert.AreEqual(
-                1,
-                callCount,
-                "Configure should redirect tokens to the provided MessageBus."
-            );
-
-            message.EmitUntargeted();
-            Assert.AreEqual(
-                1,
-                callCount,
-                "Global emissions should not reach tokens configured to use a custom bus."
-            );
-            yield break;
-        }
-
-        [UnityTest]
-        public IEnumerator MessagingComponentConfigurePreserveDefersRebindUntilReenabled()
-        {
-            MessageBus initialBus = new();
-            MessageBus newBus = new();
-            GameObject go = new(
-                nameof(MessagingComponentConfigurePreserveDefersRebindUntilReenabled),
-                typeof(MessagingComponent),
-                typeof(ManualListenerComponent)
-            );
-            _spawned.Add(go);
-
-            MessagingComponent messagingComponent = go.GetComponent<MessagingComponent>();
-            messagingComponent.Configure(initialBus, MessageBusRebindMode.RebindActive);
-
-            ManualListenerComponent listener = go.GetComponent<ManualListenerComponent>();
-            MessageRegistrationToken token = listener.RequestToken(messagingComponent);
-            _tokens.Add(token);
-
-            int callCount = 0;
-            MessageRegistrationHandle handle = token.RegisterUntargeted<SimpleUntargetedMessage>(
-                _ => ++callCount
-            );
-            _handles.Add(handle);
-            token.Enable();
-
-            SimpleUntargetedMessage message = new();
-            message.EmitUntargeted(initialBus);
-            Assert.AreEqual(1, callCount, "Initial bus should deliver to the registered handler.");
-
-            messagingComponent.Configure(newBus, MessageBusRebindMode.PreserveRegistrations);
-
-            message.EmitUntargeted(newBus);
-            Assert.AreEqual(
-                1,
-                callCount,
-                "Preserve mode should avoid rebinding active registrations immediately."
-            );
-
-            message.EmitUntargeted(initialBus);
-            Assert.AreEqual(
-                2,
-                callCount,
-                "Handlers should continue observing the original bus until re-enabled."
-            );
-
-            token.Disable();
-            token.Enable();
-
-            message.EmitUntargeted(newBus);
-            Assert.AreEqual(
-                3,
-                callCount,
-                "Re-enabling the token should rebind handlers to the new bus."
-            );
-
-            yield break;
-        }
-
-        [UnityTest]
-        public IEnumerator MessageAwareComponentConfigureMessageBusAppliesOverride()
-        {
-            MessageBus customBus = new();
-            GameObject go = new(
-                nameof(MessageAwareComponentConfigureMessageBusAppliesOverride),
-                typeof(MessagingComponent),
-                typeof(BusAwareComponent)
-            );
-            _spawned.Add(go);
-
-            BusAwareComponent component = go.GetComponent<BusAwareComponent>();
-            component.ConfigureMessageBus(customBus, MessageBusRebindMode.RebindActive);
-
-            yield return null;
-
-            SimpleUntargetedMessage message = new();
-            message.EmitUntargeted(customBus);
-            Assert.AreEqual(
-                1,
-                component.Received,
-                "MessageAwareComponent should route through the configured bus."
-            );
-
-            message.EmitUntargeted();
-            Assert.AreEqual(
-                1,
-                component.Received,
-                "Global bus should no longer deliver to the component after override."
-            );
-        }
-
-        [UnityTest]
-        public IEnumerator MessageAwareComponentConfigureMessageBusPreserveDefersUntilReenable()
-        {
-            MessageBus initialBus = new();
-            MessageBus newBus = new();
-            GameObject go = new(
-                nameof(MessageAwareComponentConfigureMessageBusPreserveDefersUntilReenable),
-                typeof(MessagingComponent),
-                typeof(BusAwareComponent)
-            );
-            _spawned.Add(go);
-
-            BusAwareComponent component = go.GetComponent<BusAwareComponent>();
-            component.ConfigureMessageBus(initialBus, MessageBusRebindMode.RebindActive);
-
-            yield return null;
-
-            SimpleUntargetedMessage message = new();
-            message.EmitUntargeted(initialBus);
-            Assert.AreEqual(
-                1,
-                component.Received,
-                "Component should receive messages emitted via the initial bus."
-            );
-
-            component.ConfigureMessageBus(newBus, MessageBusRebindMode.PreserveRegistrations);
-
-            message.EmitUntargeted(newBus);
-            Assert.AreEqual(
-                1,
-                component.Received,
-                "Preserve mode should not rebind active handlers immediately."
-            );
-
-            message.EmitUntargeted(initialBus);
-            Assert.AreEqual(
-                2,
-                component.Received,
-                "Existing registrations should continue to observe the original bus."
-            );
-
-            component.Token.Disable();
-            component.Token.Enable();
-
-            message.EmitUntargeted(newBus);
-            Assert.AreEqual(
-                3,
-                component.Received,
-                "Re-enabling the token should rebind handlers to the new bus."
-            );
-        }
-
-        private sealed class BusAwareComponent : MessageAwareComponent
-        {
-            internal int Received { get; private set; }
-
-            protected override bool RegisterForStringMessages => false;
-
-            protected override void RegisterMessageHandlers()
-            {
-                base.RegisterMessageHandlers();
-                _ = Token.RegisterUntargeted<SimpleUntargetedMessage>(_ => ++Received);
-            }
-        }
-    }
-}
-
-#endif