test(audience-sdk): centralise JsonTests per-scenario fixture keys and values

ImmutableJeffrey · ImmutableJeffrey · commit 80bae96cb877 · 2026-05-03T17:58:18.000+10:00
JsonTests had inline scenario fixtures across nineteen tests:
- "flag" (Bool true / false serialise pair)
- "n" (Int / Long serialise)
- "x" (Null serialise)
- "v" (eight float / double NaN, Infinity, normal-range, large /
  small exponent tests; reused as the diamond test's inner value)
- "items" (List serialise)
- "level", "score", "perfect", "tags" (RealisticEventPayload nested
  properties keys)
- "fast", "clean" (tags array element values)
- "next" (deep-nesting MaxDepth guard)
- "self" (cycle-detection self-reference)
- "cycle" / "nesting exceeds" (FormatException message markers)
- "k", "a", "b" (diamond shared-child scenario)

Adds a file-local const block at the top of the fixture grouping the
literals by scenario (Bool / Numeric / Null / V / Array,
RealisticPayload, cycle / depth, diamond) and migrates every test
that consumed them. Where an SDK / fixtures const already covered
the same string (TestEventNames.PlaceholderA for "a",
TestEventNames.LevelComplete for "level_complete"), the test now
references that instead.

Per the user's "everything random goes in a constant" stance.

Follow-up to SDK-272 (centralisation of duplicated literals).
diff --git a/src/Packages/Audience/Tests/Runtime/Utility/JsonTests.cs b/src/Packages/Audience/Tests/Runtime/Utility/JsonTests.cs
@@ -7,6 +7,33 @@ namespace Immutable.Audience.Tests
     [TestFixture]
     public class JsonTests
     {
+        // Per-scenario fixture keys/values for the serialise tests.
+        private const string BoolFixtureKey = "flag";
+        private const string NumericFixtureKey = "n";
+        private const string NullFixtureKey = "x";
+        private const string VShortFixture = "v";
+        private const string ArrayFixtureKey = "items";
+
+        // RealisticEventPayload: nested keys and arrays exercise nested-list serialisation.
+        private const string PropLevelKey = "level";
+        private const string PropScoreKey = "score";
+        private const string PropPerfectKey = "perfect";
+        private const string PropTagsKey = "tags";
+        private const string TagFastValue = "fast";
+        private const string TagCleanValue = "clean";
+
+        // Cycle / depth guard fixtures.
+        private const string DeepNestNextKey = "next";
+        private const string SelfRefKey = "self";
+        private const string CycleErrorMarker = "cycle";
+        private const string NestingExceedsErrorMarker = "nesting exceeds";
+
+        // Diamond scenario (shared child under sibling keys is NOT a cycle).
+        private const string DiamondInnerKey = "k";
+        private const string DiamondInnerValue = "v";
+        private const string DiamondLeftKey = "a";
+        private const string DiamondRightKey = "b";
+
         [Test]
         public void Serialize_EmptyDict_ReturnsEmptyObject()
         {
@@ -41,41 +68,41 @@ public void Serialize_StringWithSpecialChars_EscapesCorrectly()
         [Test]
         public void Serialize_BoolTrue_ReturnsLowercaseTrue()
         {
-            var data = new Dictionary<string, object> { { "flag", true } };
+            var data = new Dictionary<string, object> { { BoolFixtureKey, true } };
 
-            Assert.AreEqual("{\"flag\":true}", Json.Serialize(data));
+            Assert.AreEqual($"{{\"{BoolFixtureKey}\":true}}", Json.Serialize(data));
         }
 
         [Test]
         public void Serialize_BoolFalse_ReturnsLowercaseFalse()
         {
-            var data = new Dictionary<string, object> { { "flag", false } };
+            var data = new Dictionary<string, object> { { BoolFixtureKey, false } };
 
-            Assert.AreEqual("{\"flag\":false}", Json.Serialize(data));
+            Assert.AreEqual($"{{\"{BoolFixtureKey}\":false}}", Json.Serialize(data));
         }
 
         [Test]
         public void Serialize_IntValue_ReturnsIntegerLiteral()
         {
-            var data = new Dictionary<string, object> { { "n", 42 } };
+            var data = new Dictionary<string, object> { { NumericFixtureKey, 42 } };
 
-            Assert.AreEqual("{\"n\":42}", Json.Serialize(data));
+            Assert.AreEqual($"{{\"{NumericFixtureKey}\":42}}", Json.Serialize(data));
         }
 
         [Test]
         public void Serialize_LongValue_ReturnsIntegerLiteral()
         {
-            var data = new Dictionary<string, object> { { "n", 9876543210L } };
+            var data = new Dictionary<string, object> { { NumericFixtureKey, 9876543210L } };
 
-            Assert.AreEqual("{\"n\":9876543210}", Json.Serialize(data));
+            Assert.AreEqual($"{{\"{NumericFixtureKey}\":9876543210}}", Json.Serialize(data));
         }
 
         [Test]
         public void Serialize_NullValue_ReturnsJsonNull()
         {
-            var data = new Dictionary<string, object> { { "x", null } };
+            var data = new Dictionary<string, object> { { NullFixtureKey, null } };
 
-            Assert.AreEqual("{\"x\":null}", Json.Serialize(data));
+            Assert.AreEqual($"{{\"{NullFixtureKey}\":null}}", Json.Serialize(data));
         }
 
         [Test]
@@ -97,47 +124,47 @@ public void Serialize_NestedDict_ReturnsNestedObject()
         [Test]
         public void Serialize_FloatNaN_SerializesAsNull()
         {
-            Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", float.NaN } }));
+            Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, float.NaN } }));
         }
 
         [Test]
         public void Serialize_FloatPositiveInfinity_SerializesAsNull()
         {
-            Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", float.PositiveInfinity } }));
+            Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, float.PositiveInfinity } }));
         }
 
         [Test]
         public void Serialize_FloatNegativeInfinity_SerializesAsNull()
         {
-            Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", float.NegativeInfinity } }));
+            Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, float.NegativeInfinity } }));
         }
 
         [Test]
         public void Serialize_DoubleNaN_SerializesAsNull()
         {
-            Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", double.NaN } }));
+            Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, double.NaN } }));
         }
 
         [Test]
         public void Serialize_DoubleInfinity_SerializesAsNull()
         {
-            Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", double.PositiveInfinity } }));
+            Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, double.PositiveInfinity } }));
         }
 
         [Test]
         public void Serialize_FloatValue_NormalRange()
         {
-            var data = new Dictionary<string, object> { { "v", 3.14f } };
+            var data = new Dictionary<string, object> { { VShortFixture, 3.14f } };
             var result = Json.Serialize(data);
-            StringAssert.Contains("\"v\":", result);
-            StringAssert.DoesNotContain("\"v\":\"", result); // must not be quoted
+            StringAssert.Contains($"\"{VShortFixture}\":", result);
+            StringAssert.DoesNotContain($"\"{VShortFixture}\":\"", result);
         }
 
         [Test]
         public void Serialize_FloatValue_LargeExponent_PreservesValue()
         {
             // 1e30f in scientific notation is valid JSON; must not be silently zeroed
-            var data = new Dictionary<string, object> { { "v", 1e30f } };
+            var data = new Dictionary<string, object> { { VShortFixture, 1e30f } };
             var result = Json.Serialize(data);
             var serialised = result.Substring(result.IndexOf(':') + 1, result.Length - result.IndexOf(':') - 2);
             Assert.AreNotEqual("0", serialised);
@@ -148,7 +175,7 @@ public void Serialize_FloatValue_LargeExponent_PreservesValue()
         public void Serialize_FloatValue_SmallNegativeExponent_PreservesValue()
         {
             // 1e-30f: the old F6 fallback turned this into "0.000000"
-            var data = new Dictionary<string, object> { { "v", 1e-30f } };
+            var data = new Dictionary<string, object> { { VShortFixture, 1e-30f } };
             var result = Json.Serialize(data);
             var serialised = result.Substring(result.IndexOf(':') + 1, result.Length - result.IndexOf(':') - 2);
             Assert.AreNotEqual("0", serialised);
@@ -158,7 +185,7 @@ public void Serialize_FloatValue_SmallNegativeExponent_PreservesValue()
         [Test]
         public void Serialize_DoubleValue_SmallNegativeExponent_PreservesValue()
         {
-            var data = new Dictionary<string, object> { { "v", 1e-300 } };
+            var data = new Dictionary<string, object> { { VShortFixture, 1e-300 } };
             var result = Json.Serialize(data);
             var serialised = result.Substring(result.IndexOf(':') + 1, result.Length - result.IndexOf(':') - 2);
             Assert.AreNotEqual("0", serialised);
@@ -170,10 +197,10 @@ public void Serialize_ListValue_ReturnsJsonArray()
         {
             var data = new Dictionary<string, object>
             {
-                { "items", new List<object> { "a", 1, true } }
+                { ArrayFixtureKey, new List<object> { TestEventNames.PlaceholderA, 1, true } }
             };
 
-            Assert.AreEqual("{\"items\":[\"a\",1,true]}", Json.Serialize(data));
+            Assert.AreEqual($"{{\"{ArrayFixtureKey}\":[\"{TestEventNames.PlaceholderA}\",1,true]}}", Json.Serialize(data));
         }
 
         [Test]
@@ -187,22 +214,22 @@ public void Serialize_RealisticEventPayload_ProducesCorrectJson()
                 { MessageFields.UserId, null },
                 { MessageFields.Properties, new Dictionary<string, object>
                     {
-                        { "level", 5 },
-                        { "score", 9800L },
-                        { "perfect", true },
-                        { "tags", new List<object> { "fast", "clean" } }
+                        { PropLevelKey, 5 },
+                        { PropScoreKey, 9800L },
+                        { PropPerfectKey, true },
+                        { PropTagsKey, new List<object> { TagFastValue, TagCleanValue } }
                     }
                 }
             };
 
             var result = Json.Serialize(data);
 
             StringAssert.Contains($"\"{MessageFields.Type}\":\"{MessageTypes.Track}\"", result);
-            StringAssert.Contains($"\"{MessageFields.EventName}\":\"level_complete\"", result);
+            StringAssert.Contains($"\"{MessageFields.EventName}\":\"{TestEventNames.LevelComplete}\"", result);
             StringAssert.Contains($"\"{MessageFields.UserId}\":null", result);
-            StringAssert.Contains("\"level\":5", result);
-            StringAssert.Contains("\"perfect\":true", result);
-            StringAssert.Contains("\"tags\":[\"fast\",\"clean\"]", result);
+            StringAssert.Contains($"\"{PropLevelKey}\":5", result);
+            StringAssert.Contains($"\"{PropPerfectKey}\":true", result);
+            StringAssert.Contains($"\"{PropTagsKey}\":[\"{TagFastValue}\",\"{TagCleanValue}\"]", result);
         }
 
         [Test]
@@ -213,39 +240,39 @@ public void Serialize_NestingExceedsMaxDepth_ThrowsFormatException()
             for (var i = 0; i < Json.MaxDepth; i++)
             {
                 var next = new Dictionary<string, object>();
-                current["next"] = next;
+                current[DeepNestNextKey] = next;
                 current = next;
             }
 
             var ex = Assert.Throws<FormatException>(() => Json.Serialize(root));
-            StringAssert.Contains("nesting exceeds", ex.Message);
+            StringAssert.Contains(NestingExceedsErrorMarker, ex.Message);
         }
 
         [Test]
         public void Serialize_SelfReferentialDict_ThrowsFormatException()
         {
             var root = new Dictionary<string, object>();
-            root["self"] = root;
+            root[SelfRefKey] = root;
 
             var ex = Assert.Throws<FormatException>(() => Json.Serialize(root));
-            StringAssert.Contains("cycle", ex.Message);
+            StringAssert.Contains(CycleErrorMarker, ex.Message);
         }
 
         [Test]
         public void Serialize_SharedChildInSiblingKeys_IsNotTreatedAsCycle()
         {
             // Diamond: visited set tracks the current recursion stack, not all objects ever seen.
-            var shared = new Dictionary<string, object> { ["k"] = "v" };
+            var shared = new Dictionary<string, object> { [DiamondInnerKey] = DiamondInnerValue };
             var root = new Dictionary<string, object>
             {
-                ["a"] = shared,
-                ["b"] = shared,
+                [DiamondLeftKey] = shared,
+                [DiamondRightKey] = shared,
             };
 
             var result = Json.Serialize(root);
 
-            StringAssert.Contains("\"a\":{\"k\":\"v\"}", result);
-            StringAssert.Contains("\"b\":{\"k\":\"v\"}", result);
+            StringAssert.Contains($"\"{DiamondLeftKey}\":{{\"{DiamondInnerKey}\":\"{DiamondInnerValue}\"}}", result);
+            StringAssert.Contains($"\"{DiamondRightKey}\":{{\"{DiamondInnerKey}\":\"{DiamondInnerValue}\"}}", result);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,33 @@ namespace Immutable.Audience.Tests`
`7`	`7`	`[TestFixture]`
`8`	`8`	`public class JsonTests`
`9`	`9`	`{`
	`10`	`+ // Per-scenario fixture keys/values for the serialise tests.`
	`11`	`+ private const string BoolFixtureKey = "flag";`
	`12`	`+ private const string NumericFixtureKey = "n";`
	`13`	`+ private const string NullFixtureKey = "x";`
	`14`	`+ private const string VShortFixture = "v";`
	`15`	`+ private const string ArrayFixtureKey = "items";`
	`16`	`+`
	`17`	`+ // RealisticEventPayload: nested keys and arrays exercise nested-list serialisation.`
	`18`	`+ private const string PropLevelKey = "level";`
	`19`	`+ private const string PropScoreKey = "score";`
	`20`	`+ private const string PropPerfectKey = "perfect";`
	`21`	`+ private const string PropTagsKey = "tags";`
	`22`	`+ private const string TagFastValue = "fast";`
	`23`	`+ private const string TagCleanValue = "clean";`
	`24`	`+`
	`25`	`+ // Cycle / depth guard fixtures.`
	`26`	`+ private const string DeepNestNextKey = "next";`
	`27`	`+ private const string SelfRefKey = "self";`
	`28`	`+ private const string CycleErrorMarker = "cycle";`
	`29`	`+ private const string NestingExceedsErrorMarker = "nesting exceeds";`
	`30`	`+`
	`31`	`+ // Diamond scenario (shared child under sibling keys is NOT a cycle).`
	`32`	`+ private const string DiamondInnerKey = "k";`
	`33`	`+ private const string DiamondInnerValue = "v";`
	`34`	`+ private const string DiamondLeftKey = "a";`
	`35`	`+ private const string DiamondRightKey = "b";`
	`36`	`+`
`10`	`37`	`[Test]`
`11`	`38`	`public void Serialize_EmptyDict_ReturnsEmptyObject()`
`12`	`39`	`{`
`@@ -41,41 +68,41 @@ public void Serialize_StringWithSpecialChars_EscapesCorrectly()`
`41`	`68`	`[Test]`
`42`	`69`	`public void Serialize_BoolTrue_ReturnsLowercaseTrue()`
`43`	`70`	`{`
`44`		`- var data = new Dictionary<string, object> { { "flag", true } };`
	`71`	`+ var data = new Dictionary<string, object> { { BoolFixtureKey, true } };`
`45`	`72`
`46`		`- Assert.AreEqual("{\"flag\":true}", Json.Serialize(data));`
	`73`	`+ Assert.AreEqual($"{{\"{BoolFixtureKey}\":true}}", Json.Serialize(data));`
`47`	`74`	`}`
`48`	`75`
`49`	`76`	`[Test]`
`50`	`77`	`public void Serialize_BoolFalse_ReturnsLowercaseFalse()`
`51`	`78`	`{`
`52`		`- var data = new Dictionary<string, object> { { "flag", false } };`
	`79`	`+ var data = new Dictionary<string, object> { { BoolFixtureKey, false } };`
`53`	`80`
`54`		`- Assert.AreEqual("{\"flag\":false}", Json.Serialize(data));`
	`81`	`+ Assert.AreEqual($"{{\"{BoolFixtureKey}\":false}}", Json.Serialize(data));`
`55`	`82`	`}`
`56`	`83`
`57`	`84`	`[Test]`
`58`	`85`	`public void Serialize_IntValue_ReturnsIntegerLiteral()`
`59`	`86`	`{`
`60`		`- var data = new Dictionary<string, object> { { "n", 42 } };`
	`87`	`+ var data = new Dictionary<string, object> { { NumericFixtureKey, 42 } };`
`61`	`88`
`62`		`- Assert.AreEqual("{\"n\":42}", Json.Serialize(data));`
	`89`	`+ Assert.AreEqual($"{{\"{NumericFixtureKey}\":42}}", Json.Serialize(data));`
`63`	`90`	`}`
`64`	`91`
`65`	`92`	`[Test]`
`66`	`93`	`public void Serialize_LongValue_ReturnsIntegerLiteral()`
`67`	`94`	`{`
`68`		`- var data = new Dictionary<string, object> { { "n", 9876543210L } };`
	`95`	`+ var data = new Dictionary<string, object> { { NumericFixtureKey, 9876543210L } };`
`69`	`96`
`70`		`- Assert.AreEqual("{\"n\":9876543210}", Json.Serialize(data));`
	`97`	`+ Assert.AreEqual($"{{\"{NumericFixtureKey}\":9876543210}}", Json.Serialize(data));`
`71`	`98`	`}`
`72`	`99`
`73`	`100`	`[Test]`
`74`	`101`	`public void Serialize_NullValue_ReturnsJsonNull()`
`75`	`102`	`{`
`76`		`- var data = new Dictionary<string, object> { { "x", null } };`
	`103`	`+ var data = new Dictionary<string, object> { { NullFixtureKey, null } };`
`77`	`104`
`78`		`- Assert.AreEqual("{\"x\":null}", Json.Serialize(data));`
	`105`	`+ Assert.AreEqual($"{{\"{NullFixtureKey}\":null}}", Json.Serialize(data));`
`79`	`106`	`}`
`80`	`107`
`81`	`108`	`[Test]`
`@@ -97,47 +124,47 @@ public void Serialize_NestedDict_ReturnsNestedObject()`
`97`	`124`	`[Test]`
`98`	`125`	`public void Serialize_FloatNaN_SerializesAsNull()`
`99`	`126`	`{`
`100`		`- Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", float.NaN } }));`
	`127`	`+ Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, float.NaN } }));`
`101`	`128`	`}`
`102`	`129`
`103`	`130`	`[Test]`
`104`	`131`	`public void Serialize_FloatPositiveInfinity_SerializesAsNull()`
`105`	`132`	`{`
`106`		`- Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", float.PositiveInfinity } }));`
	`133`	`+ Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, float.PositiveInfinity } }));`
`107`	`134`	`}`
`108`	`135`
`109`	`136`	`[Test]`
`110`	`137`	`public void Serialize_FloatNegativeInfinity_SerializesAsNull()`
`111`	`138`	`{`
`112`		`- Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", float.NegativeInfinity } }));`
	`139`	`+ Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, float.NegativeInfinity } }));`
`113`	`140`	`}`
`114`	`141`
`115`	`142`	`[Test]`
`116`	`143`	`public void Serialize_DoubleNaN_SerializesAsNull()`
`117`	`144`	`{`
`118`		`- Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", double.NaN } }));`
	`145`	`+ Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, double.NaN } }));`
`119`	`146`	`}`
`120`	`147`
`121`	`148`	`[Test]`
`122`	`149`	`public void Serialize_DoubleInfinity_SerializesAsNull()`
`123`	`150`	`{`
`124`		`- Assert.AreEqual("{\"v\":null}", Json.Serialize(new Dictionary<string, object> { { "v", double.PositiveInfinity } }));`
	`151`	`+ Assert.AreEqual($"{{\"{VShortFixture}\":null}}", Json.Serialize(new Dictionary<string, object> { { VShortFixture, double.PositiveInfinity } }));`
`125`	`152`	`}`
`126`	`153`
`127`	`154`	`[Test]`
`128`	`155`	`public void Serialize_FloatValue_NormalRange()`
`129`	`156`	`{`
`130`		`- var data = new Dictionary<string, object> { { "v", 3.14f } };`
	`157`	`+ var data = new Dictionary<string, object> { { VShortFixture, 3.14f } };`
`131`	`158`	`var result = Json.Serialize(data);`
`132`		`- StringAssert.Contains("\"v\":", result);`
`133`		`- StringAssert.DoesNotContain("\"v\":\"", result); // must not be quoted`
	`159`	`+ StringAssert.Contains($"\"{VShortFixture}\":", result);`
	`160`	`+ StringAssert.DoesNotContain($"\"{VShortFixture}\":\"", result);`
`134`	`161`	`}`
`135`	`162`
`136`	`163`	`[Test]`
`137`	`164`	`public void Serialize_FloatValue_LargeExponent_PreservesValue()`
`138`	`165`	`{`
`139`	`166`	`// 1e30f in scientific notation is valid JSON; must not be silently zeroed`
`140`		`- var data = new Dictionary<string, object> { { "v", 1e30f } };`
	`167`	`+ var data = new Dictionary<string, object> { { VShortFixture, 1e30f } };`
`141`	`168`	`var result = Json.Serialize(data);`
`142`	`169`	`var serialised = result.Substring(result.IndexOf(':') + 1, result.Length - result.IndexOf(':') - 2);`
`143`	`170`	`Assert.AreNotEqual("0", serialised);`
`@@ -148,7 +175,7 @@ public void Serialize_FloatValue_LargeExponent_PreservesValue()`
`148`	`175`	`public void Serialize_FloatValue_SmallNegativeExponent_PreservesValue()`
`149`	`176`	`{`
`150`	`177`	`// 1e-30f: the old F6 fallback turned this into "0.000000"`
`151`		`- var data = new Dictionary<string, object> { { "v", 1e-30f } };`
	`178`	`+ var data = new Dictionary<string, object> { { VShortFixture, 1e-30f } };`
`152`	`179`	`var result = Json.Serialize(data);`
`153`	`180`	`var serialised = result.Substring(result.IndexOf(':') + 1, result.Length - result.IndexOf(':') - 2);`
`154`	`181`	`Assert.AreNotEqual("0", serialised);`
`@@ -158,7 +185,7 @@ public void Serialize_FloatValue_SmallNegativeExponent_PreservesValue()`
`158`	`185`	`[Test]`
`159`	`186`	`public void Serialize_DoubleValue_SmallNegativeExponent_PreservesValue()`
`160`	`187`	`{`
`161`		`- var data = new Dictionary<string, object> { { "v", 1e-300 } };`
	`188`	`+ var data = new Dictionary<string, object> { { VShortFixture, 1e-300 } };`
`162`	`189`	`var result = Json.Serialize(data);`
`163`	`190`	`var serialised = result.Substring(result.IndexOf(':') + 1, result.Length - result.IndexOf(':') - 2);`
`164`	`191`	`Assert.AreNotEqual("0", serialised);`
`@@ -170,10 +197,10 @@ public void Serialize_ListValue_ReturnsJsonArray()`
`170`	`197`	`{`
`171`	`198`	`var data = new Dictionary<string, object>`
`172`	`199`	`{`
`173`		`- { "items", new List<object> { "a", 1, true } }`
	`200`	`+ { ArrayFixtureKey, new List<object> { TestEventNames.PlaceholderA, 1, true } }`
`174`	`201`	`};`
`175`	`202`
`176`		`- Assert.AreEqual("{\"items\":[\"a\",1,true]}", Json.Serialize(data));`
	`203`	`+ Assert.AreEqual($"{{\"{ArrayFixtureKey}\":[\"{TestEventNames.PlaceholderA}\",1,true]}}", Json.Serialize(data));`
`177`	`204`	`}`
`178`	`205`
`179`	`206`	`[Test]`
`@@ -187,22 +214,22 @@ public void Serialize_RealisticEventPayload_ProducesCorrectJson()`
`187`	`214`	`{ MessageFields.UserId, null },`
`188`	`215`	`{ MessageFields.Properties, new Dictionary<string, object>`
`189`	`216`	`{`
`190`		`- { "level", 5 },`
`191`		`- { "score", 9800L },`
`192`		`- { "perfect", true },`
`193`		`- { "tags", new List<object> { "fast", "clean" } }`
	`217`	`+ { PropLevelKey, 5 },`
	`218`	`+ { PropScoreKey, 9800L },`
	`219`	`+ { PropPerfectKey, true },`
	`220`	`+ { PropTagsKey, new List<object> { TagFastValue, TagCleanValue } }`
`194`	`221`	`}`
`195`	`222`	`}`
`196`	`223`	`};`
`197`	`224`
`198`	`225`	`var result = Json.Serialize(data);`
`199`	`226`
`200`	`227`	`StringAssert.Contains($"\"{MessageFields.Type}\":\"{MessageTypes.Track}\"", result);`
`201`		`- StringAssert.Contains($"\"{MessageFields.EventName}\":\"level_complete\"", result);`
	`228`	`+ StringAssert.Contains($"\"{MessageFields.EventName}\":\"{TestEventNames.LevelComplete}\"", result);`
`202`	`229`	`StringAssert.Contains($"\"{MessageFields.UserId}\":null", result);`
`203`		`- StringAssert.Contains("\"level\":5", result);`
`204`		`- StringAssert.Contains("\"perfect\":true", result);`
`205`		`- StringAssert.Contains("\"tags\":[\"fast\",\"clean\"]", result);`
	`230`	`+ StringAssert.Contains($"\"{PropLevelKey}\":5", result);`
	`231`	`+ StringAssert.Contains($"\"{PropPerfectKey}\":true", result);`
	`232`	`+ StringAssert.Contains($"\"{PropTagsKey}\":[\"{TagFastValue}\",\"{TagCleanValue}\"]", result);`
`206`	`233`	`}`
`207`	`234`
`208`	`235`	`[Test]`
`@@ -213,39 +240,39 @@ public void Serialize_NestingExceedsMaxDepth_ThrowsFormatException()`
`213`	`240`	`for (var i = 0; i < Json.MaxDepth; i++)`
`214`	`241`	`{`
`215`	`242`	`var next = new Dictionary<string, object>();`
`216`		`- current["next"] = next;`
	`243`	`+ current[DeepNestNextKey] = next;`
`217`	`244`	`current = next;`
`218`	`245`	`}`
`219`	`246`
`220`	`247`	`var ex = Assert.Throws<FormatException>(() => Json.Serialize(root));`
`221`		`- StringAssert.Contains("nesting exceeds", ex.Message);`
	`248`	`+ StringAssert.Contains(NestingExceedsErrorMarker, ex.Message);`
`222`	`249`	`}`
`223`	`250`
`224`	`251`	`[Test]`
`225`	`252`	`public void Serialize_SelfReferentialDict_ThrowsFormatException()`
`226`	`253`	`{`
`227`	`254`	`var root = new Dictionary<string, object>();`
`228`		`- root["self"] = root;`
	`255`	`+ root[SelfRefKey] = root;`
`229`	`256`
`230`	`257`	`var ex = Assert.Throws<FormatException>(() => Json.Serialize(root));`
`231`		`- StringAssert.Contains("cycle", ex.Message);`
	`258`	`+ StringAssert.Contains(CycleErrorMarker, ex.Message);`
`232`	`259`	`}`
`233`	`260`
`234`	`261`	`[Test]`
`235`	`262`	`public void Serialize_SharedChildInSiblingKeys_IsNotTreatedAsCycle()`
`236`	`263`	`{`
`237`	`264`	`// Diamond: visited set tracks the current recursion stack, not all objects ever seen.`
`238`		`- var shared = new Dictionary<string, object> { ["k"] = "v" };`
	`265`	`+ var shared = new Dictionary<string, object> { [DiamondInnerKey] = DiamondInnerValue };`
`239`	`266`	`var root = new Dictionary<string, object>`
`240`	`267`	`{`
`241`		`- ["a"] = shared,`
`242`		`- ["b"] = shared,`
	`268`	`+ [DiamondLeftKey] = shared,`
	`269`	`+ [DiamondRightKey] = shared,`
`243`	`270`	`};`
`244`	`271`
`245`	`272`	`var result = Json.Serialize(root);`
`246`	`273`
`247`		`- StringAssert.Contains("\"a\":{\"k\":\"v\"}", result);`
`248`		`- StringAssert.Contains("\"b\":{\"k\":\"v\"}", result);`
	`274`	`+ StringAssert.Contains($"\"{DiamondLeftKey}\":{{\"{DiamondInnerKey}\":\"{DiamondInnerValue}\"}}", result);`
	`275`	`+ StringAssert.Contains($"\"{DiamondRightKey}\":{{\"{DiamondInnerKey}\":\"{DiamondInnerValue}\"}}", result);`
`249`	`276`	`}`
`250`	`277`	`}`
`251`	`278`	`}`