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,146 @@
+using System;
+using System.IO;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using Unity.Pipeline.Console;
+using Unity.Pipeline.Editor.Commands;
+using Unity.Pipeline.Models;
+
+namespace Unity.Pipeline.Tests.Editor
+{
+    /// <summary>
+    /// Tests that the recompile status never claims a clean state while compile errors stand. The
+    /// status file lives under Temp/, which Unity deletes at every editor launch, and a failed
+    /// editor compile suppresses the domain reload that would rewrite it — so the file alone is not
+    /// enough and the native compile-failure flag has to win.
+    ///
+    /// No test triggers a real compile: the flag is read through an injected probe, and the ground
+    /// truth the status overlays is set directly.
+    /// </summary>
+    class RecompileStatusTests
+    {
+        const string StatusFile = "Temp/pipeline_recompile_status.json";
+
+        ConsoleGroundTruth m_PreviousTruth;
+        Func<bool> m_PreviousProbe;
+        string m_PreviousStatus;
+
+        [SetUp]
+        public void SetUp()
+        {
+            m_PreviousTruth = ConsoleLogCapture.GroundTruth;
+            m_PreviousProbe = RecompileCommand.s_CompilationFailedProbe;
+            m_PreviousStatus = File.Exists(StatusFile) ? File.ReadAllText(StatusFile) : null;
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            ConsoleLogCapture.GroundTruth = m_PreviousTruth;
+            RecompileCommand.s_CompilationFailedProbe = m_PreviousProbe;
+
+            if (m_PreviousStatus != null)
+                File.WriteAllText(StatusFile, m_PreviousStatus);
+            else if (File.Exists(StatusFile))
+                File.Delete(StatusFile);
+        }
+
+        [Test]
+        public void RecompileStatus_ReportsFailedWhenGroundTruthSaysCompilationFailed()
+        {
+            // "idle" is what the file reads after an editor restart, since Temp/ is deleted.
+            WriteStatus("idle", false);
+            ConsoleLogCapture.GroundTruth = Sample(compilationFailed: true);
+
+            var status = JObject.Parse(RecompileCommand.RecompileStatus());
+
+            Assert.IsTrue(status["failed"].ToObject<bool>(), "The native flag must win over a stale status file");
+            Assert.IsTrue(status["compilationFailed"].ToObject<bool>());
+            Assert.AreEqual("completed", status["status"].ToString());
+        }
+
+        [Test]
+        public void RecompileStatus_DoesNotOverrideCompletedWithTheNativeFlag()
+        {
+            // The native flag still reads true for a moment after a fixing compile finishes; it
+            // clears with the domain reload that follows. A "completed" status lists what the compile
+            // that just ran actually produced, so it wins.
+            WriteStatus("completed", false);
+            ConsoleLogCapture.GroundTruth = Sample(compilationFailed: true);
+
+            var status = JObject.Parse(RecompileCommand.RecompileStatus());
+
+            Assert.IsFalse(status["failed"].ToObject<bool>(),
+                "A build that has just been fixed must not be reported as broken");
+            Assert.AreEqual("completed", status["status"].ToString());
+            Assert.IsTrue(status["compilationFailed"].ToObject<bool>(),
+                "The flag is still reported, so a client can see the disagreement");
+        }
+
+        [Test]
+        public void RecompileStatus_LeavesCleanStatusAloneWhenCompilationSucceeded()
+        {
+            WriteStatus("up_to_date", false);
+            ConsoleLogCapture.GroundTruth = Sample(compilationFailed: false);
+
+            var status = JObject.Parse(RecompileCommand.RecompileStatus());
+
+            Assert.IsFalse(status["failed"].ToObject<bool>());
+            Assert.IsFalse(status["compilationFailed"].ToObject<bool>());
+            Assert.AreEqual("up_to_date", status["status"].ToString());
+        }
+
+        [Test]
+        public void Recompile_DoesNotOverwriteFailedWithUpToDate()
+        {
+            // The reported symptom: a repeat recompile with nothing changed compiles nothing, and
+            // "up_to_date" used to erase the failure that was still true.
+            WriteStatus("completed", true, "Assets/Broken.cs(1,1): error CS1002: ; expected");
+            RecompileCommand.s_CompilationFailedProbe = () => true;
+
+            var result = RecompileCommand.Recompile();
+
+            Assert.AreEqual("failed", result.GetType().GetProperty("status").GetValue(result));
+
+            var status = JObject.Parse(RecompileCommand.RecompileStatus());
+            Assert.IsTrue(status["failed"].ToObject<bool>(), "The recorded failure must survive a no-op recompile");
+            Assert.That(status["errors"].ToObject<string[]>(), Has.Exactly(1).Contains("CS1002"),
+                "The errors from the failed compile must survive too");
+        }
+
+        [Test]
+        public void RecompileStatus_IgnoresStaleGroundTruth()
+        {
+            // Sampling stops while the Editor is blocked, so an old sample says nothing about now.
+            WriteStatus("idle", false);
+            ConsoleLogCapture.GroundTruth = new ConsoleGroundTruth
+            {
+                CompilationFailed = true,
+                SampledUtc = DateTime.UtcNow.AddSeconds(-30)
+            };
+
+            var status = JObject.Parse(RecompileCommand.RecompileStatus());
+
+            Assert.IsFalse(status["failed"].ToObject<bool>(),
+                "A stale sample must not report a build that has just been fixed as broken");
+            Assert.IsFalse(status["compilationFailed"].ToObject<bool>());
+        }
+
+        static ConsoleGroundTruth Sample(bool compilationFailed) => new ConsoleGroundTruth
+        {
+            CompilationFailed = compilationFailed,
+            SampledUtc = DateTime.UtcNow
+        };
+
+        static void WriteStatus(string status, bool failed, params string[] errors)
+        {
+            Directory.CreateDirectory("Temp");
+            File.WriteAllText(StatusFile, new JObject
+            {
+                ["status"] = status,
+                ["failed"] = failed,
+                ["errors"] = new JArray(errors)
+            }.ToString());
+        }
+    }
+}