Unity UI Test Framework

https://docs.unity3d.com/Packages/com.unity.ui.test-framework@6.3
Admin
The UI Test Framework package facilitates automated testing for UI Toolkit-based UI. It provides a...
Tokens:57,223
Snippets:682
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example: Using PopupMenuSimulator for Dropdown Interaction

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/simulate/simulate-popup-menu-actions.html

This example demonstrates how to add a PopupMenuSimulator, interact with a DropdownField, validate menu display and content, select items by name or index, and discard the menu. It requires setting up the test component and fetching the relevant UI elements.

```csharp
public class PopupMenuSimulatorExampleClass : UITestFixture
{
    PopupMenuSimulator m_PopupMenuSimulator;

    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
        // Add the test component and keep its reference
        // to interact with popup menus later.
        m_PopupMenuSimulator = AddTestComponent<PopupMenuSimulator>();
    }

    [Test]
    public void PopupMenuSimulatorExample()
    {
        // Fetch the DropdownMenu to interact with.
        DropdownField dropdownField = rootVisualElement.Q<DropdownField>("MyDropdownField");

        VisualElement dropdown = dropdownField.Q<VisualElement>(className: "unity-base-popup-field__input");

        Assume.That(dropdownField.value, Is.Null);

        // Click on the dropdown.
        simulate.Click(dropdown);
        simulate.FrameUpdate();

        // Check that the menu is displayed.
        Assert.That(m_PopupMenuSimulator.menuIsDisplayed,
            Is.True, "PopupMenu was not displayed.");

        // Check that the menu contains the item we want to select.
        m_PopupMenuSimulator.AssertContainsAction("Option1");

        // Select Option1 by its name.
        m_PopupMenuSimulator.SimulateMenuSelection("Option1");
        Assert.That(dropdownField.value, Is.EqualTo("Option1"));

        // Discard the menu.
        // PopupMenuSimulator does not currently automatically discard the menu,
        // so it needs to be manually discarded before opening another menu.
        m_PopupMenuSimulator.DiscardMenu();

        // Click on the dropdown again.
        simulate.Click(dropdown);
        simulate.FrameUpdate();

        Assert.That(m_PopupMenuSimulator.menuIsDisplayed,
            Is.True, "PopupMenu was not displayed.");

        m_PopupMenuSimulator.AssertContainsAction("Option2");

        // Simulate item selection by its index.
        var itemIndex = m_PopupMenuSimulator.FindActionIndex("Option2");
        m_PopupMenuSimulator.SimulateItemSelection(itemIndex);

        Assert.That(dropdownField.value, Is.EqualTo("Option2"));
    }

    [SetUp]
    public void SetUp()
    {
        VisualTreeAsset uxml = Resources.Load<VisualTreeAsset>("UITestFrameworkDocSample");
        uxml.CloneTree(rootVisualElement);

        simulate.FrameUpdate();
    }
}
```

--------------------------------

### FixtureSetUp Declaration

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.AbstractUITestFixture.html

Abstract method for setting up the test fixture. Marked with the SetUp attribute.

```csharp
[SetUp]
public abstract void FixtureSetUp()
```

--------------------------------

### Simulate Double-Click on a Button

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/simulate/double-click-on-a-visual-element.html

This example demonstrates how to simulate a double-click on a button using PanelSimulator.DoubleClick. It includes setup for a callback to validate the double-click action and asserts the expected behavior.

```csharp
using NUnit.Framework;
using UnityEngine.UIElements;

[Test]
public void DoubleClickExample()
{
    // Make sure the UI is totally up to date.
    simulate.FrameUpdate();

    var actionWasExecuted = false;

    void ValidateDoubleClickAction(PointerDownEvent e)
    {
        if (e.clickCount == 2)
        {
            actionWasExecuted = true;
        }
    }

    // Set up the button's double click functionality to flip a boolean.
    Button button = rootVisualElement.Q<Button>("MyButton");
    button.RegisterCallback<PointerDownEvent>(e => ValidateDoubleClickAction(e),
        TrickleDown.TrickleDown);

    // Validate that a single click does not trigger
    // our button's custom functionality.
    simulate.Click(button);
    Assert.That(actionWasExecuted, Is.False,
        "Button action was executed unexpectedly.");

    // Double click on the button's position.
    simulate.DoubleClick(button);

    // Make sure the UI Toolkit update loop executes.
    // This is technically not required for this specific case,
    // since this button just flips a boolean when it is clicked.
    // However, if the button performs actions linked to the UI Toolkit
    // update loop, like styling or scheduling, it is required.
    simulate.FrameUpdate();

    Assert.That(actionWasExecuted, Is.True,
        "Button action was not executed.");
}
```

--------------------------------

### FixtureUnitySetUp

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.CommonUITestFixture.html

Sets up the test fixture using coroutines, allowing for asynchronous setup operations.

```APIDOC
## FixtureUnitySetUp()

### Description
Sets up the test using coroutines. This method is suitable for asynchronous setup operations.

### Method
```csharp
public override IEnumerator FixtureUnitySetUp()
```

### Returns
- **IEnumerator** - An IEnumerator for yield instructions.
```

--------------------------------

### FixtureOneTimeSetUp

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.CommonUITestFixture.html

Performs one-time setup for the test fixture before any tests in the fixture are run.

```APIDOC
## FixtureOneTimeSetUp()

### Description
Sets up the test fixture. This method is called once before any tests in the fixture are executed.

### Method
```csharp
public override void FixtureOneTimeSetUp()
```
```

--------------------------------

### FixtureUnitySetUp()

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.UITestFixture.html

Sets up the test fixture using coroutines, allowing for asynchronous setup operations. Returns an IEnumerator for yield instructions.

