Skip to content

NEW: Input consumption - Priorities instead of complexity [ISX-2510]#2402

Open
Darren-Kelly-Unity wants to merge 60 commits into
developfrom
proof-of-concept/input-consumption
Open

NEW: Input consumption - Priorities instead of complexity [ISX-2510]#2402
Darren-Kelly-Unity wants to merge 60 commits into
developfrom
proof-of-concept/input-consumption

Conversation

@Darren-Kelly-Unity
Copy link
Copy Markdown
Collaborator

@Darren-Kelly-Unity Darren-Kelly-Unity commented Mar 31, 2026

Purpose of this PR

This work advances epic ISX-2510 [6.6] Reliable Interactions: shortcut overlap resolution no longer depends only on automatic composite complexity, which was hard to reason about and produced corner cases. The branch adds an opt-in action priority path (InputSettings.shortcutKeysUseActionPriority plus InputAction.Priority), wires it through InputActionState grouping and InputManagerStateMonitors ordering and consumption, and keeps complexity-based behavior when that setting is off. Design context for the epic is linked from the Jira description.

Release Notes

  • NEW: Opt-in action priority for shortcut overlap resolution — InputSettings.shortcutKeysUseActionPriority and per-action InputAction.Priority. When enabled, higher-priority actions are ordered and can consume overlapping input before lower-priority actions in the same group; the Input Actions editor shows Priority only in this mode. (ISX-2510)
  • CHANGE: InputSettings.shortcutKeysConsumeInput is documented as complexity-based shortcut resolution when action priority is disabled (prior develop behavior). Modifier composites use ordered evaluation when that complexity path is active.

Functional Testing status

Automated coverage added and extended in CoreTests_ActionsPriority.cs and updates in CoreTests_Actions.cs (hold paths, repeated binding presses, priority vs complexity, DefaultInputActions, and related scenarios). Manual passes recommended for Project Settings toggles (shortcutKeysUseActionPriority / shortcutKeysConsumeInput), Input Actions editor visibility of Priority, and play-mode shortcuts that previously relied on complexity-only ordering.

Performance Testing Status

Potential extra work when monitor lists are re-sorted (needToUpdateOrderingOfMonitors) and when action priority changes trigger regrouping updates in InputActionState. No dedicated performance benchmarks were run for this draft; recommend a quick profile on a scene with many simultaneous action monitors if risk tolerance is low.

Overall Product Risks

Technical Risk: 2 — Touches core action state, control grouping memory, and state-change monitor ordering and handled propagation; behavior is gated behind new settings but logic is subtle.

Halo Effect: 2 — Affects any project using shortcut consumption or overlapping bindings across maps; editor UX and serialized assets gain priority fields that persist even when the setting is off.

Class diagram

Git range analyzed: origin/develop...HEAD (merge-base to proof-of-concept/input-consumption tip). Diagram emphasizes priority-based shortcut resolution: settings, action priority, packed monitor indices, action state grouping, and monitor dispatch.

Expand class diagram (Mermaid)
classDiagram
  direction TB

  class InputSettings {
    +shortcutKeysConsumeInput bool
    +shortcutKeysUseActionPriority bool
    IsShortcutResolutionUsingActionPriority bool
    IsShortcutResolutionUsingComplexity bool
  }

  class InputAction {
    +Priority int
  }

  class InputActionMap {
    m_State InputActionState
  }

  class InputActionState {
    ControlGroupingTable
    OnActionPriorityChanged()
    GetComplexityFromMonitorIndex() int
  }

  class InputActionState_ControlGroupingTable {
    Stride int
    GroupElementIndex() int
    PriorityElementIndex() int
  }

  class InputActionStateMonitorIndex {
    <<struct>>
    +Packed long
    Create(map ctrl bind prio) InputActionStateMonitorIndex
    +Priority int
  }

  class IInputStateChangeMonitor {
    <<interface>>
    NotifyControlStateChanged()
  }

  class InputManagerStateMonitors {
    SortMonitorsForDeviceIfNeeded(device)
    FireStateChangeNotifications(device time event)
  }

  class StateChangeMonitorsForDevice {
    SortMonitorsByIndex()
  }

  class InputManager {
    m_StateMonitors InputManagerStateMonitors
  }

  InputAction --> InputActionMap : lives in
  InputActionMap --> InputActionState : owns
  InputAction ..> InputActionState : Priority notifies
  InputActionState ..|> IInputStateChangeMonitor
  InputActionState --> InputSettings : reads resolution mode
  InputActionState +-- InputActionState_ControlGroupingTable : uses table layout
  InputManager --> InputManagerStateMonitors : owns
  InputManagerStateMonitors --> StateChangeMonitorsForDevice : per device
  StateChangeMonitorsForDevice ..> InputActionStateMonitorIndex : unpack monitorIndex
  InputManagerStateMonitors ..> InputActionState : invokes monitors
