Initial commit: AIGame Unity client with URP, HybridCLR, YooAsset and tooling.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-21 14:21:07 +08:00
commit f3f66ab063
931 changed files with 112366 additions and 0 deletions
@@ -0,0 +1,114 @@
+using NUnit.Framework;
+using Unity.Pipeline.Editor.Commands;
+
+namespace Unity.Pipeline.Tests.Editor
+{
+    /// <summary>
+    /// Tests for auto-tick's SessionState persistence across (simulated) domain reloads.
+    /// The live editor's own server may already have auto-tick enabled, so SetUp/TearDown save and
+    /// restore whatever state was live before each test instead of assuming it starts off.
+    /// </summary>
+    class AutoTickCommandTests
+    {
+        private bool m_PrevEnabled;
+        private long m_PrevIntervalMs;
+        private bool m_HadPersisted;
+        private bool m_PrevPersistedEnabled;
+        private long m_PrevPersistedIntervalMs;
+
+        [SetUp]
+        public void SetUp()
+        {
+            m_PrevEnabled = AutoTickCommand.IsEnabled;
+            m_PrevIntervalMs = AutoTickCommand.CurrentIntervalMs;
+            m_HadPersisted = AutoTickCommand.TryGetPersistedSessionForTests(out m_PrevPersistedEnabled, out m_PrevPersistedIntervalMs);
+            AutoTickCommand.EraseSessionForTests();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            // persist:false so this only restores the live in-memory state, not SessionState -
+            // the persisted baseline (or lack thereof) is restored/erased separately below.
+            AutoTickCommand.SetAutoTick(m_PrevEnabled, (int)m_PrevIntervalMs, persist: false);
+
+            if (m_HadPersisted)
+                AutoTickCommand.SetPersistedSessionForTests(m_PrevPersistedEnabled, m_PrevPersistedIntervalMs);
+            else
+                AutoTickCommand.EraseSessionForTests();
+        }
+
+        [TestCase(true, 5)]
+        [TestCase(true, 250)]
+        [TestCase(false, 40)]
+        public void RestoreFromSession_AfterSimulatedReload_RestoresExactPriorState(bool enable, int intervalMs)
+        {
+            AutoTickCommand.SetAutoTick(enable, intervalMs);
+
+            // A domain reload clears the statics (and the update-loop subscription with them) but
+            // leaves the SessionState copy this call just wrote intact.
+            AutoTickCommand.ResetForTests();
+
+            // Pass the opposite of the persisted value as the default, so a passing assertion proves
+            // the persisted state won, not the default falling through by coincidence.
+            AutoTickCommand.RestoreFromSession(defaultEnabled: !enable);
+
+            Assert.AreEqual(enable, AutoTickCommand.IsEnabled,
+                "Restore must bring back the exact enabled state set via SetAutoTick, not the startup default.");
+            if (enable)
+            {
+                Assert.AreEqual(intervalMs, AutoTickCommand.CurrentIntervalMs,
+                    "Restore must bring back the exact interval set via SetAutoTick, not the default interval.");
+            }
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void RestoreFromSession_NoPriorExplicitCallThisSession_AppliesDefault(bool defaultEnabled)
+        {
+            // SetUp already erased SessionState and this simulates a reload on top of that, so there
+            // is no persisted choice for RestoreFromSession to find.
+            AutoTickCommand.ResetForTests();
+
+            AutoTickCommand.RestoreFromSession(defaultEnabled);
+
+            Assert.AreEqual(defaultEnabled, AutoTickCommand.IsEnabled);
+            if (defaultEnabled)
+            {
+                Assert.AreEqual(AutoTickCommand.DefaultIntervalMs, AutoTickCommand.CurrentIntervalMs,
+                    "With no explicit prior choice, restoring 'enabled' must use the default interval.");
+            }
+        }
+
+        [Test]
+        public void SetAutoTick_WithPersistFalse_RevertsToPriorPersistedBaselineAfterSimulatedReload()
+        {
+            // Establish a persisted baseline, as if the user had configured a normal auto-tick rate.
+            AutoTickCommand.SetAutoTick(true, 200);
+
+            // A temporary, expensive override (interval_ms=0 pegs a CPU core) that must not overwrite
+            // the baseline above.
+            AutoTickCommand.SetAutoTick(true, 0, persist: false);
+            Assert.AreEqual(0, AutoTickCommand.CurrentIntervalMs, "The temporary override should still apply immediately.");
+
+            AutoTickCommand.ResetForTests();
+            AutoTickCommand.RestoreFromSession(defaultEnabled: false);
+
+            Assert.AreEqual(200, AutoTickCommand.CurrentIntervalMs,
+                "persist:false must not clobber the previously persisted baseline.");
+        }
+
+        [Test]
+        public void SetAutoTick_WithPersistFalse_NoPriorBaseline_DoesNotSurviveSimulatedReload()
+        {
+            AutoTickCommand.SetAutoTick(true, 0, persist: false);
+            Assert.IsTrue(AutoTickCommand.IsEnabled);
+
+            AutoTickCommand.ResetForTests();
+            AutoTickCommand.RestoreFromSession(defaultEnabled: false);
+
+            Assert.IsFalse(AutoTickCommand.IsEnabled,
+                "With no persisted baseline, a session-only (persist:false) call must not survive a reload.");
+        }
+    }
+}