```APIDOC
## FixtureUnitySetUp()

### Description
Sets up the test fixture using coroutines, allowing for asynchronous setup operations.

### Method
`public override IEnumerator FixtureUnitySetUp()`

### Returns
* **IEnumerator**: An IEnumerator for yield instructions.
```

--------------------------------

### FixtureOneTimeSetUp Method

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.AbstractUITestFixture.html

Abstract method to be implemented for one-time test fixture setup. Marked with the NUnit OneTimeSetUp attribute.

```csharp
[OneTimeSetUp]
public abstract void FixtureOneTimeSetUp()
```

--------------------------------

### Basic Editor Window Test Setup

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/test-fixtures/test-ui-with-editor-window-instances.html

Sets up a test class using `EditorWindowUITestFixture` to test a UI within an Editor window. Ensures the window is large enough and queries for elements.

```csharp
public class BasicEditorWindowExample : EditorWindowUITestFixture<UITestFrameworkDocSampleWindow>
{
    [Test]
    public void EditorWindowTest()
    {
        // Set the panelSize to ensure the window is
        // large enough to display our UI.
        panelSize = new Vector2(800, 900);
        
        // Ensure the window's UI is up to date.
        simulate.FrameUpdate();

        // Use the rootVisualElement property to query for elements
        // within the window created by the test fixture.
        Button button = rootVisualElement.Q<Button>("MyButton");
        Assert.That(button, Is.Not.Null);

        // Test steps.
        // ...
    }

}
```

--------------------------------

### Runtime Test Class for UIDocument

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/test-fixtures/test-ui-in-runtime.html

Example of a runtime test class using RuntimeUITestFixture to test UI elements loaded from a scene. It includes setup for loading the scene and a test method to interact with UI components.

```csharp
// This class is contained in a runtime test assembly.
public class BasicUIDocumentRuntimeExampleClass : RuntimeUITestFixture
{
    [UnityOneTimeSetUp]
    public IEnumerator UnityOneTimeSetUp()
    {
        // Load the scene and yield a player
        // frame to ensure it is up to date.
        yield return SceneManager.LoadSceneAsync("UIDocumentTestScene", LoadSceneMode.Single);
        yield return null;
    }

    [Test]
    public void BasicRuntimeExampleTest()
    {
        // Fetch the UIDocument from the Scene.
        GameObject gameObject = GameObject.Find("UIDocument");
        UIDocument uiDocument = gameObject.GetComponent<UIDocument>();

        // Hook up the UIDocument for simulation.
        SetUIContent(uiDocument);

        simulate.FrameUpdate();

        Button button = rootVisualElement.Q<Button>("MyButton");
        Assert.That(button, Is.Not.Null);

        // Test steps.
        // ...
    }

    public UIDocument FetchUIDocument()
    {
        // Locate the gameObject that contains your UIDocument content.
        var gameObject = GameObject.Find("UIDocument");

        // Get the UIDocument component.
        UIDocument uiDocument = gameObject.GetComponent<UIDocument>();

        uiDocument.panelSettings = Resources.Load<PanelSettings>("UITestFrameworkDocSamplePanelSettings");
        uiDocument.visualTreeAsset = Resources.Load<VisualTreeAsset>("UITestFrameworkDocSample");

        return uiDocument;
    }
}
```

--------------------------------

### FixtureSetUp Method

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimeUITestFixture.html

Overrides the base class method to perform setup for each individual test within the fixture. This is called before each test method.

```csharp
public override void FixtureSetUp()
```

--------------------------------

### Simulate Typing Text with TouchScreenKeyboard

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/simulate/type-into-a-text-field.html

This example demonstrates how to simulate typing text when a TouchScreenKeyboard is involved, common on mobile platforms. It includes a wait loop to ensure the keyboard is visible before typing.

```csharp
using NUnit.Framework;
using UnityEngine.UIElements;
using UnityEditor.UIElements.TestUtils;
using System.Collections;
using UnityEngine;
using System;

public class TypingTextTouchScreenKeyboardExample
{
    // Assuming 'simulate' is an instance of PanelSimulator and 'rootVisualElement' is accessible.
    private PanelSimulator simulate;
    private VisualElement rootVisualElement;

    [SetUp]
    public void Setup()
    {
        // Initialize simulate and rootVisualElement as needed for your test setup.
        // For example:
        // simulate = new PanelSimulator();
        // rootVisualElement = new VisualElement();
        // simulate.Target.Add(rootVisualElement);
    }

    [UnityTest]
    public IEnumerator TypingText_TouchScreenKeyboard_Example() 
    {
        // Make sure the UI is totally up to date.
        simulate.FrameUpdate();

        // Fetch and focus the textField's textElement.
        var textField = rootVisualElement.Q<TextField>("MyTextField");
        var textElement = textField.Q<TextElement>();
        Assume.That(textField, Is.Not.Null);
        textField.Focus();

        Assume.That(textField.text, Is.Empty);
        Assume.That(textField.hasFocusPseudoState, Is.True);

        // Wait real time for the
        // TouchScreenKeyboard to pop on the device.
        float timeout = Time.realtimeSinceStartup + 3f;
        while (!TouchScreenKeyboard.visible)
        {
            if (Time.realtimeSinceStartup > timeout)
            {
                throw new TimeoutException("TouchScreenKeyboard did not pop within the timeout period.");
            }
            yield return null;
        }
    
        // Type into the textField.
        var typedText = "Typed text.";
        simulate.TypingText(typedText);
        simulate.FrameUpdate();

        Assert.That(textField.text, Is.EqualTo(typedText));
    }
}
```

--------------------------------

### Create Multiple EditorWindowPanelSimulator Instances

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/test-fixtures/create-multi-window-tests.html