Loading

Documentation Impact

Changes analyzed: origin/develop...HEAD

User-facing surface: public InputAction.Priority, public InputSettings.shortcutKeysUseActionPriority, and clarified semantics for shortcutKeysConsumeInput.

Already updated on this branch: Documentation~/Settings.md (settings table and shortcut behavior), Documentation~/ActionBindings.md (shortcut section and cross-links), and CHANGELOG.md under Added / Changed.

Residual: After review, confirm cross-references and wording match final API names in generated docs; add release-note polish if UX strings change.

Want draft doc edits beyond what is already in this branch? Reply if you want a pass on TOC, xref targets, or extra examples.

Copy link
Copy Markdown
Contributor

@u-pr u-pr Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

May require changes
The review identified several issues ranging from potential runtime exceptions and logic regressions to documentation mismatches. Most notably, there's a priority clamping issue that causes value wrap-around and a potential logic regression in how composite bindings are handled compared to previous versions.

🤖 Helpful? 👍/👎

Comment thread Assets/Samples/ProjectWideActions/ProjectWideActionsExample.cs Outdated
Comment thread Packages/com.unity.inputsystem/InputSystem/Actions/InputActionState.cs Outdated
Comment thread Packages/com.unity.inputsystem/InputSystem/Actions/InputActionState.cs Outdated
Comment thread Packages/com.unity.inputsystem/InputSystem/Actions/InputActionState.cs Outdated
Comment thread Packages/com.unity.inputsystem/InputSystem/Actions/InputActionState.cs Outdated
@codecov-github-com
Copy link
Copy Markdown

codecov-github-com Bot commented Mar 31, 2026

Codecov Report

Attention: Patch coverage is 92.16590% with 85 lines in your changes missing coverage. Please review.

Files with missing lines Patch % Lines
...itor/UITKAssetEditor/Views/ActionPropertiesView.cs 27.77% 26 Missing ⚠️
...ets/Tests/InputSystem/CoreTests_ActionsPriority.cs 96.81% 18 Missing ⚠️
...putSystem/Editor/Settings/InputSettingsProvider.cs 0.00% 16 Missing ⚠️
...System/Editor/UITKAssetEditor/Commands/Commands.cs 0.00% 10 Missing ⚠️
...em/InputSystem/Runtime/Actions/InputActionState.cs 93.02% 9 Missing ⚠️
...m/InputSystem/Runtime/InputManagerStateMonitors.cs 97.05% 5 Missing ⚠️
...em/Editor/UITKAssetEditor/SerializedInputAction.cs 66.66% 1 Missing ⚠️
@@             Coverage Diff             @@
##           develop    #2402      +/-   ##
===========================================
+ Coverage    78.13%   78.56%   +0.43%     
===========================================
  Files          483      759     +276     
  Lines        98770   129894   +31124     
