Add base test and fix for incorrect teardown / reset.

Darren-Kelly-Unity · Jun 12, 2026 · Jun 12, 2026 · Jun 12, 2026 · Jun 15, 2026 · Jun 17, 2026
commit b9b935932b09e0f8384771c679f0eefe4c2dfe3b
diff --git a/Assets/Tests/InputSystem.Editor/InputTestFixtureTeardownTests.cs b/Assets/Tests/InputSystem.Editor/InputTestFixtureTeardownTests.cs
@@ -0,0 +1,106 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+/// <summary>
+/// Regression tests for IN-107889: InputTestFixture.TearDown() fails to reset Input System state
+/// between consecutive scene-based tests.
+/// </summary>
+/// <remarks>
+/// Bug: When an <see cref="InputActionMap"/> belonging to the project-wide <see cref="InputSystem.actions"/>
+/// asset is enabled before a test's <see cref="InputTestFixture.Setup"/> runs, the TearDown/Restore
+/// cycle leaves the action map disconnected from its saved <see cref="InputActionState"/>.
+///
+/// Root cause:
+/// 1. <c>TestHook_DisableActions()</c> calls <c>Disable()</c> + <c>OnSetupChanged()</c> on the
+///    project-wide asset's maps. <c>Disable()</c> modifies the action state memory (phases → Disabled)
+///    on the <em>same</em> InputActionState objects that were just saved in the snapshot, because
+///    <c>Disable()</c> is called after <c>SaveAndResetState()</c> but references the same managed objects.
+/// 2. <c>OnSetupChanged()</c> sets <c>map.m_State = null</c>, disconnecting the map from its state.
+/// 3. <c>Restore()</c> restores <c>s_GlobalState</c> (the registry) but does NOT restore the per-map
+///    back-references (<c>InputActionMap.m_State</c>, <c>m_MapIndexInState</c>) or the action phase
+///    memory.
+///
+/// The fix:
+/// 1. <c>TestHook_DisableActions()</c> should disconnect maps without modifying the saved state's memory,
+///    so the saved snapshot retains the correct enabled phases.
+/// 2. <c>Restore()</c> should re-link the back-references after <c>RestoreSavedState()</c> and
+///    recompute <c>m_EnabledActionsCount</c> from the restored action phases.
+/// </remarks>
+internal class InputTestFixtureTeardownTests : InputTestFixture
+{
+    // Simulates a scene with a PlayerInput component using project-wide actions.
+    // Created once before any [SetUp] runs, like a scene's OnEnable().
+    private InputActionAsset m_PreTestAsset;
+    private InputActionMap m_PreTestMap;
+    private InputAction m_PreTestAction;
+
+    [OneTimeSetUp]
+    public void SimulateSceneLoad()
+    {
+        // Create an action asset simulating project-wide actions that a scene's
+        // PlayerInput component would use.
+        m_PreTestAsset = ScriptableObject.CreateInstance<InputActionAsset>();
+        m_PreTestAsset.hideFlags = HideFlags.HideAndDontSave;
+        m_PreTestMap = m_PreTestAsset.AddActionMap("Player");
+        m_PreTestAction = m_PreTestMap.AddAction("Fire", InputActionType.Button);
+
+        // Enable the map - creates an InputActionState and registers it in s_GlobalState.
+        // This simulates PlayerInput.ActivateInput() running before the test starts.
+        m_PreTestMap.Enable();
+
+        // Register as project-wide actions on the real manager.
+        // This causes TestHook_DisableActions() to treat our asset like project-wide actions
+        // (i.e. call Disable() + OnSetupChanged() on it during each Setup()).
+        InputSystem.s_Manager.actions = m_PreTestAsset;
+    }
+
+    [OneTimeTearDown]
+    public void VerifyPreTestStatePreserved()
+    {
+        // After all test TearDowns, the action map should still be linked to its saved
+        // InputActionState and the enabled count should reflect the pre-test enabled state.
+        //
+        // With the bug: map.m_State is null and map.enabled is false because:
+        //   - TestHook_DisableActions() called Disable() on the map (clearing enabled state
+        //     in the shared state memory) then OnSetupChanged() (setting m_State = null)
+        //   - Restore() restores s_GlobalState but not map.m_State or m_EnabledActionsCount
+        //
+        // With the fix: map.m_State is properly re-linked and map.enabled is true because:
+        //   - TestHook_DisableActions() no longer modifies the saved state's memory
+        //   - Restore() calls RelinkRestoredStates() to restore back-references and
+        //     recompute m_EnabledActionsCount from the action phase memory
+
+        Assert.That(m_PreTestMap.m_State, Is.Not.Null,
+            "Action map should be linked to its saved InputActionState after Restore(). " +
+            "m_State was cleared by OnSetupChanged() during TestHook_DisableActions() " +
+            "and was not re-linked by Restore().");
+
+        Assert.That(m_PreTestMap.enabled, Is.True,
+            "Action map should be enabled after Restore(): it was enabled before any test ran " +
+            "and should be restored to that enabled state after TearDown().");
+
+        // Clean up
+        InputSystem.s_Manager.actions = null;
+        Object.DestroyImmediate(m_PreTestAsset);
+    }
+
+    [Test]
+    [Order(1)]
+    public void TearDown_FirstTest_ProjectWideActionsAreReenabledForTest()
+    {
+        // During this test, project-wide actions may have been re-enabled by TestHook_EnableActions
+        // (or left disabled if TestHook_EnableActions is a no-op for the test manager).
+        // We're just running to trigger a Setup/TearDown cycle.
+        Assert.Pass("First test ran successfully (triggering Setup/TearDown cycle)");
+    }
+
+    [Test]
+    [Order(2)]
+    public void TearDown_SecondTest_StateRemainsCorrectAfterSecondCycle()
+    {
+        // After the first test's TearDown() + this Setup(), verify setup completes without errors.
+        // The [OneTimeTearDown] contains the actual assertion for the post-Restore() state.
+        Assert.Pass("Second test ran successfully (triggering second Setup/TearDown cycle)");
+    }
+}
diff --git a/Packages/com.unity.inputsystem/InputSystem/Runtime/Actions/InputActionState.cs b/Packages/com.unity.inputsystem/InputSystem/Runtime/Actions/InputActionState.cs
@@ -4532,6 +4532,61 @@
             return savedState;
         }
 