This example demonstrates how to create and manage multiple EditorWindowPanelSimulator instances within a Unity test. It utilizes CleanupUtil to ensure proper cleanup of ScriptableObjects and EditorWindows.

```csharp
public class SimulateMultipleWindows : EditorWindowUITestFixture<UITestFrameworkDocSampleWindow>
{
    [Test]
    public void MultipleWindowsExampleTest()
    {
        // Use the CleanupUtil UITestComponent to manage the ScriptableObject cleanup.
        CleanupUtil cleanupUtil = AddTestComponent<CleanupUtil>();

        // Ensure the main test UI is updated.
        simulate.FrameUpdate();

        // Create a new EditorWindow for testing.
        EditorWindow window = ScriptableObject.CreateInstance<EditorWindow>();
        window.Show();

        // Ensure the new window will be properly destroyed.
        cleanupUtil.AddDestructible(window);

        // Hook up the EditorWindow as a simulator.
        EditorWindowPanelSimulator secondEditorWindow =
            new EditorWindowPanelSimulator(window);

        // Ensure the UI for the second window is updated.
        secondEditorWindow.FrameUpdate();

        // Test steps.
        // ...
    }
}
```

--------------------------------

### FixtureOneTimeSetUp Method Declaration

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.CommonUITestFixture.html

Declares the FixtureOneTimeSetUp method, used for one-time setup operations for the entire test fixture.

```csharp
public override void FixtureOneTimeSetUp()
```

--------------------------------

### Simulate Return Key Press

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/simulate/press-tab-or-return.html

This example shows how to simulate a Return key press to trigger an action on a focused UI element, such as a button click. The `ReturnKeyPress()` method is officially supported for Editor testing. Ensure the UI is updated and the target control is focused before calling this method.

```csharp
// ReturnKeyPress is only officially supported for Editor.
[Test]
public void ReturnKeyPressExample()
{
    // Make sure the UI is totally up to date.
    simulate.FrameUpdate();

    var actionWasExecuted = false;

    // Set up the button's clicked functionality to flip a Boolean.
    Button button = rootVisualElement.Q<Button>("MyButton");
    button.clicked += () => { actionWasExecuted = true; };

    // Click on the button's position.
    button.Focus();
    simulate.ReturnKeyPress();
    simulate.FrameUpdate();

    Assert.That(actionWasExecuted, Is.True,
        "Button action was not executed.");
}
```

--------------------------------

### panelSize Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.AbstractUITestFixture.html

Gets or sets the size of the panel's rootVisualElement.

```csharp
public abstract Vector2 panelSize { get; set; }
```

--------------------------------

### EditorWindowPanelSimulator.window Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowPanelSimulator.html

Gets the EditorWindow associated with this panel simulator.

```APIDOC
## window

### Description
`EditorWindow` tied to the panel.

### Property Value
- **window** (EditorWindow) - The `EditorWindow` associated with the panel.
```

--------------------------------

### AbstractUITestFixture Methods

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.AbstractUITestFixture.html

Methods available on the AbstractUITestFixture class for managing test components and setup.

```APIDOC
## Methods

### AddTestComponent(UITestComponent)

Adds the `component` to the test fixture.

*   **Declaration:** `public abstract void AddTestComponent(UITestComponent component)`
*   **Parameters:**
    *   `UITestComponent component`: The UITestComponent to add to the test fixture.
*   **Remarks:** Adding the `component` to the test fixture triggers relevant UITestComponent virtual methods based on the current test state.

### AddTestComponent<T>()

Creates and adds a `UITestComponent` to the test fixture.

*   **Declaration:** `public T AddTestComponent<T>() where T : UITestComponent, new()`
*   **Returns:** `T` - The added test component.
*   **Type Parameters:**
    *   `T`: The type of `UITestComponent` to attach to the test fixture.

### FindTestComponent<T>()

Returns the first component of type `T` attached to the test fixture.

*   **Declaration:** `public abstract T FindTestComponent<T>()`
*   **Returns:** `T` - The first component of type `T`.
*   **Type Parameters:**
    *   `T`: The type of `UITestComponent` to search for.

### FixtureOneTimeSetUp()

Sets up the test fixture.

*   **Declaration:** `[OneTimeSetUp] public abstract void FixtureOneTimeSetUp()`
```

--------------------------------

### Simulate Mouse Move to a Button

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/simulate/move-mouse-to-a-visual-element.html

This example demonstrates how to move the mouse cursor to the center of a button element and verify that the hover pseudo-state is activated. Ensure the UI is updated before and after the mouse move event.

```csharp
using NUnit.Framework;
using UnityEngine.UIElements;

public class MouseMoveExample
{
    // Assuming 'simulate' is an instance of PanelSimulator and 'rootVisualElement' is available
    // [Test]
    public void MouseMoveToButton() 
    {
        // Make sure the UI is totally up to date.
        simulate.FrameUpdate();

        // Fetch the button
        var button = rootVisualElement.Q<Button>("MyButton");

        Assume.That(button.hasHoverPseudoState, Is.False);

        // Send events to mouse over the button.
        simulate.MouseMove(button.worldBound.center);
        simulate.FrameUpdate();

        Assert.That(button.hasHoverPseudoState, Is.True);
    }
}
```

--------------------------------

### EditorPanelSimulator panelSize Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorPanelSimulator.html

Gets or sets the size of the rootVisualElement for the EditorPanelSimulator.

```csharp
public Vector2 panelSize { get; set; }
```

--------------------------------

### Use a Custom UI Test Component in Tests

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/test-fixtures/ui-test-component/create-reusable-test-components.html

This example demonstrates how to integrate a custom UI test component into your test fixture. It shows how to add the component and access its elements within tests.