===========================================
+ Hits         77169   102048   +24879     
- Misses       21601    27846    +6245     
Flag Coverage Δ
inputsystem_MacOS_2021.3 ?
inputsystem_MacOS_2021.3_project ?
inputsystem_MacOS_6000.0 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_MacOS_6000.0_project 77.42% <92.06%> (+0.11%) ⬆️
inputsystem_MacOS_6000.2 ?
inputsystem_MacOS_6000.2_project ?
inputsystem_MacOS_6000.3 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_MacOS_6000.3_project 77.42% <92.06%> (+0.14%) ⬆️
inputsystem_MacOS_6000.4 5.32% <5.31%> (+<0.01%) ⬆️
inputsystem_MacOS_6000.4_project 77.43% <92.06%> (+0.14%) ⬆️
inputsystem_MacOS_6000.5 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_MacOS_6000.5_project 77.46% <92.06%> (+0.14%) ⬆️
inputsystem_MacOS_6000.6 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_MacOS_6000.6_project 77.46% <92.06%> (+0.14%) ⬆️
inputsystem_Ubuntu_2021.3 ?
inputsystem_Ubuntu_2021.3_project ?
inputsystem_Ubuntu_2022.3 ?
inputsystem_Ubuntu_6000.0 5.32% <5.31%> (+<0.01%) ⬆️
inputsystem_Ubuntu_6000.0_project 77.33% <92.15%> (+0.12%) ⬆️
inputsystem_Ubuntu_6000.2 ?
inputsystem_Ubuntu_6000.2_project ?
inputsystem_Ubuntu_6000.3 5.32% <5.31%> (+<0.01%) ⬆️
inputsystem_Ubuntu_6000.3_project 77.32% <92.15%> (+0.14%) ⬆️
inputsystem_Ubuntu_6000.4 5.33% <5.31%> (+<0.01%) ⬆️
inputsystem_Ubuntu_6000.4_project 77.33% <92.15%> (+0.14%) ⬆️
inputsystem_Ubuntu_6000.5 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_Ubuntu_6000.5_project 77.37% <92.15%> (+0.14%) ⬆️
inputsystem_Ubuntu_6000.6 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_Ubuntu_6000.6_project 77.37% <92.15%> (+0.14%) ⬆️
inputsystem_Windows_2021.3 ?
inputsystem_Windows_2021.3_project ?
inputsystem_Windows_6000.0 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_Windows_6000.0_project 77.55% <92.15%> (+0.12%) ⬆️
inputsystem_Windows_6000.2 ?
inputsystem_Windows_6000.2_project ?
inputsystem_Windows_6000.3 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_Windows_6000.3_project 77.54% <92.15%> (+0.14%) ⬆️
inputsystem_Windows_6000.4 5.32% <5.31%> (+<0.01%) ⬆️
inputsystem_Windows_6000.4_project 77.55% <92.15%> (+0.14%) ⬆️
inputsystem_Windows_6000.5 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_Windows_6000.5_project 77.59% <92.15%> (+0.14%) ⬆️
inputsystem_Windows_6000.6 5.31% <5.31%> (+<0.01%) ⬆️
inputsystem_Windows_6000.6_project 77.59% <92.15%> (+0.14%) ⬆️
linux_2021.3_pkg ?
linux_2021.3_project ?
linux_2022.3_pkg ?
linux_2022.3_project ?
linux_6000.0_pkg ?
linux_6000.0_project ?
linux_6000.1_pkg ?
linux_6000.1_project ?
linux_6000.2_pkg ?
linux_6000.2_project ?
linux_trunk_pkg ?
linux_trunk_project ?
mac_2021.3_pkg ?
mac_2021.3_project ?
mac_2022.3_pkg ?
mac_2022.3_project ?
mac_6000.0_pkg ?
mac_6000.0_project ?
mac_6000.1_pkg ?
mac_6000.1_project ?
mac_6000.2_pkg ?
mac_6000.2_project ?
mac_trunk_pkg ?
mac_trunk_project ?
win_2021.3_pkg ?
win_2021.3_project ?
win_2022.3_pkg ?
win_2022.3_project ?
win_6000.0_pkg ?
win_6000.0_project ?
win_6000.1_pkg ?
win_6000.1_project ?
win_6000.2_pkg ?
win_6000.2_project ?
win_trunk_pkg ?
win_trunk_project ?

Flags with carried forward coverage won't be shown. Click here to find out more.

