vallat/SpaceDroid
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test

Browse Source
This commit is contained in:
Guillaume VALLAT
2025-01-17 13:10:42 +01:00
commit 4536213c91
15115 changed files with 1442174 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/ActionDelegator.cs Normal file
View File

@@ -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();
}
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/ActionDelegator.cs.meta Normal file
View File

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

8
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes.meta Normal file
View File

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

86
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/ConditionalIgnoreAttribute.cs Normal file
View File

@@ -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>
/// An example in which tests are ignored in the Mac editor only.
/// <code>
/// 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);
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/ConditionalIgnoreAttribute.cs.meta Normal file
View File

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

106
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/EnumeratorHelper.cs Normal file
View File

@@ -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;
}
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/EnumeratorHelper.cs.meta Normal file
View File

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

24
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/ParametrizedIgnoreAttribute.cs Normal file
View File

@@ -0,0 +1,24 @@
using NUnit.Framework;
using NUnit.Framework.Interfaces;
using NUnit.Framework.Internal.Commands;
using System;
namespace UnityEngine.TestTools
{
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
public class ParametrizedIgnoreAttribute : NUnitAttribute, IWrapTestMethod
{
public object[] Arguments { get; }
public string Reason { get; set; }
public ParametrizedIgnoreAttribute(params object[] Arguments)
{
this.Arguments = Arguments;
}
public TestCommand Wrap(TestCommand command)
{
return new ParametrizedIgnoreCommand(command, Arguments, Reason);
}
}
}

3
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/ParametrizedIgnoreAttribute.cs.meta Normal file
View File

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

23
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/PreservedValuesAttribute.cs Normal file
View File

@@ -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)
{
}
}
}

3
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/PreservedValuesAttribute.cs.meta Normal file
View File

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

92
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/TestEnumerator.cs Normal file
View File

@@ -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;
}
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/TestEnumerator.cs.meta Normal file
View File

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

35
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/TestMustExpectAllLogsAttribute.cs Normal file
View File

@@ -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; }
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/TestMustExpectAllLogsAttribute.cs.meta Normal file
View File

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

21
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityCombinatorialStrategy.cs Normal file
View File

@@ -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;
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityCombinatorialStrategy.cs.meta Normal file
View File

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

102
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityPlatformAttribute.cs Normal file
View File

@@ -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;
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityPlatformAttribute.cs.meta Normal file
View File

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

233
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnitySetUpAttribute.cs Normal file
View File

@@ -0,0 +1,233 @@
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>
/// </example>
/// <example>
/// ## Base and Derived class example
/// <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>
/// </example>
/// <example>
/// ## Domain reload example
/// <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
{
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnitySetUpAttribute.cs.meta Normal file
View File

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

37
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityTearDownAttribute.cs Normal file
View File

@@ -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).
/// <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>
/// </summary>
[AttributeUsage(AttributeTargets.Method)]
public class UnityTearDownAttribute : NUnitAttribute
{
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityTearDownAttribute.cs.meta Normal file
View File

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

147
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityTestAttribute.cs Normal file
View File

@@ -0,0 +1,147 @@
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).
/// <example>
/// ## 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:
/// <code>
/// [UnityTest]
/// public IEnumerator EditorUtility_WhenExecuted_ReturnsSuccess()
/// {
/// var utility = RunEditorUtilityInTheBackground();
///
/// while (utility.isRunning)
/// {
/// yield return null;
/// }
///
/// Assert.IsTrue(utility.isSuccess);
/// }
/// </code>
/// </example>
/// <example>
/// ## 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`:
/// <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>
/// </summary>
[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);
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Attributes/UnityTestAttribute.cs.meta Normal file
View File

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

58
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/BaseDelegator.cs Normal file
View File

@@ -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);
}
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/BaseDelegator.cs.meta Normal file
View File

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

8
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands.meta Normal file
View File

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

281
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/BeforeAfterTestCommandBase.cs Normal file
View File

@@ -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");
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/BeforeAfterTestCommandBase.cs.meta Normal file
View File

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

74
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/BeforeAfterTestCommandState.cs Normal file
View File

@@ -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;
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/BeforeAfterTestCommandState.cs.meta Normal file
View File

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

34
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableApplyChangesToContextCommand.cs Normal file
View File

@@ -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);
}
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableApplyChangesToContextCommand.cs.meta Normal file
View File

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

54
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableMaxTimeCommand.cs Normal file
View File

@@ -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));
}
}
}
}

3
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableMaxTimeCommand.cs.meta Normal file
View File

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

66
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableRepeatedTestCommand.cs Normal file
View File

@@ -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;
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableRepeatedTestCommand.cs.meta Normal file
View File

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

67
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableRetryTestCommand.cs Normal file
View File

@@ -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;
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableRetryTestCommand.cs.meta Normal file
View File

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

58
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableSetUpTearDownCommand.cs Normal file
View File

@@ -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;
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableSetUpTearDownCommand.cs.meta Normal file
View File

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

136
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableTestMethodCommand.cs Normal file
View File

@@ -0,0 +1,136 @@
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;
}
try
{
if (!enumerator.MoveNext())
{
break;
}
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 (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");
}
}
}

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableTestMethodCommand.cs.meta Normal file
View File

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

11
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableTestState.cs Normal file
View File

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

3
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/EnumerableTestState.cs.meta Normal file
View File

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

8
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/IgnoreTest.cs Normal file
View File

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

3
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/IgnoreTest.cs.meta Normal file
View File

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

53
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/IgnoreTestCommand.cs Normal file
View File

@@ -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);
}
}
}
}

3
My project/Library/PackageCache/com.unity.test-framework/UnityEngine.TestRunner/NUnitExtensions/Commands/IgnoreTestCommand.cs.meta Normal file
View File

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

Some files were not shown because too many files have changed in this diff Show More