```csharp
public class TestUISetupComponentExample : UITestFixture
{
    UISetupComponent uiSetupComponent;

    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
        uiSetupComponent = AddTestComponent<UISetupComponent>();
    }

    [Test]
    public void MyTestWithUISetupComponent()
    {
        Button button = rootVisualElement.Q<Button>("UISetupComponentButton");
        Assume.That(button, Is.Not.Null);

        // Test steps.
        // ...
    }

    [Test]
    public void MyOtherTestWithUISetupComponent()
    {
        Button button = rootVisualElement.Q<Button>("UISetupComponentButton");
        Assume.That(button, Is.Not.Null);

        // Test steps.
        // ...
    }
}

```

--------------------------------

### Set Custom Window Creation Function

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowUITestFixture-1.html

Assign a Func to createWindowFunction to provide a custom method for creating the EditorWindow. This is called when the test fixture starts or if the window is null.

```csharp
public Func<EditorWindowType> createWindowFunction { get; set; }
```

--------------------------------

### Simulate Tab Key Press

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/simulate/press-tab-or-return.html

This example demonstrates how to simulate a Tab key press to move focus away from a UI element. Ensure the UI is updated and the target control is focused before calling `TabKeyPress()`. This method is officially supported for Editor testing.

```csharp
// TabKeyPress is only officially supported for Editor.
[Test]
public void TabKeyPressExample()
{
    // Make sure the UI is totally up to date.
    simulate.FrameUpdate();

    // Fetch and focus the Button.
    var button = rootVisualElement.Q<Button>("MyButton");
    button.Focus();
    simulate.FrameUpdate();

    Assume.That(button.hasFocusPseudoState, Is.True);

    // Send Tab key press.
    simulate.TabKeyPress();
    simulate.FrameUpdate();

    Assert.That(button.hasFocusPseudoState, Is.False);
}
```

--------------------------------

### Enable Debug Mode for UITestFixture (Editor Debugging)

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/test-fixtures/debug-ui-test-fixtures.html

This example demonstrates how an editor test class can inherit from a runtime base class that has already enabled debug mode for UITestFixture. The UI remains open upon test failure.

```csharp
// This class is contained in an Editor test assembly.
public class RuntimeBase_EditorDebugging : UITestFixture_RuntimeBase
{
    // This test class will run in DebugMode because its base
    // class passes the debugMode parameter to the UITestFixture constructor.

    [Test]
    public void TestToDebug()
    {
        // Test steps.
        // The UI will remain open and visible when the test fails.
        //Assert.Fail();
    }
}
```

--------------------------------

### Define a Reusable UI Test Component

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/test-fixtures/ui-test-component/create-reusable-test-components.html

This component sets up the test fixture UI by adding a button and managing content clearing. It overrides Initialize, BeforeTest, and AfterTest methods for custom setup and cleanup.

```csharp
public class UISetupComponent : UITestComponent
{
    public Button testButton { get; private set; }

    protected override void Initialize(AbstractUITestFixture testFixture)
    {
        // Required: call the base Initialize.
        base.Initialize(testFixture);

        // Force fixtures that use this test component to clear
        // the content of the rootVisualElement at the end of each test.
        fixture.clearContentAfterTest = true;
    }

    protected override void BeforeTest()
    {
        // Instantiate your elements.
        testButton = new Button() { name = "UISetupComponentButton" };

        // Add them to the rootVisualElement.
        fixture.rootVisualElement.Add(testButton);
    }

    protected override void AfterTest()
    {
        // Clean up of the rootVisualElement is automatic
        // when clearContentAfterTest is true.
        // You can add custom cleanup here if needed.
        testButton = null;
    }
}

```

--------------------------------

### panelSize Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimeUITestFixture.html

Gets or sets the size of the rootVisualElement of the panel. It's recommended to set this in your tests or setup methods to ensure adequate display space for your UI.

```APIDOC
## panelSize Property

### Description
The size of the `rootVisualElement` of the panel.

### Declaration
```csharp
public override sealed Vector2 panelSize { get; set; }
```

### Property Value
Type | Description
---|---
Vector2 | 

### Overrides
AbstractUITestFixture.panelSize

### Remarks
Set the `panelSize` in your tests or set up methods to ensure that the panel is large enough to display your UI.
```

--------------------------------

### FixtureSetUp

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowUITestFixture-1.html

Sets up the test. Creates and initializes the window if it is null.

```APIDOC
## FixtureSetUp()

### Description
Sets up the test. Creates and initializes the window if it is null.

### Method
`public override void FixtureSetUp()`

### Overrides
CommonUITestFixture.FixtureSetUp()
```

--------------------------------

### FixtureOneTimeSetUp

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowUITestFixture-1.html

Sets up the test fixture. Creates and sets up the window.

```APIDOC
## FixtureOneTimeSetUp()

### Description
Sets up the test fixture. Creates and sets up the window.

### Method
`public override void FixtureOneTimeSetUp()`

### Overrides
CommonUITestFixture.FixtureOneTimeSetUp()
```

--------------------------------

### Enable Debug Mode for UITestFixture (Runtime Base)

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/test-fixtures/debug-ui-test-fixtures.html

For tests inheriting from UITestFixture, debug mode can be enabled by passing `debugMode: true` to the base class constructor. This example shows the runtime base class setup.

```csharp
// This class is contained in a runtime test assembly.
public class UITestFixture_RuntimeBase : UITestFixture
{
    public UITestFixture_RuntimeBase() : base(debugMode: true) { }

    [Test]
    public void RuntimeTestToDebug()
    {
        // Test steps.
        // The UI will remain open and visible when the test fails.
        //Assert.Fail();
    }
}
```

--------------------------------

### FixtureSetUp Method

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowUITestFixture-1.html

