test(audience-sdk,sample): unity-only DeviceCollector and UXML alignment drafts

Two Unity-only test fixtures the dotnet test runner cannot reach (DeviceCollector depends on
UnityEngine.SystemInfo / Application; SampleAppUxml needs Unity test framework gating). Both run
under the Unity Test Framework once the project is opened in the editor.

DeviceCollectorTests (src/Packages/Audience/Tests/Editor/, excluded from the headless dotnet build
by Audience.Tests.csproj's Compile Remove="Editor/**/*.cs" rule) pin DeviceCollector's emitted key
sets against GameLaunchPropertyKeys and ContextKeys, assert that no unknown keys leak in either
direction, and verify every string-typed value is capped at Constants.MaxFieldLength.

SampleAppUxmlAlignmentTests (examples/audience/Assets/SampleApp/Tests/ Runtime/, gated by the
existing UNITY_INCLUDE_TESTS define on the SampleApp.Tests asmdef) reads
Resources/AudienceSample.uxml as XML and asserts every SampleAppUi name and Css constant that is
slug-shaped (lowercase / dashes / no spaces) appears as a name= or class= attribute somewhere in the
markup. Runtime-only CSS toggles (state-warn, copied, narrow, has-value, etc.) are filtered by the
slug-shape heuristic so the test only flags constants that look like they should map directly to
UXML.

Both files compile cleanly. They will not run under dotnet test. Run them via Unity Test Runner.

Follow-up to SDK-272 (centralisation of duplicated literals).

Author: ImmutableJeffrey

src/Packages/Audience/Runtime/AssemblyInfo.cs

@@ -1,6 +1,7 @@
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("Immutable.Audience.Runtime.Tests")]
+[assembly: InternalsVisibleTo("Immutable.Audience.Editor.Tests")]
 [assembly: InternalsVisibleTo("Immutable.Audience.Unity")]
 
 // First-party SampleApp reaches Json.Serialize and

src/Packages/Audience/Runtime/Unity/AssemblyInfo.cs

@@ -0,0 +1,4 @@
+using System.Runtime.CompilerServices;
+
+// Editor-only test fixture for DeviceCollector reads internals of this assembly.
+[assembly: InternalsVisibleTo("Immutable.Audience.Editor.Tests")]

src/Packages/Audience/Runtime/Unity/AssemblyInfo.cs.meta

@@ -0,0 +1,113 @@
+#nullable enable
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using Immutable.Audience.Unity;
+
+namespace Immutable.Audience.Tests.Editor
+{
+    // Editor-only (DeviceCollector needs a Unity domain; skipped by the headless dotnet build).
+    // Pins emitted payload keys against GameLaunchPropertyKeys and ContextKeys.
+    [TestFixture]
+    internal class DeviceCollectorTests
+    {
+        [Test]
+        public void CollectGameLaunchProperties_EmitsTheExpectedKeySet()
+        {
+            var props = DeviceCollector.CollectGameLaunchProperties();
+
+            // Always-present keys. ScreenDpi is conditional (0 on some Linux WMs).
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.Platform);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.Version);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.BuildGuid);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.UnityVersion);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.OsFamily);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.DeviceModel);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.Gpu);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.GpuVendor);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.Cpu);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.CpuCores);
+            CollectionAssert.Contains(props.Keys, GameLaunchPropertyKeys.RamMb);
+        }
+
+        [Test]
+        public void CollectGameLaunchProperties_EmitsNoUnknownKeys()
+        {
+            // Confirms the payload only carries known GameLaunchPropertyKeys entries.
+            var allowed = new HashSet<string>
+            {
+                GameLaunchPropertyKeys.Platform,
+                GameLaunchPropertyKeys.Version,
+                GameLaunchPropertyKeys.BuildGuid,
+                GameLaunchPropertyKeys.UnityVersion,
+                GameLaunchPropertyKeys.OsFamily,
+                GameLaunchPropertyKeys.DeviceModel,
+                GameLaunchPropertyKeys.Gpu,
+                GameLaunchPropertyKeys.GpuVendor,
+                GameLaunchPropertyKeys.Cpu,
+                GameLaunchPropertyKeys.CpuCores,
+                GameLaunchPropertyKeys.RamMb,
+                GameLaunchPropertyKeys.ScreenDpi,
+            };
+
+            var props = DeviceCollector.CollectGameLaunchProperties();
+            foreach (var key in props.Keys)
+                Assert.IsTrue(allowed.Contains(key),
+                    $"DeviceCollector.CollectGameLaunchProperties emitted unknown key '{key}' "
+                    + "with no matching GameLaunchPropertyKeys constant");
+        }
+
+        [Test]
+        public void CollectGameLaunchProperties_TruncatesStringValuesToMaxFieldLength()
+        {
+            // Every string value respects MaxFieldLength; an untruncated .ToString() would fail here.
+            var props = DeviceCollector.CollectGameLaunchProperties();
+            foreach (var kv in props)
+            {
+                if (kv.Value is string s)
+                    Assert.LessOrEqual(s.Length, Constants.MaxFieldLength,
+                        $"GameLaunchPropertyKeys.{kv.Key} value exceeds Constants.MaxFieldLength");
+            }
+        }
+
+        [Test]
+        public void CollectContext_EmitsTheExpectedKeySet()
+        {
+            var ctx = DeviceCollector.CollectContext();
+
+            // UserAgent is unconditional. Timezone / Locale / Screen are
+            // best-effort and may be absent under unusual hosts.
+            CollectionAssert.Contains(ctx.Keys, ContextKeys.UserAgent);
+        }
+
+        [Test]
+        public void CollectContext_EmitsNoUnknownKeys()
+        {
+            var allowed = new HashSet<string>
+            {
+                ContextKeys.UserAgent,
+                ContextKeys.Timezone,
+                ContextKeys.Locale,
+                ContextKeys.Screen,
+            };
+
+            var ctx = DeviceCollector.CollectContext();
+            foreach (var key in ctx.Keys)
+                Assert.IsTrue(allowed.Contains(key),
+                    $"DeviceCollector.CollectContext emitted unknown key '{key}' "
+                    + "with no matching ContextKeys constant");
+        }
+
+        [Test]
+        public void CollectContext_TruncatesStringValuesToMaxFieldLength()
+        {
+            var ctx = DeviceCollector.CollectContext();
+            foreach (var kv in ctx)
+            {
+                if (kv.Value is string s)
+                    Assert.LessOrEqual(s.Length, Constants.MaxFieldLength,
+                        $"ContextKeys.{kv.Key} value exceeds Constants.MaxFieldLength");
+            }
+        }
+    }
+}

src/Packages/Audience/Tests/Editor/DeviceCollectorTests.cs

@@ -0,0 +1,19 @@
+{
+    "name": "Immutable.Audience.Editor.Tests",
+    "rootNamespace": "Immutable.Audience.Tests.Editor",
+    "references": [
+        "Immutable.Audience.Runtime",
+        "Immutable.Audience.Unity",
+        "UnityEditor.TestRunner",
+        "UnityEngine.TestRunner"
+    ],
+    "includePlatforms": ["Editor"],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": ["nunit.framework.dll"],
+    "autoReferenced": false,
+    "defineConstraints": ["UNITY_INCLUDE_TESTS"],
+    "versionDefines": [],
+    "noEngineReferences": false
+}