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,127 @@
+using System.IO;
+using System.Reflection;
+using NUnit.Framework;
+using Unity.Pipeline.Compilation;
+using Unity.Pipeline.CodeReload;
+
+namespace Unity.Pipeline.Tests.Editor
+{
+    /// <summary>
+    /// Tests for CodeReloadCompiler's cleanup of versioned code reload assemblies.
+    /// </summary>
+    class CodeReloadCompilerTests
+    {
+        private string testAssemblyDir;
+
+        [SetUp]
+        public void SetUp()
+        {
+            // Keep test files OUTSIDE Assets/ (project-root Temp/, which Unity ignores) so the
+            // editor never imports them — an import triggers a domain reload that tears down the
+            // live pipeline server.
+            testAssemblyDir = Path.GetFullPath(Path.Combine("Temp", "PipelineCodeReloadTests", "CompilerTests"));
+            Directory.CreateDirectory(testAssemblyDir);
+
+            // Clear code reload state
+            CodeReloadRegistry.ClearAllForTesting();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            // Clean up test files
+            if (Directory.Exists(testAssemblyDir))
+            {
+                Directory.Delete(testAssemblyDir, true);
+            }
+
+            // Clean up code reload state and temp files
+            CodeReloadRegistry.ClearAllForTesting();
+            CodeReloadCompiler.CleanupCodeReloadDlls();
+        }
+
+        [Test]
+        public void CleanupCodeReloadDlls_WithNoFiles_SucceedsGracefully()
+        {
+            // Act
+            var result = CodeReloadCompiler.CleanupCodeReloadDlls();
+
+            // Assert
+            Assert.IsTrue(result.Success, "Cleanup should succeed even when no files exist");
+            Assert.AreEqual(0, result.DeletedFiles.Count, "Should not delete any files");
+            Assert.That(result.Message, Does.Contain("No code reload directory").Or.Contain("0 old DLL versions"));
+        }
+
+        [Test]
+        public void CleanupCodeReloadDlls_WithVersionedDlls_KeepsOnlyLatestVersion()
+        {
+            // Arrange - three versions of one assembly, plus an unversioned DLL cleanup must leave alone
+            var v1 = Path.Combine(testAssemblyDir, "Sample_001.dll");
+            var v2 = Path.Combine(testAssemblyDir, "Sample_002.dll");
+            var v3 = Path.Combine(testAssemblyDir, "Sample_003.dll");
+            var unversioned = Path.Combine(testAssemblyDir, "Plain.dll");
+            File.WriteAllText(v1, "fake dll v1");
+            File.WriteAllText(v2, "fake dll v2");
+            File.WriteAllText(v3, "fake dll v3");
+            File.WriteAllText(unversioned, "fake dll");
+
+            // Act
+            var result = CodeReloadCompiler.CleanupCodeReloadDlls(testAssemblyDir);
+
+            // Assert
+            Assert.IsTrue(result.Success, $"Cleanup should succeed. Message: {result.Message}");
+            Assert.GreaterOrEqual(result.ExecutionTimeMs, 0, "Should record execution time (0ms is acceptable for fast cleanup)");
+            Assert.IsFalse(File.Exists(v1), "Version 001 should be deleted");
+            Assert.IsFalse(File.Exists(v2), "Version 002 should be deleted");
+            Assert.IsTrue(File.Exists(v3), "Latest version should be kept");
+            Assert.IsTrue(File.Exists(unversioned), "Unversioned DLLs should be left alone");
+            CollectionAssert.AreEquivalent(new[] { "Sample_001.dll", "Sample_002.dll" }, result.DeletedFiles);
+        }
+
+        [Test]
+        public void CleanupCodeReloadDlls_WithActiveOverrides_ClearsRegistry()
+        {
+            // Arrange - register a reloadable target and an override for it
+            var target = typeof(CleanupTarget).GetMethod(nameof(CleanupTarget.Tick));
+            CodeReloadRegistry.RegisterReloadableMethod(target, new CodeReloadAttribute { Id = "CleanupTarget.Tick" });
+
+            var overrideMethod = typeof(CleanupOverrides).GetMethod(nameof(CleanupOverrides.Tick));
+            var overrideAttribute = overrideMethod.GetCustomAttribute<CodeReloadOverrideMethodAttribute>();
+            Assert.IsTrue(CodeReloadRegistry.RegisterMethodOverride(overrideMethod, overrideAttribute, typeof(CleanupOverrides)),
+                "Override should register against the reloadable target");
+            Assert.Greater(CodeReloadRegistry.GetStats().ActiveOverrideCount, 0, "Precondition: an override is active");
+
+            // Act
+            var result = CodeReloadCompiler.CleanupCodeReloadDlls(testAssemblyDir);
+
+            // Assert
+            Assert.IsTrue(result.Success, $"Cleanup should succeed. Message: {result.Message}");
+            Assert.AreEqual(0, CodeReloadRegistry.GetStats().ActiveOverrideCount, "Registry should be cleared after cleanup");
+        }
+
+        /// <summary>
+        /// Target whose method the cleanup test registers as reloadable.
+        /// </summary>
+        public class CleanupTarget
+        {
+            public int value;
+
+            public void Tick()
+            {
+                value = 42;
+            }
+        }
+
+        /// <summary>
+        /// Override for <see cref="CleanupTarget.Tick"/>, in the shape the reload pipeline generates.
+        /// </summary>
+        public static class CleanupOverrides
+        {
+            [CodeReloadOverrideMethod("CleanupTarget.Tick")]
+            public static void Tick(CleanupTarget instance)
+            {
+                instance.value = 99;
+            }
+        }
+    }
+}