Sets up an individual test. Creates and initializes the window if it is currently null. This method overrides the base class implementation.

```csharp
public override void FixtureSetUp()
{
}
```

--------------------------------

### FixtureOneTimeSetUp Method

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowUITestFixture-1.html

Sets up the test fixture by creating and configuring the window. This method overrides the base class implementation.

```csharp
public override void FixtureOneTimeSetUp()
{
}
```

--------------------------------

### EditorWindowPanelSimulator Window Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowPanelSimulator.html

Gets the EditorWindow associated with this panel simulator.

```csharp
public EditorWindow window { get; }
```

--------------------------------

### Get Default Panel Size

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Retrieves the default dimensions of a UI panel.

```csharp
public static Vector2 GetDefaultPanelSize()
```

--------------------------------

### FixtureSetUp

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.AbstractUITestFixture.html

Sets up the test fixture before any tests in the fixture run.

```APIDOC
## FixtureSetUp()

### Description
Sets up the test fixture before any tests in the fixture run.

### Method
[SetUp]
public abstract void FixtureSetUp()

### Parameters
None

### Returns
None
```

--------------------------------

### PanelSimulator.currentTimeMs Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Gets the simulated time in milliseconds for the panel. Use IncrementCurrentTimeMs or IncrementCurrentTime to advance time.

```csharp
public static long currentTimeMs { get; }
```

--------------------------------

### PanelSimulator.currentTime Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Gets the simulated time in seconds for the panel. Use IncrementCurrentTimeMs or IncrementCurrentTime to advance time.

```csharp
public static double currentTime { get; }
```

--------------------------------

### pickingDistance Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimeUITestFixture.html

Gets or sets the distance used for the picking algorithm for pointer interactions in world space.

```APIDOC
## pickingDistance Property

### Description
The distance used for the picking algorithm for pointer interactions in world space.

### Declaration
```csharp
public float pickingDistance { get; set; }
```

### Property Value
Type | Description
---|---
float | 

```

--------------------------------

### FixtureSetUp

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.CommonUITestFixture.html

Sets up the test fixture before each individual test is run.

```APIDOC
## FixtureSetUp()

### Description
Sets up the test. This method is called before each test within the fixture.

### Method
```csharp
public override void FixtureSetUp()
```
```

--------------------------------

### Get Inspector Content VisualElement

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.InspectorTestUtility.html

Obtains the VisualElement that displays the properties of the inspected object. For IMGUI-only inspectors, this will be an IMGUIContainer.

```csharp
public static VisualElement GetInspectorContent(this InspectorElement inspector)
```

--------------------------------

### CreatePanel Method

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorPanelSimulator.html

Initializes the rootVisualElement and creates the panel for the EditorPanelSimulator.

```csharp
public void CreatePanel()
```

--------------------------------

### Get the Editor from InspectorElement

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.InspectorTestUtility.html

Retrieves the Editor object associated with a given InspectorElement. This is useful for accessing editor-specific functionalities.

```csharp
public static Editor GetEditor(this InspectorElement inspector)
```

--------------------------------

### EditorWindowPanelSimulator Constructor

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowPanelSimulator.html

Initializes a new instance of the EditorWindowPanelSimulator class, setting up the provided EditorWindow for simulation.

```APIDOC
## EditorWindowPanelSimulator(EditorWindow)

### Description
Sets up the provided `window` for simulation.

### Parameters
#### Path Parameters
- **window** (EditorWindow) - Required - The `EditorWindow` to set up for simulation.
```

--------------------------------

### EditorWindowPanelSimulator Constructor

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowPanelSimulator.html

Initializes a new instance of the EditorWindowPanelSimulator class, setting up the provided EditorWindow for simulation.

```csharp
public EditorWindowPanelSimulator(EditorWindow window)
```

--------------------------------

### RuntimePanelSimulator Constructor (With Settings)

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimePanelSimulator.html

Creates a RuntimePanelSimulator instance with provided PanelSettings. This allows for custom panel configurations to be used during runtime tests.

```csharp
public RuntimePanelSimulator(PanelSettings panelSettings)
```

--------------------------------

### MouseMove (Vector2, Vector2)

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Sends incremental PointerMoveEvents to the panel, moving the mouse from a starting position to a final position.

```APIDOC
## MouseMove(Vector2, Vector2, EventModifiers)

### Description
Sends incremental `PointerMoveEvent`s to the panel.

### Method
```
public void MouseMove(Vector2 positionFrom, Vector2 positionTo, EventModifiers modifiers = EventModifiers.None)
```

### Parameters
#### Path Parameters
- **positionFrom** (Vector2) - Required - The absolute starting position of the Mouse.
- **positionTo** (Vector2) - Required - The absolute final position to move the Mouse to.
- **modifiers** (EventModifiers) - Optional - The `EventModifiers` for the events.

### Remarks
Increments the current simulated time by timePerSimulatedFrame after dispatching each event. After all events have been sent, disposes of the events. This method produces unpredictable results if used on a world space panel.
```

--------------------------------

### PanelSimulator.timePerSimulatedFrameMs Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Gets or sets the time in milliseconds to increment simulated time per frame. Defaults to 200 milliseconds.

```csharp
public long timePerSimulatedFrameMs { get; set; }
```

--------------------------------

### CreateDefaultUIScene()

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimeUITestFixture.html

Sets up a GameObject with an empty UIDocument. This is useful for creating a basic UI scene to test against. You can optionally set a style sheet using themeStyleSheet.

```APIDOC
## CreateDefaultUIScene()

### Description
Sets up a GameObject with an empty `UIDocument`. Use themeStyleSheet to set the style sheet. To use your own UI content during the test, use SetUIContent(UIDocument).

### Method
public void CreateDefaultUIScene()

### Parameters
None
```