Files with missing lines Coverage Δ
Assets/Samples/InGameHints/InGameHintsActions.cs 15.04% <ø> (-2.66%) ⬇️
Assets/Tests/InputSystem/CoreTests_Actions.cs 98.09% <100.00%> (-0.32%) ⬇️
Assets/Tests/InputSystem/CoreTests_Analytics.cs 99.27% <100.00%> (-0.10%) ⬇️
Assets/Tests/InputSystem/CoreTests_Editor.cs 97.70% <100.00%> (-0.26%) ⬇️
Assets/Tests/InputSystem/CoreTests_State.cs 96.47% <100.00%> (+0.04%) ⬆️
...sts/InputSystem/InputActionCodeGeneratorActions.cs 55.69% <ø> (-3.80%) ⬇️
...nputSystem/Actions/InputActionStateMonitorIndex.cs 100.00% <100.00%> (ø)
...InputSystem/Editor/Analytics/InputBuildAnalytic.cs 78.02% <100.00%> (-1.59%) ⬇️
...tor/UITKAssetEditor/InputActionsEditorConstants.cs 100.00% <100.00%> (ø)
...untime/Actions/Composites/ButtonWithOneModifier.cs 100.00% <100.00%> (ø)
... and 16 more

... and 280 files with indirect coverage changes

ℹ️ Need help interpreting these results?

Copy link
Copy Markdown
Collaborator

@ekcoh ekcoh left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks for putting up this draft PR. I looked through the tests only so far and I think we should have a discussion around it which would be more helpful than doing asynchronous feedback on the comments. Test cases generally make sense but I fail to decipher some differences and rules in them I fail to understand. Also I am missing tests using priorities when interaction is not a shortcut modifier, I would assume the same rules apply regardless of binding? I think there is opportunity to reduce code diff here by doing some code reuse in the tests without having tests full of if statements.

I also think it would be good to have tests with repeated input which I mentioned before. I didn't spot any such tests unless I missed something. This would look like e.g. with a binding 'X', here value of X button provided as binary

X:                 0 1 1
Action 1 (Prio 1): 0 - 0
Action 2 (Prio 2): 0 1 0
                   a b c

   a: button up, nothing happens
   b: button down, triggers both, but only action 2 fires notification since higher prio
   c: button down again (repeat), triggers none since action 1 saw and reacted to state transition but did not fire

Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
Comment thread Assets/Tests/InputSystem/CoreTests_Actions.cs Outdated
@Darren-Kelly-Unity
Copy link
Copy Markdown
Collaborator Author

/review

@u-pr
Copy link
Copy Markdown
Contributor

u-pr Bot commented May 27, 2026

PR Reviewer Guide 🔍

(Review updated until commit ac5d101)

Here are some key observations to aid the review process:

🎫 Ticket compliance analysis 🔶

ISX-2510 - Partially compliant

Compliant requirements:

  • Improve reliability of overlapping shortcut interactions.
  • Move beyond the current complexity-only consumption model.
  • Complete programming for the change.
  • Complete automated testing for the change.
  • Document the behavior changes.

Non-compliant requirements:

  • Merge the work to develop.

Requires further human verification:

  • Alignment with XR considerations.
  • Whether planning/design sign-off is complete for the epic.
  • Manual verification of project settings toggles and Input Actions editor behavior.
⏱️ Estimated effort to review: 5 🔵🔵🔵🔵🔵

This PR is large and cross-cutting, touching core runtime monitor logic, action serialization, editor UI, analytics, docs, and a substantial new test suite.

🏅 Score: 90

The change is comprehensive and well-tested, but it is also invasive in core input-resolution code and therefore carries above-average merge risk.

🧪 PR contains tests
🔒 No security concerns identified
⚡ No major issues detected
  • Update review

🤖 Helpful? Please react with 👍/👎 | Questions❓Please reach out in Slack #ask-u-pr

@Darren-Kelly-Unity
Copy link
Copy Markdown
Collaborator Author

/review

@u-pr
Copy link
Copy Markdown
Contributor

u-pr Bot commented May 27, 2026

Persistent review updated to latest commit e52d920

1 similar comment
@u-pr
Copy link
Copy Markdown
Contributor

u-pr Bot commented May 27, 2026

Persistent review updated to latest commit e52d920

