first commit

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/AssemblyInfo.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyTitle("UnityEngine.TestRunner")]
+
+[assembly: InternalsVisibleTo("UnityEditor.TestRunner")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
+[assembly: InternalsVisibleTo("Unity.PerformanceTesting")]
+[assembly: InternalsVisibleTo("Unity.PerformanceTesting.Editor")]
+[assembly: InternalsVisibleTo("Assembly-CSharp-testable")]
+[assembly: InternalsVisibleTo("Assembly-CSharp-Editor-testable")]
+[assembly: InternalsVisibleTo("UnityEngine.TestRunner.Tests")]
+[assembly: InternalsVisibleTo("UnityEditor.TestRunner.Tests")]
+[assembly: InternalsVisibleTo("Unity.PackageManagerUI.Editor")]
+
+[assembly: AssemblyVersion("1.0.0")]

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/AssemblyInfo.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1ad55f5ad04d1d045a1f287409c650dd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/AllocatingGCMemoryConstraint.cs

@@ -0,0 +1,128 @@
+using System;
+using NUnit.Framework;
+using NUnit.Framework.Constraints;
+using UnityEngine.Profiling;
+
+namespace UnityEngine.TestTools.Constraints
+{
+    /// <summary>
+    /// An NUnit test constraint class to test whether a given block of code makes any GC allocations.
+    /// 
+    /// Use this class with NUnit's Assert.That() method to make assertions about the GC behaviour of your code. The constraint executes the delegate you provide, and checks if it has caused any GC memory to be allocated. If any GC memory was allocated, the constraint passes; otherwise, the constraint fails.
+    ///
+    /// Usually you negate this constraint to make sure that your delegate does not allocate any GC memory. This is easy to do using the Is class:
+    /// </summary>
+    /// <example>
+    /// <code>
+    /// using NUnit.Framework;
+    /// using UnityEngine.TestTools.Constraints;
+    /// using Is = UnityEngine.TestTools.Constraints.Is;
+    /// 
+    /// public class MyTestClass
+    /// {
+    ///     [Test]
+    ///     public void SettingAVariableDoesNotAllocate()
+    ///     {
+    ///         Assert.That(() => {
+    ///             int a = 0;
+    ///             a = 1;
+    ///         }, Is.Not.AllocatingGCMemory());
+    ///     }
+    /// }
+    /// </code>
+    /// </example>
+    public class AllocatingGCMemoryConstraint : Constraint
+    {
+        private class AllocatingGCMemoryResult : ConstraintResult
+        {
+            private readonly int diff;
+            public AllocatingGCMemoryResult(IConstraint constraint, object actualValue, int diff) : base(constraint, actualValue, diff > 0)
+            {
+                this.diff = diff;
+            }
+
+            public override void WriteMessageTo(MessageWriter writer)
+            {
+                if (diff == 0)
+                    writer.WriteMessageLine("The provided delegate did not make any GC allocations.");
+                else
+                    writer.WriteMessageLine("The provided delegate made {0} GC allocation(s).", diff);
+            }
+        }
+
+        private ConstraintResult ApplyTo(Action action, object original)
+        {
+            var recorder = Recorder.Get("GC.Alloc");
+
+            // The recorder was created enabled, which means it captured the creation of the Recorder object itself, etc.
+            // Disabling it flushes its data, so that we can retrieve the sample block count and have it correctly account
+            // for these initial allocations.
+            recorder.enabled = false;
+
+#if !UNITY_WEBGL
+            recorder.FilterToCurrentThread();
+#endif
+
+            recorder.enabled = true;
+
+            try
+            {
+                action();
+            }
+            finally
+            {
+                recorder.enabled = false;
+#if !UNITY_WEBGL
+                recorder.CollectFromAllThreads();
+#endif
+            }
+
+            return new AllocatingGCMemoryResult(this, original, recorder.sampleBlockCount);
+        }
+
+        /// <summary>
+        /// Applies GC memory constraint to the test.
+        /// </summary>
+        /// <param name="obj">An object to apply the GC constraint to. Should be a <see cref="TestDelegate"/>.</param>
+        /// <returns>A ConstraintResult</returns>
+        /// <exception cref="ArgumentNullException">Throws a <see cref="ArgumentNullException"/> if the provided object is null.</exception>
+        /// <exception cref="ArgumentException">Throws a <see cref="ArgumentException"/> if the provided object is not a <see cref="TestDelegate"/>.</exception>
+        public override ConstraintResult ApplyTo(object obj)
+        {
+            if (obj == null)
+                throw new ArgumentNullException();
+
+            TestDelegate d = obj as TestDelegate;
+            if (d == null)
+                throw new ArgumentException(string.Format("The actual value must be a TestDelegate but was {0}",
+                    obj.GetType()));
+
+            return ApplyTo(() => d.Invoke(), obj);
+        }
+
+        /// <summary>
+        /// Test whether the constraint is satisfied by a given reference.
+        /// The default implementation simply dereferences the value but
+        /// derived classes may override it to provide for delayed processing.
+        /// </summary>
+        /// <typeparam name="TActual">The type of the actual value delegate to be tested.</typeparam>
+        /// <param name="del">A reference to the value delegate to be tested</param>
+        /// <returns>A ConstraintResult</returns>
+        /// <exception cref="ArgumentNullException">Throws a <see cref="ArgumentNullException"/> if the provided delegate is null.</exception>
+        public override ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
+        {
+            if (del == null)
+                throw new ArgumentNullException();
+
+            return ApplyTo(() => del.Invoke(), del);
+        }
+
+        /// <summary>
+        /// The Description of what this constraint tests, for to use in messages and in the ConstraintResult.
+        /// </summary>
+        public override string Description
+        {
+            get { return "allocates GC memory"; }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/AllocatingGCMemoryConstraint.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/ConstraintsExtensions.cs

@@ -0,0 +1,24 @@
+using System;
+using NUnit.Framework.Constraints;
+
+namespace UnityEngine.TestTools.Constraints
+{
+    /// <summary>
+    /// An NUnit test constraint class to test whether a given block of code makes any GC allocations.
+    /// </summary>
+    public static class ConstraintExtensions
+    {
+        /// <summary>
+        /// Use this with NUnit's Assert.That() method to make assertions about the GC behaviour of your code. The constraint executes the delegate you provide, and checks if it caused any GC memory to be allocated. If any GC memory was allocated, the constraint passes; otherwise, the constraint fails.
+        /// See https://docs.unity3d.com/Packages/com.unity.test-framework@1.1/api/UnityEngine.TestTools.Constraints.AllocatingGCMemoryConstraint.html for an example.
+        /// </summary>
+        /// <param name="chain">The chain of constraints to append this constraint to.</param>
+        /// <returns>The generated constraint.</returns>
+        public static AllocatingGCMemoryConstraint AllocatingGCMemory(this ConstraintExpression chain)
+        {
+            var constraint = new AllocatingGCMemoryConstraint();
+            chain.Append(constraint);
+            return constraint;
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/ConstraintsExtensions.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/InvalidSignatureException.cs

@@ -0,0 +1,19 @@
+using System;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+
+namespace UnityEngine.TestTools.TestRunner
+{
+    internal class InvalidSignatureException : ResultStateException
+    {
+        public InvalidSignatureException(string message)
+            : base(message)
+        {
+        }
+
+        public override ResultState ResultState
+        {
+            get { return ResultState.NotRunnable; }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/InvalidSignatureException.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/Is.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace UnityEngine.TestTools.Constraints
+{
+    /// <summary>
+    /// NUnit allows you to write test assertions in a more descriptive and human readable way using the Assert.That mechanism, where the first parameter is an object under test and the second parameter describes conditions that the object has to meet.
+    ///
+    /// We have 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`.
+    /// </summary>
+    public class Is : NUnit.Framework.Is
+    {
+        /// <summary>
+        /// A constraint type that invokes the delegate you provide as the parameter of Assert.That and checks whether it causes any GC memory allocations.
+        /// </summary>
+        /// <returns>An AllocationGCMemoryConstrain.</returns>
+        /// <example>
+        /// <code>
+        /// using Is = UnityEngine.TestTools.Constraints.Is;
+        ///
+        /// class MyTestClass
+        /// {
+        ///     [Test]
+        ///     public void MyTest()
+        ///     {
+        ///         Assert.That(() =&gt; {
+        ///         var i = new int[500];
+        ///         }, Is.AllocatingGCMemory());
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        public static AllocatingGCMemoryConstraint AllocatingGCMemory()
+        {
+            return new AllocatingGCMemoryConstraint();
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/Is.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogAssert.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Text.RegularExpressions;
+using UnityEngine.TestTools.Logging;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// `LogAssert` lets you expect Unity log messages that would otherwise cause the test to fail. A test fails if Unity logs a message other than a regular log or warning message. Use `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.
+    /// </summary>
+    public static class LogAssert
+    {
+        /// <summary>
+        /// 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.
+        /// If multiple LogAssert.Expect are used to expect multiple messages, they are expected to be logged in that order.
+        /// </summary>
+        /// <param name="type">A type of log to expect. It can take one of the [LogType enum](https://docs.unity3d.com/ScriptReference/LogType.html) values.</param>
+        /// <param name="message">A string value that should equate to the expected message.</param>
+        /// <example>
+        /// <code>
+        /// [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");
+        /// }
+        ///
+        /// </code>
+        /// </example>
+        public static void Expect(LogType type, string message)
+        {
+            LogScope.Current.ExpectedLogs.Enqueue(new LogMatch { LogType = type, Message = message });
+        }
+
+        /// <summary>
+        /// 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.
+        /// </summary>
+        /// <param name="type">A type of log to expect. It can take one of the [LogType enum](https://docs.unity3d.com/ScriptReference/LogType.html) values.</param>
+        /// <param name="message">A regular expression pattern to match the expected message.</param>
+        public static void Expect(LogType type, Regex message)
+        {
+            LogScope.Current.ExpectedLogs.Enqueue(new LogMatch { LogType = type, MessageRegex = message });
+        }
+
+        /// <summary>
+        /// Verifies that a log message of any 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.
+        /// If multiple LogAssert.Expect are used to expect multiple messages, they are expected to be logged in that order.
+        /// </summary>
+        /// <param name="message">A string value that should equate to the expected message.</param>
+        /// <example>
+        /// <code>
+        /// [Test]
+        /// public void LogAssertExample()
+        /// {
+        ///     // Expect a log entry of any kind with this message
+        ///     LogAssert.Expect("Log message");
+        ///
+        ///     // Logging the message does not cause the test to fail
+        ///     Debug.LogError("Log message");
+        /// }
+        ///
+        /// </code>
+        /// </example>
+        public static void Expect(string message)
+        {
+            LogScope.Current.ExpectedLogs.Enqueue(new LogMatch { LogType = null, Message = message });
+        }
+
+        /// <summary>
+        /// Verifies that a log message of any 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.
+        /// </summary>
+        /// <param name="message">A regular expression pattern to match the expected message.</param>
+        public static void Expect(Regex message)
+        {
+            LogScope.Current.ExpectedLogs.Enqueue(new LogMatch { LogType = null, MessageRegex = message });
+        }
+
+        /// <summary>
+        /// 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 <see cref="TestMustExpectAllLogsAttribute"/> attribute instead.
+        /// </summary>
+        public static void NoUnexpectedReceived()
+        {
+            LogScope.Current.NoUnexpectedReceived();
+        }
+
+        /// <summary>Set this property to `true` to prevent unexpected error log messages from triggering an assertion. By default, it is `false`.</summary>
+        /// <value>The value of the ignoreFailingMessages boolean property.</value>
+        public static bool ignoreFailingMessages
+        {
+            get
+            {
+                return LogScope.Current.IgnoreFailingMessages;
+            }
+            set
+            {
+                if (value != LogScope.Current.IgnoreFailingMessages)
+                {
+                    Debug.LogFormat(LogType.Log, LogOption.NoStacktrace, null, "\nIgnoreFailingMessages:" + (value ? "true" : "false"));
+                }
+                LogScope.Current.IgnoreFailingMessages = value;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogAssert.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogScope.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b1d8465ba1376b148bdab58965101f47
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogScope/ILogScope.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+
+namespace UnityEngine.TestTools.Logging
+{
+    internal interface ILogScope : IDisposable
+    {
+        Queue<LogMatch> ExpectedLogs { get; set; }
+        List<LogEvent> AllLogs { get; }
+        List<LogEvent> FailingLogs { get; }
+        void EvaluateLogScope(bool endOfScopeCheck);
+        bool IgnoreFailingMessages { get; set; }
+        bool IsNUnitException { get; }
+        bool IsNUnitSuccessException { get; }
+        bool IsNUnitInconclusiveException { get; }
+        bool IsNUnitIgnoreException { get; }
+        string NUnitExceptionMessage { get; }
+        void AddLog(string message, string stacktrace, LogType type);
+        bool AnyFailingLogs();
+        void ProcessExpectedLogs();
+        void NoUnexpectedReceived();
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogScope/ILogScope.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogScope/LogEvent.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace UnityEngine.TestTools.Logging
+{
+    internal class LogEvent
+    {
+        public string Message { get; set; }
+
+        public string StackTrace { get; set; }
+
+        public LogType LogType { get; set; }
+
+        public bool IsHandled { get; set; }
+
+        public override string ToString()
+        {
+            return string.Format("[{0}] {1}", LogType, Message);
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogScope/LogEvent.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogScope/LogMatch.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace UnityEngine.TestTools.Logging
+{
+    [Serializable]
+    internal class LogMatch
+    {
+        [SerializeField]
+        private bool m_UseRegex;
+        [SerializeField]
+        private string m_Message;
+        [SerializeField]
+        private string m_MessageRegex;
+        [SerializeField]
+        private string m_LogType;
+
+        public string Message
+        {
+            get { return m_Message; }
+            set
+            {
+                m_Message = value;
+                m_UseRegex = false;
+            }
+        }
+
+        public Regex MessageRegex
+        {
+            get
+            {
+                if (!m_UseRegex)
+                {
+                    return null;
+                }
+
+                return new Regex(m_MessageRegex);
+            }
+            set
+            {
+                if (value != null)
+                {
+                    m_MessageRegex = value.ToString();
+                    m_UseRegex = true;
+                }
+                else
+                {
+                    m_MessageRegex = null;
+                    m_UseRegex = false;
+                }
+            }
+        }
+
+        public LogType? LogType
+        {
+            get
+            {
+                if (!string.IsNullOrEmpty(m_LogType))
+                {
+                    return Enum.Parse(typeof(LogType), m_LogType) as LogType ? ;
+                }
+
+                return null;
+            }
+            set
+            {
+                if (value != null)
+                {
+                    m_LogType = value.Value.ToString();
+                }
+                else
+                {
+                    m_LogType = null;
+                }
+            }
+        }
+
+        public bool Matches(LogEvent log)
+        {
+            if (LogType != null && LogType != log.LogType)
+            {
+                return false;
+            }
+
+            if (m_UseRegex)
+            {
+                return MessageRegex.IsMatch(log.Message);
+            }
+
+            return Message.Equals(log.Message);
+        }
+
+        public override string ToString()
+        {
+            if (m_UseRegex)
+                return string.Format("[{0}] Regex: {1}", LogType, MessageRegex);
+            return string.Format("[{0}] {1}", LogType, Message);
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogScope/LogMatch.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogScope/LogScope.cs

@@ -0,0 +1,248 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.TestTools.TestRunner;
+
+namespace UnityEngine.TestTools.Logging
+{
+    internal sealed class LogScope : ILogScope
+    {
+        private static List<LogScope> s_ActiveScopes = new List<LogScope>();
+
+        private readonly object m_Lock = new object();
+        private bool m_Disposed;
+        private bool m_NeedToProcessLogs;
+
+        public Queue<LogMatch> ExpectedLogs { get; set; }
+        public List<LogEvent> AllLogs { get; }
+        public List<LogEvent> FailingLogs { get; }
+        public bool IgnoreFailingMessages { get; set; }
+        public bool IsNUnitException { get; private set; }
+        public bool IsNUnitSuccessException { get; private set; }
+        public bool IsNUnitInconclusiveException { get; private set; }
+        public bool IsNUnitIgnoreException { get; private set; }
+        public string NUnitExceptionMessage { get; private set; }
+
+        public static LogScope Current
+        {
+            get
+            {
+                if (s_ActiveScopes.Count == 0)
+                    throw new InvalidOperationException("No log scope is available");
+                return s_ActiveScopes[0];
+            }
+        }
+
+        public static bool HasCurrentLogScope()
+        {
+            return s_ActiveScopes.Count > 0;
+        }
+
+        public LogScope()
+        {
+            AllLogs = new List<LogEvent>();
+            FailingLogs = new List<LogEvent>();
+            ExpectedLogs = new Queue<LogMatch>();
+            IgnoreFailingMessages = false;
+            Activate();
+        }
+
+        private void Activate()
+        {
+            s_ActiveScopes.Insert(0, this);
+            RegisterScope(this);
+            Application.logMessageReceivedThreaded -= AddLog;
+            Application.logMessageReceivedThreaded += AddLog;
+        }
+
+        private void Deactivate()
+        {
+            Application.logMessageReceivedThreaded -= AddLog;
+            s_ActiveScopes.Remove(this);
+            UnregisterScope(this);
+        }
+
+        private static void RegisterScope(LogScope logScope)
+        {
+            Application.logMessageReceivedThreaded += logScope.AddLog;
+        }
+
+        private static void UnregisterScope(LogScope logScope)
+        {
+            Application.logMessageReceivedThreaded -= logScope.AddLog;
+        }
+
+        public void AddLog(string message, string stacktrace, LogType type)
+        {
+            lock (m_Lock)
+            {
+                m_NeedToProcessLogs = true;
+                var log = new LogEvent
+                {
+                    LogType = type,
+                    Message = message,
+                    StackTrace = stacktrace,
+                };
+
+                AllLogs.Add(log);
+
+                if (IsNUnitResultStateException(stacktrace, type))
+                {
+                    if (message.StartsWith("SuccessException"))
+                    {
+                        IsNUnitException = true;
+                        IsNUnitSuccessException = true;
+                        if (message.StartsWith("SuccessException: "))
+                        {
+                            NUnitExceptionMessage = message.Substring("SuccessException: ".Length);
+                            return;
+                        }
+                    }
+                    else if (message.StartsWith("InconclusiveException"))
+                    {
+                        IsNUnitException = true;
+                        IsNUnitInconclusiveException = true;
+                        if (message.StartsWith("InconclusiveException: "))
+                        {
+                            NUnitExceptionMessage = message.Substring("InconclusiveException: ".Length);
+                            return;
+                        }
+                    }
+                    else if (message.StartsWith("IgnoreException"))
+                    {
+                        IsNUnitException = true;
+                        IsNUnitIgnoreException = true;
+                        if (message.StartsWith("IgnoreException: "))
+                        {
+                            NUnitExceptionMessage = message.Substring("IgnoreException: ".Length);
+                            return;
+                        }
+                    }
+                }
+
+                if (IsFailingLog(type) && !IgnoreFailingMessages)
+                {
+                    FailingLogs.Add(log);
+                }
+            }
+        }
+
+        private static bool IsNUnitResultStateException(string stacktrace, LogType logType)
+        {
+            if (logType != LogType.Exception)
+                return false;
+
+            return string.IsNullOrEmpty(stacktrace) || stacktrace.StartsWith("NUnit.Framework.Assert.");
+        }
+
+        private static bool IsFailingLog(LogType type)
+        {
+            switch (type)
+            {
+                case LogType.Assert:
+                case LogType.Error:
+                case LogType.Exception:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (m_Disposed)
+            {
+                return;
+            }
+
+            m_Disposed = true;
+
+            if (disposing)
+            {
+                Deactivate();
+            }
+        }
+
+        public bool AnyFailingLogs()
+        {
+            ProcessExpectedLogs();
+            return FailingLogs.Any();
+        }
+
+        public void EvaluateLogScope(bool endOfScopeCheck)
+        {
+            ProcessExpectedLogs();
+            if (FailingLogs.Any())
+            {
+                var failureInWrongOrder = FailingLogs.FirstOrDefault(log => ExpectedLogs.Any(expected => expected.Matches(log)));
+                if (failureInWrongOrder != null)
+                {
+                    var nextExpected = ExpectedLogs.Peek();
+                    throw new OutOfOrderExpectedLogMessageException(failureInWrongOrder, nextExpected);
+                }
+
+                var failingLog = FailingLogs.First();
+                throw new UnhandledLogMessageException(failingLog);
+            }
+            if (endOfScopeCheck && ExpectedLogs.Any())
+            {
+                throw new UnexpectedLogMessageException(ExpectedLogs.Peek());
+            }
+        }
+
+        public void ProcessExpectedLogs()
+        {
+            lock (m_Lock)
+            {
+                if (!m_NeedToProcessLogs || !ExpectedLogs.Any())
+                    return;
+
+                LogMatch expectedLog = null;
+                foreach (var logEvent in AllLogs)
+                {
+                    if (!ExpectedLogs.Any())
+                        break;
+                    if (logEvent.IsHandled)
+                    {
+                        continue;
+                    }
+                    if (expectedLog == null && ExpectedLogs.Any())
+                        expectedLog = ExpectedLogs.Peek();
+
+                    if (expectedLog != null && expectedLog.Matches(logEvent))
+                    {
+                        ExpectedLogs.Dequeue();
+                        logEvent.IsHandled = true;
+                        if (FailingLogs.Any(expectedLog.Matches))
+                        {
+                            var failingLog = FailingLogs.First(expectedLog.Matches);
+                            FailingLogs.Remove(failingLog);
+                        }
+                        expectedLog = null;
+                    }
+                }
+                m_NeedToProcessLogs = false;
+            }
+        }
+
+        public void NoUnexpectedReceived()
+        {
+            lock (m_Lock)
+            {
+                ProcessExpectedLogs();
+
+                var unhandledLog = AllLogs.FirstOrDefault(x => !x.IsHandled);
+                if (unhandledLog != null)
+                {
+                    throw new UnhandledLogMessageException(unhandledLog);
+                }
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/LogScope/LogScope.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/OutOfOrderExpectedLogMessageException.cs

@@ -0,0 +1,27 @@
+using System;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using UnityEngine.TestTools.Logging;
+
+namespace UnityEngine.TestTools.TestRunner
+{
+    internal class OutOfOrderExpectedLogMessageException : ResultStateException
+    {
+        public OutOfOrderExpectedLogMessageException(LogEvent log, LogMatch nextExpected)
+            : base(BuildMessage(log, nextExpected))
+        {
+        }
+
+        private static string BuildMessage(LogEvent log, LogMatch nextExpected)
+        {
+            return $"Expected {log.LogType} with '{log.Message}' arrived out of order. Expected {nextExpected.LogType} with '{nextExpected.Message}' next.";
+        }
+
+        public override ResultState ResultState
+        {
+            get { return ResultState.Failure; }
+        }
+
+        public override string StackTrace { get { return null; } }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/OutOfOrderExpectedLogMessageException.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2fcdb9402e0a4427bd5bd01f71ecf6d5
+timeCreated: 1652951919

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/UnexpectedLogMessageException.cs

@@ -0,0 +1,30 @@
+using System;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using UnityEngine.TestTools.Logging;
+
+namespace UnityEngine.TestTools.TestRunner
+{
+    internal class UnexpectedLogMessageException : ResultStateException
+    {
+        public LogMatch LogEvent;
+
+        public UnexpectedLogMessageException(LogMatch log)
+            : base(BuildMessage(log))
+        {
+            LogEvent = log;
+        }
+
+        private static string BuildMessage(LogMatch log)
+        {
+            return string.Format("Expected log did not appear: {0}", log);
+        }
+
+        public override ResultState ResultState
+        {
+            get { return ResultState.Failure; }
+        }
+
+        public override string StackTrace { get { return null; } }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/UnexpectedLogMessageException.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/UnhandledLogMessageException.cs

@@ -0,0 +1,36 @@
+using System;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using UnityEngine.TestTools.Logging;
+using UnityEngine.TestTools.Utils;
+
+namespace UnityEngine.TestTools.TestRunner
+{
+    internal class UnhandledLogMessageException : ResultStateException
+    {
+        public LogEvent LogEvent;
+        private readonly string m_CustomStackTrace;
+
+        public UnhandledLogMessageException(LogEvent log)
+            : base(BuildMessage(log))
+        {
+            LogEvent = log;
+            m_CustomStackTrace = StackTraceFilter.Filter(log.StackTrace);
+        }
+
+        private static string BuildMessage(LogEvent log)
+        {
+            return string.Format("Unhandled log message: '{0}'. Use UnityEngine.TestTools.LogAssert.Expect", log);
+        }
+
+        public override ResultState ResultState
+        {
+            get { return ResultState.Failure; }
+        }
+
+        public override string StackTrace
+        {
+            get { return m_CustomStackTrace; }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/UnhandledLogMessageException.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/UnityTestTimeoutException.cs

@@ -0,0 +1,29 @@
+using System;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+
+namespace UnityEngine.TestTools.TestRunner
+{
+    internal class UnityTestTimeoutException : ResultStateException
+    {
+        public UnityTestTimeoutException(int timeout)
+            : base(BuildMessage(timeout))
+        {
+        }
+
+        private static string BuildMessage(int timeout)
+        {
+            return string.Format("Timeout value of {0} ms was exceeded. If this is intended, increase the timeout value using a TimeoutAttribute.", timeout);
+        }
+
+        public override ResultState ResultState
+        {
+            get { return ResultState.Failure; }
+        }
+
+        public override string StackTrace
+        {
+            get { return ""; }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/Assertions/UnityTestTimeoutException.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3e8d6af343b383544ba5743d119f4062
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/ActionDelegator.cs

@@ -0,0 +1,71 @@
+using System;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+using UnityEngine.TestTools.Logging;
+
+namespace UnityEngine.TestTools.NUnitExtensions
+{
+    /// <summary>
+    /// This class delegates actions from the NUnit thread that should be executed on the main thread.
+    /// NUnit thread calls Delegate which blocks the execution on the thread until the action is executed.
+    /// The main thread will poll for awaiting actions (HasAction) and invoke them (Execute).
+    /// Once the action is executed, the main thread releases the lock and executino on the NUnit thread is continued.
+    /// </summary>
+    internal class ActionDelegator : BaseDelegator
+    {
+        private Func<object> m_Action;
+        public object Delegate(Action action)
+        {
+            return Delegate(() => { action(); return null; });
+        }
+
+        public object Delegate(Func<object> action)
+        {
+            if (m_Aborted)
+            {
+                return null;
+            }
+
+            AssertState();
+            m_Context = UnityTestExecutionContext.CurrentContext;
+
+            m_Signal.Reset();
+            m_Action = action;
+
+            WaitForSignal();
+
+            return HandleResult();
+        }
+
+        private void AssertState()
+        {
+            if (m_Action != null)
+            {
+                throw new Exception("Action not executed yet");
+            }
+        }
+
+        public bool HasAction()
+        {
+            return m_Action != null;
+        }
+
+        public void Execute(LogScope logScope)
+        {
+            try
+            {
+                SetCurrentTestContext();
+                m_Result = m_Action();
+                logScope.EvaluateLogScope(true);
+            }
+            catch (Exception e)
+            {
+                m_Exception = e;
+            }
+            finally
+            {
+                m_Action = null;
+                m_Signal.Set();
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/ActionDelegator.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0cb14878543cf3d4f8472b15f7ecf0e3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/ConditionalIgnoreAttribute.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// This attribute is an alternative to the standard `Ignore` attribute in [NUnit](https://nunit.org/). It allows for ignoring tests only under a specified condition. The condition evaluates during `OnLoad`, referenced by ID.
+    /// </summary>
+    public class ConditionalIgnoreAttribute : NUnitAttribute, IApplyToTest
+    {
+        private string m_ConditionKey;
+        private string m_IgnoreReason;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConditionalIgnoreAttribute"/> class with a condition key.
+        /// </summary>
+        /// <param name="conditionKey">The key to check for enabling the conditional ignore. The condition is set with the static <see cref="AddConditionalIgnoreMapping"/> method.</param>
+        /// <param name="ignoreReason">The reason for the ignore.</param>
+        public ConditionalIgnoreAttribute(string conditionKey, string ignoreReason)
+        {
+            m_ConditionKey = conditionKey;
+            m_IgnoreReason = ignoreReason;
+        }
+
+        /// <summary>
+        /// Modifies a test as defined for the specific attribute.
+        /// </summary>
+        /// <param name="test">The test to modify</param>
+        public void ApplyToTest(Test test)
+        {
+            var key = m_ConditionKey.ToLowerInvariant();
+            if (m_ConditionMap.ContainsKey(key) && m_ConditionMap[key])
+            {
+                test.RunState = RunState.Ignored;
+                string skipReason = string.Format(m_IgnoreReason);
+                test.Properties.Add(PropertyNames.SkipReason, skipReason);
+            }
+        }
+
+        private static Dictionary<string, bool> m_ConditionMap = new Dictionary<string, bool>();
+
+        /// <summary>
+        /// Adds a flag indicating whether tests with the same key should be ignored.
+        /// </summary>
+        /// <param name="key">The key to ignore tests for.</param>
+        /// <param name="value">A boolean value indicating whether the tests should be ignored.</param>
+        /// <example>
+        /// <code>
+        /// // An example in which tests are ignored in the Mac editor only.
+        /// 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();
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        public static void AddConditionalIgnoreMapping(string key, bool value)
+        {
+            m_ConditionMap.Add(key.ToLowerInvariant(), value);
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/ConditionalIgnoreAttribute.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/EnumeratorHelper.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace UnityEngine.TestTools
+{
+    internal class EnumeratorHelper
+    {
+        public static bool IsRunningNestedEnumerator => enumeratorStack.Count > 0;
+
+        private static IEnumerator currentEnumerator;
+        private static Stack<IEnumerator> enumeratorStack = new Stack<IEnumerator>();
+
+        /// <summary>
+        /// This method executes a given enumerator and all nested enumerators.
+        /// If any resuming (setting of pc) is needed, it needs to be done before being passed to this method.
+        /// </summary>
+        public static IEnumerator UnpackNestedEnumerators(IEnumerator testEnumerator)
+        {
+            if (testEnumerator == null)
+            {
+                throw new ArgumentNullException(nameof(testEnumerator));
+            }
+
+            currentEnumerator = testEnumerator;
+            enumeratorStack.Clear();
+
+            return ProgressOnEnumerator();
+        }
+
+        private static IEnumerator ProgressOnEnumerator()
+        {
+            while (true)
+            {
+                if (!currentEnumerator.MoveNext())
+                {
+                    if (enumeratorStack.Count == 0)
+                    {
+                        yield break;
+                    }
+                    currentEnumerator = enumeratorStack.Pop();
+                    continue;
+                }
+                
+                if (currentEnumerator.Current is IEnumerator nestedEnumerator)
+                {
+                    enumeratorStack.Push(currentEnumerator);
+                    currentEnumerator = nestedEnumerator;
+                }
+                else
+                {
+                    yield return currentEnumerator.Current;
+                }
+            }
+        }
+        
+        public static void SetEnumeratorPC(int pc)
+        {
+            if (currentEnumerator == null)
+            {
+                throw new Exception("No enumerator is currently running.");
+            }
+            
+            if (IsRunningNestedEnumerator)
+            {
+                throw new Exception("Cannot set the enumerator PC while running nested enumerators.");
+            }
+            
+            ActivePcHelper.SetEnumeratorPC(currentEnumerator, pc);
+        }
+
+        public static int GetEnumeratorPC()
+        {
+            if (currentEnumerator == null)
+            {
+                throw new Exception("No enumerator is currently running.");
+            }
+
+            if (IsRunningNestedEnumerator)
+            {
+                // Restrict the getting of PC, as it will not reflect what is currently running;
+                throw new Exception("Cannot get the enumerator PC while running nested enumerators.");
+            }
+
+            return ActivePcHelper.GetEnumeratorPC(currentEnumerator);
+        }
+
+        private static TestCommandPcHelper pcHelper;
+        internal static TestCommandPcHelper ActivePcHelper
+        {
+            get
+            {
+                if (pcHelper == null)
+                {
+                    pcHelper = new TestCommandPcHelper();
+                }
+
+                return pcHelper;
+            }
+            set
+            {
+                pcHelper = value;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/EnumeratorHelper.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/ParametrizedIgnoreAttribute.cs

@@ -0,0 +1,82 @@
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal.Commands;
+using System;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// This attribute is an alternative to the standard `Ignore` attribute in [NUnit](http://www.nunit.org/). It allows for ignoring tests based on arguments which were passed to the test method.
+    /// </summary>
+    /// <example>
+    /// <para>The following example shows a method to use the `ParametrizedIgnore` attribute to ignore only one test with specific combination of arguments, where someString is `b` and someInt is `10`.</para>
+    /// <code>using NUnit.Framework;
+    /// using System.Collections.Generic;
+    /// using UnityEngine.TestTools;
+    ///
+    /// public class MyTestsClass
+    /// {
+    ///     public static IEnumerable&lt;TestCaseData&gt; MyTestCaseSource()
+    ///     {
+    ///         for (int i = 0; i &lt; 5; i++)
+    ///         {
+    ///             yield return new TestCaseData("a", i);
+    ///             yield return new TestCaseData("b", i);
+    ///         }
+    ///     }
+    ///
+    ///     [Test, TestCaseSource("MyTestCaseSource")]
+    ///     [ParametrizedIgnore("b", 3)]
+    ///     public void Test(string someString, int someInt)
+    ///     {
+    ///         Assert.Pass();
+    ///     }
+    /// }</code>
+    /// <para>It could also be used together with `Values` attribute in [NUnit](http://www.nunit.org/).</para>
+    /// <code>using NUnit.Framework;
+    /// using UnityEngine.TestTools;
+    /// 
+    /// public class MyTestsClass
+    /// {
+    ///     [Test]
+    ///     [ParametrizedIgnore("b", 10)]
+    ///     public void Test(
+    ///         [Values("a", "b")] string someString,
+    ///         [Values(5, 10)] int someInt)
+    ///     {
+    ///         Assert.Pass();
+    ///     }
+    /// }</code>
+    /// </example>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
+    public class ParametrizedIgnoreAttribute : NUnitAttribute, IWrapTestMethod
+    {
+        /// <summary>
+        /// Argument combination for the test case to ignore.
+        /// </summary>
+        public object[] Arguments { get; }
+        /// <summary>
+        /// Reason for the ignore.
+        /// </summary>
+        public string Reason { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ParametrizedIgnoreAttribute"/> class with a argument combination that is ignored.
+        /// </summary>
+        /// <param name="arguments">The argument combination to ignore</param>
+        public ParametrizedIgnoreAttribute(params object[] arguments)
+        {
+            this.Arguments = arguments;
+        }
+
+        /// <summary>
+        /// Wraps a test command with the command to handled parametrized ignore.
+        /// </summary>
+        /// <param name="command">The command to wrap.</param>
+        /// <returns>A command handling parametrized ignore, with respect to the inner command.</returns>
+        public TestCommand Wrap(TestCommand command)
+        {
+            return new ParametrizedIgnoreCommand(command, Arguments, Reason);
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/ParametrizedIgnoreAttribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e9c53c5109a7498ca4408e53f2593b1a
+timeCreated: 1699350131

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/PreservedValuesAttribute.cs

@@ -0,0 +1,23 @@
+using NUnit.Framework;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// Like the ValuesAttribute it is used to provide literal arguments for
+    /// an individual parameter of a test. It has the Preserve attribute added,
+    /// allowing it to persist in players build at a high stripping level.
+    /// </summary>
+    [Preserve]
+    public class PreservedValuesAttribute : ValuesAttribute
+    {
+        /// <summary>
+        /// Construct the values attribute with a set of arguments.
+        /// </summary>
+        /// <param name="args">The set of arguments for the test parameter.</param>
+        public PreservedValuesAttribute(params object[] args) : base(args)
+        {
+
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/PreservedValuesAttribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 528c8790cf844716aead80624be893aa
+timeCreated: 1699350924

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/TestEnumerator.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+
+namespace UnityEngine.TestTools
+{
+    internal class TestEnumerator
+    {
+        private readonly ITestExecutionContext m_Context;
+        private static IEnumerator m_TestEnumerator;
+
+        public static IEnumerator Enumerator { get { return m_TestEnumerator; } }
+
+        public static void Reset()
+        {
+            m_TestEnumerator = null;
+        }
+
+        public TestEnumerator(ITestExecutionContext context, IEnumerator testEnumerator)
+        {
+            m_Context = context;
+            m_TestEnumerator = testEnumerator;
+        }
+
+        public IEnumerator Execute()
+        {
+            m_Context.CurrentResult.SetResult(ResultState.Success);
+
+            return Execute(m_TestEnumerator, new EnumeratorContext(m_Context));
+        }
+
+        private IEnumerator Execute(IEnumerator enumerator, EnumeratorContext context)
+        {
+            while (true)
+            {
+                if (context.ExceptionWasRecorded)
+                {
+                    break;
+                }
+
+                try
+                {
+                    if (!enumerator.MoveNext())
+                    {
+                        break;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    context.RecordExceptionWithHint(ex);
+                    break;
+                }
+
+                if (enumerator.Current is IEnumerator nestedEnumerator)
+                {
+                    yield return Execute(nestedEnumerator, context);
+                }
+                else
+                {
+                    yield return enumerator.Current;
+                }
+            }
+        }
+
+        private class EnumeratorContext
+        {
+            private readonly ITestExecutionContext m_Context;
+
+            public EnumeratorContext(ITestExecutionContext context)
+            {
+                m_Context = context;
+            }
+
+            public bool ExceptionWasRecorded
+            {
+                get;
+                private set;
+            }
+
+            public void RecordExceptionWithHint(Exception ex)
+            {
+                if (ExceptionWasRecorded)
+                {
+                    return;
+                }
+                m_Context.CurrentResult.RecordException(ex);
+                ExceptionWasRecorded = true;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/TestEnumerator.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/TestMustExpectAllLogsAttribute.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// The presence of this attribute makes the Test Runner expect every single log. By
+    /// default, the runner only fails automatically on any error logs, so this adds warnings and infos as well.
+    /// It is the same as calling `LogAssert.NoUnexpectedReceived()` at the bottom of every affected test.
+    ///
+    /// This attribute can be applied to test assemblies (affects every test in the assembly), fixtures (affects every test in the fixture), or on individual test methods. It is also automatically inherited from base
+    /// fixtures.
+    ///
+    /// The `MustExpect` property (on by default) lets you selectively 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 whitelist individual failing fixtures and test methods
+    /// by attaching `[TestMustExpectAllLogs(MustExpect=false)]` until they can be migrated. This also means new tests in that
+    /// assembly would be required to have the more strict checking.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]
+    public class TestMustExpectAllLogsAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes and returns an instance of TestMustExpectAllLogsAttribute.
+        /// </summary>
+        /// <param name="mustExpect">
+        /// A value indicating whether the test must expect all logs.
+        /// </param>
+        public TestMustExpectAllLogsAttribute(bool mustExpect = true)
+            => MustExpect = mustExpect;
+        /// <summary>
+        /// Returns the flag of whether the test must expect all logs.
+        /// </summary>
+        public bool MustExpect { get; }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/TestMustExpectAllLogsAttribute.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityCombinatorialStrategy.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal.Builders;
+
+namespace UnityEngine.TestTools
+{
+    internal class UnityCombinatorialStrategy : CombinatorialStrategy, ICombiningStrategy
+    {
+        public new IEnumerable<ITestCaseData> GetTestCases(IEnumerable[] sources)
+        {
+            var testCases = base.GetTestCases(sources);
+            foreach (var testCase in testCases)
+            {
+                testCase.GetType().GetProperty("ExpectedResult").SetValue(testCase, new object(), null);
+            }
+            return testCases;
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityCombinatorialStrategy.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityPlatformAttribute.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// 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 <see cref="RuntimePlatform"/> 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
+    /// </summary>
+    /// <example>
+    /// <code>
+    /// <![CDATA[
+    /// 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);
+    ///     }
+    /// }
+    /// ]]>
+    /// </code>
+    /// </example>
+    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
+    public class UnityPlatformAttribute : NUnitAttribute, IApplyToTest
+    {
+        /// <summary>
+        /// A subset of platforms you need to have your tests run on.
+        /// </summary>
+        public RuntimePlatform[] include { get; set; }
+        /// <summary>
+        /// List the platforms you do not want to have your tests run on.
+        /// </summary>
+        public RuntimePlatform[] exclude { get; set; }
+
+        private string m_skippedReason;
+
+        /// <summary>
+        /// Constructs a new instance of the <see cref="UnityPlatformAttribute"/> class.
+        /// </summary>
+        public UnityPlatformAttribute()
+        {
+            include = new List<RuntimePlatform>().ToArray();
+            exclude = new List<RuntimePlatform>().ToArray();
+        }
+
+        /// <summary>
+        /// Constructs a new instance of the <see cref="UnityPlatformAttribute"/> class with a list of platforms to include.
+        /// </summary>
+        /// <param name="include">The different <see cref="RuntimePlatform"/> to run the test on.</param>
+        public UnityPlatformAttribute(params RuntimePlatform[] include)
+            : this()
+        {
+            this.include = include;
+        }
+
+        /// <summary>
+        /// Modifies a test as defined for the specific attribute.
+        /// </summary>
+        /// <param name="test">The test to modify</param>
+        public void ApplyToTest(Test test)
+        {
+            if (test.RunState == RunState.NotRunnable || test.RunState == RunState.Ignored || IsPlatformSupported(Application.platform))
+            {
+                return;
+            }
+            test.RunState = RunState.Skipped;
+            test.Properties.Add(PropertyNames.SkipReason, m_skippedReason);
+        }
+
+        internal bool IsPlatformSupported(RuntimePlatform testTargetPlatform)
+        {
+            if (include.Any() && !include.Any(x => x == testTargetPlatform))
+            {
+                m_skippedReason = string.Format("Only supported on {0}", string.Join(", ", include.Select(x => x.ToString()).ToArray()));
+                return false;
+            }
+
+            if (exclude.Any(x => x == testTargetPlatform))
+            {
+                m_skippedReason = string.Format("Not supported on  {0}", string.Join(", ", exclude.Select(x => x.ToString()).ToArray()));
+                return false;
+            }
+            return true;
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityPlatformAttribute.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnitySetUpAttribute.cs

@@ -0,0 +1,229 @@
+using System;
+using NUnit.Framework;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// The `UnitySetUp` and <see cref="UnityTearDownAttribute"/> attributes are identical to the standard `SetUp` and `TearDown` attributes, with the exception that they allow for <see cref="IEditModeTestYieldInstruction"/>. The `UnitySetUp` and `UnityTearDown` attributes expect a return type of [IEnumerator](https://docs.microsoft.com/en-us/dotnet/api/system.collections.ienumerator?view=netframework-4.8).
+    /// </summary>
+    /// <example>
+    /// <code>
+    /// <![CDATA[
+    /// public class SetUpTearDownExample
+    /// {
+    ///     [UnitySetUp]
+    ///     public IEnumerator SetUp()
+    ///     {
+    ///         yield return new EnterPlayMode();
+    ///     }
+    ///
+    ///     [Test]
+    ///     public void MyTest()
+    ///     {
+    ///         Debug.Log("This runs inside playmode");
+    ///     }
+    ///
+    ///     [UnityTearDown]
+    ///     public IEnumerator TearDown()
+    ///     {
+    ///         yield return new ExitPlayMode();
+    ///     }
+    /// }
+    /// ]]>
+    /// </code>
+    /// <para>## Base and Derived class example</para>
+    /// <code>
+    /// <![CDATA[
+    /// public class BaseClass
+    /// {
+    ///    [OneTimeSetUp]
+    ///    public void OneTimeSetUp()
+    ///    {
+    ///       Debug.Log("OneTimeSetUp Base");
+    ///    }
+    ///
+    ///    [SetUp]
+    ///    public void SetUp()
+    ///    {
+    ///       Debug.Log("SetUp Base");
+    ///    }
+    ///
+    ///    [UnitySetUp]
+    ///    public IEnumerator UnitySetUp()
+    ///    {
+    ///       Debug.Log("UnitySetup Base");
+    ///       yield return null;
+    ///    }
+    ///
+    ///    [TearDown]
+    ///    public void TearDown()
+    ///    {
+    ///       Debug.Log("TearDown Base");
+    ///    }
+    ///
+    ///    [UnityTearDown]
+    ///    public IEnumerator UnityTearDown()
+    ///    {
+    ///       Debug.Log("UnityTearDown Base");
+    ///       yield return null;
+    ///    }
+    /// }
+    ///
+    /// public class DerivedClass : BaseClass
+    /// {
+    ///    [OneTimeSetUp]
+    ///    public new void OneTimeSetUp()
+    ///    {
+    ///       Debug.Log("OneTimeSetUp");
+    ///    }
+    ///
+    ///    [SetUp]
+    ///    public new void SetUp()
+    ///    {
+    ///       Debug.Log("SetUp");
+    ///    }
+    ///
+    ///    [UnitySetUp]
+    ///    public new IEnumerator UnitySetUp()
+    ///    {
+    ///       Debug.Log("UnitySetup");
+    ///       yield return null;
+    ///    }
+    ///
+    ///    [Test]
+    ///    public void UnitTest()
+    ///    {
+    ///       Debug.Log("Test");
+    ///    }
+    ///
+    ///    [UnityTest]
+    ///    public IEnumerator UnityTest()
+    ///    {
+    ///       Debug.Log("UnityTest before yield");
+    ///       yield return null;
+    ///       Debug.Log("UnityTest after yield");
+    ///    }
+    ///
+    ///    [TearDown]
+    ///    public new void TearDown()
+    ///    {
+    ///       Debug.Log("TearDown");
+    ///    }
+    ///
+    ///    [UnityTearDown]
+    ///    public new IEnumerator UnityTearDown()
+    ///    {
+    ///       Debug.Log("UnityTearDown");
+    ///       yield return null;
+    ///    }
+    ///
+    ///    [OneTimeTearDown]
+    ///    public void OneTimeTearDown()
+    ///    {
+    ///       Debug.Log("OneTimeTearDown");
+    ///    }
+    /// }
+    /// ]]>
+    /// </code>
+    /// <para>## Domain reload example</para>
+    /// <code>
+    /// <![CDATA[
+    /// public class BaseClass
+    /// {
+    ///    [OneTimeSetUp]
+    ///    public void OneTimeSetUp()
+    ///    {
+    ///       Debug.Log("OneTimeSetUp Base");
+    ///    }
+    ///
+    ///    [SetUp]
+    ///    public void SetUp()
+    ///    {
+    ///       Debug.Log("SetUp Base");
+    ///    }
+    ///
+    ///    [UnitySetUp]
+    ///    public IEnumerator UnitySetUp()
+    ///    {
+    ///       Debug.Log("UnitySetup Base");
+    ///       yield return null;
+    ///    }
+    ///
+    ///    [TearDown]
+    ///    public void TearDown()
+    ///    {
+    ///       Debug.Log("TearDown Base");
+    ///    }
+    ///
+    ///    [UnityTearDown]
+    ///    public IEnumerator UnityTearDown()
+    ///    {
+    ///       Debug.Log("UnityTearDown Base");
+    ///       yield return null;
+    ///    }
+    /// }
+    ///
+    /// public class DerivedClass : BaseClass
+    /// {
+    ///    [OneTimeSetUp]
+    ///    public new void OneTimeSetUp()
+    ///    {
+    ///       Debug.Log("OneTimeSetUp");
+    ///    }
+    ///
+    ///    [SetUp]
+    ///    public new void SetUp()
+    ///    {
+    ///       Debug.Log("SetUp");
+    ///    }
+    ///
+    ///    [UnitySetUp]
+    ///    public new IEnumerator UnitySetUp()
+    ///    {
+    ///       Debug.Log("UnitySetup");
+    ///       yield return null;
+    ///    }
+    ///
+    ///    [Test]
+    ///    public void UnitTest()
+    ///    {
+    ///       Debug.Log("Test");
+    ///    }
+    ///
+    ///    [UnityTest]
+    ///    public IEnumerator UnityTest()
+    ///    {
+    ///       Debug.Log("UnityTest before yield");
+    ///       yield return new EnterPlayMode();
+    ///       //Domain reload happening
+    ///       yield return new ExitPlayMode();
+    ///       Debug.Log("UnityTest after yield");
+    ///    }
+    ///
+    ///    [TearDown]
+    ///    public new void TearDown()
+    ///    {
+    ///       Debug.Log("TearDown");
+    ///    }
+    ///
+    ///    [UnityTearDown]
+    ///    public new IEnumerator UnityTearDown()
+    ///    {
+    ///       Debug.Log("UnityTearDown");
+    ///       yield return null;
+    ///    }
+    ///
+    ///    [OneTimeTearDown]
+    ///    public void OneTimeTearDown()
+    ///    {
+    ///       Debug.Log("OneTimeTearDown");
+    ///    }
+    /// }
+    /// ]]>
+    /// </code>
+    /// </example>
+    [AttributeUsage(AttributeTargets.Method)]
+    public class UnitySetUpAttribute : NUnitAttribute
+    {
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnitySetUpAttribute.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityTearDownAttribute.cs

@@ -0,0 +1,37 @@
+using System;
+using NUnit.Framework;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// The <see cref="UnitySetUpAttribute"/> and `UnityTearDown` attributes are identical to the standard `SetUp` and `TearDown` attributes, with the exception that they allow for <see cref="IEditModeTestYieldInstruction"/>. The `UnitySetUp` and `UnityTearDown` attributes expect a return type of [IEnumerator](https://docs.microsoft.com/en-us/dotnet/api/system.collections.ienumerator?view=netframework-4.8).
+    /// </summary>
+    /// <example>
+    /// <code>
+    ///public class SetUpTearDownExample
+    /// {
+    ///     [UnitySetUp]
+    ///     public IEnumerator SetUp()
+    ///     {
+    ///         yield return new EnterPlayMode();
+    ///     }
+    ///
+    ///     [Test]
+    ///     public void MyTest()
+    ///     {
+    ///         Debug.Log("This runs inside playmode");
+    ///     }
+    ///
+    ///     [UnityTearDown]
+    ///     public IEnumerator TearDown()
+    ///     {
+    ///         yield return new ExitPlayMode();
+    ///     }
+    /// }
+    /// </code>
+    /// </example>
+    [AttributeUsage(AttributeTargets.Method)]
+    public class UnityTearDownAttribute : NUnitAttribute
+    {
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityTearDownAttribute.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityTestAttribute.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Builders;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// `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).
+    /// </summary>
+    /// <example>
+    /// <para>
+    /// ## 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:
+    /// </para>
+    /// <code>
+    /// [UnityTest]
+    /// public IEnumerator EditorUtility_WhenExecuted_ReturnsSuccess()
+    /// {
+    ///     var utility = RunEditorUtilityInTheBackground();
+    ///
+    ///     while (utility.isRunning)
+    ///     {
+    ///         yield return null;
+    ///     }
+    ///
+    ///     Assert.IsTrue(utility.isSuccess);
+    /// }
+    /// </code>
+    /// <para>
+    /// ## 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`:
+    /// </para>
+    /// <code>
+    /// [UnityTest]
+    /// public IEnumerator GameObject_WithRigidBody_WillBeAffectedByPhysics()
+    /// {
+    ///     var go = new GameObject();
+    ///     go.AddComponent&lt;Rigidbody&gt;();
+    ///     var originalPosition = go.transform.position.y;
+    ///
+    ///     yield return new WaitForFixedUpdate();
+    ///
+    ///     Assert.AreNotEqual(originalPosition, go.transform.position.y);
+    /// }
+    /// </code>
+    /// </example>
+    [AttributeUsage(AttributeTargets.Method)]
+    public class UnityTestAttribute : CombiningStrategyAttribute, IImplyFixture, ISimpleTestBuilder, ITestBuilder, IApplyToTest
+    {
+        private const string k_MethodMarkedWithUnitytestMustReturnIenumerator = "Method marked with UnityTest must return IEnumerator.";
+
+        /// <summary>
+        /// Initializes and returns an instance of UnityTestAttribute.
+        /// </summary>
+        public UnityTestAttribute() : base(new UnityCombinatorialStrategy(), new ParameterDataSourceProvider()) {}
+
+        private readonly NUnitTestCaseBuilder _builder = new NUnitTestCaseBuilder();
+
+        /// <summary>
+        /// This method builds the TestMethod from the Test and the method info. In addition it removes the expected result of the test.
+        /// </summary>
+        /// <param name="method">The method info.</param>
+        /// <param name="suite">The test.</param>
+        /// <returns>A TestMethod object</returns>
+        TestMethod ISimpleTestBuilder.BuildFrom(IMethodInfo method, Test suite)
+        {
+            var t = CreateTestMethod(method, suite);
+
+            AdaptToUnityTestMethod(t);
+
+            return t;
+        }
+
+        /// <summary>
+        /// This method hides the base method from CombiningStrategyAttribute.
+        /// It builds a TestMethod from a Parameterized Test and the method info.
+        /// In addition it removes the expected result of the test.
+        /// </summary>
+        /// <param name="method">The method info.</param>
+        /// <param name="suite">The test.</param>
+        /// <returns>A TestMethod object</returns>
+        IEnumerable<TestMethod> ITestBuilder.BuildFrom(IMethodInfo method, Test suite)
+        {
+            var testMethods  = base.BuildFrom(method, suite);
+
+            foreach (var t in testMethods)
+            {
+                AdaptToUnityTestMethod(t);
+            }
+
+            return testMethods;
+        }
+
+        private TestMethod CreateTestMethod(IMethodInfo method, Test suite)
+        {
+            TestCaseParameters parms = new TestCaseParameters
+            {
+                ExpectedResult = new object(),
+                HasExpectedResult = true
+            };
+
+            var t = _builder.BuildTestMethod(method, suite, parms);
+            return t;
+        }
+
+        private static void AdaptToUnityTestMethod(TestMethod t)
+        {
+            if (t.parms != null)
+            {
+                t.parms.HasExpectedResult = false;
+            }
+        }
+
+        private static bool IsMethodReturnTypeIEnumerator(IMethodInfo method)
+        {
+            return !method.ReturnType.IsType(typeof(IEnumerator));
+        }
+
+        /// <summary>
+        /// This method hides the base method ApplyToTest from CombiningStrategyAttribute.
+        /// In addition it ensures that the test with the `UnityTestAttribute` has an IEnumerator as return type.
+        /// </summary>
+        /// <param name="test">The test.</param>
+        public new void ApplyToTest(Test test)
+        {
+            if (IsMethodReturnTypeIEnumerator(test.Method))
+            {
+                test.RunState = RunState.NotRunnable;
+                test.Properties.Set(PropertyNames.SkipReason, k_MethodMarkedWithUnitytestMustReturnIenumerator);
+            }
+
+            base.ApplyToTest(test);
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityTestAttribute.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/BaseDelegator.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Threading;
+using NUnit.Framework.Internal;
+
+namespace UnityEngine.TestTools.NUnitExtensions
+{
+    internal abstract class BaseDelegator
+    {
+        protected ManualResetEvent m_Signal = new ManualResetEvent(false);
+
+        protected object m_Result;
+        protected Exception m_Exception;
+        protected ITestExecutionContext m_Context;
+
+        protected bool m_Aborted;
+
+        protected object HandleResult()
+        {
+            SetCurrentTestContext();
+            if (m_Exception != null)
+            {
+                var temp = m_Exception;
+                m_Exception = null;
+                throw temp;
+            }
+            var tempResult = m_Result;
+            m_Result = null;
+            return tempResult;
+        }
+
+        protected void WaitForSignal()
+        {
+            while (!m_Signal.WaitOne(100))
+            {
+                if (m_Aborted)
+                {
+                    m_Aborted = false;
+                    Reflect.MethodCallWrapper = null;
+                    throw new Exception();
+                }
+            }
+        }
+
+        public void Abort()
+        {
+            m_Aborted = true;
+        }
+
+        protected void SetCurrentTestContext()
+        {
+            var prop = typeof(TestExecutionContext).GetProperty("CurrentContext");
+            if (prop != null)
+            {
+                prop.SetValue(null, m_Context, null);
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/BaseDelegator.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6b72875690e0f7343911e06af3145bd5
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/BeforeAfterTestCommandBase.cs

@@ -0,0 +1,281 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+using UnityEngine.TestTools.Logging;
+using UnityEngine.TestTools.TestRunner;
+
+namespace UnityEngine.TestTools
+{
+    internal abstract class BeforeAfterTestCommandBase<T> : DelegatingTestCommand, IEnumerableTestMethodCommand where T : class
+    {
+        private string m_BeforeErrorPrefix;
+        private string m_AfterErrorPrefix;
+        protected BeforeAfterTestCommandBase(TestCommand innerCommand, string beforeErrorPrefix, string afterErrorPrefix)
+            : base(innerCommand)
+        {
+            m_BeforeErrorPrefix = beforeErrorPrefix;
+            m_AfterErrorPrefix = afterErrorPrefix;
+        }
+
+        protected T[] BeforeActions = new T[0];
+
+        protected T[] AfterActions = new T[0];
+
+        protected static MethodInfo[] GetActions(IDictionary<Type, List<MethodInfo>> cacheStorage, Type fixtureType, Type attributeType, Type[] returnTypes)
+        {
+            if (cacheStorage.TryGetValue(fixtureType, out var result))
+            {
+                return result.ToArray();
+            }
+
+            cacheStorage[fixtureType] = GetMethodsWithAttributeFromFixture(fixtureType,  attributeType, returnTypes);
+
+            return cacheStorage[fixtureType].ToArray();
+        }
+
+        protected static T[] GetTestActions(IDictionary<MethodInfo,  List<T>> cacheStorage, MethodInfo methodInfo)
+        {
+            if (cacheStorage.TryGetValue(methodInfo, out var result))
+            {
+                return result.ToArray();
+            }
+
+            var attributesForMethodInfo = new List<T>();
+            var attributes = methodInfo.GetCustomAttributes(false);
+            foreach (var attribute in attributes)
+            {
+                if (attribute is T attribute1)
+                {
+                    attributesForMethodInfo.Add(attribute1);
+                }
+            }
+
+            cacheStorage[methodInfo] = attributesForMethodInfo;
+
+            return cacheStorage[methodInfo].ToArray();
+        }
+
+        private static List<MethodInfo> GetMethodsWithAttributeFromFixture(Type fixtureType, Type setUpType, Type[] returnTypes)
+        {
+            MethodInfo[] methodsWithAttribute = Reflect.GetMethodsWithAttribute(fixtureType, setUpType, true);
+            var methodsInfo = new List<MethodInfo>();
+            methodsInfo.AddRange(methodsWithAttribute.Where(method => returnTypes.Any(type => type == method.ReturnType)));
+            return methodsInfo;
+        }
+
+        protected abstract IEnumerator InvokeBefore(T action, Test test, UnityTestExecutionContext context);
+
+        protected abstract IEnumerator InvokeAfter(T action, Test test, UnityTestExecutionContext context);
+
+        protected virtual bool MoveBeforeEnumerator(IEnumerator enumerator, Test test)
+        {
+            return enumerator.MoveNext();
+        }
+
+        protected virtual bool MoveAfterEnumerator(IEnumerator enumerator, Test test)
+        {
+            return enumerator.MoveNext();
+        }
+
+        protected abstract BeforeAfterTestCommandState GetState(UnityTestExecutionContext context);
+
+        protected virtual bool AllowFrameSkipAfterAction(T action)
+        {
+            return true;
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            var unityContext = (UnityTestExecutionContext)context;
+            var state = GetState(unityContext);
+            if (state == null)
+            {
+                throw new Exception($"No state in context for {GetType().Name}.");
+            }
+
+            if(state.ShouldRestore)
+            {
+                state.ApplyContext(unityContext);
+            }
+
+            while (state.NextBeforeStepIndex < BeforeActions.Length)
+            {
+                var action = BeforeActions[state.NextBeforeStepIndex];
+                IEnumerator enumerator;
+                try
+                {
+                    enumerator = EnumeratorHelper.UnpackNestedEnumerators(InvokeBefore(action, Test, unityContext));
+                    EnumeratorHelper.SetEnumeratorPC(state.NextBeforeStepPc);
+                }
+                catch (Exception ex)
+                {
+                    state.TestHasRun = true;
+                    context.CurrentResult.RecordPrefixedException(m_BeforeErrorPrefix, ex);
+                    break;
+                }
+
+                using (var logScope = new LogScope())
+                {
+                    while (true)
+                    {
+                        try
+                        {
+                            if (!enumerator.MoveNext())
+                            {
+                                logScope.EvaluateLogScope(true);
+                                break;
+                            }
+
+                            if (!AllowFrameSkipAfterAction(action)) // Evaluate the log scope right away for the commands where we do not yield
+                            {
+                                logScope.EvaluateLogScope(true);
+                            }
+                            if (enumerator.Current is IEditModeTestYieldInstruction)
+                            {
+                                if (unityContext.TestMode == TestPlatform.PlayMode)
+                                {
+                                    throw new Exception($"PlayMode test are not allowed to yield {enumerator.Current.GetType().Name}");
+                                }
+
+                                if (EnumeratorHelper.IsRunningNestedEnumerator)
+                                {
+                                    throw new Exception($"Nested enumerators are not allowed to yield {enumerator.Current.GetType().Name}");
+                                }
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            state.TestHasRun = true;
+                            context.CurrentResult.RecordPrefixedException(m_BeforeErrorPrefix, ex);
+                            state.StoreContext(unityContext);
+                            break;
+                        }
+
+                        if (!EnumeratorHelper.IsRunningNestedEnumerator)
+                        {
+                            // Only store the state in the main enumerator. Domain reloads are not supported from nested enumerators.
+                            state.NextBeforeStepPc = EnumeratorHelper.GetEnumeratorPC();
+                            state.StoreContext(unityContext);
+                        }
+                        
+                        if (!AllowFrameSkipAfterAction(action))
+                        {
+                            break;
+                        }
+
+                        yield return enumerator.Current;
+                    }
+                }
+
+                state.NextBeforeStepIndex++;
+                state.NextBeforeStepPc = 0;
+            }
+
+            if (!state.TestHasRun)
+            {
+                state.ShouldRestore = false; // Any inner commands that can perform domain reloads are responsible for restoring the context
+                if (innerCommand is IEnumerableTestMethodCommand)
+                {
+                    var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                    foreach (var iterator in executeEnumerable)
+                    {
+                        yield return iterator;
+                    }
+                }
+                else
+                {
+                    context.CurrentResult = innerCommand.Execute(context);
+                }
+
+                state.TestHasRun = true;
+            }
+
+            while (state.NextAfterStepIndex < AfterActions.Length)
+            {
+                state.TestAfterStarted = true;
+                var action = AfterActions[state.NextAfterStepIndex];
+                IEnumerator enumerator;
+                try
+                {
+                    enumerator = EnumeratorHelper.UnpackNestedEnumerators(InvokeAfter(action, Test, unityContext));
+                    EnumeratorHelper.SetEnumeratorPC(state.NextAfterStepPc);
+                }
+                catch (Exception ex)
+                {
+                    context.CurrentResult.RecordPrefixedException(m_AfterErrorPrefix, ex);
+                    state.StoreContext(unityContext);
+                    break;
+                }
+
+                using (var logScope = new LogScope())
+                {
+                    while (true)
+                    {
+                        try
+                        {
+                            if (!enumerator.MoveNext())
+                            {
+                                logScope.EvaluateLogScope(true);
+                                break;
+                            }
+                            
+                            if (!AllowFrameSkipAfterAction(action)) // Evaluate the log scope right away for the commands where we do not yield
+                            {
+                                logScope.EvaluateLogScope(true);
+                            }
+                            if (enumerator.Current is IEditModeTestYieldInstruction)
+                            {
+                                if (unityContext.TestMode == TestPlatform.PlayMode)
+                                {
+                                    throw new Exception($"PlayMode test are not allowed to yield {enumerator.Current.GetType().Name}");
+                                }
+
+                                if (EnumeratorHelper.IsRunningNestedEnumerator)
+                                {
+                                    throw new Exception($"Nested enumerators are not allowed to yield {enumerator.Current.GetType().Name}");
+                                }
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            context.CurrentResult.RecordPrefixedException(m_AfterErrorPrefix, ex);
+                            state.StoreContext(unityContext);
+                            break;
+                        }
+
+                        if (!EnumeratorHelper.IsRunningNestedEnumerator)
+                        {
+                            // Only store the state in the main enumerator. Domain reloads are not supported from nested enumerators.
+                            state.NextAfterStepPc = EnumeratorHelper.GetEnumeratorPC();
+                            state.StoreContext(unityContext);
+                        }
+                        
+                        if (!AllowFrameSkipAfterAction(action))
+                        {
+                            break;
+                        }
+
+                        yield return enumerator.Current;
+                    }
+                }
+
+                state.NextAfterStepIndex++;
+                state.NextAfterStepPc = 0;
+            }
+
+            state.Reset();
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new NotImplementedException("Use ExecuteEnumerable");
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/BeforeAfterTestCommandBase.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/BeforeAfterTestCommandState.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Reflection;
+using System.Text;
+using NUnit.Framework.Interfaces;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    [Serializable]
+    internal class BeforeAfterTestCommandState
+    {
+        private const BindingFlags Flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy;
+        public int NextBeforeStepIndex;
+        public int NextBeforeStepPc;
+        public int NextAfterStepIndex;
+        public int NextAfterStepPc;
+        public bool TestHasRun;
+        public TestStatus CurrentTestResultStatus;
+        public string CurrentTestResultLabel;
+        public FailureSite CurrentTestResultSite;
+        public string CurrentTestMessage;
+        public string CurrentTestStrackTrace;
+        public bool TestAfterStarted;
+        public string Output;
+        public long StartTicks;
+        public double StartTimeOA;
+        public bool ShouldRestore;
+
+        public void Reset()
+        {
+            NextBeforeStepIndex = 0;
+            NextBeforeStepPc = 0;
+            NextAfterStepIndex = 0;
+            NextAfterStepPc = 0;
+            TestHasRun = false;
+            CurrentTestResultStatus = TestStatus.Inconclusive;
+            CurrentTestResultLabel = null;
+            CurrentTestResultSite = default(FailureSite);
+            CurrentTestMessage = null;
+            CurrentTestStrackTrace = null;
+            TestAfterStarted = false;
+            Output = null;
+            StartTicks = 0;
+            StartTimeOA = 0;
+            ShouldRestore = false;
+        }
+
+        public void StoreContext(UnityTestExecutionContext context)
+        {
+            var result = context.CurrentResult;
+            CurrentTestResultStatus = result.ResultState.Status;
+            CurrentTestResultLabel = result.ResultState.Label;
+            CurrentTestResultSite = result.ResultState.Site;
+            CurrentTestMessage = result.Message;
+            CurrentTestStrackTrace = result.StackTrace;
+            Output = result.Output;
+            StartTicks = context.StartTicks;
+            StartTimeOA = context.StartTime.ToOADate();
+            ShouldRestore = true;
+        }
+
+        public void ApplyContext(UnityTestExecutionContext context)
+        {
+            var outputProp = context.CurrentResult.GetType().BaseType.GetField("_output", Flags);
+            var stringBuilder = (outputProp.GetValue(context.CurrentResult) as StringBuilder);
+            stringBuilder.Clear();
+            stringBuilder.Append(Output);
+            context.StartTicks = StartTicks;
+            context.StartTime = DateTime.FromOADate(StartTimeOA);
+            context.CurrentResult.SetResult(new ResultState(CurrentTestResultStatus, CurrentTestResultLabel, CurrentTestResultSite), CurrentTestMessage, CurrentTestStrackTrace);
+            ShouldRestore = false;
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/BeforeAfterTestCommandState.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableApplyChangesToContextCommand.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class EnumerableApplyChangesToContextCommand : ApplyChangesToContextCommand, IEnumerableTestMethodCommand
+    {
+        public EnumerableApplyChangesToContextCommand(TestCommand innerCommand, IEnumerable<IApplyToContext> changes)
+            : base(innerCommand, changes) {}
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            ApplyChanges(context);
+
+            if (innerCommand is IEnumerableTestMethodCommand)
+            {
+                var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                foreach (var iterator in executeEnumerable)
+                {
+                    yield return iterator;
+                }
+            }
+            else
+            {
+                context.CurrentResult = innerCommand.Execute(context);
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableApplyChangesToContextCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableMaxTimeCommand.cs

@@ -0,0 +1,54 @@
+using System.Collections;
+using System.Diagnostics;
+using System.Reflection;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class EnumerableMaxTimeCommand : DelegatingTestCommand, IEnumerableTestMethodCommand
+    {
+        private int maxTime;
+        public EnumerableMaxTimeCommand(MaxTimeCommand commandToReplace) : base(commandToReplace.GetInnerCommand())
+        {
+            maxTime = (int)typeof(MaxTimeCommand)
+                .GetField("maxTime", BindingFlags.NonPublic | BindingFlags.Instance)
+                .GetValue(commandToReplace);
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new System.NotImplementedException("Use ExecuteEnumerable");
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            long timestamp = Stopwatch.GetTimestamp();
+            
+            if (innerCommand is IEnumerableTestMethodCommand)
+            {
+                var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                foreach (var iterator in executeEnumerable)
+                {
+                    yield return iterator;
+                }
+            }
+            else
+            {
+                context.CurrentResult = innerCommand.Execute(context);
+            }
+            
+            var duration = (Stopwatch.GetTimestamp() - timestamp) / (double) Stopwatch.Frequency;
+            var testResult = context.CurrentResult;
+            testResult.Duration = duration;
+            if (testResult.ResultState == ResultState.Success)
+            {
+                var durationInMilliseconds = duration * 1000.0;
+                if (durationInMilliseconds > maxTime)
+                    testResult.SetResult(ResultState.Failure, string.Format("Elapsed time of {0}ms exceeds maximum of {1}ms", (object) durationInMilliseconds, (object) this.maxTime));
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableMaxTimeCommand.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aa5dd1a9432747fd89501213ba621de6
+timeCreated: 1713961779

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableRepeatedTestCommand.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections;
+using System.Reflection;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class EnumerableRepeatedTestCommand : DelegatingTestCommand, IEnumerableTestMethodCommand
+    {
+        private int repeatCount;
+
+        public EnumerableRepeatedTestCommand(RepeatAttribute.RepeatedTestCommand commandToReplace) : base(commandToReplace.GetInnerCommand())
+        {
+            repeatCount = (int)typeof(RepeatAttribute.RepeatedTestCommand)
+                .GetField("repeatCount", BindingFlags.NonPublic | BindingFlags.Instance)
+                .GetValue(commandToReplace);
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new NotImplementedException("Use ExecuteEnumerable");
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            var unityContext = (UnityTestExecutionContext)context;
+            int count = unityContext.EnumerableTestState.Repeat;
+            var firstCycleAfterResume = count > 0;
+
+            while (count < repeatCount || (firstCycleAfterResume && count <= repeatCount))
+            {
+                if (!firstCycleAfterResume)
+                {
+                    count++;
+                }
+
+                firstCycleAfterResume = false;
+                unityContext.EnumerableTestState.Repeat = count;
+
+                if (innerCommand is IEnumerableTestMethodCommand)
+                {
+                    var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                    foreach (var iterator in executeEnumerable)
+                    {
+                        yield return iterator;
+                    }
+                }
+                else
+                {
+                    context.CurrentResult = innerCommand.Execute(context);
+                }
+
+                if (context.CurrentResult.ResultState != ResultState.Success)
+                {
+                    break;
+                }
+            }
+
+            unityContext.EnumerableTestState.Repeat = 0;
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableRepeatedTestCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableRetryTestCommand.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections;
+using System.Reflection;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class EnumerableRetryTestCommand : DelegatingTestCommand, IEnumerableTestMethodCommand
+    {
+        private int retryCount;
+
+        public EnumerableRetryTestCommand(RetryAttribute.RetryCommand commandToReplace) : base(commandToReplace.GetInnerCommand())
+        {
+            retryCount = (int)typeof(RetryAttribute.RetryCommand)
+                .GetField("_retryCount", BindingFlags.NonPublic | BindingFlags.Instance)
+                .GetValue(commandToReplace);
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new NotImplementedException("Use ExecuteEnumerable");
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            var unityContext = (UnityTestExecutionContext)context;
+            int count = unityContext.EnumerableTestState.Retry;
+            var firstCycleAfterResume = count > 0;
+
+            while (count < retryCount || (firstCycleAfterResume && count <= retryCount))
+            {
+                if (!firstCycleAfterResume)
+                {
+                    count++;
+                }
+
+                firstCycleAfterResume = false;
+
+                unityContext.EnumerableTestState.Retry = count;
+
+                if (innerCommand is IEnumerableTestMethodCommand)
+                {
+                    var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                    foreach (var iterator in executeEnumerable)
+                    {
+                        yield return iterator;
+                    }
+                }
+                else
+                {
+                    context.CurrentResult = innerCommand.Execute(context);
+                }
+
+                if (context.CurrentResult.ResultState != ResultState.Failure)
+                {
+                    break;
+                }
+            }
+
+            unityContext.EnumerableTestState.Retry = 0;
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableRetryTestCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableSetUpTearDownCommand.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using Unity.Profiling;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class EnumerableSetUpTearDownCommand : BeforeAfterTestCommandBase<MethodInfo>
+    {
+        private static readonly Dictionary<Type, List<MethodInfo>> m_BeforeActionsCache = new Dictionary<Type, List<MethodInfo>>();
+        private static readonly Dictionary<Type, List<MethodInfo>> m_AfterActionsCache = new Dictionary<Type, List<MethodInfo>>();
+
+        public EnumerableSetUpTearDownCommand(TestCommand innerCommand)
+            : base(innerCommand, "SetUp", "TearDown")
+        {
+            using (new ProfilerMarker(nameof(EnumerableSetUpTearDownCommand)).Auto())
+            {
+                if (Test.TypeInfo.Type != null)
+                {
+                    BeforeActions = GetActions(m_BeforeActionsCache, Test.TypeInfo.Type, typeof(UnitySetUpAttribute), new[] {typeof(IEnumerator)});
+                    AfterActions = GetActions(m_AfterActionsCache, Test.TypeInfo.Type, typeof(UnityTearDownAttribute), new[] {typeof(IEnumerator)}).Reverse().ToArray();
+                }
+            }
+        }
+
+        protected override bool MoveAfterEnumerator(IEnumerator enumerator, Test test)
+        {
+            using (new ProfilerMarker(test.Name + ".TearDown").Auto())
+                return base.MoveAfterEnumerator(enumerator, test);
+        }
+
+        protected override bool MoveBeforeEnumerator(IEnumerator enumerator, Test test)
+        {
+            using (new ProfilerMarker(test.Name + ".Setup").Auto())
+                return base.MoveBeforeEnumerator(enumerator, test);
+        }
+
+        protected override IEnumerator InvokeBefore(MethodInfo action, Test test, UnityTestExecutionContext context)
+        {
+            return (IEnumerator)Reflect.InvokeMethod(action, context.TestObject);
+        }
+
+        protected override IEnumerator InvokeAfter(MethodInfo action, Test test, UnityTestExecutionContext context)
+        {
+            return (IEnumerator)Reflect.InvokeMethod(action, context.TestObject);
+        }
+
+        protected override BeforeAfterTestCommandState GetState(UnityTestExecutionContext context)
+        {
+            return context.SetUpTearDownState;
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableSetUpTearDownCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableTestMethodCommand.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using Unity.Profiling;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+using UnityEngine.TestTools.TestRunner;
+
+namespace UnityEngine.TestTools
+{
+    internal class EnumerableTestMethodCommand : TestCommand, IEnumerableTestMethodCommand
+    {
+        private readonly TestMethod testMethod;
+
+        public EnumerableTestMethodCommand(TestMethod testMethod)
+            : base(testMethod)
+        {
+            this.testMethod = testMethod;
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            var unityContext = (UnityTestExecutionContext) context;
+            yield return null;
+
+            IEnumerator currentExecutingTestEnumerator;
+            try
+            {
+                currentExecutingTestEnumerator = new TestEnumeratorWrapper(testMethod).GetEnumerator(context);
+            }
+            catch (Exception ex)
+            {
+                context.CurrentResult.RecordException(ex);
+                yield break;
+            }
+
+            if (currentExecutingTestEnumerator != null)
+            {
+                var testEnumeraterYieldInstruction = new TestEnumerator(context, currentExecutingTestEnumerator);
+
+                yield return testEnumeraterYieldInstruction;
+
+                var enumerator = testEnumeraterYieldInstruction.Execute();
+
+                var executingEnumerator = ExecuteEnumerableAndRecordExceptions(enumerator, new EnumeratorContext(context), unityContext);
+                while (AdvanceEnumerator(executingEnumerator))
+                {
+                    yield return executingEnumerator.Current;
+                }
+            }
+            else
+            {
+                if (context.CurrentResult.ResultState != ResultState.Ignored)
+                {
+                    context.CurrentResult.SetResult(ResultState.Success);
+                }
+            }
+        }
+
+        private bool AdvanceEnumerator(IEnumerator enumerator)
+        {
+            using (new ProfilerMarker(testMethod.MethodName).Auto())
+                return enumerator.MoveNext();
+        }
+
+        private IEnumerator ExecuteEnumerableAndRecordExceptions(IEnumerator enumerator, EnumeratorContext context, UnityTestExecutionContext unityContext)
+        {
+            while (true)
+            {
+                if (context.ExceptionWasRecorded)
+                {
+                    break;
+                }
+
+                bool executionDone = false;
+                try
+                {
+                    executionDone = !enumerator.MoveNext();
+                    if (unityContext.TestMode == TestPlatform.PlayMode && enumerator.Current is IEditModeTestYieldInstruction)
+                    {
+                        throw new Exception($"PlayMode test are not allowed to yield {enumerator.Current.GetType().Name}");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    context.RecordExceptionWithHint(ex);
+                    break;
+                }
+
+                if (unityContext.HasTimedOut())
+                {
+                    unityContext.CurrentResult.RecordException(new UnityTestTimeoutException(unityContext.TestCaseTimeout));
+                    yield return new RestoreTestContextAfterDomainReload(); // If this is right after a domain reload, give the editor a chance to restore.
+                    yield break;
+                }
+                if (executionDone)
+                {
+                    break;
+                }
+
+                if (enumerator.Current is IEnumerator nestedEnumerator)
+                {
+                    yield return ExecuteEnumerableAndRecordExceptions(nestedEnumerator, context, unityContext);
+                }
+                else
+                {
+                    yield return enumerator.Current;
+                }
+            }
+        }
+
+        private class EnumeratorContext
+        {
+            private readonly ITestExecutionContext m_Context;
+
+            public EnumeratorContext(ITestExecutionContext context)
+            {
+                m_Context = context;
+            }
+
+            public bool ExceptionWasRecorded
+            {
+                get;
+                private set;
+            }
+
+            public void RecordExceptionWithHint(Exception ex)
+            {
+                if (ExceptionWasRecorded)
+                {
+                    return;
+                }
+                m_Context.CurrentResult.RecordException(ex);
+                ExceptionWasRecorded = true;
+            }
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new NotImplementedException("Use ExecuteEnumerable");
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableTestMethodCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableTestState.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace UnityEngine.TestTools
+{
+    [Serializable]
+    internal class EnumerableTestState
+    {
+        public int Repeat;
+        public int Retry;
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableTestState.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 356852e4738840b4b1ab533d3a66f0e1
+timeCreated: 1606321047

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/IgnoreTest.cs

@@ -0,0 +1,8 @@
+namespace UnityEngine.TestTools
+{
+    internal class IgnoreTest
+    {
+        public string test { get; set; }
+        public string ignoreComment { get; set; }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/IgnoreTest.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9bbdc426fc0a48e1b66deaac7ea8f64c
+timeCreated: 1675764691

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/IgnoreTestCommand.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class IgnoreTestCommand : DelegatingTestCommand, IEnumerableTestMethodCommand
+    {
+        private ITest _test;
+        public IgnoreTestCommand(TestCommand innerCommand, ITest test) : base(innerCommand)
+        {
+            _test = test;
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new NotImplementedException("Use ExecuteEnumerable");
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            var ignoreTests = ((UnityTestExecutionContext) context).IgnoreTests;
+            if (ignoreTests != null && ignoreTests.Length > 0)
+            {
+                var fullName = _test.GetFullNameWithoutDllPath();
+                foreach (var ignoreTest in ignoreTests)
+                {
+                    if (ignoreTest.test.Equals(fullName))
+                    {
+                        context.CurrentResult.SetResult(ResultState.Ignored,ignoreTest.ignoreComment);
+                        yield break;
+                    }
+                }
+            }
+            if (innerCommand is IEnumerableTestMethodCommand)
+            {
+                var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                foreach (var iterator in executeEnumerable)
+                {
+                    yield return iterator;
+                }
+            }
+            else
+            {
+                context.CurrentResult = innerCommand.Execute(context);
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/IgnoreTestCommand.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e55eddf2afda488db58fb17f985fee99
+timeCreated: 1675765192

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/ImmediateEnumerableCommand.cs

@@ -0,0 +1,31 @@
+using System;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class ImmediateEnumerableCommand : DelegatingTestCommand
+    {
+        public ImmediateEnumerableCommand(TestCommand innerCommand)
+            : base(innerCommand) {}
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            if (innerCommand is IEnumerableTestMethodCommand)
+            {
+                var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                foreach (var iterator in executeEnumerable)
+                {
+                    if (iterator != null)
+                    {
+                        throw new Exception("Only null can be yielded at this point.");
+                    }
+                }
+                return context.CurrentResult;
+            }
+
+            return innerCommand.Execute(context);
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/ImmediateEnumerableCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/OuterUnityTestActionCommand.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class OuterUnityTestActionCommand : BeforeAfterTestCommandBase<IOuterUnityTestAction>
+    {
+        private static readonly Dictionary<MethodInfo, List<IOuterUnityTestAction>> m_TestActionsCache = new Dictionary<MethodInfo, List<IOuterUnityTestAction>>();
+        public OuterUnityTestActionCommand(TestCommand innerCommand)
+            : base(innerCommand, "BeforeTest", "AfterTest")
+        {
+            if (Test.TypeInfo.Type != null)
+            {
+                BeforeActions = GetTestActions(m_TestActionsCache, Test.Method.MethodInfo);
+                AfterActions = BeforeActions;
+            }
+        }
+
+        protected override IEnumerator InvokeBefore(IOuterUnityTestAction action, Test test, UnityTestExecutionContext context)
+        {
+            return action.BeforeTest(test);
+        }
+
+        protected override IEnumerator InvokeAfter(IOuterUnityTestAction action, Test test, UnityTestExecutionContext context)
+        {
+            return action.AfterTest(test);
+        }
+
+        protected override BeforeAfterTestCommandState GetState(UnityTestExecutionContext context)
+        {
+            return context.OuterUnityTestActionState;
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/OuterUnityTestActionCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/ParametrizedIgnoreCommand.cs

@@ -0,0 +1,65 @@
+using System.Collections;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using System.Linq;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class ParametrizedIgnoreCommand : DelegatingTestCommand, IEnumerableTestMethodCommand
+    {
+        private readonly TestCommand m_Command;
+
+        public object[] Arguments { get; }
+        public string Reason { get; }
+
+        public ParametrizedIgnoreCommand(TestCommand command, object[] arguments, string reason = "") : base(command)
+        {
+            m_Command = command;
+            Arguments = arguments;
+            Reason = reason;
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            if (context.CurrentTest is TestMethod testMethod)
+            {
+                var isIgnored = testMethod.parms.Arguments.SequenceEqual(Arguments);
+                if (isIgnored)
+                {
+                    context.CurrentResult.SetResult(ResultState.Ignored, Reason);
+                    return context.CurrentResult;
+                }
+            }
+
+            return m_Command.Execute(context);
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        { 
+            if (context.CurrentTest is TestMethod testMethod)
+            {
+                var isIgnored = testMethod.parms.Arguments.SequenceEqual(Arguments);
+                if (isIgnored)
+                {
+                    context.CurrentResult.SetResult(ResultState.Ignored, Reason);
+                    yield break;
+                }
+            }
+            
+            if (innerCommand is IEnumerableTestMethodCommand)
+            {
+                var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                foreach (var iterator in executeEnumerable)
+                {
+                    yield return iterator;
+                }
+            }
+            else
+            {
+                context.CurrentResult = innerCommand.Execute(context);
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/ParametrizedIgnoreCommand.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 74987b94d22047d8b286a727906b7019
+timeCreated: 1699350178

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/RepeatCommand.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections;
+using System.Diagnostics;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class RepeatCommand : DelegatingTestCommand, IEnumerableTestMethodCommand
+    {
+        public RepeatCommand(TestCommand innerCommand)
+            : base(innerCommand)
+        {
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new NotImplementedException("Use ExecuteEnumerable");
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            var unityContext = (UnityTestExecutionContext)context;
+            if (unityContext.RetryRepeatState?.GetHashCode() == null)
+            {
+                unityContext.RetryRepeatState = new EnumerableTestState();
+            }
+
+            while(unityContext.RetryRepeatState.Repeat < unityContext.RepeatCount + 1)
+            {
+                if (innerCommand is IEnumerableTestMethodCommand)
+                {
+                    var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                    foreach (var iterator in executeEnumerable)
+                    {
+                        yield return iterator;
+                    }
+                }
+                else
+                {
+                    context.CurrentResult = innerCommand.Execute(context);
+                }
+
+                if (context.CurrentResult.ResultState != ResultState.Success)
+                {
+                    unityContext.RetryRepeatState.Repeat++;
+                    break;
+                }
+
+                if (unityContext.RetryRepeatState.Repeat < unityContext.RepeatCount)
+                {
+                    ReportTestFinishStartPair(unityContext);
+                }
+                unityContext.RetryRepeatState.Repeat++;
+            }
+           
+            SetIterationProperty(unityContext, unityContext.RetryRepeatState.Repeat-1);
+            unityContext.RetryRepeatState.Repeat = 0;
+        }
+
+        private static void ReportTestFinishStartPair(UnityTestExecutionContext unityContext)
+        {
+            unityContext.CurrentResult.StartTime = unityContext.StartTime;
+            unityContext.CurrentResult.EndTime = DateTime.UtcNow;
+            long tickCount = Stopwatch.GetTimestamp() - unityContext.StartTicks;
+            double seconds = (double) tickCount / Stopwatch.Frequency;
+            unityContext.CurrentResult.Duration = seconds;
+            SetIterationProperty(unityContext, unityContext.RetryRepeatState.Repeat);
+            unityContext.Listener.TestFinished(unityContext.CurrentResult);
+
+            // Start new test iteration
+            unityContext.CurrentResult = unityContext.CurrentTest.MakeTestResult();
+            unityContext.StartTime = DateTime.UtcNow;
+            unityContext.StartTicks = Stopwatch.GetTimestamp();
+            unityContext.Listener.TestStarted(unityContext.CurrentTest);
+        }
+
+        private static void SetIterationProperty(UnityTestExecutionContext unityContext, int iteration)
+        {
+            unityContext.CurrentResult.Test.Properties.Set("repeatIteration", iteration);
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/RepeatCommand.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 851f94140ec64b7db846948429a87f01
+timeCreated: 1680611750

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/RetryCommand.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections;
+using System.Diagnostics;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+using UnityEngine.TestRunner.TestProtocol;
+
+namespace UnityEngine.TestTools
+{
+    internal class RetryCommand  : DelegatingTestCommand, IEnumerableTestMethodCommand
+    {
+        public RetryCommand(TestCommand innerCommand)
+            : base(innerCommand)
+        {
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new NotImplementedException("Use ExecuteEnumerable");
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            var unityContext = (UnityTestExecutionContext)context;
+            if (unityContext.RetryRepeatState?.GetHashCode() == null)
+            {
+                unityContext.RetryRepeatState = new EnumerableTestState();
+            }
+
+            while(unityContext.RetryRepeatState.Retry < unityContext.RetryCount + 1)
+            {
+                if (innerCommand is IEnumerableTestMethodCommand)
+                {
+                    var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+                    foreach (var iterator in executeEnumerable)
+                    {
+                        yield return iterator;
+                    }
+                }
+                else
+                {
+                    context.CurrentResult = innerCommand.Execute(context);
+                }
+
+                if (context.CurrentResult.ResultState != ResultState.Failure || context.CurrentResult.ResultState == ResultState.Error)
+                {
+                    unityContext.RetryRepeatState.Retry++;
+                    break;
+                }
+
+                if (unityContext.Automated && unityContext.RetryRepeatState.Retry < unityContext.RetryCount)
+                {
+                    ReportTestFinishStartPair(unityContext);
+                }
+                unityContext.RetryRepeatState.Retry++;
+            }
+            
+            SetIterationProperty(unityContext, unityContext.RetryRepeatState.Retry - 1);
+            unityContext.RetryRepeatState.Retry = 0;
+        }
+
+        private static void ReportTestFinishStartPair(UnityTestExecutionContext unityContext)
+        {
+            unityContext.CurrentResult.StartTime = unityContext.StartTime;
+            unityContext.CurrentResult.EndTime = DateTime.UtcNow;
+            long tickCount = Stopwatch.GetTimestamp() - unityContext.StartTicks;
+            double seconds = (double) tickCount / Stopwatch.Frequency;
+            unityContext.CurrentResult.Duration = seconds;
+            SetIterationProperty(unityContext, unityContext.RetryRepeatState.Retry);
+            unityContext.Listener.TestFinished(unityContext.CurrentResult);
+
+            // Start new test iteration
+            unityContext.CurrentResult = unityContext.CurrentTest.MakeTestResult();
+            unityContext.StartTime = DateTime.UtcNow;
+            unityContext.StartTicks = Stopwatch.GetTimestamp();
+            unityContext.Listener.TestStarted(unityContext.CurrentTest);
+        }
+
+        private static void SetIterationProperty(UnityTestExecutionContext unityContext, int iteration)
+        {
+            unityContext.CurrentResult.Test.Properties.Set("retryIteration", iteration);
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/RetryCommand.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f180b12c4cff494c91056caa03f9c109
+timeCreated: 1677662056

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/SetUpTearDownCommand.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.ExceptionServices;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using Unity.Profiling;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class SetUpTearDownCommand : BeforeAfterTestCommandBase<MethodInfo>
+    {
+        private static readonly Dictionary<Type, List<MethodInfo>> m_BeforeActionsCache = new Dictionary<Type, List<MethodInfo>>();
+        private static readonly Dictionary<Type, List<MethodInfo>> m_AfterActionsCache = new Dictionary<Type, List<MethodInfo>>();
+
+        public SetUpTearDownCommand(TestCommand innerCommand)
+            : base(innerCommand, "SetUp", "TearDown")
+        {
+            using (new ProfilerMarker(nameof(SetUpTearDownCommand)).Auto())
+            {
+                if (Test.TypeInfo.Type != null)
+                {
+                    BeforeActions = GetActions(m_BeforeActionsCache, Test.TypeInfo.Type, typeof(SetUpAttribute), new[] {typeof(void), typeof(Task)});
+                    AfterActions =  GetActions(m_AfterActionsCache, Test.TypeInfo.Type, typeof(TearDownAttribute), new[] {typeof(void), typeof(Task)}).Reverse().ToArray();
+                }
+            }
+        }
+
+        protected override bool AllowFrameSkipAfterAction(MethodInfo action)
+        {
+            return action.ReturnType == typeof(Task);
+        }
+
+        protected override IEnumerator InvokeBefore(MethodInfo action, Test test, UnityTestExecutionContext context)
+        {
+            if (action.ReturnType == typeof(Task))
+            {
+                Task task;
+                using (new ProfilerMarker(test.Name + ".Setup").Auto())
+                    task = HandleTaskCommand(action, context);
+                while (!task.IsCompleted)
+                {
+                    yield return null;
+                }
+
+                if (task.IsFaulted)
+                {
+                    ExceptionDispatchInfo.Capture(task.Exception.InnerExceptions.Count == 1 ? task.Exception.InnerException : task.Exception).Throw();
+                }
+            }
+            else
+            {
+                using (new ProfilerMarker(test.Name + ".Setup").Auto())
+                    Reflect.InvokeMethod(action, context.TestObject);
+                yield return null;
+            }
+        }
+
+        protected override IEnumerator InvokeAfter(MethodInfo action, Test test, UnityTestExecutionContext context)
+        {
+            if (action.ReturnType == typeof(Task))
+            {
+                Task task;
+                using (new ProfilerMarker(test.Name + ".TearDown").Auto())
+                    task = HandleTaskCommand(action, context);
+                while (!task.IsCompleted)
+                {
+                    yield return null;
+                }
+
+                if (task.IsFaulted)
+                {
+                    ExceptionDispatchInfo.Capture(task.Exception.InnerExceptions.Count == 1 ? task.Exception.InnerException : task.Exception).Throw();
+                }
+            }
+            else
+            {
+                using (new ProfilerMarker(test.Name + ".TearDown").Auto())
+                    Reflect.InvokeMethod(action, context.TestObject);
+                yield return null;
+            }
+        }
+
+        private Task HandleTaskCommand(MethodInfo action, UnityTestExecutionContext context)
+        {
+            try
+            {
+                return Reflect.InvokeMethod(action, context.TestObject) as Task;
+            }
+            catch (TargetInvocationException e)
+            {
+                throw e;
+            }
+        }
+
+        protected override BeforeAfterTestCommandState GetState(UnityTestExecutionContext context)
+        {
+            // Normal Setup/Teardown does not support domain reloads and will not need a persisted state.
+            return new BeforeAfterTestCommandState();
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/SetUpTearDownCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/StrictCheckCommand.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEditor;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+#if UNITY_EDITOR
+using UnityEditorInternal;
+#endif
+
+namespace UnityEngine.TestTools
+{
+    internal class StrictCheckCommand : DelegatingTestCommand, IEnumerableTestMethodCommand
+    {
+        public StrictCheckCommand(TestCommand innerCommand) : base(innerCommand)
+        {
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            var unityContext = UnityTestExecutionContext.CurrentContext;
+            var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
+            foreach (var iterator in executeEnumerable)
+            {
+                yield return iterator;
+            }
+
+            if (!unityContext.FeatureFlags.strictDomainReload)
+            {
+                yield break;
+            }
+            // Refreshing the asset database before the check, to ensure that
+            // no potential pending domain reloads propagate to the following test
+            // (due to ex. creation or deletion of asset files in the TearDown of a test).
+#if UNITY_EDITOR
+            AssetDatabase.Refresh();
+#endif
+            if (isDomainReloadPending())
+            {
+                context.CurrentResult.SetResult(ResultState.Failure, "A pending domain reload was detected.");
+            }
+        }
+        private static bool isDomainReloadPending()
+        {
+#if UNITY_EDITOR
+            return (InternalEditorUtility.IsScriptReloadRequested() || EditorApplication.isCompiling);
+#else
+            return false;
+#endif
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/StrictCheckCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/TaskTestMethodCommand.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using Unity.Profiling;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+using UnityEngine.TestTools.TestRunner;
+
+namespace UnityEngine.TestTools
+{
+    internal class TaskTestMethodCommand : TestCommand, IEnumerableTestMethodCommand
+    {
+        private readonly TestMethod testMethod;
+
+        public TaskTestMethodCommand(TestMethod testMethod)
+            : base(testMethod)
+        {
+            this.testMethod = testMethod;
+        }
+
+        public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
+        {
+            yield return null;
+
+            IEnumerator currentExecutingTestEnumerator;
+            try
+            {
+                currentExecutingTestEnumerator = new TestTaskWrapper(testMethod).Execute(context);
+            }
+            catch (Exception ex)
+            {
+                context.CurrentResult.RecordException(ex);
+                yield break;
+            }
+
+            if (currentExecutingTestEnumerator != null)
+            {
+                var testEnumeratorYieldInstruction = new TestEnumerator(context, currentExecutingTestEnumerator);
+
+                yield return testEnumeratorYieldInstruction;
+
+                var enumerator = testEnumeratorYieldInstruction.Execute();
+
+                var executingEnumerator = ExecuteEnumerableAndRecordExceptions(enumerator, context);
+                bool enumeratorDone = false;
+                while (enumeratorDone == false)
+                {
+                    enumeratorDone = !AdvanceEnumerator(executingEnumerator);
+                    if (((UnityTestExecutionContext) context).HasTimedOut())
+                    {
+                        context.CurrentResult.RecordException(new UnityTestTimeoutException(context.TestCaseTimeout));
+                        yield break;
+                    }
+
+                    yield return executingEnumerator.Current;
+                }
+            }
+            else
+            {
+                if (context.CurrentResult.ResultState != ResultState.Ignored)
+                {
+                    context.CurrentResult.SetResult(ResultState.Success);
+                }
+            }
+        }
+
+        private bool AdvanceEnumerator(IEnumerator enumerator)
+        {
+            using (new ProfilerMarker(testMethod.MethodName).Auto())
+            {
+                return enumerator.MoveNext();
+            }
+        }
+
+        private static IEnumerator ExecuteEnumerableAndRecordExceptions(IEnumerator enumerator, ITestExecutionContext context)
+        {
+            while (true)
+            {
+                try
+                {
+                    if (!enumerator.MoveNext())
+                    {
+                        break;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    context.CurrentResult.RecordException(ex);
+                    break;
+                }
+
+                if (enumerator.Current is IEnumerator)
+                {
+                    var current = (IEnumerator)enumerator.Current;
+                    yield return ExecuteEnumerableAndRecordExceptions(current, context);
+                }
+                else
+                {
+                    yield return enumerator.Current;
+                }
+            }
+        }
+
+        public override TestResult Execute(ITestExecutionContext context)
+        {
+            throw new NotImplementedException("Use ExecuteEnumerable");
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/TaskTestMethodCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/TestActionCommand.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using NUnit.Framework;
+using NUnit.Framework.Internal;
+using NUnit.Framework.Internal.Commands;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+
+namespace UnityEngine.TestTools
+{
+    internal class TestActionCommand : BeforeAfterTestCommandBase<ITestAction>
+    {
+        private static readonly Dictionary<MethodInfo, List<ITestAction>> m_TestActionsCache = new Dictionary<MethodInfo, List<ITestAction>>();
+
+        public TestActionCommand(TestCommand innerCommand)
+            : base(innerCommand, "BeforeTest", "AfterTest")
+        {
+            if (Test.TypeInfo.Type != null)
+            {
+                BeforeActions = GetTestActions(m_TestActionsCache, Test.Method.MethodInfo);
+                AfterActions = BeforeActions;
+            }
+        }
+
+        protected override bool AllowFrameSkipAfterAction(ITestAction action)
+        {
+            return false;
+        }
+
+        protected override IEnumerator InvokeBefore(ITestAction action, Test test, UnityTestExecutionContext context)
+        {
+            action.BeforeTest(test);
+            yield return null;
+        }
+
+        protected override IEnumerator InvokeAfter(ITestAction action, Test test, UnityTestExecutionContext context)
+        {
+            action.AfterTest(test);
+            yield return null;
+        }
+
+        protected override BeforeAfterTestCommandState GetState(UnityTestExecutionContext context)
+        {
+            // TestActionCommand does not support domain reloads and will not need a persisted state.
+            return new BeforeAfterTestCommandState();
+        }
+    }
+}

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/TestActionCommand.cs.meta

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

Library/PackageCache/com.unity.test-framework@5ac417e07314/UnityEngine.TestRunner/NUnitExtensions/Commands/TestCommandPcHelper.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections;
+
+namespace UnityEngine.TestTools
+{
+    internal class TestCommandPcHelper
+    {
+        public virtual void SetEnumeratorPC(IEnumerator enumerator, int pc)
+        {
+            // Noop implementation used in playmode.
+        }
+
+        public virtual int GetEnumeratorPC(IEnumerator enumerator)
+        {
+            return 0;
+        }
+    }
+}