--------------------------------

### PanelSimulator.timePerSimulatedFrame Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Gets or sets the time in seconds to increment simulated time per frame. Defaults to 0.2 seconds.

```csharp
public double timePerSimulatedFrame { get; set; }
```

--------------------------------

### Basic Editor Test with UITestFixture

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/test-fixtures/test-ui-without-editor-window-dependencies.html

Sets up a test class using UITestFixture to create and manage an empty Editor panel. Use rootVisualElement to add UI elements and simulate frame updates for testing.

```csharp
// This class is contained in an Editor test assembly.
public class BasicEditorExample : UITestFixture
{
    // This test class will spawn an EditorPanel that you
    // can add UI elements to via the rootVisualElement property.
    [Test]
    public void EditorPanelTest()
    {
        // Set the panelSize to ensure the panel is
        // large enough to display our UI.
        panelSize = new Vector2(800, 900);
        
        // Use the rootVisualElement property to add elements
        // to your UI.
        rootVisualElement.Add(new Button() { name = "MyButton" });

        // Ensure the panel's UI is up to date.
        simulate.FrameUpdate();

        Button button = rootVisualElement.Q<Button>("MyButton");
        Assert.That(button, Is.Not.Null);

        // Test steps.
        // ...
    }
}
```

--------------------------------

### themeStyleSheet

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.CommonUITestFixture.html

Gets or sets the theme style sheet used by this test fixture. Defaults to null, applying the default theme.

```APIDOC
## themeStyleSheet

### Description
Theme style sheet used by this test fixture.

### Declaration
```
public override ThemeStyleSheet themeStyleSheet { get; set; }
```

### Property Value
- **ThemeStyleSheet**: The theme style sheet to apply.
```

--------------------------------

### FixtureSetUp Method Declaration

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.CommonUITestFixture.html

Declares the FixtureSetUp method, which is called to set up the test fixture before each test.

```csharp
public override void FixtureSetUp()
```

--------------------------------

### PopupMenuSimulator TargetElement Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PopupMenuSimulator.html

Gets the VisualElement that determines the root of the popup menu. This is useful for context within the UI hierarchy.

```csharp
public VisualElement targetElement { get; }
```

--------------------------------

### RuntimePanelSimulator Constructor (No Settings)

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimePanelSimulator.html

Creates a RuntimePanelSimulator instance without any specific PanelSettings. This is useful when default panel settings are sufficient for the test scenario.

```csharp
public RuntimePanelSimulator()
```

--------------------------------

### Set Panel Size

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowUITestFixture-1.html

Set the panelSize property in your tests or setup methods to ensure the window is adequately sized for your UI elements.

```csharp
public override sealed Vector2 panelSize { get; set; }
```

--------------------------------

### RecreatePanel

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowUITestFixture-1.html

Recreates the panel. Calls createWindowFunction if it's set; otherwise, creates the window using CreateInstance(Type).

```APIDOC
## RecreatePanel()

### Description
Recreates the panel. Calls createWindowFunction if it's set; otherwise, creates the window using CreateInstance(Type).

### Method
`public override void RecreatePanel()`

### Overrides
AbstractUITestFixture.RecreatePanel()
```

--------------------------------

### Get Mouse Capture Handler for VisualElement

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.VisualElementUtility.html

Retrieves the event handler that is currently capturing the mouse for a given VisualElement. This can be used to inspect or manage mouse capture.

```csharp
public static IEventHandler GetMouseCaptureHandler(VisualElement currentElement)
```

--------------------------------

### pickingDirection Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimeUITestFixture.html

Gets or sets the direction used for the picking algorithm for pointer interactions in world space. This can be set to use the element's or the panel's direction.

```APIDOC
## pickingDirection Property

### Description
The direction used for the picking algorithm for pointer interactions in world space. The picking direction can use the element's direction (default) or the panel's direction. When the panel's direction is used, picking occurs in the panel's forward axis regardless of the element's rotation within the panel.

### Declaration
```csharp
public PickingDirection pickingDirection { get; set; }
```

### Property Value
Type | Description
---|---
PickingDirection | 

```

--------------------------------

### RecreatePanel()

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.UITestFixture.html

Recreates the simulated UI Toolkit panel, providing a fresh instance for testing purposes.

```APIDOC
## RecreatePanel()

### Description
Recreates the simulated UI Toolkit panel, providing a fresh instance for testing purposes.

### Method
`public override sealed void RecreatePanel()`
```

--------------------------------

### ReturnKeyPress

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Sends key events to the panel to simulate pressing the Return key.

```APIDOC
## ReturnKeyPress(EventModifiers)

### Description
Sends key events to the panel to simulate pressing the Return key.

### Method
`ReturnKeyPress`

### Parameters
#### Path Parameters
- **modifiers** (EventModifiers) - Optional - The `EventModifiers` for the event. Defaults to `EventModifiers.None`.

### Remarks
**Note:** This function does not generate Navigation events. Interactions with certain controls that depend on Navigation events are therefore not supported in Play mode tests. 
Increments the current simulated time by timePerSimulatedFrame after dispatching each event. After all events have been sent, disposes of the events.
```

--------------------------------

### RuntimePanelSimulator Picking Direction Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimePanelSimulator.html

Sets or gets the picking direction for pointer interactions. This determines whether interactions are based on the element's or the panel's forward axis.

```csharp
public PickingDirection pickingDirection { get; set; }
```

--------------------------------

### EditorWindowUITestFixture Constructor

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowUITestFixture-1.html

Instantiates an empty EditorWindowUITestFixture. Use the simulate property to access the UI Toolkit panel and the window property to access the window.

```csharp
protected EditorWindowUITestFixture()
```