+        /// <summary>
+        /// After <see cref="InputTestStateManager.Restore"/> restores the global registry via
+        /// <c>RestoreSavedState()</c>, the per-map back-references on each <see cref="InputActionMap"/>
+        /// (<c>m_State</c>, <c>m_MapIndexInState</c>) and the per-action index
+        /// (<c>InputAction.m_ActionIndexInState</c>) may be stale because they were cleared by
+        /// <c>Destroy()</c> during <c>StaticDisposeCurrentState()</c>. This method re-links those
+        /// references from the restored <see cref="s_GlobalState"/> and recomputes
+        /// <c>m_EnabledActionsCount</c> from the action phase memory so that maps and actions
+        /// correctly reflect their pre-test enabled state. See IN-107889.
+        /// </summary>
+        internal static void RelinkRestoredStates()
+        {
+            var count = s_GlobalState.globalList.length;
+            for (var i = 0; i < count; ++i)
+            {
+                var handle = s_GlobalState.globalList[i];
+                if (!handle.IsAllocated)
+                    continue;
+                if (handle.Target is InputActionState state)
+                    state.RelinkMapsAndRecomputeEnabledCount();
+            }
+        }
+
+        private unsafe void RelinkMapsAndRecomputeEnabledCount()
+        {
+            for (var mapIndex = 0; mapIndex < totalMapCount; ++mapIndex)
+            {
+                var map = maps[mapIndex];
+                if (map == null)
+                    continue;
+
+                map.m_State = this;
+                map.m_MapIndexInState = mapIndex;
+
+                var indices = mapIndices[mapIndex];
+                var mapActions = map.m_Actions;
+                if (mapActions != null)
+                {
+                    for (var k = 0; k < indices.actionCount; ++k)
+                        mapActions[k].m_ActionIndexInState = indices.actionStartIndex + k;
+                }
+
+                // Recompute m_EnabledActionsCount from the restored action phase memory.
+                // This correctly reflects enabled/disabled state without any explicit Disable()
+                // call having been made (see TestHook_DisableActions changes for IN-107889).
+                var enabledCount = 0;
+                for (var k = 0; k < indices.actionCount; ++k)
+                {
+                    if (!actionStates[indices.actionStartIndex + k].isDisabled)
+                        ++enabledCount;
+                }
+                map.m_EnabledActionsCount = enabledCount;
+            }
+        }
+
         private void AddToGlobalList()
         {
             CompactGlobalList();

diff --git a/Packages/com.unity.inputsystem/InputSystem/Runtime/InputSystem.cs b/Packages/com.unity.inputsystem/InputSystem/Runtime/InputSystem.cs
@@ -3518,9 +3518,32 @@ internal static void InitializeInPlayer(IInputRuntime runtime = null, bool loadS
 #if UNITY_INCLUDE_TESTS
         internal static void TestHook_DisableActions()
         {
-            DisableActions(triggerSetupChanged: true);
-            if (s_Manager != null)
+            // Disconnect the project-wide action maps from their InputActionState without
+            // calling Disable(), which would corrupt the saved state snapshot.
+            //
+            // The normal DisableActions() path calls Disable() then OnSetupChanged() on the
+            // project-wide asset. Disable() modifies action phase memory on the *same* managed
+            // InputActionState objects that were already captured in the SaveAndResetState()
+            // snapshot (GCHandles point to the live objects; no deep copy is made). This means
+            // the restored snapshot has disabled phases even though the maps were enabled when
+            // the snapshot was taken, causing Restore() to leave maps incorrectly disabled.
+            //
+            // Instead, we just null out the map back-references and let Restore() re-link them.
+            // Control monitors registered through the old runtime don't need unsubscribing here
+            // because the test manager installs a new runtime; the old runtime is never polled
+            // during the test. See IN-107889.
+            var projectWideActions = s_Manager?.actions;
+            if (projectWideActions != null)
+            {
+                foreach (var map in projectWideActions.actionMaps)
+                {
+                    map.m_State = null;
+                    map.m_MapIndexInState = InputActionState.kInvalidIndex;
+                    map.m_EnabledActionsCount = 0;
+                }
+                projectWideActions.m_SharedStateForAllMaps = null;
                 s_Manager.actions = null;
+            }
         }
 
         internal static void TestHook_EnableActions()

diff --git a/Packages/com.unity.inputsystem/Tests/TestFixture/InputTestStateManager.cs b/Packages/com.unity.inputsystem/Tests/TestFixture/InputTestStateManager.cs
@@ -121,6 +121,10 @@ public void Restore()
             state.inputUserState.RestoreSavedState();
             state.touchState.RestoreSavedState();
             state.inputActionState.RestoreSavedState();
+            // Re-link per-map/per-action back-references that were cleared during
+            // StaticDisposeCurrentState(). Also recomputes m_EnabledActionsCount
+            // from the restored action phase memory. See IN-107889.
+            InputActionState.RelinkRestoredStates();
 
             InputSystemTestHooks.TestHook_RestoreFromSavedState(state.manager, state.remote, state.remoteConnection);
             InputUpdate.Restore(state.managerState.updateState);