com.wallstop-studios.dxmessaging 2.1.4 → 2.1.6

package/.llm/skills/templates/skill-template.md

@@ -0,0 +1,143 @@
+---
+# Template for new skills - copy this file and fill in all fields
+# Required Fields
+title: "Skill Title Here"
+id: "skill-id-here" # Must match filename (without .md)
+category: "category-name" # Must match parent folder name
+version: "1.0.0"
+created: "YYYY-MM-DD"
+updated: "YYYY-MM-DD"
+
+# Source Information
+source:
+  repository: "owner/repo-name"
+  files:
+    - path: "path/to/primary/file.cs"
+      lines: "10-50" # Optional
+      commit: "" # Optional
+  url: "" # Optional
+
+# Classification
+tags:
+  - "tag1"
+  - "tag2"
+
+complexity:
+  level: "intermediate" # basic|intermediate|advanced|expert
+  reasoning: ""
+
+# Impact Assessment
+impact:
+  performance:
+    rating: "medium" # none|low|medium|high|critical
+    details: ""
+  maintainability:
+    rating: "medium"
+    details: ""
+  testability:
+    rating: "medium"
+    details: ""
+
+# Dependencies and Prerequisites
+prerequisites: []
+
+dependencies:
+  packages: []
+  skills: []
+
+# Applicability
+applies_to:
+  languages:
+    - "C#"
+  frameworks:
+    - "Unity"
+  versions:
+    unity: ">=2021.3"
+    dotnet: ">=netstandard2.0"
+
+# Optional
+aliases: []
+related: []
+status: "draft" # draft|review|stable|deprecated
+---
+
+# {title}
+
+> **One-line summary**: Brief description of what this pattern accomplishes.
+
+## Overview
+
+Explain what this pattern is and why it matters.
+
+## Problem Statement
+
+Describe the specific problem this pattern addresses.
+
+## Solution
+
+### Core Concept
+
+Explain the fundamental idea.
+
+### Implementation
+
+```csharp
+// Primary code example
+```
+
+### Step-by-Step Breakdown
+
+1. **Step 1**: Explanation
+1. **Step 2**: Explanation
+
+## Variations
+
+### Variation A: {Name}
+
+```csharp
+// Variation code
+```
+
+## Usage Examples
+
+### Example 1: {Scenario}
+
+```csharp
+// Complete example
+```
+
+## Anti-Patterns
+
+### ❌ Don't Do This
+
+```csharp
+// Bad example
+```
+
+**Why it's wrong**: Explanation.
+
+## Testing Considerations
+
+- Testing notes
+
+```csharp
+// Test example
+```
+
+## Performance Notes
+
+- Performance characteristics
+
+## See Also
+
+- [Related Skill](../category/skill.md)
+
+## References
+
+- [Source](https://example.com)
+
+## Changelog
+
+| Version | Date       | Changes         |
+| ------- | ---------- | --------------- |
+| 1.0.0   | YYYY-MM-DD | Initial version |

package/.llm/skills/testing/comprehensive-test-coverage.md

@@ -0,0 +1,141 @@
+---
+title: "Comprehensive Test Coverage Requirements"
+id: "comprehensive-test-coverage"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-22"
+updated: "2026-01-22"
+
+source:
+  repository: "wallstop/DxMessaging"
+  files:
+    - path: "Tests/Runtime/Core/NominalTests.cs"
+    - path: "Tests/Runtime/"
+  url: "https://github.com/wallstop/DxMessaging"
+
+tags:
+  - "testing"
+  - "coverage"
+  - "edge-cases"
+  - "data-driven"
+  - "unity"
+  - "nunit"
+  - "best-practices"
+  - "quality"
+
+complexity:
+  level: "intermediate"
+  reasoning: "Requires understanding of test design principles and NUnit features"
+
+impact:
+  performance:
+    rating: "none"
+    details: "Testing patterns only; no runtime impact"
+  maintainability:
+    rating: "critical"
+    details: "Comprehensive tests prevent regressions and document expected behavior"
+  testability:
+    rating: "critical"
+    details: "Defines the standard for test quality across the codebase"
+
+prerequisites:
+  - "Understanding of NUnit testing framework"
+  - "Familiarity with Unity Test Framework"
+  - "Knowledge of messaging library concepts"
+
+dependencies:
+  packages: []
+  skills:
+    - "data-driven-tests"
+    - "test-failure-investigation"
+    - "test-diagnostics"
+
+applies_to:
+  languages:
+    - "C#"
+  frameworks:
+    - "Unity"
+    - ".NET"
+    - "NUnit"
+  versions:
+    unity: ">=2021.3"
+    dotnet: ">=netstandard2.0"
+
+aliases:
+  - "Test requirements"
+  - "Test coverage policy"
+  - "Testing standards"
+  - "Edge case testing"
+
+related:
+  - "data-driven-tests"
+  - "test-failure-investigation"
+  - "test-diagnostics"
+  - "test-categories"
+  - "test-base-class-cleanup"
+  - "shared-test-fixtures"
+  - "test-coverage-scenario-categories"
+  - "test-coverage-data-driven"
+  - "test-coverage-organization-assertions"
+  - "test-coverage-unity-anti-patterns"
+
+status: "stable"
+---
+
+# Comprehensive Test Coverage Requirements
+
+> **One-line summary**: Every new feature and bug fix requires tests covering happy paths, negative scenarios, edge cases, and "impossible" situations.
+
+## Overview
+
+Comprehensive test coverage is not optional. Every code change must include tests that verify:
+
+1. The feature works as intended (happy path)
+1. The feature handles errors gracefully (negative scenarios)
+1. The feature behaves correctly at boundaries (edge cases)
+1. The feature survives unexpected usage (unexpected situations)
+1. The feature handles "impossible" scenarios defensively
+
+## When Tests Are Required
+
+| Scenario                 | Requirement                                                |
+| ------------------------ | ---------------------------------------------------------- |
+| New feature              | Tests for all public APIs                                  |
+| Bug fix                  | Regression test that fails before fix, passes after        |
+| Performance optimization | Benchmark tests proving improvement                        |
+| Refactoring              | Existing tests must pass; add tests if coverage gaps exist |
+| API change               | Update existing tests + add tests for new behavior         |
+
+## Solution
+
+### Core Concept
+
+Design tests around **coverage categories** and **data-driven patterns**:
+
+- Normal/happy path
+- Negative/error conditions
+- Edge/boundary cases
+- Unexpected usage
+- "Impossible" defensive cases
+
+Use `[TestCase]` and `[TestCaseSource]` to consolidate coverage without duplication.
+
+## See Also
+
+- [Scenario Coverage Categories](test-coverage-scenario-categories.md)
+- [Data-Driven Coverage Patterns](test-coverage-data-driven.md)
+- [Organization and Assertions](test-coverage-organization-assertions.md)
+- [Unity Considerations and Anti-Patterns](test-coverage-unity-anti-patterns.md)
+- [Data-Driven Tests](data-driven-tests.md)
+- [Test Failure Investigation](test-failure-investigation.md)
+
+## References
+
+- NUnit Documentation: https://docs.nunit.org/
+- Unity Test Framework: https://docs.unity3d.com/Packages/com.unity.test-framework@latest
+
+## Changelog
+
+| Version | Date       | Changes         |
+| ------- | ---------- | --------------- |
+| 1.0.0   | 2026-01-22 | Initial version |

package/.llm/skills/testing/data-driven-tests-sources.md

@@ -0,0 +1,255 @@
+---
+title: "Data-Driven Test Sources"
+id: "data-driven-tests-sources"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-22"
+updated: "2026-01-22"
+
+source:
+  repository: "wallstop/DxMessaging"
+  files:
+    - path: "Tests/Runtime/"
+  url: "https://github.com/wallstop/DxMessaging"
+
+tags:
+  - "testing"
+  - "parameterized"
+  - "data-driven"
+  - "nunit"
+
+complexity:
+  level: "intermediate"
+  reasoning: "Builds on NUnit parameterized tests with reusable sources"
+
+impact:
+  performance:
+    rating: "none"
+    details: "Testing patterns only"
+  maintainability:
+    rating: "high"
+    details: "Reduces duplicated test code"
+  testability:
+    rating: "high"
+    details: "Encourages broad coverage"
+
+prerequisites:
+  - "Understanding of NUnit"
+
+dependencies:
+  packages: []
+  skills:
+    - "data-driven-tests"
+
+applies_to:
+  languages:
+    - "C#"
+  frameworks:
+    - "Unity"
+    - ".NET"
+    - "NUnit"
+
+aliases:
+  - "TestCaseSource patterns"
+
+related:
+  - "data-driven-tests"
+
+status: "stable"
+---
+
+# Data-Driven Test Sources
+
+> **One-line summary**: Advanced TestCaseSource patterns and reusable data sets.
+
+## Overview
+
+This skill explains advanced TestCaseSource patterns.
+
+## Solution
+
+Use these sources to build reusable data sets for tests.
+
+### Using TestCaseSource for Complex Data
+
+```csharp
+[TestFixture]
+public sealed class MatchModeTests
+{
+    // Static method providing test cases
+    private static IEnumerable<TestCaseData> CaseSensitivityCases()
+    {
+        // Exact match
+        yield return new TestCaseData(MatchMode.Exact, "Player", "Player", true)
+            .SetName("Exact_SameCase_Matches");
+        yield return new TestCaseData(MatchMode.Exact, "Player", "player", false)
+            .SetName("Exact_DifferentCase_NoMatch");
+        yield return new TestCaseData(MatchMode.Exact, "Player", "PLAYER", false)
+            .SetName("Exact_AllCaps_NoMatch");
+
+        // Case insensitive
+        yield return new TestCaseData(MatchMode.CaseInsensitive, "Player", "player", true)
+            .SetName("CaseInsensitive_LowerCase_Matches");
+        yield return new TestCaseData(MatchMode.CaseInsensitive, "Player", "PLAYER", true)
+            .SetName("CaseInsensitive_UpperCase_Matches");
+
+        // Contains
+        yield return new TestCaseData(MatchMode.Contains, "Player", "Play", true)
+            .SetName("Contains_Prefix_Matches");
+        yield return new TestCaseData(MatchMode.Contains, "Player", "layer", true)
+            .SetName("Contains_Suffix_Matches");
+        yield return new TestCaseData(MatchMode.Contains, "Player", "xyz", false)
+            .SetName("Contains_Missing_NoMatch");
+
+        // Edge cases
+        yield return new TestCaseData(MatchMode.Exact, "", "", true)
+            .SetName("Exact_EmptyStrings_Match");
+        yield return new TestCaseData(MatchMode.Exact, "Test", null, false)
+            .SetName("Exact_NullPattern_NoMatch");
+    }
+
+    [Test]
+    [TestCaseSource(nameof(CaseSensitivityCases))]
+    public void MatchModeMatchesCorrectly(
+        MatchMode matchMode,
+        string text,
+        string pattern,
+        bool expectedMatch)
+    {
+        bool actualMatch = Matcher.IsMatch(text, pattern, matchMode);
+
+        Assert.AreEqual(
+            expectedMatch,
+            actualMatch,
+            $"MatchMode={matchMode}, Text='{text}', Pattern='{pattern ?? "null"}'. " +
+            $"Expected match={expectedMatch}, actual={actualMatch}");
+    }
+}
+```
+
+### Using Static Property for Test Cases
+
+```csharp
+[TestFixture]
+public sealed class VectorMathTests
+{
+    // Property providing test data
+    private static IEnumerable<TestCaseData> DotProductCases
+    {
+        get
+        {
+            yield return new TestCaseData(
+                new Vector3(1, 0, 0),
+                new Vector3(1, 0, 0),
+                1f)
+                .SetName("Parallel_SameDirection");
+
+            yield return new TestCaseData(
+                new Vector3(1, 0, 0),
+                new Vector3(-1, 0, 0),
+                -1f)
+                .SetName("Parallel_OppositeDirection");
+
+            yield return new TestCaseData(
+                new Vector3(1, 0, 0),
+                new Vector3(0, 1, 0),
+                0f)
+                .SetName("Perpendicular");
+
+            yield return new TestCaseData(
+                new Vector3(3, 4, 0),
+                new Vector3(4, 3, 0),
+                24f)
+                .SetName("Arbitrary_3D");
+        }
+    }
+
+    [Test]
+    [TestCaseSource(nameof(DotProductCases))]
+    public void DotProductCalculatesCorrectly(Vector3 a, Vector3 b, float expected)
+    {
+        float result = Vector3.Dot(a, b);
+        Assert.AreEqual(expected, result, 0.0001f);
+    }
+}
+```
+
+### Using External Test Data Class
+
+```csharp
+// Separate class for test data (useful for sharing across fixtures)
+public static class ColorConversionTestData
+{
+    public static IEnumerable<TestCaseData> RgbToHexCases
+    {
+        get
+        {
+            yield return new TestCaseData(Color.red, "#FF0000");
+            yield return new TestCaseData(Color.green, "#00FF00");
+            yield return new TestCaseData(Color.blue, "#0000FF");
+            yield return new TestCaseData(Color.white, "#FFFFFF");
+            yield return new TestCaseData(Color.black, "#000000");
+            yield return new TestCaseData(new Color(0.5f, 0.5f, 0.5f), "#808080");
+        }
+    }
+
+    public static IEnumerable<TestCaseData> HexToRgbCases
+    {
+        get
+        {
+            yield return new TestCaseData("#FF0000", Color.red);
+            yield return new TestCaseData("#ff0000", Color.red); // lowercase
+            yield return new TestCaseData("FF0000", Color.red);  // no #
+        }
+    }
+}
+
+[TestFixture]
+public sealed class ColorConversionTests
+{
+    [Test]
+    [TestCaseSource(typeof(ColorConversionTestData), nameof(ColorConversionTestData.RgbToHexCases))]
+    public void ToHexConvertsCorrectly(Color color, string expectedHex)
+    {
+        string result = ColorUtils.ToHex(color);
+        Assert.AreEqual(expectedHex, result, $"Color {color} should convert to {expectedHex}");
+    }
+
+    [Test]
+    [TestCaseSource(typeof(ColorConversionTestData), nameof(ColorConversionTestData.HexToRgbCases))]
+    public void FromHexConvertsCorrectly(string hex, Color expectedColor)
+    {
+        Color result = ColorUtils.FromHex(hex);
+        Assert.AreEqual(expectedColor.r, result.r, 0.01f);
+        Assert.AreEqual(expectedColor.g, result.g, 0.01f);
+        Assert.AreEqual(expectedColor.b, result.b, 0.01f);
+    }
+}
+```
+
+### Combining Multiple Test Case Sources
+
+```csharp
+[TestFixture]
+public sealed class BoundaryTests
+{
+    private static int[] ValidValues => new[] { 0, 1, 50, 99, 100 };
+    private static int[] InvalidLowValues => new[] { -100, -1 };
+    private static int[] InvalidHighValues => new[] { 101, 200, 1000 };
+
+    [Test]
+    [TestCaseSource(nameof(ValidValues))]
+    public void AcceptsValidValues(int value)
+    {
+        Assert.DoesNotThrow(() => validator.Validate(value));
+    }
+
+    [Test]
+    [TestCaseSource(nameof(InvalidLowValues))]
+    [TestCaseSource(nameof(InvalidHighValues))]
+    public void RejectsInvalidValues(int value)
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => validator.Validate(value));
+    }
+}
+```

package/.llm/skills/testing/data-driven-tests-usage.md

@@ -0,0 +1,107 @@
+---
+title: "Data-Driven Test Usage Patterns"
+id: "data-driven-tests-usage"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-22"
+updated: "2026-01-22"
+
+source:
+  repository: "wallstop/DxMessaging"
+  files:
+    - path: "Tests/Runtime/"
+  url: "https://github.com/wallstop/DxMessaging"
+
+tags:
+  - "testing"
+  - "parameterized"
+  - "data-driven"
+  - "nunit"
+
+complexity:
+  level: "intermediate"
+  reasoning: "Builds on NUnit parameterized tests with reusable sources"
+
+impact:
+  performance:
+    rating: "none"
+    details: "Testing patterns only"
+  maintainability:
+    rating: "high"
+    details: "Reduces duplicated test code"
+  testability:
+    rating: "high"
+    details: "Encourages broad coverage"
+
+prerequisites:
+  - "Understanding of NUnit"
+
+dependencies:
+  packages: []
+  skills:
+    - "data-driven-tests"
+
+applies_to:
+  languages:
+    - "C#"
+  frameworks:
+    - "Unity"
+    - ".NET"
+    - "NUnit"
+
+aliases:
+  - "TestCaseSource patterns"
+
+related:
+  - "data-driven-tests"
+
+status: "stable"
+---
+
+# Data-Driven Test Usage Patterns
+
+> **One-line summary**: Usage tips for naming, failures, and diagnostics.
+
+## Overview
+
+This skill highlights naming and diagnostics for data-driven tests.
+
+## Solution
+
+Use the patterns below to keep parameterized tests readable.
+
+## Usage
+
+### Descriptive Failure Messages
+
+```csharp
+[Test]
+[TestCase("abc", "ABC")]
+[TestCase("Hello World", "HELLO WORLD")]
+public void ToUpperConvertsCorrectly(string input, string expected)
+{
+    string result = input.ToUpper();
+
+    // Include all relevant info in failure message
+    Assert.AreEqual(
+        expected,
+        result,
+        $"Input: '{input}'\nExpected: '{expected}'\nActual: '{result}'");
+}
+```
+
+### Using SetName for Clear Test Names
+
+```csharp
+private static IEnumerable<TestCaseData> EdgeCases()
+{
+    yield return new TestCaseData("", 0)
+        .SetName("EmptyString_ReturnsZero");
+
+    yield return new TestCaseData((string)null, 0)
+        .SetName("NullString_ReturnsZero");
+
+    yield return new TestCaseData("   ", 0)
+        .SetName("WhitespaceOnly_ReturnsZero");
+}
+```