--------------------------------

### PopupMenuSimulator

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.html

Provides a testable wrapper for both Editor and runtime popup menu interactions in UI Toolkit tests. Allows simulation and verification of popup menu display, item selection, and menu content without invoking the native system menu.

```APIDOC
## Class PopupMenuSimulator

Provides a testable wrapper for both Editor and runtime popup menu interactions in UI Toolkit tests. Allows simulation and verification of popup menu display, item selection, and menu content without invoking the native system menu.
```

--------------------------------

### Assembly Definition for Test Fixture

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/create-your-first-ui-test.html

Defines an assembly for the test fixture, referencing necessary UI Test Framework and Editor assemblies. This setup is required for running UI tests.

```json
{
    "name": "SimpleEditorWindow.Tests.Editor",
    "references": [
        "UnityEngine.TestRunner",
        "UnityEditor.TestRunner",
        "Unity.UI.TestFramework.Editor",
        "Unity.UI.TestFramework.Runtime",
        "SimpleEditorWindow.Editor"
    ],
    "includePlatforms": [
        "Editor"
    ]
}
```

--------------------------------

### FixtureUnitySetUp Declaration

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.AbstractUITestFixture.html

Abstract method for setting up the test using coroutines. Returns an IEnumerator for yield instructions.

```csharp
public abstract IEnumerator FixtureUnitySetUp()
```

--------------------------------

### RecreatePanel

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.AbstractUITestFixture.html

Recreates the simulated UI Toolkit panel, providing a fresh instance for testing.

```APIDOC
## RecreatePanel()

### Description
Recreates the simulated UI Toolkit panel, providing a fresh instance for testing.

### Method
public abstract void RecreatePanel()

### Parameters
None

### Returns
None
```

--------------------------------

### CreateDefaultUIScene Method

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimeUITestFixture.html

Sets up a default UI scene with an empty UIDocument. You can optionally set a style sheet using themeStyleSheet. To use custom UI content, call SetUIContent(UIDocument).

```csharp
public void CreateDefaultUIScene()
```

--------------------------------

### RuntimePanelSimulator Picking Distance Property

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimePanelSimulator.html

Sets or gets the distance used for the picking algorithm in pointer interactions. This property controls how far pointer interactions are considered valid in world space.

```csharp
public float pickingDistance { get; set; }
```

--------------------------------

### RuntimePanelSimulator Constructors

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.RuntimePanelSimulator.html

Initializes a new instance of the RuntimePanelSimulator class. You can create an instance with default panel settings or provide specific PanelSettings.

```APIDOC
## RuntimePanelSimulator()

### Description
Creates a `RuntimePanelSimulator` with a null `PanelSettings`.

### Declaration
```
public RuntimePanelSimulator()
```
```

```APIDOC
## RuntimePanelSimulator(PanelSettings)

### Description
Creates a `RuntimePanelSimulator` with the provided `panelSettings`.

### Declaration
```
public RuntimePanelSimulator(PanelSettings panelSettings)
```

### Parameters
| Type | Name | Description |
|---|---|---|
| PanelSettings | panelSettings | The `PanelSettings` object to set for the created panel. |
```

--------------------------------

### FixtureUnitySetUp Method Declaration

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.CommonUITestFixture.html

Declares the FixtureUnitySetUp method, used for setting up the test fixture using coroutines, allowing for asynchronous operations.

```csharp
public override IEnumerator FixtureUnitySetUp()
```

--------------------------------

### simulate

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.CommonUITestFixture.html

Provides access to the PanelSimulator for interacting with the simulated panel. This is the primary interface for simulating UI interactions.

```APIDOC
## simulate

### Description
Returns the `PanelSimulator` used by the test fixture.

### Declaration
```
public override sealed PanelSimulator simulate { get; set; }
```

### Property Value
- **PanelSimulator**: The simulator object for interacting with the panel.
```

--------------------------------

### Simulate Mouse Move Between Positions

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Sends incremental PointerMoveEvents to the panel, simulating mouse movement from a starting position to a final position. This method may produce unpredictable results on world space panels.

```csharp
public void MouseMove(Vector2 positionFrom, Vector2 positionTo, EventModifiers modifiers = EventModifiers.None)
```

--------------------------------

### ReleasePanel()

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.UITestFixture.html

Releases the currently simulated UI Toolkit panel, freeing up resources.

```APIDOC
## ReleasePanel()

### Description
Releases the currently simulated UI Toolkit panel, freeing up resources.

### Method
`public override sealed void ReleasePanel()`
```

--------------------------------

### ReleasePanel

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.AbstractUITestFixture.html

Releases the currently simulated UI Toolkit panel.

```APIDOC
## ReleasePanel()

### Description
Releases the currently simulated UI Toolkit panel.

### Method
public abstract void ReleasePanel()

### Parameters
None

### Returns
None
```

--------------------------------

### Using CleanupUtil to manage test object lifecycle

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/test-fixtures/ui-test-component/clean-up-objects-after-tests.html

Add the CleanupUtil component to your test fixture to automatically dispose of or destroy objects at the end of each test. This example demonstrates adding both a GameObject and a custom disposable item.

```csharp
public class CleanupUtilExampleClass : UITestFixture
{
    CleanupUtil m_CleanupUtil;

    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
        // Add the test component and keep its reference
        // to add objects to be destroyed later.
        m_CleanupUtil = AddTestComponent<CleanupUtil>();
    }

    [Test]
    public void CleanupUtilExample()
    {
        // Create a game object to use in the test.
        GameObject go = new GameObject("GameObjectToDispose");

        // Add the game object to be destroyed after the test.
        // GameObject is of type Object so we use the AddDestructible method.
        m_CleanupUtil.AddDestructible(go);

        // Create another item.
        DisposableTestItem item = new DisposableTestItem();

        // Add the item to be disposed after the test.
        // DisposableTestItem implements the IDisposable interface
        // so we use the AddDisposable method.
        m_CleanupUtil.AddDisposable(item);

        // Test steps.
        // ...
    }
}

internal class DisposableTestItem : IDisposable
{
    public void Dispose()
    {
        // Dispose steps.
    }
}
```

