first commit

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/TableOfContents.md

@@ -0,0 +1,66 @@
+* [Unity Test Framework overview](./index.md)
+* [Edit Mode vs. Play Mode tests](./edit-mode-vs-play-mode-tests.md)
+* [Getting started with UTF](./getting-started.md)
+  * [How to create a new test assembly](./workflow-create-test-assembly.md)
+  * [How to create a test](./workflow-create-test.md)
+  * [How to run a test](./workflow-run-test.md)
+  * [How to create a Play Mode test](./workflow-create-playmode-test.md)
+  * [How to run a Play Mode test as standalone](./workflow-run-playmode-test-standalone.md)
+* [Resources](./resources.md)
+* [Extending UTF](./extending.md)
+  * [How to split the build and run process for standalone Play Mode tests](./reference-attribute-testplayerbuildmodifier.md#split-build-and-run-for-player-mode-tests)
+  * [How to run tests programmatically](./extension-run-tests.md)
+  * [How to get test results](./extension-get-test-results.md)
+  * [How to retrieve the list of tests](./extension-retrieve-test-list.md)
+* [Reference](./manual.md#reference)
+  * [Running tests from the command-line](./reference-command-line.md)
+  * [UnityTest attribute](./reference-attribute-unitytest.md)
+  * [Setup and cleanup at build time](./reference-setup-and-cleanup.md)
+    * [IPrebuildSetup](./reference-setup-and-cleanup.md#iprebuildsetup)
+    * [IPostBuildCleanup](./reference-setup-and-cleanup.md#ipostbuildcleanup)
+  * [Actions outside of tests](./reference-actions-outside-tests.md) 
+    * [Action execution order](./reference-actions-outside-tests.md#action-execution-order)
+    * [UnitySetUp and UnityTearDown](./reference-unitysetup-and-unityteardown.md)
+    * [OuterUnityTestAction](./reference-outerunitytestaction.md)
+    * [Domain Reloads](./reference-actions-outside-tests.md#domain-reloads)
+  * [Custom attributes](./reference-custom-attributes.md)
+    * [ConditionalIgnore attribute](./reference-attribute-conditionalignore.md)
+    * [PostBuildCleanup attribute](./reference-setup-and-cleanup.md#prebuildsetup-and-postbuildcleanup)
+    * [PrebuildSetup attribute](./reference-setup-and-cleanup.md#prebuildsetup-and-postbuildcleanup)
+    * [TestMustExpectAllLogs attribute](./reference-attribute-testmustexpectalllogs.md)
+    * [TestPlayerBuildModifier attribute](./reference-attribute-testplayerbuildmodifier.md)
+    * [TestRunCallback attribute](./reference-attribute-testruncallback.md)
+    * [UnityPlatform attribute](./reference-attribute-unityplatform.md)
+    * [UnitySetUp attribute](./reference-unitysetup-and-unityteardown.md)
+    * [UnityTearDown attribute](./reference-unitysetup-and-unityteardown.md)
+    * [UnityTest attribute](./reference-attribute-unitytest.md)
+  * [Custom equality comparers](./reference-custom-equality-comparers.md)
+    * [ColorEqualityComparer](./reference-comparer-color.md)
+    * [FloatEqualityComparer](./reference-comparer-float.md)
+    * [QuaternionEqualityComparer](./reference-comparer-quaternion.md)
+    * [Vector2EqualityComparer](./reference-comparer-vector2.md)
+    * [Vector3EqualityComparer](./reference-comparer-vector3.md)
+    * [Vector4EqualityComparer](./reference-comparer-vector4.md)
+    * [Custom equality comparers with equals operator](./reference-comparer-equals.md)
+    * [Test Utils](./reference-test-utils.md)
+  * [Custom yield instructions](./reference-custom-yield-instructions.md) 
+      * [IEditModeTestYieldInstruction](./reference-custom-yield-instructions.md#IEditModeTestYieldInstruction)
+      * [EnterPlayMode](./reference-custom-yield-instructions.md#enterplaymode)
+      * [ExitPlayMode](./reference-custom-yield-instructions.md#exitplaymode)
+      * [RecompileScripts](./reference-recompile-scripts.md)
+      * [WaitForDomainReload](./reference-wait-for-domain-reload.md)
+  * [Custom assertion](./reference-custom-assertion.md)
+    * [LogAssert](./reference-custom-assertion.md#logassert)
+  * [Custom constraints](./reference-custom-constraints.md)
+    * [Is](./reference-custom-constraints.md#is)
+  * [Parameterized tests](./reference-tests-parameterized.md)
+  * [MonoBehaviour tests](./reference-tests-monobehaviour.md)
+    * [MonoBehaviourTest<T>](./reference-tests-monobehaviour.md#monobehaviourtestt)
+    * [IMonoBehaviourTest](./reference-tests-monobehaviour.md#imonobehaviourtest)
+  * [TestRunnerApi](./reference-test-runner-api.md)
+    * [ExecutionSettings](./reference-execution-settings.md)
+    * [Filter](./reference-filter.md)
+    * [ITestRunSettings](./reference-itest-run-settings.md)
+    * [ICallbacks](./reference-icallbacks.md)
+    * [IErrorCallbacks](./reference-ierror-callbacks.md)
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/edit-mode-vs-play-mode-tests.md

@@ -0,0 +1,53 @@
+# Edit Mode vs. Play Mode tests
+
+Let’s clarify a bit what Play Mode and Edit Mode test means from the Unity Test Framework perspective: 
+
+## Edit Mode tests
+
+**Edit Mode** tests (also known as Editor tests) are only run in the Unity Editor and have access to the Editor code in addition to the game code.
+
+With Edit Mode tests it is possible to test any of your [Editor extensions](https://docs.unity3d.com/Manual/ExtendingTheEditor.html) using the [UnityTest](./reference-attribute-unitytest.md) attribute. For Edit Mode tests, your test code runs in the [EditorApplication.update](https://docs.unity3d.com/ScriptReference/EditorApplication-update.html) callback loop. 
+
+> **Note**: You can also control entering and exiting Play Mode from your Edit Mode test. This allow your test to make changes before entering Play Mode.
+
+Edit Mode tests should meet one of the following conditions:
+
+* They should have an [assembly definition](./workflow-create-test-assembly.md) with reference to *nunit.framework.dll* and has only the Editor as a target platform:
+
+```assembly
+    "includePlatforms": [
+        "Editor"
+    ],
+```
+
+* Legacy condition: put tests in the project’s [Editor](https://docs.unity3d.com/Manual/SpecialFolders.html) folder.
+
+## Play Mode tests
+
+You can run **Play Mode** tests as a [standalone in a Player](./workflow-run-playmode-test-standalone.md) or inside the Editor. Play Mode tests allow you to exercise your game code, as the tests run as [coroutines](https://docs.unity3d.com/ScriptReference/Coroutine.html) if marked with the `UnityTest` attribute. 
+
+Play Mode tests should correspond to the following conditions:
+
+* Have an [assembly definition](./workflow-create-test-assembly.md) with reference to *nunit.framework.dll*. 
+* Have the test scripts located in a folder with the .asmdef file.
+* The test assembly should reference an assembly within the code that you need to test.
+
+```assembly
+    "references": [
+        "NewAssembly"
+    ],
+    "optionalUnityReferences": [
+        "TestAssemblies"
+   ],
+    "includePlatforms": [],
+```
+
+## Recommendations
+
+### Attributes
+
+Use the [NUnit](http://www.nunit.org/) `Test` attribute instead of the `UnityTest` attribute, unless you need to [yield special instructions](./reference-custom-yield-instructions.md), in Edit Mode, or if you need to skip a frame or wait for a certain amount of time in Play Mode.
+
+### References
+
+It is possible for your Test Assemblies to reference the test tools in `UnityEngine.TestRunner` and `UnityEditor.TestRunner`. The latter is only available in Edit Mode. You can specify these references in the `Assembly Definition References` on the Assembly Definition.

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/extending.md

@@ -0,0 +1,10 @@
+# Extending Unity Test Framework
+It is possible to extend the Unity Test Framework (UTF) in many ways, for custom workflows for your projects and for other packages to build on top of UTF.
+
+These extensions are a supplement to the ones already offered by [NUnit](https://github.com/nunit/docs/wiki/Framework-Extensibility).
+
+Some workflows for extending UTF include:
+* [How to split the build and run process for standalone Play Mode tests](./reference-attribute-testplayerbuildmodifier.md#split-build-and-run-for-player-mode-tests)
+* [How to run tests programmatically](./extension-run-tests.md)
+* [How to get test results](./extension-get-test-results.md)
+* [How to retrieve the list of tests](./extension-retrieve-test-list.md) 

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/extension-get-test-results.md

@@ -0,0 +1,45 @@
+# How to get test results
+You can receive callbacks when the active test run, or individual tests, starts and finishes. You can register callbacks by invoking `RegisterCallbacks` on the [TestRunnerApi](./reference-test-runner-api.md) with an instance of a class that implements [ICallbacks](./reference-icallbacks.md). There are four `ICallbacks` methods for the start and finish of both the whole run and each level of the test tree. 
+
+## Example
+An example of how listeners can be set up: 
+
+> **Note**: Listeners receive callbacks from all test runs, regardless of the registered `TestRunnerApi` for that instance.
+
+``` C#
+public void SetupListeners()
+{
+   var api = ScriptableObject.CreateInstance<TestRunnerApi>();
+   api.RegisterCallbacks(new MyCallbacks());
+}
+
+private class MyCallbacks : ICallbacks
+{
+    public void RunStarted(ITestAdaptor testsToRun)
+    {
+       
+    }
+
+    public void RunFinished(ITestResultAdaptor result)
+    {
+       
+    }
+
+    public void TestStarted(ITestAdaptor test)
+    {
+       
+    }
+
+    public void TestFinished(ITestResultAdaptor result)
+    {
+        if (!result.HasChildren && result.ResultState != "Passed")
+        {
+            Debug.Log(string.Format("Test {0} {1}", result.Test.Name, result.ResultState));
+        }
+    }
+}
+```
+
+> **Note**: The registered callbacks are not persisted on domain reloads. So it is necessary to re-register the callback after a domain reloads, usually with [InitializeOnLoad](https://docs.unity3d.com/Manual/RunningEditorCodeOnLaunch.html).
+
+It is possible to provide a `priority` as an integer as the second argument when registering a callback. This influences the invocation order of different callbacks. The default value is zero. It is also possible to provide `RegisterCallbacks` with a class instance that implements [IErrorCallbacks](./reference-ierror-callbacks.md) that is an extended version of `ICallbacks`. `IErrorCallbacks` also has a callback method for `OnError` that invokes if the run fails to start, for example, due to compilation errors or if an [IPrebuildSetup](./reference-setup-and-cleanup.md) throws an exception. 

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/extension-retrieve-test-list.md

@@ -0,0 +1,13 @@
+# How to retrieve the list of tests
+It is possible to use the [TestRunnerApi](./reference-test-runner-api.md) to retrieve the test tree for a given test mode (**Edit Mode** or **Play Mode**). You can retrieve the test tree by invoking `RetrieveTestList` with the desired `TestMode` and a callback action, with an [ITestAdaptor](./reference-itest-adaptor.md) representing the test tree.
+
+## Example
+The following example retrieves the test tree for Edit Mode tests and prints the number of total test cases:
+``` C#
+var api = ScriptableObject.CreateInstance<TestRunnerApi>();
+api.RetrieveTestList(TestMode.EditMode, (testRoot) =>
+{
+    Debug.Log(string.Format("Tree contains {0} tests.", testRoot.TestCaseCount));
+});
+```
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/extension-run-tests.md

@@ -0,0 +1,72 @@
+# How to run tests programmatically
+## Filters
+
+Run tests by calling `Execute` on the [TestRunnerApi](./reference-test-runner-api.md), and provide some execution settings that consists of a [Filter](./reference-filter.md). The `Filter` specifies what tests to run. 
+
+### Example
+
+The following is an example of how to run all **Play Mode** tests in a project:
+
+``` C#
+var testRunnerApi = ScriptableObject.CreateInstance<TestRunnerApi>();
+var filter = new Filter()
+{
+    testMode = TestMode.PlayMode
+};
+testRunnerApi.Execute(new ExecutionSettings(filter));
+```
+## Multiple filter values
+
+It is possible to specify a more specific filter by filling out the fields on the `Filter` class in more detail.
+
+Many of the fields allow for multiple values. The runner tries to match tests against at least one of the values provided and then runs any tests that match. 
+
+### Example
+
+In this example, the API runs tests with full names that fit either of the two names provided:
+
+``` C#
+var api = ScriptableObject.CreateInstance<TestRunnerApi>();
+api.Execute(new ExecutionSettings(new Filter()
+{
+    testNames = new[] {"MyTestClass.NameOfMyTest", "SpecificTestFixture.NameOfAnotherTest"}
+}));
+```
+## Multiple filter fields
+
+If using multiple different fields on the filter, then it matches against tests that fulfill all the different fields.
+
+### Example
+
+In this example, it runs any test that fits either of the two test names, and that also belongs to a test assembly that fits the given name.
+
+``` C#
+var api = ScriptableObject.CreateInstance<TestRunnerApi>();
+api.Execute(new ExecutionSettings(new Filter()
+{
+    assemblyNames = new [] {"MyTestAssembly"},
+    testNames = new [] {"MyTestClass.NameOfMyTest", "MyTestClass.AnotherNameOfATest"}
+}));
+```
+## Multiple constructor filters
+
+The execution settings take one or more filters in its constructor. If there is no filter provided, then it runs all **Edit Mode** tests by default. If there are multiple filters provided, then a test runs if it matches any of the filters.
+
+### Example
+
+In this example, it runs any tests that are either in the assembly named `MyTestAssembly` or if the full name of the test matches either of the two provided test names:
+
+``` C#
+var api = ScriptableObject.CreateInstance<TestRunnerApi>();
+api.Execute(new ExecutionSettings(
+    new Filter()
+    {
+        assemblyNames = new[] {"MyTestAssembly"},
+    },
+    new Filter()
+    {
+        testNames = new[] {"MyTestClass.NameOfMyTest", "MyTestClass.AnotherNameOfATest"}
+    }
+));
+```
+> **Note**: Specifying different test modes or platforms in each `Filter` is not currently supported. The test mode and platform is from the first `Filter` only and defaults to Edit Mode, if not supplied. 

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/getting-started.md

@@ -0,0 +1,18 @@
+# Getting started with Unity Test Framework
+
+To access the Unity Test Framework (UTF) in the Unity Editor, open the **Test Runner** window; go to **Window** > **General** > **Test Runner**.
+
+![Unity Test Runner window](./images/test-runner-window.png)
+
+To get started with UTF, follow the workflows below:
+
+* [How to create a new test assembly](./workflow-create-test-assembly.md)
+* [How to create a test](./workflow-create-test.md)
+* [How to run a test](./workflow-run-test.md)
+* [How to create a Play Mode test](./workflow-create-playmode-test.md)
+* [How to run a Play Mode test as standalone](./workflow-run-playmode-test-standalone.md)
+
+
+
+For further information, see the [resources](./resources.md) and [reference](./manual.md#reference) sections.
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/index.md

@@ -0,0 +1,56 @@
+# About Unity Test Framework
+
+The Unity Test Framework (UTF) enables Unity users to test their code in both **Edit Mode** and **Play Mode**, and also on target platforms such as [Standalone](https://docs.unity3d.com/Manual/Standalone.html), Android, iOS, etc.
+
+This package provides a standard test framework for users of Unity and developers at Unity so that both benefit from the same features and can write tests the same way. 
+
+UTF uses a Unity integration of NUnit library, which is an open-source unit testing library for .Net languages. UTF currently uses NUnit version 3.5. For more information about NUnit, see the [official NUnit website](http://www.nunit.org/) and the [NUnit documentation](https://docs.nunit.org/).
+
+> **Note**: UTF is not a new concept or toolset; it is an adjusted and more descriptive naming for the toolset otherwise known as Unity Test Runner, which is now available as this package. 
+
+# Installing Unity Test Framework
+
+To install this package, follow the instructions in the [Package Manager documentation](https://docs.unity3d.com/Packages/com.unity.package-manager-ui@latest/index.html).
+
+> **Note**: Search for the Test Framework package. In Unity 2019.2 and higher, you may need to enable the package before use. 
+
+# Using Unity Test Framework
+
+To learn how to use the Unity Test Framework package in your project, read the [manual](./manual.md).
+
+# Technical details
+
+## Requirements
+
+This version of the Unity Test Framework is compatible with the following versions of the Unity Editor:
+
+* 2019.2 and later.
+
+## Known limitations
+
+Unity Test Framework version 1.0.18 includes the following known limitations:
+
+* The `UnityTest` attribute does not support WSA platform.
+* The `UnityTest` attribute does not support [Parameterized tests](https://github.com/nunit/docs/wiki/Parameterized-Tests) (except for `ValueSource`).
+* The `UnityTest` attribute does not support the `NUnit` [Repeat](https://github.com/nunit/docs/wiki/Repeat-Attribute) attribute.
+* Nested test fixture cannot run from the Editor UI. 
+* When using the `NUnit` [Retry](https://github.com/nunit/docs/wiki/Retry-Attribute) attribute in PlayMode tests, it throws `InvalidCastException`.
+* Async tests are not supported in the current version of UTF.
+
+## Package contents
+
+The following table indicates the root folders in the package where you can find useful resources:
+
+| Location                                   | Description                                 |
+| :----------------------------------------- | :------------------------------------------ |
+| _/com.unity.test-framework/Documentation~_ | Contains the documentation for the package. |
+
+## Document revision history
+
+| Date         | Reason                                                |
+| :----------- | :---------------------------------------------------- |
+| February 4, 2021 | Applied user feedback to the documentation. Matches package version 1.1.22 |
+| August 23, 2019 | Applied feedback to the documentation |
+| July 25, 2019 | Documentation updated to include features in version 1.1.0 |
+| July 11, 2019 | Documentation updated. Matches package version 1.0.18 |
+| May 27, 2019 | Documentation created. Matches package version 1.0.14 |

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/manual.md

@@ -0,0 +1,80 @@
+# Unity Test Framework manual
+
+This is the manual for the Unity Test Framework (UTF):
+
+## **Introduction**
+
+* [Unity Test Framework overview](./index.md)
+* [Edit Mode vs. Play Mode tests](edit-mode-vs-play-mode-tests.md)
+
+## **Getting started**
+
+* [Getting started with UTF](./getting-started.md)
+  * Workflows:
+    * [How to create a new test assembly](./workflow-create-test-assembly.md)
+    * [How to create a test](./workflow-create-test.md)
+    * [How to run a test](workflow-run-test.md)
+    * [How to create a Play Mode test](./workflow-create-playmode-test.md)
+    * [How to run a Play Mode test in player](./workflow-run-playmode-test-standalone.md)
+* [Resources](./resources.md)
+
+## Extending UTF
+
+* [Extending UTF](./extending.md)
+  * Workflows:
+    * [How to split the build and run process for standalone Play Mode tests](./reference-attribute-testplayerbuildmodifier.md#split-build-and-run)
+    * [How to run tests programmatically](./extension-run-tests.md)
+    * [How to get test results](./extension-get-test-results.md)
+    * [How to retrieve the list of tests](./extension-retrieve-test-list.md)
+
+## Reference
+
+* [Running tests from the command-line](./reference-command-line.md)
+* [UnityTest attribute](./reference-attribute-unitytest.md)
+* [Setup and cleanup at build time](./reference-setup-and-cleanup.md)
+  * [IPrebuildSetup](./reference-setup-and-cleanup.md#iprebuildsetup)
+  * [IPostBuildCleanup](./reference-setup-and-cleanup.md#ipostbuildcleanup)
+* [Actions outside of tests](./reference-actions-outside-tests.md) 
+  * [Action execution order](./reference-actions-outside-tests.md#action-execution-order)
+  * [UnitySetUp and UnityTearDown](./reference-unitysetup-and-unityteardown.md)
+  * [OuterUnityTestAction](./reference-outerunitytestaction.md)
+  * [Domain Reloads](./reference-actions-outside-tests.md#domain-reloads)
+* [Custom attributes](./reference-custom-attributes.md)
+  * [ConditionalIgnore attribute](./reference-attribute-conditionalignore.md)
+  * [PostBuildCleanup attribute](./reference-setup-and-cleanup.md#prebuildsetup-and-postbuildcleanup)
+  * [PrebuildSetup attribute](./reference-setup-and-cleanup.md#prebuildsetup-and-postbuildcleanup)
+  * [TestMustExpectAllLogs attribute](./reference-attribute-testmustexpectalllogs.md)
+  * [TestPlayerBuildModifier attribute](./reference-attribute-testplayerbuildmodifier.md)
+  * [TestRunCallback attribute](./reference-attribute-testruncallback.md)
+  * [UnityPlatform attribute](./reference-attribute-unityplatform.md)
+  * [UnitySetUp attribute](./reference-actions-outside-tests.md#unitysetup-and-unityteardown)
+  * [UnityTearDown attribute](./reference-actions-outside-tests.md#unitysetup-and-unityteardown)
+  * [UnityTest attribute](./reference-attribute-unitytest.md)
+* [Custom equality comparers](./reference-custom-equality-comparers.md)
+  * [ColorEqualityComparer](./reference-comparer-color.md)
+  * [FloatEqualityComparer](./reference-comparer-float.md)
+  * [QuaternionEqualityComparer](./reference-comparer-quaternion.md)
+  * [Vector2EqualityComparer](./reference-comparer-vector2.md)
+  * [Vector3EqualityComparer](./reference-comparer-vector3.md)
+  * [Vector4EqualityComparer](./reference-comparer-vector4.md)
+  * [Custom equality comparers with equals operator](./reference-comparer-equals.md)
+  * [Test Utils](./reference-test-utils.md)
+* [Custom yield instructions](./reference-custom-yield-instructions.md)
+  * [IEditModeTestYieldInstruction](./reference-custom-yield-instructions.md#IEditModeTestYieldInstruction)
+  * [EnterPlayMode](./reference-custom-yield-instructions.md#enterplaymode)
+  * [ExitPlayMode](./reference-custom-yield-instructions.md#exitplaymode)
+* [Custom assertion](./reference-custom-assertion.md)
+  * [LogAssert](./reference-custom-assertion.md#logassert)
+* [Custom constraints](./reference-custom-constraints.md) 
+  * [Is](./reference-custom-constraints.md#is)
+* [Parameterized tests](./reference-tests-parameterized.md)
+* [MonoBehaviour tests](./reference-tests-monobehaviour.md)
+  * [MonoBehaviourTest<T>](./reference-tests-monobehaviour.md#monobehaviourtestt)
+  * [IMonoBehaviourTest](./reference-tests-monobehaviour.md#imonobehaviourtest)
+
+* [TestRunnerApi](./reference-test-runner-api.md)
+    * [ExecutionSettings](./reference-execution-settings.md)
+    * [Filter](./reference-filter.md)
+    * [ITestRunSettings](./reference-itest-run-settings.md)
+    * [ICallbacks](./reference-icallbacks.md)
+    * [IErrorCallbacks](./reference-ierror-callbacks.md)

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-actions-outside-tests.md

@@ -0,0 +1,32 @@
+# Actions outside of tests
+
+When writing tests, it is possible to avoid duplication of code by using the [SetUp and TearDown](https://docs.nunit.org/articles/nunit/technical-notes/usage/SetUp-and-TearDown.html) methods built into [NUnit](http://www.nunit.org/). The Unity Test Framework has extended these methods with extra functionality, which can yield commands and skip frames, in the same way as [UnityTest](./reference-attribute-unitytest.md).
+
+## Action execution order
+
+The actions related to a test run in the following order:
+
+* Attributes implementing [IApplyToContext](https://docs.nunit.org/articles/nunit/extending-nunit/IApplyToContext-Interface.html) 
+* Any attribute implementing [OuterUnityTestAction](./reference-outerunitytestaction.md) has its `BeforeTest` invoked
+* Tests with [UnitySetUp](./reference-unitysetup-and-unityteardown.md) methods in their test class
+* Attributes implementing [IWrapSetUpTearDown](https://docs.nunit.org/articles/nunit/extending-nunit/ICommandWrapper-Interface.html) 
+* Any method with the [SetUp]) attribute
+* [Action attributes](https://nunit.org/docs/2.6/actionAttributes.html) have their `BeforeTest` method invoked 
+* Attributes implementing [IWrapTestMethod](https://docs.nunit.org/articles/nunit/extending-nunit/ICommandWrapper-Interface.html)  
+* **The test itself runs**
+* [Action attributes](https://nunit.org/docs/2.6/actionAttributes.html) have their `AfterTest` method invoked
+* Any method with the [TearDown](https://docs.nunit.org/articles/nunit/technical-notes/usage/SetUp-and-TearDown.html) attribute
+* Tests with [UnityTearDown](./reference-unitysetup-and-unityteardown.md) methods in their test class
+* Any [OuterUnityTestAction](./reference-outerunitytestaction.md) has its `AfterTest` invoked
+
+The list of actions is the same for both `Test` and `UnityTest`.
+
+### Execution order flow
+
+![Action Execution Order](./images/execution-order-full.svg)
+
+> **Note**: Some browsers do not support SVG image files. If the image above does not display properly (for example, if you cannot see any text), please try another browser, such as [Google Chrome](https://www.google.com/chrome/) or [Mozilla Firefox](https://www.mozilla.org). 
+
+## Domain Reloads
+
+In **Edit Mode** tests it is possible to yield instructions that can result in a domain reload, such as entering or exiting **Play Mode** (see [Custom yield instructions](./reference-custom-yield-instructions.md)). When a domain reload happens, all non-Unity actions (such as `OneTimeSetup` and `Setup`) are rerun before the code, which initiated the domain reload, continues. Unity actions (such as `UnitySetup`) are not rerun. If the Unity action is the code that initiated the domain reload, then the rest of the code in the `UnitySetup` method runs after the domain reload.

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-attribute-conditionalignore.md

@@ -0,0 +1,39 @@
+# ConditionalIgnore attribute
+
+This attribute is an alternative to the standard `Ignore` attribute in [NUnit](http://www.nunit.org/). It allows for ignoring tests only under a specified condition. The condition evaluates during `OnLoad`, referenced by ID. 
+
+## Example
+
+The following example shows a method to use the `ConditionalIgnore` attribute to ignore a test if the Unity Editor is running macOS:
+
+```C#
+using UnityEditor;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+
+[InitializeOnLoad]
+public class OnLoad
+{
+    static OnLoad()
+    {
+        var editorIsOSX = false;
+        #if UNITY_EDITOR_OSX
+            editorIsOSX = true;
+        #endif
+        
+        ConditionalIgnoreAttribute.AddConditionalIgnoreMapping("IgnoreInMacEditor", editorIsOSX);
+    }
+}
+
+public class MyTestClass
+{
+    [Test, ConditionalIgnore("IgnoreInMacEditor", "Ignored on Mac editor.")]
+    public void TestNeverRunningInMacEditor()
+    {
+        Assert.Pass();
+    }
+}
+
+```
+
+> **Note**: You can only use `InitializeOnLoad` in **Edit Mode** tests.

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-attribute-testmustexpectalllogs.md

@@ -0,0 +1,11 @@
+# TestMustExpectAllLogs attribute
+
+The presence of this attribute causes the **Test Runner** to expect every single log. By default, the Test Runner only fails on error logs, but `TestMustExpectAllLogs` fails on warnings and info level messages as well. It is the same as calling the method [LogAssert.NoUnexpectedReceived](./reference-custom-assertion.md#static-methods) at the bottom of every affected test.
+
+## Assembly-wide usage
+
+You can apply this attribute to test assemblies (that affects every test in the assembly), fixtures (affects every test in the fixture), or on individual test methods. It is also inherited from base fixtures.
+
+The `MustExpect` property (`true` by default) lets you enable or disable the higher level value. 
+
+For example when migrating an assembly to this more strict checking method, you might attach `[assembly:TestMustExpectAllLogs]` to the assembly itself, but then whitelist failing fixtures and test methods with `[TestMustExpectAllLogs(MustExpect=false)]` until you have migrated them. This also means new tests in that assembly would have the more strict checking.

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-attribute-testplayerbuildmodifier.md

@@ -0,0 +1,105 @@
+# TestPlayerBuildModifier attribute
+
+You can use the `TestPlayerBuildModifier` attribute to accomplish a couple of different scenarios:
+
+## Modify the Player build options for Play Mode tests
+
+It is possible to change the [BuildPlayerOptions](https://docs.unity3d.com/ScriptReference/BuildPlayerOptions.html) for the test **Player**, to achieve custom behavior when running **Play Mode** tests. Modifying the build options allows for changing the target location of the build as well as changing [BuildOptions](https://docs.unity3d.com/ScriptReference/BuildOptions.html).
+
+To modify the `BuildPlayerOptions`, do the following: 
+
+* Implement the `ITestPlayerBuildModifier` 
+* Reference the implementation type in a `TestPlayerBuildModifier` attribute on an assembly level.
+
+### Example
+
+```c#
+using UnityEditor;
+using UnityEditor.TestTools;
+
+[assembly:TestPlayerBuildModifier(typeof(BuildModifier))]
+public class BuildModifier : ITestPlayerBuildModifier
+{
+    public BuildPlayerOptions ModifyOptions(BuildPlayerOptions playerOptions)
+    {
+        if (playerOptions.target == BuildTarget.iOS)
+        {
+            playerOptions.options |= BuildOptions.SymlinkLibraries; // Enable symlink libraries when running on iOS
+        }
+        
+        playerOptions.options |= BuildOptions.AllowDebugging; // Enable allow Debugging flag on the test Player.
+        return playerOptions;
+    }
+}
+```
+
+> **Note:** When building the Player, it includes all `TestPlayerBuildModifier` attributes across all loaded assemblies, independent of the currently used test filter. As the implementation references the `UnityEditor` namespace, the code is typically implemented in an Editor only assembly, as the `UnityEditor` namespace is not available otherwise.
+
+## Split build and run
+
+It is possible to use the Unity Editor for building the Player with tests, without [running the tests](./workflow-run-playmode-test-standalone.md). This allows for running the Player on e.g. another machine. In this case, it is necessary to modify the Player to build and implement a custom handling of the test result.
+
+By using `TestPlayerBuildModifier`, you can alter the `BuildOptions` to not start the Player after the build as well as build the Player at a specific location. Combined with [PostBuildCleanup](./reference-setup-and-cleanup.md#prebuildsetup-and-postbuildcleanup), you can automatically exit the Editor on completion of the build.
+
+### Example
+
+```c#
+using System;
+using System.IO;
+using System.Linq;
+using Tests;
+using UnityEditor;
+using UnityEditor.TestTools;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+[assembly:TestPlayerBuildModifier(typeof(HeadlessPlayModeSetup))]
+[assembly:PostBuildCleanup(typeof(HeadlessPlayModeSetup))]
+
+namespace Tests
+{
+    public class HeadlessPlayModeSetup : ITestPlayerBuildModifier, IPostBuildCleanup
+    {
+        private static bool s_RunningPlayerTests;
+        public BuildPlayerOptions ModifyOptions(BuildPlayerOptions playerOptions)
+        {
+            // Do not launch the player after the build completes.
+            playerOptions.options &= ~BuildOptions.AutoRunPlayer;
+
+            // Set the headlessBuildLocation to the output directory you desire. It does not need to be inside the project.
+            var headlessBuildLocation = Path.GetFullPath(Path.Combine(Application.dataPath, ".//..//PlayModeTestPlayer"));
+            var fileName = Path.GetFileName(playerOptions.locationPathName);
+            if (!string.IsNullOrEmpty(fileName))
+            {
+                headlessBuildLocation = Path.Combine(headlessBuildLocation, fileName);
+            }
+            playerOptions.locationPathName = headlessBuildLocation;
+
+            // Instruct the cleanup to exit the Editor if the run came from the command line. 
+            // The variable is static because the cleanup is being invoked in a new instance of the class.
+            s_RunningPlayerTests = true;
+            return playerOptions;
+        }
+
+        public void Cleanup()
+        {
+            if (s_RunningPlayerTests && IsRunningTestsFromCommandLine())
+            {
+                // Exit the Editor on the next update, allowing for other PostBuildCleanup steps to run.
+                EditorApplication.update += () => { EditorApplication.Exit(0); };
+            }
+        }
+
+        private static bool IsRunningTestsFromCommandLine()
+        {
+            var commandLineArgs = Environment.GetCommandLineArgs();
+            return commandLineArgs.Any(value => value == "-runTests");
+        }
+    }
+}
+```
+
+If the Editor is still running after the Play Mode tests have run, the Player tries to report the results back, using [PlayerConnection](https://docs.unity3d.com/ScriptReference/Networking.PlayerConnection.PlayerConnection.html), which has a reference to the IP address of the Editor machine, when built. 
+
+To implement a custom way of reporting the results of the test run, let one of the assemblies in the Player include a [TestRunCallback](./reference-attribute-testruncallback.md). At `RunFinished`, it is possible to get the full test report as XML from the [NUnit](http://www.nunit.org/) test result by calling `result.ToXml(true)`. You can save the result and then save it on the device or send it to another machine as needed.
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-attribute-testruncallback.md

@@ -0,0 +1,46 @@
+# TestRunCallback attribute
+
+It is possible for the test framework to invoke callbacks as the current test run progresses. To do this, there is a `TestRunCallback` attribute which takes the type of `ITestRunCallback` implementation. You can invoke the callbacks with [NUnit](http://www.nunit.org/) `ITest` and `ITestResult` classes. 
+
+At the `RunStarted` and `RunFinished` methods, the test and test results are for the whole test tree. These methods invoke at each node in the test tree; first with the whole test assembly, then with the test class, and last with the test method.
+
+From these callbacks, it is possible to read the partial or the full results, and it is furthermore possible to save the XML version of the result for further processing or continuous integration.
+
+## Example
+
+```C#
+using NUnit.Framework.Interfaces;
+using UnityEngine;
+using UnityEngine.TestRunner;
+
+[assembly:TestRunCallback(typeof(MyTestRunCallback))]
+
+public class MyTestRunCallback : ITestRunCallback
+{
+    public void RunStarted(ITest testsToRun)
+    {
+        
+    }
+
+    public void RunFinished(ITestResult testResults)
+    {
+        
+    }
+
+    public void TestStarted(ITest test)
+    {
+        
+    }
+
+    public void TestFinished(ITestResult result)
+    {
+        if (!result.Test.IsSuite)
+        {
+            Debug.Log($"Result of {result.Name}: {result.ResultState.Status}");
+        }
+    }
+}
+
+```
+
+> **Note:** The `TestRunCallback` does not need any references to the `UnityEditor` namespace and is thus able to run in standalone Players, on the **Player** side.

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-attribute-unityplatform.md

@@ -0,0 +1,35 @@
+# UnityPlatform attribute
+
+Use this attribute to define a specific set of platforms you want or do not want your test(s) to run on.
+
+You can use this attribute on the test method, test class, or test assembly level. Use the supported [RuntimePlatform](https://docs.unity3d.com/ScriptReference/RuntimePlatform.html) enumeration values to specify the platforms. You can also specify which platforms to test by passing one or more `RuntimePlatform` values along with or without the include or exclude properties as parameters to the [Platform](https://github.com/nunit/docs/wiki/Platform-Attribute) attribute constructor. 
+
+The test(s) skips if the current target platform is:
+
+- Not explicitly specified in the included platforms list 
+- In the excluded platforms list 
+
+```c#
+using UnityEngine;
+using UnityEngine.TestTools;
+using NUnit.Framework;
+
+[TestFixture]
+public class TestClass
+{
+    [Test]
+    [UnityPlatform(RuntimePlatform.WindowsPlayer)]
+    public void TestMethod()
+    {
+        Assert.AreEqual(Application.platform, RuntimePlatform.WindowsPlayer);
+    }
+}
+```
+
+## Properties
+
+| Syntax                      | Description                                                  |
+| --------------------------- | ------------------------------------------------------------ |
+| `RuntimePlatform[] exclude` | List the platforms you do not want to have your tests run on. |
+| `RuntimePlatform[] include` | A subset of platforms you need to have your tests run on.    |
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-attribute-unitytest.md

@@ -0,0 +1,51 @@
+# UnityTest attribute
+
+`UnityTest` attribute is the main addition to the standard [NUnit](http://www.nunit.org/) library for the Unity Test Framework. This type of unit test allows you to skip a frame from within a test (so background tasks can finish) or give certain commands to the Unity **Editor**, such as performing a domain reload or entering **Play Mode** from an **Edit Mode** test.
+
+In Play Mode, the `UnityTest` attribute runs as a [coroutine](https://docs.unity3d.com/Manual/Coroutines.html). Whereas Edit Mode tests run in the [EditorApplication.update](https://docs.unity3d.com/ScriptReference/EditorApplication-update.html) callback loop.
+
+The `UnityTest` attribute is, in fact, an alternative to the `NUnit` [Test attribute](https://github.com/nunit/docs/wiki/Test-Attribute), which allows yielding instructions back to the framework. Once the instruction is complete, the test run continues. If you `yield return null`, you skip a frame. That might be necessary to ensure that some changes do happen on the next iteration of either the `EditorApplication.update` loop or the [game loop](https://docs.unity3d.com/Manual/ExecutionOrder.html).
+
+## Edit Mode example
+
+The most simple example of an Edit Mode test could be the one that yields `null` to skip the current frame and then continues to run:
+
+```C#
+[UnityTest]
+public IEnumerator EditorUtility_WhenExecuted_ReturnsSuccess()
+{
+    var utility = RunEditorUtilityInTheBackground();
+
+    while (utility.isRunning)
+    {
+        yield return null;
+    }
+
+    Assert.IsTrue(utility.isSuccess);
+}    
+```
+
+## Play Mode example
+
+In Play Mode, a test runs as a coroutine attached to a [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html). So all the yield instructions available in coroutines, are also available in your test. 
+
+From a Play Mode test you can use one of Unity’s [Yield Instructions](https://docs.unity3d.com/ScriptReference/YieldInstruction.html):
+
+- [WaitForFixedUpdate](https://docs.unity3d.com/ScriptReference/WaitForFixedUpdate.html): to ensure changes expected within the next cycle of physics calculations.
+- [WaitForSeconds](https://docs.unity3d.com/ScriptReference/WaitForSeconds.html): if you want to pause your test coroutine for a fixed amount of time. Be careful about creating long-running tests.
+
+The simplest example is to yield to `WaitForFixedUpdate`:
+
+```c#
+[UnityTest]
+public IEnumerator GameObject_WithRigidBody_WillBeAffectedByPhysics()
+{
+    var go = new GameObject();
+    go.AddComponent<Rigidbody>();
+    var originalPosition = go.transform.position.y;
+
+    yield return new WaitForFixedUpdate();
+
+    Assert.AreNotEqual(originalPosition, go.transform.position.y);
+}
+```

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-command-line.md

@@ -0,0 +1,120 @@
+# Running tests from the command line
+
+It’s pretty simple to run a test project from the command line. Here is an example in Windows:
+
+```bash
+Unity.exe -runTests -batchmode -projectPath PATH_TO_YOUR_PROJECT -testResults C:\temp\results.xml -testPlatform PS4
+```
+
+> **Note**: Use the `-batchmode` option when running tests on the command line to remove the need for manual user inputs. For more information, see Unity [Command line arguments](https://docs.unity3d.com/Manual/CommandLineArguments.html).
+
+## Test Framework command line arguments
+
+### forgetProjectPath
+
+Don't save your current **Project** into the Unity launcher/hub history.
+
+### runTests
+
+Runs tests in the Project.
+
+### testCategory
+
+A semicolon-separated list of test categories to include in the run. A semi-colon separated list should be formatted as a string enclosed in quotation marks, e.g. `testCategory "firstCategory;secondCategory"`. If using both `testFilter` and `testCategory`, then only tests that match both are run. This argument supports negation using '!'. If using '!MyCategory' then no tests with the 'MyCategory' category will be included in the run.
+
+### testFilter
+
+A semicolon-separated list of test names to run, or a regular expression pattern to match tests by their full name. A semi-colon separated list should be formatted as a string enclosed in quotation marks, e.g. `testFilter "Low;Medium"`. This argument supports negation using '!'. If using the test filter '!MyNamespace.Something.MyTest', then all tests except that test will be run.
+
+### testPlatform
+
+The platform to run tests on. Accepted values: 
+
+* **EditMode**
+    * Edit Mode tests. Equivalent to running tests from the EditMode tab of the Test Runner window.
+* **PlayMode**
+    * Play Mode tests that run in the Editor. Equivalent to running tests from the PlayMode tab of the Test Runner window.
+* Any value from the [BuildTarget](https://docs.unity3d.com/ScriptReference/BuildTarget.html) enum.
+    * Play Mode tests that run on a player built for the specified platform. Equivalent to using the **Run all tests (`<target_platform>`)** dropdown in the PlayMode tab of the Test Runner window.
+
+> **Note**: If no value is specified for this argument, tests run in Edit Mode.
+
+### assemblyNames
+
+A semicolon-separated list of test assemblies to include in the run. A semi-colon separated list should be formatted as a string enclosed in quotation marks, e.g. `assemblyNames "firstAssembly;secondAssembly"`.
+
+### testResults
+
+The path where Unity should save the result file. By default, Unity saves it in the Project’s root folder. Test results follow the XML format as defined by NUnit, see the [NUnit documentation](https://docs.nunit.org/articles/nunit/technical-notes/usage/Test-Result-XML-Format.html). There is currently no common definition for exit codes reported by individual Unity components under test. The best way to understand the source of a problem is the content of error messages and stack traces.
+
+### playerHeartbeatTimeout
+
+The time, in seconds, the editor should wait for heartbeats after starting a test run on a player. This defaults to 10 minutes.
+
+### runSynchronously
+
+If included, the test run will run tests synchronously, guaranteeing that all tests runs in one editor update call. Note that this is only supported for EditMode tests, and that tests which take multiple frames (i.e. `[UnityTest]` tests, or tests with `[UnitySetUp]` or `[UnityTearDown]` scaffolding) will be filtered out.
+
+### testSettingsFile 
+
+Path to a *TestSettings.json* file that allows you to set up extra options for your test run. An example of the *TestSettings.json* file could look like this:
+
+```json
+{
+  "scriptingBackend":"WinRTDotNET",
+  "Architecture":null,
+  "apiProfile":0
+}
+```
+
+#### apiProfile
+
+The .Net compatibility level. Set to one of the following values:  
+
+- 1 - .Net 2.0 
+- 2 - .Net 2.0 Subset 
+- 3 - .Net 4.6 
+- 5 - .Net micro profile (used by Mono scripting backend if **Stripping Level** is set to **Use micro mscorlib**) 
+- 6 - .Net Standard 2.0 
+
+#### appleEnableAutomaticSigning
+
+Sets option for automatic signing of Apple devices.
+
+#### appleDeveloperTeamID 
+
+Sets the team ID for the apple developer account.
+
+#### architecture
+
+Target architecture for Android. Set to one of the following values: 
+
+* None = 0
+* ARMv7 = 1
+* ARM64 = 2
+* X86 = 4
+* All = 4294967295
+
+#### iOSManualProvisioningProfileType
+
+Set to one of the following values: 
+
+* 0 - Automatic 
+* 1 - Development 
+* 2 - Distribution iOSManualProvisioningProfileID
+
+#### scriptingBackend
+
+ Set to one of the following values, which should be given as a string literal enclosed in quotes:
+
+- Mono2x
+- IL2CPP
+- WinRTDotNET
+
+#### playerGraphicsAPI
+
+ Set graphics API that will be used during test execution in the player. Value can be any [GraphicsDeviceType](https://docs.unity3d.com/ScriptReference/Rendering.GraphicsDeviceType.html) as a string literal enclosed in quotes. Value will only be set if it is supported on the target platform.
+
+### androidBuildAppBundle
+
+A boolean setting that allows to build an Android App Bundle (AAB) instead of APK for tests.

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-comparer-color.md

@@ -0,0 +1,47 @@
+# ColorEqualityComparer
+
+Use this class to compare two `Color` objects. `ColorEqualityComparer.Instance` has default calculation error value set to 0.01f. To set a test specific error value instantiate a comparer instance using the [one argument constructor](#constructors).
+
+## Static properties
+
+| Syntax     | Description                                                  |
+| ---------- | ------------------------------------------------------------ |
+| `Instance` | A singleton instance of the comparer with a default error value set to 0.01f. |
+
+## Constructors
+
+| Syntax                               | Description                                                  |
+| ------------------------------------ | ------------------------------------------------------------ |
+| `ColorEqualityComparer(float error)` | Creates an instance of the comparer with a custom error value. |
+
+## Public methods
+
+| Syntax                                       | Description                                                  |
+| -------------------------------------------- | ------------------------------------------------------------ |
+| `bool Equals(Color expected, Color actual);` | Compares the actual and expected `Color` objects for equality using  `Utils.AreFloatsEqualAbsoluteError` to compare the `RGB` and `Alpha` attributes of `Color`. Returns `true` if expected and actual objects are equal otherwise, it returns `false`. |
+
+## Example
+
+```c#
+[TestFixture]
+public class ColorEqualityTest
+{
+    [Test]
+    public void GivenColorsAreEqual_WithAllowedCalculationError()
+    {
+        // Using default error
+        var firstColor = new Color(0f, 0f, 0f, 0f);
+        var secondColor = new Color(0f, 0f, 0f, 0f);
+
+        Assert.That(firstColor, Is.EqualTo(secondColor).Using(ColorEqualityComparer.Instance));
+		
+        // Allowed error 10e-5f
+        var comparer = new ColorEqualityComparer(10e-5f);
+        firstColor = new Color(0f, 0f, 0f, 1f);
+        secondColor = new Color(10e-6f, 0f, 0f, 1f);
+
+        Assert.That(firstColor, Is.EqualTo(secondColor).Using(comparer));
+    }
+}
+```
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-comparer-equals.md

@@ -0,0 +1,27 @@
+# Custom equality comparers with equals operator
+
+If you need to compare Vectors using the overloaded operator == (see [Vector2.operator ==](https://docs.unity3d.com/ScriptReference/Vector2-operator_eq.html),  [Vector3.operator ==](https://docs.unity3d.com/ScriptReference/Vector3-operator_eq.html), and [Vector4.operator ==](https://docs.unity3d.com/ScriptReference/Vector4-operator_eq.html))  you should use the respective comparer implementations:
+
+- Vector2ComparerWithEqualsOperator
+- Vector3ComparerWithEqualsOperator
+- Vector4ComparerWithEqualsOperator
+
+The interface is the same as for other [equality comparers](./reference-custom-equality-comparers.md) except the public [constructor](./reference-custom-equality-comparers.md#constructors) `error` parameter is inapplicable in this case. 
+
+## Example
+
+```c#
+[TestFixture]
+public class Vector3Test
+{
+    [Test]
+    public void VerifyThat_TwoVector3ObjectsAreEqual()
+    {
+        var actual = new Vector3(10e-7f, 10e-7f, 10e-7f);
+        var expected = new Vector3(0f, 0f, 0f);
+
+        Assert.That(actual, Is.EqualTo(expected).Using(Vector3ComparerWithEqualsOperator.Instance));
+    }
+}
+```
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-comparer-float.md

@@ -0,0 +1,46 @@
+# FloatEqualityComparer
+
+Use this class to compare two float values for equality with [NUnit](http://www.nunit.org/) constraints. Use `FloatEqualityComparer.Instance` comparer to have the default error value set to 0.0001f. For any other error, use the [one argument constructor](#constructors) to create a comparer.
+
+## Static Properties
+
+| Syntax     | Description                                                  |
+| ---------- | ------------------------------------------------------------ |
+| `Instance` | A singleton instance of the comparer with a default error value set to 0.0001f. |
+
+## Constructors
+
+| Syntax                                      | Description                                                  |
+| ------------------------------------------- | ------------------------------------------------------------ |
+| `FloatEqualityComparer(float allowedError)` | Creates an instance of the comparer with a custom error value. |
+
+## Public methods
+
+| Syntax                                       | Description                                                  |
+| -------------------------------------------- | ------------------------------------------------------------ |
+| `bool Equals(float expected, float actual);` | Compares the `actual` and `expected` float values for equality using `Utils.AreFloatsEqual`. |
+
+## Example
+
+```c#
+[TestFixture]
+public class FloatsTest
+{
+    [Test]
+    public void VerifyThat_TwoFloatsAreEqual()
+    {
+        var comparer = new FloatEqualityComparer(10e-6f);
+        var actual = -0.00009f;
+        var expected = 0.00009f;
+
+        Assert.That(actual, Is.EqualTo(expected).Using(comparer));
+
+        // Default relative error 0.0001f
+        actual = 10e-8f;
+        expected = 0f;
+
+        Assert.That(actual, Is.EqualTo(expected).Using(FloatEqualityComparer.Instance));
+    }
+}
+```
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-comparer-quaternion.md

@@ -0,0 +1,46 @@
+# QuaternionEqualityComparer
+
+Use this utility to compare two [Quaternion](https://docs.unity3d.com/ScriptReference/Quaternion.html) objects for equality with [NUnit](http://www.nunit.org/) assertion constraints. Use the static instance `QuaternionEqualityComparer.Instance` to have the default calculation error value set to 0.00001f. For any other custom error value, use the [one argument constructor](#constructors).
+
+## Static properties
+
+| Syntax     | Description                                                |
+| ---------- | ---------------------------------------------------------- |
+| `Instance` | A comparer instance with the default error value 0.00001f. |
+
+## Constructors
+
+| Syntax                                           | Description                                                  |
+| ------------------------------------------------ | ------------------------------------------------------------ |
+| `QuaternionEqualityComparer(float allowedError)` | Creates an instance of the comparer with a custom allowed error value. |
+
+## Public methods
+
+| Syntax                                                | Description                                                  |
+| ----------------------------------------------------- | ------------------------------------------------------------ |
+| `bool Equals(Quaternion expected, Quaternion actual)` | Compares the `actual` and `expected` `Quaternion` objects for equality using the [Quaternion.Dot](https://docs.unity3d.com/ScriptReference/Quaternion.Dot.html) method. |
+
+## Example
+
+```c#
+[TestFixture]
+public class QuaternionTest
+{
+    [Test]
+    public void VerifyThat_TwoQuaternionsAreEqual()
+    {
+        var actual = new Quaternion(10f, 0f, 0f, 0f);
+        var expected = new Quaternion(1f, 10f, 0f, 0f);
+        var comparer = new QuaternionEqualityComparer(10e-6f);
+
+        Assert.That(actual, Is.EqualTo(expected).Using(comparer));
+
+        //Using default error 0.00001f
+        actual = new Quaternion(10f, 0f, 0.1f, 0f);
+        expected = new Quaternion(1f, 10f, 0.1f, 0f);
+
+        Assert.That(actual, Is.EqualTo(expected).Using(QuaternionEqualityComparer.Instance));
+    }
+}
+```
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-comparer-vector2.md

@@ -0,0 +1,47 @@
+# Vector2EqualityComparer
+
+Use this class to compare two [Vector2](https://docs.unity3d.com/ScriptReference/Vector2.html) objects for equality with [NUnit](http://www.nunit.org/) constraints. Use the static `Vector2EqualityComparer.Instance` to have the calculation error value set to default 0.0001f. For any other error value, instantiate a new comparer object with the [one argument constructor](#constructors).
+
+## Static properties
+
+| Syntax     | Description                                                  |
+| ---------- | ------------------------------------------------------------ |
+| `Instance` | A comparer instance with the default error value set to 0.0001f. |
+
+## Constructors
+
+| Syntax                                 | Description                                    |
+| -------------------------------------- | ---------------------------------------------- |
+| `Vector2EqualityComparer(float error)` | Creates an instance with a custom error value. |
+
+## Public methods
+
+| Syntax                                     | Description                                                  |
+| ------------------------------------------ | ------------------------------------------------------------ |
+| `Equals(Vector2 expected, Vector2 actual)` | Compares the `actual` and `expected` `Vector2` objects for equality using the [Utils.AreFloatsEqual](./reference-test-utils.md) method. |
+
+## Example
+
+```c#
+[TestFixture]
+public class Vector2Test
+{
+    [Test]
+    public void VerifyThat_TwoVector2ObjectsAreEqual()
+    {
+        // Custom calculation error
+        var actual = new Vector2(10e-7f, 10e-7f);
+        var expected = new Vector2(0f, 0f);
+        var comparer = new Vector2EqualityComparer(10e-6f);
+
+        Assert.That(actual, Is.EqualTo(expected).Using(comparer));
+
+        //Default error 0.0001f
+        actual = new Vector2(0.01f, 0.01f);
+        expected = new Vector2(0.01f, 0.01f);
+
+        Assert.That(actual, Is.EqualTo(expected).Using(Vector2EqualityComparer.Instance));
+    }
+}
+```
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-comparer-vector3.md

@@ -0,0 +1,47 @@
+# Vector3EqualityComparer
+
+Use this class to compare two [Vector3](https://docs.unity3d.com/ScriptReference/Vector3.html) objects for equality with `NUnit` constraints. Call `Vector3EqualityComparer.Instance` comparer to perform a comparison with the default calculation error value 0.0001f. To specify a different error value, use the [one argument constructor](#constructors) to instantiate a new comparer.
+
+## Static properties
+
+| Syntax     | Description                                                  |
+| ---------- | ------------------------------------------------------------ |
+| `Instance` | A comparer instance with the default calculation error value equal to 0.0001f. |
+
+## Constructors
+
+| Syntax                                        | Description                                    |
+| --------------------------------------------- | ---------------------------------------------- |
+| `Vector3EqualityComparer(float allowedError)` | Creates an instance with a custom error value. |
+
+## Public methods
+
+| Syntax                                          | Description                                                  |
+| ----------------------------------------------- | ------------------------------------------------------------ |
+| `bool Equals(Vector3 expected, Vector3 actual)` | Compares the `actual` and `expected` `Vector3` objects for equality using [Utils.AreFloatsEqual](http://todo) to compare the `x`, `y`, and `z` attributes of `Vector3`. |
+
+## Example
+
+```c#
+[TestFixture]
+public class Vector3Test
+{
+    [Test]
+    public void VerifyThat_TwoVector3ObjectsAreEqual()
+    {
+        // Custom error 10e-6f
+        var actual = new Vector3(10e-8f, 10e-8f, 10e-8f);
+        var expected = new Vector3(0f, 0f, 0f);
+        var comparer = new Vector3EqualityComparer(10e-6f);
+
+        Assert.That(actual, Is.EqualTo(expected).Using(comparer));
+
+        //Default error 0.0001f
+        actual = new Vector3(0.01f, 0.01f, 0f);
+        expected = new Vector3(0.01f, 0.01f, 0f);
+
+        Assert.That(actual, Is.EqualTo(expected).Using(Vector3EqualityComparer.Instance));
+    }
+}
+```
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-comparer-vector4.md

@@ -0,0 +1,47 @@
+# Vector4EqualityComparer
+
+Use this class to compare two [Vector4](https://docs.unity3d.com/ScriptReference/Vector4.html) objects for equality with [NUnit](http://www.nunit.org/) constraints. Call `Vector4EqualityComparer.Instance` to perform comparisons using default calculation error value 0.0001f. To set a custom test value, instantiate a new comparer using the [one argument constructor](#constructor).
+
+## Static Properties
+
+| Syntax                             | Description                                                  |
+| ---------------------------------- | ------------------------------------------------------------ |
+| `Vector4EqualityComparer Instance` | A comparer instance with the default calculation error value set to 0.0001f. |
+
+## Constructors
+
+| Syntax                                        | Description                                    |
+| --------------------------------------------- | ---------------------------------------------- |
+| `Vector4EqualityComparer(float allowedError)` | Creates an instance with a custom error value. |
+
+## Public methods
+
+| Syntax                                           | Description                                                  |
+| ------------------------------------------------ | ------------------------------------------------------------ |
+| `bool Equals(Vector4 expected, Vector4 actual);` | Compares the `actual` and `expected` `Vector4` objects for equality using [Utils.AreFloatsEqual](http://todo) to compare the `x`, `y`, `z`, and `w` attributes of `Vector4`. |
+
+## Example
+
+```c#
+[TestFixture]
+public class Vector4Test
+{
+    [Test]
+    public void VerifyThat_TwoVector4ObjectsAreEqual()
+    {
+        // Custom error 10e-6f
+        var actual = new Vector4(0, 0, 1e-6f, 1e-6f);
+        var expected = new Vector4(1e-6f, 0f, 0f, 0f);
+        var comparer = new Vector4EqualityComparer(10e-6f);
+
+        Assert.That(actual, Is.EqualTo(expected).Using(comparer));
+
+        // Default error 0.0001f
+        actual = new Vector4(0.01f, 0.01f, 0f, 0f);
+        expected = new Vector4(0.01f, 0.01f, 0f, 0f);
+
+        Assert.That(actual, Is.EqualTo(expected).Using(Vector4EqualityComparer.Instance));
+    }
+}
+```
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-custom-assertion.md

@@ -0,0 +1,66 @@
+# Custom assertion
+
+A test fails if Unity logs a message other than a regular log or warning message. Use [LogAssert](#logassert) to check for an expected message in the log so that the test does not fail when Unity logs the message.
+
+Use `LogAssert.Expect` before running the code under test, as the check for expected logs runs at the end of each frame.
+
+A test also reports a failure, if an expected message does not appear, or if Unity does not log any regular log or warning messages.
+
+## Example
+
+```c#
+[Test]
+public void LogAssertExample()
+{
+    // Expect a regular log message
+    LogAssert.Expect(LogType.Log, "Log message");
+    
+    // The test fails without the following expected log message     
+    Debug.Log("Log message");
+    
+    // An error log
+    Debug.LogError("Error message");
+    
+    // Without expecting an error log, the test would fail
+    LogAssert.Expect(LogType.Error, "Error message");
+}
+```
+
+## LogAssert
+
+`LogAssert` lets you expect Unity log messages that would otherwise cause the test to fail. It is available under the namespace `UnityEngine.TestTools`, see the Scripting API for more details.
+
+### Static properties
+
+| Syntax                       | Description                                                  |
+| ---------------------------- | ------------------------------------------------------------ |
+| `bool ignoreFailingMessages` | Set this property to `true` to prevent unexpected error log messages from triggering an assertion. By default, it is `false`. |
+
+### Static Methods
+
+| Syntax                                                       | Description                                                  |
+| ------------------------------------------------------------ | ------------------------------------------------------------ |
+| `void Expect(LogType type, string message);` `void Expect(LogType type, Regex message);` | Verifies that a log message of a specified type appears in the log. A test won’t fail from an expected error, assertion, or exception log message. It does fail if an expected message does not appear in the log. |
+| `void NoUnexpectedReceived();`                               | Triggers an assertion when receiving any log messages and fails the test if some are unexpected messages. If multiple tests need to check for no received unexpected logs, consider using the [TestMustExpectAllLogs](./reference-attribute-testmustexpectalllogs.md) attribute instead. |
+
+### Expect string message
+
+`void Expect(LogType type, string message);`
+
+#### Parameters
+
+| Syntax           | Description                                                  |
+| ---------------- | ------------------------------------------------------------ |
+| `LogType type`   | A type of log to expect. It can take one of the [LogType enum](https://docs.unity3d.com/ScriptReference/LogType.html) values. |
+| `string message` | A string value that should equate to the expected message.   |
+
+### Expect Regex message
+
+`void Expect(LogType type, Regex message);`
+
+#### Parameters
+
+| Syntax          | Description                                                  |
+| --------------- | ------------------------------------------------------------ |
+| `LogType type`  | A type of log to expect. It can take one of the [LogType enum](https://docs.unity3d.com/ScriptReference/LogType.html) values. |
+| `Regex message` | A regular expression pattern to match the expected message.  |

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-custom-attributes.md

@@ -0,0 +1,15 @@
+# Custom attributes
+
+As a part of UTF’s public API we provide the following attributes:
+
+* [ConditionalIgnore attribute](./reference-attribute-conditionalignore.md)
+* [PostBuildCleanup attribute](./reference-setup-and-cleanup.md#prebuildsetup-and-postbuildcleanup)
+* [PrebuildSetup attribute](./reference-setup-and-cleanup.md#prebuildsetup-and-postbuildcleanup)
+* [TestMustExpectAllLogs attribute](./reference-attribute-testmustexpectalllogs.md)
+* [TestPlayerBuildModifier attribute](./reference-attribute-testplayerbuildmodifier.md)
+* [TestRunCallback attribute](./reference-attribute-testruncallback.md)
+* [UnityPlatform attribute](./reference-attribute-unityplatform.md)
+* [UnitySetUp attribute](./reference-actions-outside-tests.md#unitysetup-and-unityteardown)
+* [UnityTearDown attribute](./reference-actions-outside-tests.md#unitysetup-and-unityteardown)
+* [UnityTest attribute](./reference-attribute-unitytest.md)
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-custom-constraints.md

@@ -0,0 +1,31 @@
+# Custom constraints 
+
+`NUnit` allows you to write test assertions in a more descriptive and human readable way using the [Assert.That](https://github.com/nunit/docs/wiki/Assertions) mechanism, where the first parameter is an object under test and the second parameter describes conditions that the object has to meet. 
+
+## Is
+
+We’ve extended `NUnit` API with a custom constraint type and declared an overlay `Is` class. To resolve ambiguity between the original implementation and the custom one you must explicitly declare it with a using statement or via addressing through the full type name `UnityEngine.TestTools.Constraints.Is`.
+
+### Static Methods
+
+| Syntax               | Description                                                  |
+| -------------------- | ------------------------------------------------------------ |
+| `AllocatingGCMemory` | A constraint type that invokes the delegate you provide as the parameter of `Assert.That` and checks whether it causes any GC memory allocations. It passes if any GC memory is allocated and fails if not. |
+
+## Example
+
+```c#
+using Is = UnityEngine.TestTools.Constraints.Is;
+
+class MyTestClass
+{
+    [Test]
+    public void MyTest()
+    {
+        Assert.That(() => {
+            var i = new int[500];
+        }, Is.AllocatingGCMemory());
+    }
+}
+```
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-custom-equality-comparers.md

@@ -0,0 +1,32 @@
+# Custom equality comparers
+
+To enable easier verification of custom Unity type values in your tests we provide you with some custom equality comparers:
+
+* [ColorEqualityComparer](./reference-comparer-color.md)
+* [FloatEqualityComparer](./reference-comparer-float.md)
+* [QuaternionEqualityComparer](./reference-comparer-quaternion.md)
+* [Vector2EqualityComparer](./reference-comparer-vector2.md)
+* [Vector3EqualityComparer](./reference-comparer-vector3.md)
+* [Vector4EqualityComparer](./reference-comparer-vector4.md)
+
+Use these classes to compare two objects of the same type for equality within the range of a given tolerance using [NUnit ](https://github.com/nunit/docs/wiki/Constraints)or [custom constraints](./reference-custom-constraints.md) . Call Instance to apply the default calculation error value to the comparison. To set a specific error value, instantiate a new comparer object using a one argument constructor `ctor(float error)`.
+
+## Static properties
+
+| Syntax     | Description                                                  |
+| ---------- | ------------------------------------------------------------ |
+| `Instance` | A singleton instance of the comparer with a predefined default error value. |
+
+## Constructors
+
+| Syntax              | Description                                                  |
+| ------------------- | ------------------------------------------------------------ |
+| `ctor(float error)` | Creates an instance of comparer with a custom error `value.allowedError`. The relative error to be considered while comparing two values. |
+
+## Public methods
+
+| Syntax                               | Description                                                  |
+| ------------------------------------ | ------------------------------------------------------------ |
+| `bool Equals(T expected, T actual);` | Compares the actual and expected objects for equality using a custom comparison mechanism. Returns `true` if expected and actual objects are equal, otherwise it returns `false`. |
+
+ 

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-custom-yield-instructions.md

@@ -0,0 +1,60 @@
+# Custom yield instructions
+
+By implementing this interface below, you can define custom yield instructions in **Edit Mode** tests.
+
+## IEditModeTestYieldInstruction
+
+In an Edit Mode test, you can use `IEditModeTestYieldInstruction` interface to implement your own instruction. There are also a couple of commonly used implementations available:
+
+- [EnterPlayMode](#enterplaymode)
+- [ExitPlayMode](#exitplaymode)
+- [RecompileScripts](./reference-recompile-scripts.md)
+- [WaitForDomainReload](./reference-wait-for-domain-reload.md)
+
+## Example
+
+```c#
+[UnityTest]
+
+public IEnumerator PlayOnAwakeDisabled_DoesntPlayWhenEnteringPlayMode()
+
+{
+    var videoPlayer = PrefabUtility.InstantiatePrefab(m_VideoPlayerPrefab.GetComponent<VideoPlayer>()) as VideoPlayer;
+
+    videoPlayer.playOnAwake = false;
+
+    yield return new EnterPlayMode();
+
+    var videoPlayerGO = GameObject.Find(m_VideoPlayerPrefab.name);
+
+    Assert.IsFalse(videoPlayerGO.GetComponent<VideoPlayer>().isPlaying);
+
+    yield return new ExitPlayMode();
+
+    Object.DestroyImmediate(GameObject.Find(m_VideoPlayerPrefab.name));
+}
+```
+
+## Properties
+
+| Syntax                       | Description                                                  |
+| ---------------------------- | ------------------------------------------------------------ |
+| `bool ExpectDomainReload`    | Returns `true` if the instruction expects a domain reload to occur. |
+| `bool ExpectedPlaymodeState` | Returns `true` if the instruction expects the Unity Editor to be in **Play Mode**. |
+
+## Methods
+
+| Syntax                  | Description                                                  |
+| ----------------------- | ------------------------------------------------------------ |
+| `IEnumerator Perform()` | Used to define multi-frame operations performed when instantiating a yield instruction. |
+
+## EnterPlayMode
+
+* Implements `IEditModeTestYieldInstruction`. Creates a yield instruction to enter Play Mode.
+* When creating an Editor test that uses the `UnityTest` attribute, use this to trigger the Editor to enter Play Mode. 
+* Throws an exception if the Editor is already in Play Mode or if there is a [script compilation error](https://support.unity3d.com/hc/en-us/articles/205930539-How-do-I-interpret-a-compiler-error-).
+
+## ExitPlayMode
+
+* Implements `IEditModeTestYieldInstruction`. A new instance of the class is a yield instruction to exit Play Mode.
+* Throws an exception if the Editor is not in Play Mode.

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-execution-settings.md

@@ -0,0 +1,17 @@
+# ExecutionSettings
+The `ExecutionSettings` is a set of filters and other settings provided when running a set of tests from the [TestRunnerApi](./reference-test-runner-api.md).
+
+## Constructors
+
+| Syntax                                                | Description                                              |
+| ----------------------------------------------------- | -------------------------------------------------------- |
+| `ExecutionSettings(params Filter[] filtersToExecute)` | Creates an instance with a given set of filters, if any. |
+
+## Fields
+
+| Syntax                       | Description                                                  |
+| ---------------------------- | ------------------------------------------------------------ |
+| `Filter[] filters`          | A collection of [Filters](./reference-filter.md) to execute tests on. |
+| `ITestRunSettings overloadTestRunSettings` | An instance of [ITestRunSettings](./reference-itest-run-settings.md) to set up before running tests on a Player. |
+| `bool runSynchronously`     | If true, the call to `Execute()` will run tests synchronously, guaranteeing that all tests have finished running by the time the call returns. Note that this is only supported for EditMode tests, and that tests which take multiple frames (i.e. `[UnityTest]` tests, or tests with `[UnitySetUp]` or `[UnityTearDown]` scaffolding) will be filtered out. |
+| 'int playerHeartbeatTimeout' | The time, in seconds, the editor should wait for heartbeats after starting a test run on a player. This defaults to 10 minutes. |

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-filter.md

@@ -0,0 +1,15 @@
+# Filter
+The filter class provides the [TestRunnerApi](./reference-test-runner-api.md) with a specification of what tests to run when [running tests programmatically](./extension-run-tests.md).
+
+## Fields
+
+| Syntax                        | Description                                                  |
+| ----------------------------- | ------------------------------------------------------------ |
+| `TestMode testMode`           | An enum flag that specifies if **Edit Mode** or **Play Mode** tests should run. Applying both Edit Mode and Play Mode is currently not supported when running tests from the API. |
+| `string[] testNames`          | The full name of the tests to match the filter. This is usually in the format `FixtureName.TestName`. If the test has test arguments, then include them in parenthesis. E.g. `MyTestClass2.MyTestWithMultipleValues(1)`. |
+| `string[] groupNames`         | The same as `testNames`, except that it allows for Regex. This is useful for running specific fixtures or namespaces. E.g. `"^MyNamespace\\."` Runs any tests where the top namespace is `MyNamespace`. |
+| `string[] categoryNames`      | The name of a [Category](https://nunit.org/docs/2.2.7/category.html) to include in the run. Any test or fixtures runs that have a `Category` matching the string. |
+| `string[] assemblyNames`      | The name of assemblies included in the run. That is the assembly name, without the .dll file extension. E.g., `MyTestAssembly`. |
+| `BuildTarget? targetPlatform` | The [BuildTarget](https://docs.unity3d.com/ScriptReference/BuildTarget.html) platform to run the test on. If set to `null`, then the Editor is the target for the tests. |
+
+

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-icallbacks.md

@@ -0,0 +1,48 @@
+# ICallbacks
+An interface for receiving callbacks when running tests. All test runs invoke the callbacks until the next domain reload.
+
+The `RunStarted` method runs when the whole test run starts. Then the `TestStarted` method runs with information about the tests it is about to run on an assembly level. Afterward, it runs on a test fixture level and then on the individual test. If the test is a [parameterized test](./https://github.com/nunit/docs/wiki/Parameterized-Tests), then it is also invoked for each parameter combination. After each part of the test tree have completed running, the corresponding `TestFinished` method runs with the test result. At the end of the run, the `RunFinished` event runs with the test result.
+
+An extended version of the callback, [IErrorCallbacks](./reference-ierror-callbacks.md), extends this `ICallbacks` to receive calls when a run fails due to a build error.
+
+## Public methods
+
+| Syntax                                         | Description                                                  |
+| ---------------------------------------------- | ------------------------------------------------------------ |
+| `void RunStarted(ITestAdaptor testsToRun)`     | Invoked when the test run starts. The [ITestAdaptor](./reference-itest-adaptor.md) represents the tree of tests to run. |
+| `void RunFinished(ITestResultAdaptor result)`  | Invoked when the test run finishes. The [ITestResultAdaptor](./reference-itest-result-adaptor.md) represents the results of the set of tests that have run. |
+| `void TestStarted(ITestAdaptor test)`          | Invoked on each node of the test tree, as that part of the tree starts to run. |
+| `void TestFinished(ITestResultAdaptor result)` | Invoked on each node of the test tree once that part of the test tree has finished running. The [ITestResultAdaptor](./reference-itest-result-adaptor.md) represents the results of the current node of the test tree. |
+
+## Example
+An example that sets up a listener on the API. The listener prints the number of failed tests after the run has finished:
+``` C#
+public void SetupListeners()
+{
+    var api = ScriptableObject.CreateInstance<TestRunnerApi>();
+    api.RegisterCallbacks(new MyCallbacks());
+}
+
+private class MyCallbacks : ICallbacks
+{
+    public void RunStarted(ITestAdaptor testsToRun)
+    {
+  
+    }
+
+    public void RunFinished(ITestResultAdaptor result)
+    {
+        Debug.Log(string.Format("Run finished {0} test(s) failed.", result.FailCount));
+    }
+
+    public void TestStarted(ITestAdaptor test)
+    {
+  
+    }
+
+    public void TestFinished(ITestResultAdaptor result)
+    {
+  
+    }
+}
+```

Library/PackageCache/com.unity.test-framework@1.1.33/Documentation~/reference-ierror-callbacks.md

@@ -0,0 +1,9 @@
+# IErrorCallbacks
+An extended version of the [ICallbacks](./reference-icallbacks.md), which get invoked if the test run fails due to a build error or if any [IPrebuildSetup](./reference-setup-and-cleanup.md) has a failure.
+
+## Public methods
+
+| Syntax                       | Description                                                         |
+| ---------------------------- | ------------------------------------------------------------------- |
+| void OnError(string message) | The error message detailing the reason for the run to fail.         |
+