…ontrolType` (`Button`) in the built-in asset and embedded C# JSON, so validation, rebinding filters, and UI that rely on expected control layout recognize it as a button action again.
@u-pr
Copy link
Copy Markdown
Contributor

u-pr Bot commented May 27, 2026

Persistent review updated to latest commit ced22e0

@Darren-Kelly-Unity
Copy link
Copy Markdown
Collaborator Author

Darren-Kelly-Unity commented May 27, 2026

            #if UNITY_ANALYTICS || UNITY_EDITOR
            InputAnalytics.Initialize(this);
            m_Runtime.onShutdown = () => InputAnalytics.OnShutdown(this);
#endif

            m_StateMonitors = new InputManagerStateMonitors(() => m_DevicesCount, () => isProcessingEvents, m_Runtime);
        }

For issue 1:

For issue 2:
From looking at the code I can't seem to see any issue here.

As a product risk for shipping players, it is low today because production code does not use reInstallRuntime after initial creation.

PR Reviewer Guide 🔍

(Review updated until commit ced22e0)

Here are some key observations to aid the review process:

🎫 Ticket compliance analysis ✅
ISX-2510 - PR Code Verified

Compliant requirements:

  • Improve reliability of overlapping shortcut interactions instead of relying only on automatic complexity.
  • Document the behavior changes.
  • Complete programming for the feature.
  • Complete automated testing for the feature.

Requires further human verification:

  • Align the shortcut-overlap solution with XR expectations/dependencies.
  • Complete planning and design sign-off for the feature.
  • Merge the work to develop.
  • Confirm manual/editor UX behavior for the new settings and Priority field visibility.

⏱️ Estimated effort to review: 4 🔵🔵🔵🔵⚪
This PR is large and cross-cutting, touching runtime action resolution, monitor infrastructure, editor UI, serialization, analytics, docs, and many tests.

🏅 Score: 81
The change is well-covered and thoughtfully implemented, but there are a couple of runtime edge cases that can break the advertised shortcut-resolution behavior.

🧪 PR contains tests
🔒 No security concerns identified
⚡ Recommended focus areas for review

Hold leakage
Priority-based consumption only suppresses overlaps when there is a current input event to mark as handled. Interactions that reach Performed from a timeout instead of a fresh event can still complete on lower-priority overlapping actions after the higher-priority action has already won. A concrete case is two overlapping hold actions such as B and higher-priority Shift+B: keep both held long enough and both can perform.

// When we perform an action, we mark the event handled such that FireStateChangeNotifications()
// can reset other monitors (priority: strictly lower priority; complexity: same group after sort).
var settings = InputSystem.settings;
var secondary = GetControlBindingPriority(trigger.controlIndex);
var shouldConsumeHandled = settings.IsShortcutResolutionUsingActionPriority
    ? secondary > 0
    : secondary > 1;
if (shouldConsumeHandled &&
    // we can end up switching to performed state from an interaction with a timeout, at which point
    // the original event will probably have been removed from memory, so make sure to check
    // we still have one
    m_CurrentlyProcessingThisEvent.valid)

Monitor reset
InstallRuntime now recreates the entire state-monitor manager, which drops all registered control monitors and pending timeouts. If the runtime is reinstalled after actions are already enabled, those actions can stop receiving state changes or timer callbacks until they are re-resolved or re-enabled.

            #if UNITY_ANALYTICS || UNITY_EDITOR
            InputAnalytics.Initialize(this);
            m_Runtime.onShutdown = () => InputAnalytics.OnShutdown(this);
#endif

            m_StateMonitors = new InputManagerStateMonitors(() => m_DevicesCount, () => isProcessingEvents, m_Runtime);
        }
  • Update review

🤖 Helpful? Please react with 👍/👎 | Questions❓Please reach out in Slack #ask-u-pr

I looked into the Hold leakage mentioned and it doesn't seem to be much of an issue:
When Hold reaches Performed only because the timer expired, that transition often does not go through m_CurrentlyProcessingThisEvent.valid == true, and does not set handled.

From the current implementation: the code knowingly avoids setting handled when there is no valid event—likely to avoid writing handled on invalid/stale memory—so this is an intentional safety tradeoff with observable leakage for timeouts.

@u-pr
Copy link
Copy Markdown
Contributor

u-pr Bot commented May 27, 2026

Persistent review updated to latest commit ac5d101

@Pauliusd01
Copy link
Copy Markdown
Collaborator

/test_plan

@u-pr
Copy link
Copy Markdown
Contributor

u-pr Bot commented May 28, 2026

Test Plan

  • Test plan approved by PR author
  • Test execution in progress
  • Test execution complete
  • Ready for merge

Summary of Changes & Risk Assessment

Summary of Changes

This PR introduces a new opt-in Action Priority system for resolving overlapping input shortcuts (e.g., B vs Shift+B). It moves away from relying solely on automatic "composite complexity" (number of keys) and allows developers to explicitly define which action takes precedence via InputAction.Priority. Key changes include a new global setting InputSettings.shortcutKeysUseActionPriority, refactored InputManagerStateMonitors for priority-aware sorting, and bit-packed monitor indices in InputActionStateMonitorIndex.cs.

Risk Assessment

  • High Risk Areas: Core runtime input resolution (InputActionState.cs), monitor sorting and consumption logic in InputManagerStateMonitors.cs. Errors here could lead to "dead" input or duplicate triggers in shipping games.
  • Medium Risk Areas: Serialization of the new m_Priority field in InputAction.cs, Editor UI visibility/toggles in InputSettingsProvider.cs.
  • Low Risk Areas: Analytics reporting for new settings, documentation updates, and sample generated code updates.

Test Scenarios

Functional Testing

  • Priority vs. Complexity: Enable shortcutKeysUseActionPriority. Create two actions on the same key: Action A (Priority 10) and Action B (Priority 20). Verify Action B always triggers and consumes input, even if Action A has a more "complex" binding (e.g., a composite).
  • Priority 0 (Non-Consumption): Verify that if a performed action has Priority = 0, it does not mark the event as handled, allowing lower-priority actions to still trigger (as specified in InputActionsEditorConstants.cs:L37).
  • Editor UI Sync: Toggle Action Priority Shortcut Resolution in Project Settings. Verify the Priority field in the Input Actions Editor correctly appears/disappears and that HelpBoxes update based on the matrix of toggles in InputSettingsProvider.cs.
  • Clamping Logic: Verify InputAction.Priority is correctly clamped between 0 and 65535 in both the setter and the JSON import path (InputActionMap.cs:L1601).

Regression Testing

  • Legacy Complexity Support: Disable shortcutKeysUseActionPriority and enable shortcutKeysConsumeInput. Verify that shortcut resolution still uses composite complexity (the number of bindings) exactly as it did in previous versions.
  • Modifier Order (Complexity Mode): Verify that when using complexity-based resolution, modifier order is enforced (modifier must be pressed first) as per IsShortcutComplexityModifierOrderActive in InputSettings.cs.
  • Generated Code Stability: Verify that re-generating C# wrappers for existing .inputactions assets does not break projects and correctly includes the new priority field with a default of 0.
🔍 Regression Deep Dive (additional risks identified)
  • Runtime Re-installation: Verify that calling InputManager.InstallRuntime with the same runtime instance (e.g., during domain reload or test setup) does not wipe existing state monitors or pending timeouts (InputManager.cs:L2298).
  • Priority Update while Enabled: Change an action's Priority via script while the action is currently enabled. Verify that the runtime state monitor is correctly removed and re-added with the new priority without duplicating monitors (InputActionState.cs:L1090).
  • Hold Interaction suppression: Test the "Hold leakage" scenario mentioned in PR comments. Verify that a higher-priority action suppresses a lower-priority action even when the transition is triggered by a timer (e.g., two overlapping Holds).

Edge Cases

  • Tie-breaking: Test two actions with the exact same non-zero priority on the same control. Verify behavior is deterministic (e.g., based on internal binding order) or at least does not crash.
  • Device Removal: Verify that removing a device correctly cleans up the new m_MonitorsPerDevice structures in InputManagerStateMonitors.cs to avoid memory leaks.

💡 This test plan updates automatically when /test_plan is run on new commits. If you have any feedback, please reach out in #ai-qa


🤖 Helpful? Please react with 👍/👎 | Questions❓Please reach out in Slack #ask-u-pr

@Pauliusd01

This comment was marked as resolved.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

work in progress Indicates that the PR is work in progress and any review efforts can be post-poned.

Projects

None yet

Development

Successfully merging this pull request may close these issues.

5 participants