--------------------------------

### KeyUp

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Simulates releasing a key on the panel, including specified modifiers.

```APIDOC
## KeyUp(KeyCode keyCode, EventModifiers modifiers = EventModifiers.None)

### Description
Sends key events to the panel to simulate releasing a given key.

### Method
public void KeyUp(KeyCode keyCode, EventModifiers modifiers = EventModifiers.None)

### Parameters
#### Path Parameters
- **keyCode** (KeyCode) - Required - The `KeyCode` for the event.
- **modifiers** (EventModifiers) - Optional - The `EventModifiers` for the event.

### Remarks
Increments the current simulated time by timePerSimulatedFrame after dispatching each event. After all events have been sent, disposes of the events.

Do the following to send specific key events: 
  * To send text, use TypingText(string, bool).
  * To send Return, use ReturnKeyPress(EventModifiers).
  * To send KeypadEnter, use KeypadEnterKeyPress(EventModifiers).
  * To send Tab, use TabKeyPress(EventModifiers).

**Note:** This function does not generate Navigation events. Interactions with certain controls that depend on Navigation events are therefore not supported in Play mode tests.
```

--------------------------------

### RuntimePanelSimulator

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.html

A PanelSimulator for use with runtime tests.

```APIDOC
## Class RuntimePanelSimulator

A PanelSimulator for use with runtime tests.
```

--------------------------------

### Simulate Return Key Press

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.PanelSimulator.html

Sends key events to simulate pressing the Return key. Does not generate Navigation events.

```csharp
public void ReturnKeyPress(EventModifiers modifiers = EventModifiers.None)
```

--------------------------------

### EditorPanelSimulator Constructors

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorPanelSimulator.html

Constructors for creating an EditorPanelSimulator instance.

```APIDOC
## EditorPanelSimulator()

### Description
Creates a new Editor panel.

### Declaration
```csharp
public EditorPanelSimulator()
```
```

--------------------------------

### Simple Editor Window Script

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/manual/create-your-first-ui-test.html

Creates a basic Editor window with a button that changes its text when clicked. This script serves as the UI element to be tested.

```csharp
using UnityEditor;
using UnityEngine;
using UnityEngine.UIElements;

public class SimpleEditorWindow : EditorWindow
{
    [MenuItem("Window/UI Toolkit/UI Test Framework/Simple Editor Window")]
    public static void ShowExample()
    {
        SimpleEditorWindow wnd = GetWindow<SimpleEditorWindow>();
        wnd.titleContent = new GUIContent("SimpleEditorWindow");
    }

    public void CreateGUI()
    {
        VisualElement root = rootVisualElement;

        Button button = new Button() { text = "Button not clicked" };
        button.clicked += () => { button.text = "Button was clicked!"; };
        root.Add(button);
    }
}
```

--------------------------------

### EditorPanelSimulator Constructor

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorPanelSimulator.html

Creates a new instance of the EditorPanelSimulator, initializing a default editor panel.

```csharp
public EditorPanelSimulator()
```

--------------------------------

### RecreatePanel Method

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.EditorWindowUITestFixture-1.html

Recreates the panel. It calls createWindowFunction if it is set; otherwise, it creates the window using CreateInstance(Type). This method overrides the base class implementation.

```csharp
public override void RecreatePanel()
{
}
```

--------------------------------

### Instantiate UITestFixture with AutoDetect

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.UITestFixture.html

Protected constructor for instantiating a UITestFixture using AutoDetect functionality. This is the default instantiation method.

```csharp
protected UITestFixture()
```

--------------------------------

### CleanupUtil Methods

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEngine.UIElements.TestFramework.CleanupUtil.html

Provides methods to manage the lifecycle of objects that need to be cleaned up after tests. You can add objects for destruction or disposal, and the utility will handle their cleanup automatically or on demand.

```APIDOC
## Class CleanupUtil

Tracks and cleans up objects that require disposal or destruction after tests. When added to a test fixture, `CleanupUtil` automatically cleans up all registered objects after the test execution.

### Methods

#### AddDestructible(Object)

Adds an object for destruction after the test.

##### Declaration

```csharp
public void AddDestructible(Object destructible)
```

##### Parameters

| Type   | Name         | Description                                                                 |
|--------|--------------|-----------------------------------------------------------------------------|
| Object | destructible | The `UnityEngine.Object` to destroy. This can be a GameObject, ScriptableObject, or any other object. |

#### AddDisposable(IDisposable)

Adds an object for disposal after the test.

##### Declaration

```csharp
public void AddDisposable(IDisposable disposable)
```

##### Parameters

| Type      | Name       | Description              |
|-----------|------------|--------------------------|
| IDisposable | disposable | The object for disposal. |

#### Cleanup()

Cleans up all objects that you added for disposal or destruction.

##### Declaration

```csharp
public void Cleanup()
```
```

--------------------------------

### Create StyleSheet from String

Source: https://docs.unity3d.com/Packages/com.unity.ui.test-framework%406.3/api/UnityEditor.UIElements.TestFramework.StylesApplicator.html

Creates a StyleSheet object from a string containing USS content. Useful for dynamic style generation.

```csharp
public static StyleSheet CreateStyleSheetFromString(string contents, string fakePath = "Assets/test.uss", bool ignoreError = false)
```
Tokens:
Raw