com.valectric.mooserunner 2.1.4

package/Samples~/Demos/MooseRunner.Demo.Tests/DummyTestClass1.cs

@@ -0,0 +1,301 @@
+using System;
+using System.Collections;
+using System.IO;
+using System.Reflection;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using MooseRunner.Multiplaytest;
+
+using System.Linq;
+using System.Runtime.CompilerServices;
+
+using System.Xml;
+using UnityEngine.SceneManagement;
+
+namespace MooseRunner.Internal.Tests
+{
+    public class DummyTestClass1 : DummyTestBase1
+    {
+        /// <summary>
+        /// Sets up the test environment before any test is executed.
+        /// Ensures that the "OneCameraScene" is created with a camera. 
+        /// If the scene does not exist, it creates a new scene with a camera, 
+        /// unloads all other scenes, and makes the new scene active.
+        /// </summary>
+        /// <returns>An enumerator for the asynchronous setup process.</returns>
+
+        [OneTimeSetUp]
+        public new async Task SetUpOnce()
+        {
+            await MooseRunnerFacade.Instance.LoadSceneFromNameAsync("OneCameraScene");
+        }
+
+        // Regular setup, called before each individual test
+        [SetUp]
+        public IEnumerator SetUp()
+        {
+            Debug.Log("DummyTestClass1 SetUp: Called before each test.");
+    
+            // Pause for 500ms
+            yield return new WaitForSeconds(0.5f); // 500ms pause
+        }
+
+        // Dummy test that runs synchronously
+        [Test]
+        public new void SyncTest()
+        {
+            Debug.Log("DummyTestClass1 SyncTest: This is a synchronous test.");
+            ExtractMooseRunnerMethodsWithCommentsToFile();  //Just to help when generating base draft using chatGPT.
+            MessageDisplayManager.Instance.ShowMessage("DummyTestClass1 SyncTest");
+            Assert.IsTrue(true); // Dummy assertion
+        }
+
+        // Dummy test that runs asynchronously (PlayMode)
+        [UnityTest]
+        public IEnumerator CoroutineTest()
+        {
+            Debug.Log("DummyTestClass1 CoroutineTest: This is an coroutine test.");
+            for (int i = 0; i < 20; i++)
+            {
+                MessageDisplayManager.Instance.ShowMessage("DummyTestClass1 CoroutineTest wait for " + (20 - i).ToString());
+                yield return new WaitForSeconds(1); // Simulate some asynchronous behavior
+            }
+            MessageDisplayManager.Instance.ShowMessage("DummyTestClass1 CoroutineTest wait for 0");
+            Assert.IsTrue(true); // Dummy assertion
+        }
+
+        // Regular teardown, called after each individual test
+        [TearDown]
+        public void TearDown()
+        {
+            Debug.Log("DummyTestClass1 TearDown: Called after each test.");
+        }
+
+        // One-time teardown, called once after all tests in this class
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+            Debug.Log("DummyTestClass1 OneTimeTearDown: Called once after all tests.");
+        }
+
+        #region REAL_TEST_METHODS
+        // Real test methods go here
+
+        private const int _simulatedRuntimeInGameSeconds = 10; // Simulated duration in game seconds
+        private int _fixedUpdateCount;
+        private float _totalRealTimeElapsed;
+        private float _maxFixedUpdateTime;
+
+        /// <summary>
+        /// Unit test that runs a coroutine to measure real-world time and count FixedUpdate calls,
+        /// waiting for a duration affected by Time.timeScale and ensuring no missed frames.
+        /// </summary>
+        /// <returns>IEnumerator for the Unity test runner.</returns>
+        [UnityTest]
+        public IEnumerator MeasureFixedUpdatePerformance()
+        {
+            MessageDisplayManager.Instance.ShowMessage("MeasureFixedUpdatePerformance start");
+            // Initialize variables
+            _fixedUpdateCount = 0;
+            _totalRealTimeElapsed = 0.0f;
+            _maxFixedUpdateTime = 0.0f;
+
+            // Create a GameObject to attach FixedUpdate counting behavior
+            var testObject = new GameObject("TestObject");
+            testObject.AddComponent<FixedUpdateCounter>().Initialize(this);
+
+            // Record the starting real-world time
+            float startTime = Time.realtimeSinceStartup;
+
+            Debug.Log("Timescale: " + Time.timeScale + " SimulatedRuntimeInGameSeconds: " + _simulatedRuntimeInGameSeconds);
+
+            // Wait for the specified duration in game time (affected by Time.timeScale)
+            for (int i = 0; i < _simulatedRuntimeInGameSeconds; i++)
+            {
+                MessageDisplayManager.Instance.ShowMessage("MeasureFixedUpdatePerformance wait for " + (_simulatedRuntimeInGameSeconds - i).ToString());
+                yield return new WaitForSeconds(1);
+            }
+            MessageDisplayManager.Instance.ShowMessage("MeasureFixedUpdatePerformance wait for 0");
+
+            Debug.Log("Wait done");
+
+            // Calculate the total real-world time elapsed
+            _totalRealTimeElapsed = Time.realtimeSinceStartup - startTime;
+
+            // Calculate the expected number of FixedUpdate calls
+            int expectedFixedUpdates = Mathf.CeilToInt(_simulatedRuntimeInGameSeconds / 0.02f); // Simulated time divided by 0.02s per FixedUpdate
+
+            // Clean up
+            GameObject.Destroy(testObject);
+
+            // Assertion 1: Check if the number of FixedUpdate calls is within an acceptable range
+            Assert.IsTrue(
+                Mathf.Abs(_fixedUpdateCount - expectedFixedUpdates) <= 60,
+                $"Expected approximately {expectedFixedUpdates} FixedUpdate calls, but got {_fixedUpdateCount}."
+            );
+            
+            // Assertion 2: Check if the total real-world time is within the expected scaled-down time range
+            float expectedRealTime = _simulatedRuntimeInGameSeconds / Time.timeScale;
+            Assert.IsTrue(
+                Mathf.Abs(_totalRealTimeElapsed - expectedRealTime) < 0.8f, // Allow a small margin of error
+                $"The real-world time elapsed ({_totalRealTimeElapsed:F2} seconds) should be close to the expected scaled time ({expectedRealTime:F2} seconds)."
+            );
+
+
+            //Assertion 3: Check if the max delta time is bigger that the default value + 30% to see in any frame is missed.
+            Assert.IsTrue(
+                _maxFixedUpdateTime <= 0.02f * 1.3f,
+                $"The maximum FixedUpdate delta time ({_maxFixedUpdateTime:F4} seconds) should not exceed 30% more than the default FixedUpdate time (0.02 seconds)."
+            );
+
+
+            Debug.Log("maxFixedUpdateTime: " + _maxFixedUpdateTime);
+
+
+        }
+
+
+        public static void ExtractMooseRunnerMethodsWithCommentsToFile()
+        {
+            string outputFilePath = "FilteredMooseRunnerMethodsWithComments.txt";
+            Assembly[] allAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+            using (var writer = new StreamWriter(outputFilePath, false))
+            {
+                foreach (Assembly asm in allAssemblies)
+                {
+                    string asmName = asm.GetName().Name;
+                    if (!asmName.StartsWith("MooseRunner", StringComparison.OrdinalIgnoreCase))
+                    {
+                        continue;
+                    }
+
+                    writer.WriteLine($"Assembly: {asmName}");
+
+                    Type[] allTypes;
+                    try
+                    {
+                        allTypes = asm.GetTypes();
+                    }
+                    catch (ReflectionTypeLoadException e)
+                    {
+                        allTypes = e.Types.Where(t => t != null).ToArray();
+                    }
+
+                    foreach (Type t in allTypes)
+                    {
+                        if (t.IsDefined(typeof(CompilerGeneratedAttribute), true) || t.FullName.Contains("<") || t.FullName.Contains("Private"))
+                        {
+                            continue; // Skip compiler-generated and private implementation classes
+                        }
+
+                        writer.WriteLine($"\tClass: {t.FullName}");
+                        string classComment = GetXmlDocumentationForType(t);
+                        if (!string.IsNullOrWhiteSpace(classComment))
+                        {
+                            writer.WriteLine($"\t\tComment: {classComment.Trim()}");
+                        }
+
+                        var methods = t.GetMethods(
+                            BindingFlags.Public | BindingFlags.NonPublic |
+                            BindingFlags.Instance | BindingFlags.Static);
+
+                        foreach (MethodInfo m in methods)
+                        {
+                            if (m.IsDefined(typeof(CompilerGeneratedAttribute), true) || IsSystemMethod(m))
+                            {
+                                continue; // Skip compiler-generated and system methods
+                            }
+
+                            writer.WriteLine($"\t\tMethod: {m.Name}");
+                            string methodComment = GetXmlDocumentationForMethod(m);
+                            if (!string.IsNullOrWhiteSpace(methodComment))
+                            {
+                                writer.WriteLine($"\t\t\tComment: {methodComment.Trim()}");
+                            }
+                        }
+                    }
+
+                    writer.WriteLine();
+                }
+            }
+
+            Debug.Log($"Filtered MooseRunner methods with comments have been written to: {outputFilePath}");
+        }
+
+        /// <summary>
+        /// Determines if a method is system-generated or framework-related.
+        /// </summary>
+        private static bool IsSystemMethod(MethodInfo method)
+        {
+            var systemNamespaces = new[] { "System", "UnityEngine", "Microsoft", "Mono" };
+            return systemNamespaces.Any(ns => method.DeclaringType?.Namespace?.StartsWith(ns) == true) ||
+                   method.Name.StartsWith("get_") || method.Name.StartsWith("set_") || method.Name.StartsWith("add_") ||
+                   method.Name.StartsWith("remove_") || method.Name.StartsWith("op_");
+        }
+
+        /// <summary>
+        /// Retrieves XML documentation for a class (type).
+        /// </summary>
+        private static string GetXmlDocumentationForType(Type type)
+        {
+            return type.GetCustomAttributes<DocumentationAttribute>()?.FirstOrDefault()?.Documentation ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Retrieves XML documentation for a method.
+        /// </summary>
+        private static string GetXmlDocumentationForMethod(MethodInfo method)
+        {
+            return method.GetCustomAttributes<DocumentationAttribute>()?.FirstOrDefault()?.Documentation ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Example attribute for holding XML documentation (simulates IntelliSense-like comments).
+        /// </summary>
+        [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
+        sealed class DocumentationAttribute : Attribute
+        {
+            public string Documentation { get; }
+            public DocumentationAttribute(string documentation)
+            {
+                Documentation = documentation;
+            }
+        }
+
+
+
+
+
+
+        /// <summary>
+        /// Helper class to count FixedUpdate calls and simulate real-world time.
+        /// </summary>
+        private class FixedUpdateCounter : MonoBehaviour
+        {
+            private DummyTestClass1 parent;
+
+            public void Initialize(DummyTestClass1 parent)
+            {
+                this.parent = parent;
+            }
+
+            void FixedUpdate()
+            {
+                if (parent == null) {
+                    Destroy(gameObject); //If disconected destroy itself.
+                    return;
+                }
+                parent._fixedUpdateCount++;
+                if (Time.deltaTime > parent._maxFixedUpdateTime)
+                {
+                    parent._maxFixedUpdateTime = Time.deltaTime;
+                }
+
+            }
+        }
+        #endregion REAL_TEST_METHODS
+    }
+}

package/Samples~/Demos/MooseRunner.Demo.Tests/DummyTestClass1.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dbd74b7835b241743a3b7774a9895d5a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Samples~/Demos/MooseRunner.Demo.Tests/DummyTestClass2.cs

@@ -0,0 +1,69 @@
+using System.Collections;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using UnityEngine.TestTools;
+using MooseRunner.Multiplaytest;
+
+
+namespace MooseRunner.Internal.Tests
+{
+    public class DummyTestClass2
+    {
+        /// <summary>
+        /// Sets up the test environment before any test is executed.
+        /// Ensures that the "OneCameraScene" is created with a camera. 
+        /// If the scene does not exist, it creates a new scene with a camera, 
+        /// unloads all other scenes, and makes the new scene active.
+        /// </summary>
+        /// <returns>An enumerator for the asynchronous setup process.</returns>
+
+        [OneTimeSetUp]
+        public async Task SetUpOnce()
+        {
+            await MooseRunnerFacade.Instance.LoadSceneFromNameAsync("OneCameraScene");
+        }
+
+        // Regular setup, called before each individual test
+        [SetUp]
+        public void SetUp()
+        {
+            Debug.Log("DummyTestClass2 SetUp: Called before each test.");
+        }
+
+        // Dummy test that runs synchronously
+        [Test]
+        public void SyncTest()
+        {
+            Debug.Log("DummyTestClass2 SyncTest: This is a synchronous test.");
+            MessageDisplayManager.Instance.ShowMessage("DummyTestClass2 SyncTest");
+            Assert.IsTrue(true); // Dummy assertion
+        }
+
+        // Dummy test that runs asynchronously (PlayMode)
+        [UnityTest]
+        public IEnumerator CoroutineTest()
+        {
+            Debug.Log("DummyTestClass2 CoroutineTest: This is an coroutine test.");
+            MessageDisplayManager.Instance.ShowMessage("DummyTestClass2 Coroutine wait for 1");
+            yield return new WaitForSeconds(1); // Simulate some asynchronous behavior
+            MessageDisplayManager.Instance.ShowMessage("DummyTestClass2 Coroutine wait for 0");
+            Assert.IsTrue(true); // Dummy assertion
+        }
+
+        // Regular teardown, called after each individual test
+        [TearDown]
+        public void TearDown()
+        {
+            Debug.Log("DummyTestClass2 TearDown: Called after each test.");
+        }
+
+        // One-time teardown, called once after all tests in this class
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+            Debug.Log("DummyTestClass2 OneTimeTearDown: Called once after all tests.");
+        }
+    }
+}

package/Samples~/Demos/MooseRunner.Demo.Tests/DummyTestClass2.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 69aad0a9050743b47af599d040071fc1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Samples~/Demos/MooseRunner.Demo.Tests/ExplicitAttributeTests.cs

@@ -0,0 +1,36 @@
+using NUnit.Framework;
+using UnityEngine;
+
+namespace MooseRunner.Internal.Tests
+{
+    /// <summary>
+    /// Tests to verify [Explicit] attribute handling in MooseRunner.
+    /// - Normal tests should run in batch mode (class/assembly/root selection)
+    /// - [Explicit] tests should only run when directly selected
+    /// </summary>
+    [TestFixture]
+    public class ExplicitAttributeTests
+    {
+        [Test]
+        public void NormalTest_ShouldAlwaysRun()
+        {
+            Debug.Log("NormalTest_ShouldAlwaysRun: This test runs in all scenarios.");
+            Assert.Pass("Normal test passed");
+        }
+
+        [Test]
+        [Explicit("This test should only run when explicitly selected")]
+        public void ExplicitTest_ShouldOnlyRunWhenDirectlySelected()
+        {
+            Debug.Log("ExplicitTest_ShouldOnlyRunWhenDirectlySelected: This test should only run when directly selected.");
+            Assert.Pass("Explicit test passed - this means it was directly selected");
+        }
+
+        [Test]
+        public void AnotherNormalTest_ShouldAlwaysRun()
+        {
+            Debug.Log("AnotherNormalTest_ShouldAlwaysRun: This is another normal test.");
+            Assert.Pass("Another normal test passed");
+        }
+    }
+}

package/Samples~/Demos/MooseRunner.Demo.Tests/ExplicitAttributeTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a7375cda4fc58724f88a1b5b24b64037

package/Samples~/Demos/MooseRunner.Demo.Tests/HumanReviewModeDemo.cs

@@ -0,0 +1,99 @@
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using MooseRunner.Multiplaytest;
+using MooseRunner.helper;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace MooseRunner.Internal.Tests
+{
+    /// <summary>
+    /// Demonstrates the Human Review Mode feature.
+    /// When Human Review Mode is enabled in MooseRunner settings,
+    /// this test adds delays so humans can observe state transitions.
+    /// </summary>
+    public class HumanReviewModeDemo
+    {
+        private GameObject _cube;
+
+        [SetUp]
+        public void SetUp()
+        {
+            DoNotDestroyOnTeardown.CleanSceneImmediate();
+        }
+
+        /// <summary>
+        /// Demonstrates Human Review Mode by moving a cube through different positions.
+        /// When Human Review Mode is ON: pauses 1 second between each position.
+        /// When Human Review Mode is OFF: runs at full speed.
+        /// </summary>
+        [Test]
+        public async UniTask CubeMovesWithHumanReviewDelays(CancellationToken ct)
+        {
+            // Arrange
+            bool humanReviewMode = MooseRunnerFacade.Instance.GetHumanReviewMode();
+            Debug.Log($"Human Review Mode: {(humanReviewMode ? "ON - will pause between steps" : "OFF - running at full speed")}");
+
+            _cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            _cube.name = "DemoCube";
+            _cube.transform.position = Vector3.zero;
+
+            // Act & Assert - Move through positions
+            Vector3[] positions = new[]
+            {
+                new Vector3(0, 0, 0),
+                new Vector3(2, 0, 0),
+                new Vector3(2, 2, 0),
+                new Vector3(0, 2, 0),
+                new Vector3(0, 0, 0)
+            };
+
+            for (int i = 0; i < positions.Length; i++)
+            {
+                _cube.transform.position = positions[i];
+                Debug.Log($"Step {i + 1}/{positions.Length}: Cube at {positions[i]}");
+
+                // If Human Review Mode is enabled, pause for observation
+                if (humanReviewMode)
+                {
+                    await UniTask.Delay(1000, cancellationToken: ct); // 1 second pause
+                }
+                else
+                {
+                    await UniTask.Yield(ct); // Just yield to next frame
+                }
+            }
+
+            Assert.AreEqual(Vector3.zero, _cube.transform.position);
+            Debug.Log("Test complete!");
+        }
+
+        /// <summary>
+        /// Simple test to verify the API works correctly.
+        /// </summary>
+        [Test]
+        public void CanReadAndSetHumanReviewMode()
+        {
+            // Get initial state
+            bool initialState = MooseRunnerFacade.Instance.GetHumanReviewMode();
+            Debug.Log($"Initial Human Review Mode: {initialState}");
+
+            // Toggle it
+            MooseRunnerFacade.Instance.SetHumanReviewMode(!initialState);
+            bool toggledState = MooseRunnerFacade.Instance.GetHumanReviewMode();
+            Assert.AreEqual(!initialState, toggledState, "SetHumanReviewMode should change the state");
+
+            // Restore original state
+            MooseRunnerFacade.Instance.SetHumanReviewMode(initialState);
+            Assert.AreEqual(initialState, MooseRunnerFacade.Instance.GetHumanReviewMode(), "Should restore to initial state");
+
+            Debug.Log("API test passed!");
+        }
+
+        [TearDown]
+        public async UniTask TearDown(CancellationToken ct)
+        {
+            await DoNotDestroyOnTeardown.CleanSceneSafeUsingUpdateAsync(false, ct);
+        }
+    }
+}

package/Samples~/Demos/MooseRunner.Demo.Tests/HumanReviewModeDemo.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d9c4bd004b2df0c4f8d8a6094b3aaf5a

package/Samples~/Demos/MooseRunner.Demo.Tests/InstanceHandlingVerificationTest.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace MooseRunner.Internal.Tests
+{
+    /// <summary>
+    /// Test class to verify that OneTimeSetUp and OneTimeTearDown methods get fresh instances
+    /// while regular test methods (SetUp/Test/TearDown) share the same instance within a test cycle.
+    /// Uses _instanceId with default value 99 to track instance persistence.
+    /// </summary>
+    public class InstanceHandlingVerificationTest
+    {
+
+        // Instance identifier - defaults to 99, each method should verify the expected previous value
+        private int _instanceId = 99;
+
+        // Constructor called when creating a new instance
+        public InstanceHandlingVerificationTest()
+        {
+            Debug.Log($"Constructor called, _instanceId set to {_instanceId}");
+        }
+
+        [OneTimeSetUp]
+        public void OneTimeSetUpMethod()
+        {
+            // OneTimeSetUp should get a fresh instance, so _instanceId should be 99 (default)
+            Assert.AreEqual(99, _instanceId, "OneTimeSetUp should start with default _instanceId = 99 (fresh instance)");
+
+            _instanceId = 100; // Set to new value
+            Debug.Log($"OneTimeSetUp: verified _instanceId was 99, changed to {_instanceId}");
+        }
+
+        [SetUp]
+        public void SetUpMethod()
+        {
+            // SetUp should get a fresh instance for each test, so _instanceId should be 99 (default)
+            Assert.AreEqual(99, _instanceId, "SetUp should start with default _instanceId = 99 (fresh instance for each test)");
+
+            _instanceId = 200; // Set to new value for test methods to verify
+            Debug.Log($"SetUp: verified _instanceId was 99, changed to {_instanceId}");
+        }
+
+        [Test]
+        public void FirstTest()
+        {
+            // Test should use same instance as SetUp, so _instanceId should be 200
+            Assert.AreEqual(200, _instanceId, "FirstTest should see _instanceId = 200 from SetUp (same instance)");
+
+            _instanceId = 300; // Change for TearDown to verify
+            Debug.Log($"FirstTest: verified _instanceId was 200, changed to {_instanceId}");
+        }
+
+        [Test]
+        public void SecondTest()
+        {
+            // Test should use same instance as SetUp, so _instanceId should be 200
+            Assert.AreEqual(200, _instanceId, "SecondTest should see _instanceId = 200 from SetUp (same instance)");
+
+            _instanceId = 400; // Change for TearDown to verify
+            Debug.Log($"SecondTest: verified _instanceId was 200, changed to {_instanceId}");
+        }
+
+        [UnityTest]
+        public IEnumerator CoroutineTest()
+        {
+            // Test should use same instance as SetUp, so _instanceId should be 200
+            Assert.AreEqual(200, _instanceId, "CoroutineTest should see _instanceId = 200 from SetUp (same instance)");
+
+            _instanceId = 500; // Change for TearDown to verify
+            Debug.Log($"CoroutineTest: verified _instanceId was 200, changed to {_instanceId}");
+            yield return new WaitForSeconds(0.1f);
+        }
+
+        [TearDown]
+        public void TearDownMethod()
+        {
+            // TearDown should use same instance as the test method, so _instanceId should be what the test set
+            // (300 for FirstTest, 400 for SecondTest, 500 for CoroutineTest)
+            Assert.IsTrue(_instanceId == 300 || _instanceId == 400 || _instanceId == 500,
+                $"TearDown should see _instanceId from test method (300, 400, or 500), but got {_instanceId}");
+            
+            Debug.Log($"TearDown: verified _instanceId was {_instanceId} (from test method - same instance)");
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeTearDownMethod()
+        {
+            // OneTimeTearDown should get a fresh instance, so _instanceId should be 99 (default)
+            Assert.AreEqual(99, _instanceId, "OneTimeTearDown should start with default _instanceId = 99 (fresh instance)");
+            
+            Debug.Log($"OneTimeTearDown: verified _instanceId was 99 (fresh instance)");
+            
+        }
+    }
+}

package/Samples~/Demos/MooseRunner.Demo.Tests/InstanceHandlingVerificationTest.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 18936c5f5d120004196c6ebb90918936

package/Samples~/Demos/MooseRunner.Demo.Tests/MooseRunner.Demo.Tests.asmdef

@@ -0,0 +1,23 @@
+{
+  "name": "MooseRunner.Demo.Tests",
+  "rootNamespace": "",
+  "references": [
+    "UnityEngine.TestRunner",
+    "MooseRunner.Demo.Support",
+    "UniTask",
+    "MooseRunner.helper",
+    "MooseRunner.Runtime"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "precompiledReferences": [
+    "nunit.framework.dll"
+  ],
+  "autoReferenced": false,
+  "defineConstraints": [
+    "UNITY_INCLUDE_TESTS"
+  ],
+  "versionDefines": [],
+  "noEngineReferences": false
+}

package/Samples~/Demos/MooseRunner.Demo.Tests/MooseRunner.Demo.Tests.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 28c2a1491b1c6ad4d841540d822ae61c
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: