diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/BaseDelegator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/BaseDelegator.cs new file mode 100644 index 0000000000000000000000000000000000000000..65bcbbaa0880415327c8c3271682ccd17dda2176 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/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); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/BaseDelegator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/BaseDelegator.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..613537b8a64ec23ee2fb6bc2614aec2ecf963ee1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/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: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/Commands.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/Commands.meta new file mode 100644 index 0000000000000000000000000000000000000000..75dd09d4522a7dc3ef5bb3175ddd708b2802589c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/Commands.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 6b72875690e0f7343911e06af3145bd5 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/ConstructDelegator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/ConstructDelegator.cs new file mode 100644 index 0000000000000000000000000000000000000000..dd7fbc29f6777b7a10a8e14de8a2caec4c64c474 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/ConstructDelegator.cs @@ -0,0 +1,141 @@ +using System; +using System.Linq; +using NUnit.Framework.Internal; +using UnityEngine.TestRunner.NUnitExtensions.Runner; +using UnityEngine.TestTools.Logging; +using UnityEngine.TestTools.TestRunner; + +namespace UnityEngine.TestTools.NUnitExtensions +{ + /// + /// Specialization of BaseDelegator that makes sure objects are created on the MainThread. + /// It also deals with ScriptableObjects so that tests can survive assembly reload. + /// + internal class ConstructDelegator + { + private Type m_RequestedType; + private object[] m_Arguments; + + private ScriptableObject m_CurrentRunningTest; + private readonly IStateSerializer m_StateSerializer; + + protected Exception m_Exception; + protected object m_Result; + protected ITestExecutionContext m_Context; + + public ConstructDelegator(IStateSerializer stateSerializer) + { + m_StateSerializer = stateSerializer; + } + + 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 SetCurrentTestContext() + { + var prop = typeof(UnityTestExecutionContext).GetProperty("CurrentContext"); + if (prop != null) + { + prop.SetValue(null, m_Context, null); + } + } + + public object Delegate(Type type, object[] arguments) + { + AssertState(); + m_Context = UnityTestExecutionContext.CurrentContext; + + m_RequestedType = type; + m_Arguments = arguments; + + using (var logScope = new LogScope()) + { + Execute(logScope); + } + + return HandleResult(); + } + + private void AssertState() + { + if (m_RequestedType != null) + { + throw new Exception("Constructor not executed yet"); + } + } + + public bool HasAction() + { + return m_RequestedType != null; + } + + public void Execute(LogScope logScope) + { + try + { + if (typeof(ScriptableObject).IsAssignableFrom(m_RequestedType)) + { + if (m_CurrentRunningTest != null && m_RequestedType != m_CurrentRunningTest.GetType()) + { + DestroyCurrentTestObjectIfExists(); + } + if (m_CurrentRunningTest == null) + { + if (m_StateSerializer.CanRestoreFromScriptableObject(m_RequestedType)) + { + m_CurrentRunningTest = m_StateSerializer.RestoreScriptableObjectInstance(); + } + else + { + m_CurrentRunningTest = ScriptableObject.CreateInstance(m_RequestedType); + } + } + m_Result = m_CurrentRunningTest; + } + else + { + DestroyCurrentTestObjectIfExists(); + m_Result = Activator.CreateInstance(m_RequestedType, m_Arguments); + if (m_StateSerializer.CanRestoreFromJson(m_RequestedType)) + { + m_StateSerializer.RestoreClassFromJson(ref m_Result); + } + } + if (logScope.AnyFailingLogs()) + { + var failingLog = logScope.FailingLogs.First(); + throw new UnhandledLogMessageException(failingLog); + } + if (logScope.ExpectedLogs.Any()) + throw new UnexpectedLogMessageException(LogScope.Current.ExpectedLogs.Peek()); + } + catch (Exception e) + { + m_Exception = e; + } + finally + { + m_RequestedType = null; + m_Arguments = null; + } + } + + public void DestroyCurrentTestObjectIfExists() + { + if (m_CurrentRunningTest == null) + return; + Object.DestroyImmediate(m_CurrentRunningTest); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/ConstructDelegator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/ConstructDelegator.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..cb04fc8abc2c38bb23ecdcc0bdd47f23d35ac64a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/ConstructDelegator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b42e1db66fe9c634798674cb9e1df2ca +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/Filters.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/Filters.meta new file mode 100644 index 0000000000000000000000000000000000000000..a0aa99461940435f9da523801ab0bdb99987abdd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/Filters.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: c3de99f9efc582a48995bc8e8c2df418 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IAsyncTestAssemblyBuilder.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IAsyncTestAssemblyBuilder.cs new file mode 100644 index 0000000000000000000000000000000000000000..6bc1593251647fbac067004cfbad4c1d0d8a2a88 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IAsyncTestAssemblyBuilder.cs @@ -0,0 +1,12 @@ +using System.Collections.Generic; +using System.Reflection; +using NUnit.Framework.Api; +using NUnit.Framework.Interfaces; + +namespace UnityEngine.TestTools.NUnitExtensions +{ + internal interface IAsyncTestAssemblyBuilder : ITestAssemblyBuilder + { + IEnumerator BuildAsync(Assembly[] assemblies, TestPlatform[] testPlatforms, IDictionary options); + } +} \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IAsyncTestAssemblyBuilder.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IAsyncTestAssemblyBuilder.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..64283a34ade4cd5f060cb9354fd3efe29bbc3463 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IAsyncTestAssemblyBuilder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c3aa5c3d59b94854e843f10b75b3ad63 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IStateSerializer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IStateSerializer.cs new file mode 100644 index 0000000000000000000000000000000000000000..951d079ea4edc34810987ade933a8395444e6a34 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IStateSerializer.cs @@ -0,0 +1,12 @@ +using System; + +namespace UnityEngine.TestTools.NUnitExtensions +{ + internal interface IStateSerializer + { + ScriptableObject RestoreScriptableObjectInstance(); + void RestoreClassFromJson(ref object instance); + bool CanRestoreFromJson(Type requestedType); + bool CanRestoreFromScriptableObject(Type requestedType); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IStateSerializer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IStateSerializer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1d3271523f8146d9a91fe7ebf7d30932dce968b0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/IStateSerializer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5f875a14565308a40a5262d2504da705 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/Runner.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/Runner.meta new file mode 100644 index 0000000000000000000000000000000000000000..1604cb56cf613e3bf7b8e076d78f936ac37cad7a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/Runner.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 37888acc09d9ee848bf9559f06645c45 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestExtensions.cs new file mode 100644 index 0000000000000000000000000000000000000000..7e74030702249b4c542c3107e8dde28d058a45a8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestExtensions.cs @@ -0,0 +1,153 @@ +using System.Collections.Generic; +using System.Linq; +using NUnit.Framework.Interfaces; +using NUnit.Framework.Internal; +using UnityEngine.TestRunner.NUnitExtensions.Filters; + +namespace UnityEngine.TestRunner.NUnitExtensions +{ + internal static class TestExtensions + { + private static IEnumerable GetTestCategories(this ITest test) + { + var categories = test.Properties[PropertyNames.Category].Cast().ToList(); + if (categories.Count == 0 && test is TestMethod) + { + // only mark tests as Uncategorized if the test fixture doesn't have a category, + // otherwise the test inherits the Fixture category + var fixtureCategories = test.Parent.Properties[PropertyNames.Category].Cast().ToList(); + if (fixtureCategories.Count == 0) + categories.Add(CategoryFilterExtended.k_DefaultCategory); + } + return categories; + } + + public static bool HasCategory(this ITest test, string[] categoryFilter) + { + var categories = test.GetAllCategoriesFromTest().Distinct(); + return categoryFilter.Any(c => categories.Any(r => r == c)); + } + + public static List GetAllCategoriesFromTest(this ITest test) + { + if (test.Parent == null) + return test.GetTestCategories().ToList(); + + var categories = GetAllCategoriesFromTest(test.Parent); + categories.AddRange(test.GetTestCategories()); + return categories; + } + + public static void ParseForNameDuplicates(this ITest test) + { + var duplicates = new Dictionary(); + for (var i = 0; i < test.Tests.Count; i++) + { + var child = test.Tests[i]; + int count; + if (duplicates.TryGetValue(child.FullName, out count)) + { + count++; + child.Properties.Add("childIndex", count); + duplicates[child.FullName] = count; + } + else + { + duplicates.Add(child.FullName, 1); + } + ParseForNameDuplicates(child); + } + } + + public static int GetChildIndex(this ITest test) + { + var index = test.Properties["childIndex"]; + return (int)index[0]; + } + + public static bool HasChildIndex(this ITest test) + { + var index = test.Properties["childIndex"]; + return index.Count > 0; + } + + static string GetAncestorPath(ITest test) + { + var path = ""; + var testParent = test.Parent; + + while (testParent != null && testParent.Parent != null && !string.IsNullOrEmpty(testParent.Name)) + { + path = testParent.Name + "/" + path; + testParent = testParent.Parent; + } + + return path; + } + + public static string GetUniqueName(this ITest test) + { + var id = GetAncestorPath(test) + GetFullName(test); + if (test.HasChildIndex()) + { + var index = test.GetChildIndex(); + if (index >= 0) + id += index; + } + if (test.IsSuite) + { + id += "[suite]"; + } + return id; + } + + public static string GetFullName(ITest test) + { + var typeInfo = test.TypeInfo ?? test.Parent?.TypeInfo ?? test.Tests.FirstOrDefault()?.TypeInfo; + if (typeInfo == null) + { + return "[" + test.Name + "]"; + } + + var assemblyId = typeInfo.Assembly.GetName().Name; + if (assemblyId == test.Name) + { + return $"[{test.Name}]"; + } + + return string.Format("[{0}][{1}]", assemblyId, test.FullName); + } + + public static string GetSkipReason(this ITest test) + { + if (test.Properties.ContainsKey(PropertyNames.SkipReason)) + return (string)test.Properties.Get(PropertyNames.SkipReason); + + return null; + } + + public static string GetParentId(this ITest test) + { + if (test.Parent != null) + return test.Parent.Id; + + return null; + } + + public static string GetParentFullName(this ITest test) + { + if (test.Parent != null) + return test.Parent.FullName; + + return null; + } + + public static string GetParentUniqueName(this ITest test) + { + if (test.Parent != null) + return GetUniqueName(test.Parent); + + return null; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestExtensions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..3230eb4464204086f6a447e759d5512138863529 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestExtensions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8bc74398aa3944646ade4ee78cd57484 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestResultExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestResultExtensions.cs new file mode 100644 index 0000000000000000000000000000000000000000..d79072b0dbc09df430fb3b64229f1594ebb3086d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestResultExtensions.cs @@ -0,0 +1,77 @@ +using System; +using NUnit.Framework; +using NUnit.Framework.Interfaces; +using NUnit.Framework.Internal; + +namespace UnityEngine.TestRunner.NUnitExtensions +{ + internal static class TestResultExtensions + { + public static void RecordPrefixedException(this TestResult testResult, string prefix, Exception ex, ResultState resultState = null) + + { + if (ex is NUnitException) + { + ex = ex.InnerException; + } + + if (resultState == null) + { + resultState = testResult.ResultState == ResultState.Cancelled + ? ResultState.Cancelled + : ResultState.Error; + } + + var exceptionMessage = ExceptionHelper.BuildMessage(ex); + string stackTrace = "--" + prefix + NUnit.Env.NewLine + ExceptionHelper.BuildStackTrace(ex); + if (testResult.StackTrace != null) + { + stackTrace = testResult.StackTrace + NUnit.Env.NewLine + stackTrace; + } + + if (testResult.Test.IsSuite) + { + resultState = resultState.WithSite(FailureSite.TearDown); + } + + if (ex is ResultStateException) + { + exceptionMessage = ex.Message; + resultState = ((ResultStateException)ex).ResultState; + stackTrace = StackFilter.Filter(ex.StackTrace); + } + + string message = (string.IsNullOrEmpty(prefix) ? "" : (prefix + " : ")) + exceptionMessage; + if (testResult.Message != null) + { + message = testResult.Message + NUnit.Env.NewLine + message; + } + + testResult.SetResult(resultState, message, stackTrace); + } + + public static void RecordPrefixedError(this TestResult testResult, string prefix, string error, ResultState resultState = null) + + { + if (resultState == null) + { + resultState = testResult.ResultState == ResultState.Cancelled + ? ResultState.Cancelled + : ResultState.Error; + } + + if (testResult.Test.IsSuite) + { + resultState = resultState.WithSite(FailureSite.TearDown); + } + + string message = (string.IsNullOrEmpty(prefix) ? "" : (prefix + " : ")) + error; + if (testResult.Message != null) + { + message = testResult.Message + NUnit.Env.NewLine + message; + } + + testResult.SetResult(resultState, message); + } + } +} \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestResultExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestResultExtensions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ff97b17ba20e16dd14d4493aad9f4703e1b527f8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/TestResultExtensions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 65fb6da362a78334ab360a125cfafdaf +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/UnityTestAssemblyBuilder.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/UnityTestAssemblyBuilder.cs new file mode 100644 index 0000000000000000000000000000000000000000..79f4aa5db286ae3c212d494c0163a1f70123e020 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/UnityTestAssemblyBuilder.cs @@ -0,0 +1,58 @@ +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using NUnit; +using NUnit.Framework.Api; +using NUnit.Framework.Interfaces; +using NUnit.Framework.Internal; + +namespace UnityEngine.TestTools.NUnitExtensions +{ + internal class UnityTestAssemblyBuilder : DefaultTestAssemblyBuilder, IAsyncTestAssemblyBuilder + { + private readonly string m_ProductName; + public UnityTestAssemblyBuilder() + { + m_ProductName = Application.productName; + } + + public ITest Build(Assembly[] assemblies, TestPlatform[] testPlatforms, IDictionary options) + { + var test = BuildAsync(assemblies, testPlatforms, options); + while (test.MoveNext()) + { + } + + return test.Current; + } + + public IEnumerator BuildAsync(Assembly[] assemblies, TestPlatform[] testPlatforms, IDictionary options) + { + var productName = string.Join("_", m_ProductName.Split(Path.GetInvalidFileNameChars())); + var suite = new TestSuite(productName); + for (var index = 0; index < assemblies.Length; index++) + { + var assembly = assemblies[index]; + var platform = testPlatforms[index]; + + var assemblySuite = Build(assembly, options) as TestSuite; + if (assemblySuite != null && assemblySuite.HasChildren) + { + assemblySuite.Properties.Set("platform", platform); + suite.Add(assemblySuite); + } + + yield return null; + } + + yield return suite; + } + + public static Dictionary GetNUnitTestBuilderSettings(TestPlatform testPlatform) + { + var emptySettings = new Dictionary(); + emptySettings.Add(FrameworkPackageSettings.TestParameters, "platform=" + testPlatform); + return emptySettings; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/UnityTestAssemblyBuilder.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/UnityTestAssemblyBuilder.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f0fdf17159ea454017ae9862a54f728c8c10e54f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/NUnitExtensions/UnityTestAssemblyBuilder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 98ba0396e4b4ee8498a8f097affcfddf +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/Callbacks.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/Callbacks.meta new file mode 100644 index 0000000000000000000000000000000000000000..899ce7924249a32dcd8fccece2f746cd52e150a0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/Callbacks.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 61e236e8570a95e4eb754fb291e102e0 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/ITestRunnerListener.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/ITestRunnerListener.cs new file mode 100644 index 0000000000000000000000000000000000000000..6a2fa5b28f42c7f09030bc68828d3f1f27c47aa5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/ITestRunnerListener.cs @@ -0,0 +1,26 @@ +using System; +using NUnit.Framework.Interfaces; +using UnityEngine.Events; + +namespace UnityEngine.TestTools.TestRunner +{ + internal interface ITestRunnerListener + { + void RunStarted(ITest testsToRun); + void RunFinished(ITestResult testResults); + void TestStarted(ITest test); + void TestFinished(ITestResult result); + } + + [Serializable] + internal class TestFinishedEvent : UnityEvent {} + + [Serializable] + internal class TestStartedEvent : UnityEvent {} + + [Serializable] + internal class RunFinishedEvent : UnityEvent {} + + [Serializable] + internal class RunStartedEvent : UnityEvent {} +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/ITestRunnerListener.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/ITestRunnerListener.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..848ab3d91904cb539265af67e27181a75a20542d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/ITestRunnerListener.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d1b534518943030499685344fd1d476d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/Messages.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/Messages.meta new file mode 100644 index 0000000000000000000000000000000000000000..5ab167ccab5215c99286270b57b9bf2c6ad5165e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/Messages.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 256a0ca37fa972840bce7fca446e75e7 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsController.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsController.cs new file mode 100644 index 0000000000000000000000000000000000000000..87091ca1b893774d31fb66f500c3d3325bbf8be2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsController.cs @@ -0,0 +1,129 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using UnityEngine.SceneManagement; +using UnityEngine.TestRunner.NUnitExtensions; +using UnityEngine.TestRunner.NUnitExtensions.Runner; +using UnityEngine.TestTools.NUnitExtensions; +using UnityEngine.TestTools.Utils; + +namespace UnityEngine.TestTools.TestRunner +{ + [Serializable] + [AddComponentMenu("")] + internal class PlaymodeTestsController : MonoBehaviour + { + private IEnumerator m_TestSteps; + + [SerializeField] + private List m_AssembliesWithTests; + public List AssembliesWithTests + { + get + { + return m_AssembliesWithTests; + } + set + { + m_AssembliesWithTests = value; + } + } + + [SerializeField] + internal TestStartedEvent testStartedEvent = new TestStartedEvent(); + [SerializeField] + internal TestFinishedEvent testFinishedEvent = new TestFinishedEvent(); + [SerializeField] + internal RunStartedEvent runStartedEvent = new RunStartedEvent(); + [SerializeField] + internal RunFinishedEvent runFinishedEvent = new RunFinishedEvent(); + + internal const string kPlaymodeTestControllerName = "Code-based tests runner"; + + [SerializeField] + public PlaymodeTestsControllerSettings settings = new PlaymodeTestsControllerSettings(); + + internal UnityTestAssemblyRunner m_Runner; + + public IEnumerator Start() + { + //Skip 2 frame because Unity. + yield return null; + yield return null; + StartCoroutine(Run()); + } + + internal static bool IsControllerOnScene() + { + return GameObject.Find(kPlaymodeTestControllerName) != null; + } + + internal static PlaymodeTestsController GetController() + { + return GameObject.Find(kPlaymodeTestControllerName).GetComponent(); + } + + public IEnumerator TestRunnerCoroutine() + { + while (m_TestSteps.MoveNext()) + { + yield return m_TestSteps.Current; + } + + if (m_Runner.IsTestComplete) + { + runFinishedEvent.Invoke(m_Runner.Result); + Cleanup(); + + yield return null; + } + } + + public IEnumerator Run() + { + CoroutineTestWorkItem.monoBehaviourCoroutineRunner = this; + gameObject.hideFlags |= HideFlags.DontSave; + + if (settings.sceneBased) + { + SceneManager.LoadScene(1, LoadSceneMode.Additive); + yield return null; + } + + var testListUtil = new PlayerTestAssemblyProvider(new AssemblyLoadProxy(), m_AssembliesWithTests); + m_Runner = new UnityTestAssemblyRunner(new UnityTestAssemblyBuilder(), new PlaymodeWorkItemFactory()); + + var loadedTests = m_Runner.Load(testListUtil.GetUserAssemblies().Select(a => a.Assembly).ToArray(), TestPlatform.PlayMode, UnityTestAssemblyBuilder.GetNUnitTestBuilderSettings(TestPlatform.PlayMode)); + loadedTests.ParseForNameDuplicates(); + runStartedEvent.Invoke(m_Runner.LoadedTest); + + var testListenerWrapper = new TestListenerWrapper(testStartedEvent, testFinishedEvent); + m_TestSteps = m_Runner.Run(testListenerWrapper, settings.BuildNUnitFilter()).GetEnumerator(); + + yield return TestRunnerCoroutine(); + } + + public void Cleanup() + { + if (m_Runner != null) + { + m_Runner.StopRun(); + m_Runner = null; + } + if (Application.isEditor) + { + Destroy(gameObject); + } + } + + public static void TryCleanup() + { + var controller = GetController(); + if (controller != null) + { + controller.Cleanup(); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsController.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsController.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..969377835ccffa5460a1a655adbce237f0a72120 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsController.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 102e512f651ee834f951a2516c1ea3b8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsControllerSettings.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsControllerSettings.cs new file mode 100644 index 0000000000000000000000000000000000000000..cb6bb54b0e02279f59c90ace8709ccf2b7545554 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsControllerSettings.cs @@ -0,0 +1,36 @@ +using System; +using System.Linq; +using NUnit.Framework.Interfaces; +using NUnit.Framework.Internal.Filters; +using UnityEngine.SceneManagement; +using UnityEngine.TestTools.TestRunner.GUI; + +namespace UnityEngine.TestTools.TestRunner +{ + [Serializable] + internal class PlaymodeTestsControllerSettings + { + [SerializeField] + public RuntimeTestRunnerFilter[] filters; + public bool sceneBased; + public string originalScene; + public string bootstrapScene; + + public static PlaymodeTestsControllerSettings CreateRunnerSettings(RuntimeTestRunnerFilter[] filters) + { + var settings = new PlaymodeTestsControllerSettings + { + filters = filters, + sceneBased = false, + originalScene = SceneManager.GetActiveScene().path, + bootstrapScene = null + }; + return settings; + } + + internal ITestFilter BuildNUnitFilter() + { + return new OrFilter(filters.Select(f => f.BuildNUnitFilter()).ToArray()); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsControllerSettings.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsControllerSettings.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..06448a7fac3ef3e277ff2fdf51ca523da51f181b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/PlaymodeTestsControllerSettings.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2799eb4c84e72e54092a292cf626936b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/RemoteHelpers.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/RemoteHelpers.meta new file mode 100644 index 0000000000000000000000000000000000000000..d23c0a71f5231c295ff1f047e01fb042833fe077 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/RemoteHelpers.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 91c20d2c22b8b3a4cb6c816bd225591a +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/RuntimeTestRunnerFilter.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/RuntimeTestRunnerFilter.cs new file mode 100644 index 0000000000000000000000000000000000000000..0adca0a44107ed97030b30aaca47bbe65869240a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/RuntimeTestRunnerFilter.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using NUnit.Framework.Interfaces; +using NUnit.Framework.Internal; +using NUnit.Framework.Internal.Filters; +using UnityEngine.TestRunner.NUnitExtensions.Filters; + +namespace UnityEngine.TestTools.TestRunner.GUI +{ + [Serializable] + internal class RuntimeTestRunnerFilter + { + public string[] assemblyNames; + public string[] groupNames; + public string[] categoryNames; + public string[] testNames; + public bool synchronousOnly = false; + + public ITestFilter BuildNUnitFilter() + { + var filters = new List(); + + AddFilters(filters, testNames, (s) => new FullNameFilter(s)); + AddFilters(filters, groupNames, (s) => new FullNameFilter(s) {IsRegex = true}); + AddFilters(filters, assemblyNames, (s) => new AssemblyNameFilter(s)); + AddFilters(filters, categoryNames, (s) => new CategoryFilterExtended(s) {IsRegex = true}); + + if (synchronousOnly) + { + filters.Add(new SynchronousFilter()); + } + + return filters.Count == 0 ? TestFilter.Empty : new AndFilter(filters.ToArray()); + } + + private static void AddFilters(List filters, string[] values, Func builder) + { + if (values == null || values.Length == 0) + { + return; + } + + var inclusionFilters = values.Where(v => !v.StartsWith("!")).Select(v => builder(v) as ITestFilter).ToArray(); + var exclusionFilters = values.Where(v => v.StartsWith("!")) + .Select(v => new NotFilter(builder(v.Substring(1))) as ITestFilter) + .ToArray(); + if (inclusionFilters.Length > 0 && exclusionFilters.Length > 0) + { + filters.Add(new AndFilter(new OrFilter(inclusionFilters), new AndFilter(exclusionFilters))); + } + else if (inclusionFilters.Length > 0) + { + filters.Add(new OrFilter(inclusionFilters)); + } + else // Only exclusionFilters + { + filters.Add(new AndFilter(exclusionFilters)); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/RuntimeTestRunnerFilter.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/RuntimeTestRunnerFilter.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5f9aa3b6b752f91114f907b89b7b713f27a5b14c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/RuntimeTestRunnerFilter.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a025ba7ee40d0104db8d08b1d9eabb0d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/SynchronousFilter.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/SynchronousFilter.cs new file mode 100644 index 0000000000000000000000000000000000000000..525da47a15dfc37db3962f627edacfc132588a15 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/SynchronousFilter.cs @@ -0,0 +1,51 @@ +using System.Collections; +using System.Linq; +using System.Reflection; +using NUnit.Framework.Interfaces; +using NUnit.Framework.Internal; + +namespace UnityEngine.TestTools.TestRunner.GUI +{ + class SynchronousFilter : ITestFilter + { + public TNode ToXml(bool recursive) + { + return new TNode("synchronousOnly"); + } + + public TNode AddToXml(TNode parentNode, bool recursive) + { + return parentNode.AddElement("synchronousOnly"); + } + + public bool Pass(ITest test) + { + if (test.Method == null) + return true; + + if (test.Method.ReturnType.Type == typeof(IEnumerator)) + return false; + + if (test.Method.GetCustomAttributes(true).Any()) + return false; + + if (test.TypeInfo?.Type != null) + { + if (Reflect.GetMethodsWithAttribute(test.TypeInfo.Type, typeof(UnitySetUpAttribute), true) + .Any(mi => mi.ReturnType == typeof(System.Collections.IEnumerator))) + return false; + + if (Reflect.GetMethodsWithAttribute(test.TypeInfo.Type, typeof(UnityTearDownAttribute), true) + .Any(mi => mi.ReturnType == typeof(System.Collections.IEnumerator))) + return false; + } + + return true; + } + + public bool IsExplicitMatch(ITest test) + { + return Pass(test); + } + } +} \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/SynchronousFilter.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/SynchronousFilter.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..08c6010abd06391e5504733fd26cf1aadf23e7b5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/SynchronousFilter.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b9aec9d3b0a86466ab4647d01e8fc87d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestEnumeratorWrapper.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestEnumeratorWrapper.cs new file mode 100644 index 0000000000000000000000000000000000000000..5ed2ec8485f53b4feec2454b34c8f7e0f4609e30 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestEnumeratorWrapper.cs @@ -0,0 +1,51 @@ +using System; +using System.Collections; +using System.Reflection; +using NUnit.Framework; +using NUnit.Framework.Interfaces; +using NUnit.Framework.Internal; + +namespace UnityEngine.TestTools.TestRunner +{ + internal class TestEnumeratorWrapper + { + private readonly TestMethod m_TestMethod; + + public TestEnumeratorWrapper(TestMethod testMethod) + { + m_TestMethod = testMethod; + } + + public IEnumerator GetEnumerator(ITestExecutionContext context) + { + if (m_TestMethod.Method.ReturnType.Type == typeof(IEnumerator)) + { + return HandleEnumerableTest(context); + } + var message = string.Format("Return type {0} of {1} in {2} is not supported.", + m_TestMethod.Method.ReturnType, m_TestMethod.Method.Name, m_TestMethod.Method.TypeInfo.FullName); + if (m_TestMethod.Method.ReturnType.Type == typeof(IEnumerable)) + { + message += "\nDid you mean IEnumerator?"; + } + throw new InvalidSignatureException(message); + } + + private IEnumerator HandleEnumerableTest(ITestExecutionContext context) + { + try + { + return m_TestMethod.Method.MethodInfo.Invoke(context.TestObject, m_TestMethod.parms != null ? m_TestMethod.parms.OriginalArguments : null) as IEnumerator; + } + catch (TargetInvocationException e) + { + if (e.InnerException is IgnoreException) + { + context.CurrentResult.SetResult(ResultState.Ignored, e.InnerException.Message); + return null; + } + throw; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestEnumeratorWrapper.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestEnumeratorWrapper.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f19ee3e337387cc859a4ac222409778f3217f10c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestEnumeratorWrapper.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9ad0b0c865b01af4ca1b414689e71259 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestListenerWrapper.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestListenerWrapper.cs new file mode 100644 index 0000000000000000000000000000000000000000..ffa23de5c9b39b369c5a5f5687c7392314318c24 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestListenerWrapper.cs @@ -0,0 +1,30 @@ +using NUnit.Framework.Interfaces; + +namespace UnityEngine.TestTools.TestRunner +{ + internal class TestListenerWrapper : ITestListener + { + private readonly TestFinishedEvent m_TestFinishedEvent; + private readonly TestStartedEvent m_TestStartedEvent; + + public TestListenerWrapper(TestStartedEvent testStartedEvent, TestFinishedEvent testFinishedEvent) + { + m_TestStartedEvent = testStartedEvent; + m_TestFinishedEvent = testFinishedEvent; + } + + public void TestStarted(ITest test) + { + m_TestStartedEvent.Invoke(test); + } + + public void TestFinished(ITestResult result) + { + m_TestFinishedEvent.Invoke(result); + } + + public void TestOutput(TestOutput output) + { + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestListenerWrapper.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestListenerWrapper.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..aefe0393c40e22b8e2e24a6687e019459d356791 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestListenerWrapper.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 73deb9b8722aa284eab27c4dc90956c6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyLoadProxy.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyLoadProxy.cs new file mode 100644 index 0000000000000000000000000000000000000000..9edc517152f36405321234612d4930f32882268f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyLoadProxy.cs @@ -0,0 +1,12 @@ +using System.Reflection; + +namespace UnityEngine.TestTools.Utils +{ + internal class AssemblyLoadProxy : IAssemblyLoadProxy + { + public IAssemblyWrapper Load(string assemblyString) + { + return new AssemblyWrapper(Assembly.Load(assemblyString)); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyLoadProxy.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyLoadProxy.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..8bb527d95691e4c90a7464fce881ff993f1ccc5d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyLoadProxy.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fb593906b7b6d824087dcaebf6c082e0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyWrapper.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyWrapper.cs new file mode 100644 index 0000000000000000000000000000000000000000..86a39cb8ac83eebd659b3c02522ebafb26b33028 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyWrapper.cs @@ -0,0 +1,33 @@ +using System; +using System.Reflection; + +namespace UnityEngine.TestTools.Utils +{ + internal class AssemblyWrapper : IAssemblyWrapper + { + public AssemblyWrapper(Assembly assembly) + { + Assembly = assembly; + Name = assembly.GetName(); + } + + public Assembly Assembly { get; } + + public AssemblyName Name { get; } + + public virtual string Location + { + get + { + //Some platforms dont support this + throw new NotImplementedException(); + } + } + + public virtual AssemblyName[] GetReferencedAssemblies() + { + //Some platforms dont support this + throw new NotImplementedException(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyWrapper.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyWrapper.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1e4a718476dc53991119b84bf9fe3d51895e43cc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/AssemblyWrapper.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2e3b9bbf2c1a3cd4f88883ca32882ec6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyLoadProxy.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyLoadProxy.cs new file mode 100644 index 0000000000000000000000000000000000000000..feffa62e81ae5d771212623f5c2a2b32c33394f2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyLoadProxy.cs @@ -0,0 +1,7 @@ +namespace UnityEngine.TestTools.Utils +{ + internal interface IAssemblyLoadProxy + { + IAssemblyWrapper Load(string assemblyString); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyLoadProxy.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyLoadProxy.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..284d33b0e470e883ded09e62105b1cadbff0ae9c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyLoadProxy.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 12dfd4bdbb5c8e6419432fbc54ef25d9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyWrapper.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyWrapper.cs new file mode 100644 index 0000000000000000000000000000000000000000..e8205714eeca2ebb8a85b20d53cbfbbc8544a56f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyWrapper.cs @@ -0,0 +1,12 @@ +using System.Reflection; + +namespace UnityEngine.TestTools.Utils +{ + internal interface IAssemblyWrapper + { + Assembly Assembly { get; } + AssemblyName Name { get; } + string Location { get; } + AssemblyName[] GetReferencedAssemblies(); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyWrapper.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyWrapper.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..486888d5ffb1450548f4330b6cfbbcccfdfafdf3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IAssemblyWrapper.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1c5afe945b715e149a70113a4be7b32a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IScriptingRuntimeProxy.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IScriptingRuntimeProxy.cs new file mode 100644 index 0000000000000000000000000000000000000000..0dc2b7f3dd32d0899b57872c0f30846941dc13fc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IScriptingRuntimeProxy.cs @@ -0,0 +1,7 @@ +namespace UnityEngine.TestTools.Utils +{ + internal interface IScriptingRuntimeProxy + { + string[] GetAllUserAssemblies(); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IScriptingRuntimeProxy.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IScriptingRuntimeProxy.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..85ae9850df028d8174098aef350fca789ad81980 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/IScriptingRuntimeProxy.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fe4aef60e4ace544c8430da8ef8acba2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/ITestAssemblyProvider.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/ITestAssemblyProvider.cs new file mode 100644 index 0000000000000000000000000000000000000000..74f27692f1d99c2e6f3507916ca8c55419f21ebc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/ITestAssemblyProvider.cs @@ -0,0 +1,10 @@ +using NUnit.Framework.Interfaces; + +namespace UnityEngine.TestTools.Utils +{ + internal interface ITestAssemblyProvider + { + ITest GetTestsWithNUnit(); + IAssemblyWrapper[] GetUserAssemblies(); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/ITestAssemblyProvider.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/ITestAssemblyProvider.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d7e856b7cc3afb7d5f9cd68ac578fe2efe6accaf --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/ITestAssemblyProvider.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c5acba6181d845c4e92146009bd4480f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/PlayerTestAssemblyProvider.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/PlayerTestAssemblyProvider.cs new file mode 100644 index 0000000000000000000000000000000000000000..bb0aa941c9b6b5d4998d99886110ed30d0021217 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/PlayerTestAssemblyProvider.cs @@ -0,0 +1,66 @@ +using System.Collections.Generic; +using System.IO; +using System.Linq; +using NUnit.Framework.Interfaces; +using UnityEngine.TestTools.NUnitExtensions; + +namespace UnityEngine.TestTools.Utils +{ + internal class PlayerTestAssemblyProvider + { + private IAssemblyLoadProxy m_AssemblyLoadProxy; + private readonly List m_AssembliesToLoad; + + //Cached until domain reload + private static List m_LoadedAssemblies; + + internal PlayerTestAssemblyProvider(IAssemblyLoadProxy assemblyLoadProxy, List assembliesToLoad) + { + m_AssemblyLoadProxy = assemblyLoadProxy; + m_AssembliesToLoad = assembliesToLoad; + LoadAssemblies(); + } + + public ITest GetTestsWithNUnit() + { + return BuildTests(TestPlatform.PlayMode, m_LoadedAssemblies.ToArray()); + } + + public List GetUserAssemblies() + { + return m_LoadedAssemblies; + } + + protected static ITest BuildTests(TestPlatform testPlatform, IAssemblyWrapper[] assemblies) + { + var settings = UnityTestAssemblyBuilder.GetNUnitTestBuilderSettings(testPlatform); + var builder = new UnityTestAssemblyBuilder(); + return builder.Build(assemblies.Select(a => a.Assembly).ToArray(), Enumerable.Repeat(testPlatform, assemblies.Length).ToArray(), settings); + } + + private void LoadAssemblies() + { + if (m_LoadedAssemblies != null) + { + return; + } + + m_LoadedAssemblies = new List(); + + foreach (var userAssembly in m_AssembliesToLoad) + { + IAssemblyWrapper a; + try + { + a = m_AssemblyLoadProxy.Load(userAssembly); + } + catch (FileNotFoundException) + { + continue; + } + if (a != null) + m_LoadedAssemblies.Add(a); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/PlayerTestAssemblyProvider.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/PlayerTestAssemblyProvider.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ffee12cfd8948661f7d7a057db30d09244d88bcf --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/PlayerTestAssemblyProvider.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 43a3aec217baa9644a7cf34b5f93fed9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/ScriptingRuntimeProxy.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/ScriptingRuntimeProxy.cs new file mode 100644 index 0000000000000000000000000000000000000000..0f1eb2bc9fb1cdbbec74b277c0a36f2247605c98 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AssemblyProvider/ScriptingRuntimeProxy.cs @@ -0,0 +1,10 @@ +namespace UnityEngine.TestTools.Utils +{ + internal class ScriptingRuntimeProxy : IScriptingRuntimeProxy + { + public string[] GetAllUserAssemblies() + { + return ScriptingRuntime.GetAllUserAssemblies(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PostBuildCleanupAttribute.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PostBuildCleanupAttribute.cs new file mode 100644 index 0000000000000000000000000000000000000000..e93804be1148da58b8022798cb6edf888e096124 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PostBuildCleanupAttribute.cs @@ -0,0 +1,23 @@ +using System; + +namespace UnityEngine.TestTools +{ + /// + /// PostBuildCleanup attributes run if the respective test or test class is in the current test run. The test is included either by running all tests or setting a [filter](https://docs.unity3d.com/Packages/com.unity.test-framework@1.1/manual/workflow-create-test.html#filters) that includes the test. If multiple tests reference the same pre-built setup or post-build cleanup, then it only runs once. + /// + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)] + public class PostBuildCleanupAttribute : Attribute + { + public PostBuildCleanupAttribute(Type targetClass) + { + TargetClass = targetClass; + } + + public PostBuildCleanupAttribute(string targetClassName) + { + TargetClass = AttributeHelper.GetTargetClassFromName(targetClassName, typeof(IPostBuildCleanup)); + } + + internal Type TargetClass { get; private set; } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PostBuildCleanupAttribute.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PostBuildCleanupAttribute.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b45a7a66f31e6e80a62a8bc5b42c831f134f94b6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PostBuildCleanupAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 621fd19bcb071b64aa1d68f0271aa780 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PrebuildSceneSetupAttribute.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PrebuildSceneSetupAttribute.cs new file mode 100644 index 0000000000000000000000000000000000000000..1e4f2d169e260ac01588910d9846e33ecd030d28 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PrebuildSceneSetupAttribute.cs @@ -0,0 +1,70 @@ +using System; + +namespace UnityEngine.TestTools +{ + /// + /// PrebuildSetup attribute run if the test or test class is in the current test run. The test is included either by running all tests or setting a filter that includes the test. If multiple tests reference the same pre-built setup or post-build cleanup, then it only runs once. + /// + [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)] + public class PrebuildSetupAttribute : Attribute + { + public PrebuildSetupAttribute(Type targetClass) + { + TargetClass = targetClass; + } + /// + /// + /// + /// + /// + /// + /// [TestFixture] + /// public class CreateSpriteTest : IPrebuildSetup + /// { + /// Texture2D m_Texture; + /// Sprite m_Sprite; + /// + /// public void Setup() + /// { + /// + /// #if UNITY_EDITOR + /// + /// var spritePath = "Assets/Resources/Circle.png"; + /// var ti = UnityEditor.AssetImporter.GetAtPath(spritePath) as UnityEditor.TextureImporter; + /// ti.textureCompression = UnityEditor.TextureImporterCompression.Uncompressed; + /// ti.SaveAndReimport(); + /// + /// #endif + /// } + /// + /// [SetUp] + /// public void SetUpTest() + /// { + /// m_Texture = Resources.Load<Texture2D>("Circle"); + /// } + /// + /// [Test] + /// public void WhenNullTextureIsPassed_CreateShouldReturnNullSprite() + /// { + /// + /// // Check with Valid Texture. + /// LogAssert.Expect(LogType.Log, "Circle Sprite Created"); + /// Sprite.Create(m_Texture, new Rect(0, 0, m_Texture.width, m_Texture.height), new Vector2(0.5f, 0.5f)); + /// Debug.Log("Circle Sprite Created"); + /// + /// // Check with NULL Texture. Should return NULL Sprite. + /// m_Sprite = Sprite.Create(null, new Rect(0, 0, m_Texture.width, m_Texture.heig`t), new Vector2(0.5f, 0.5f)); + /// Assert.That(m_Sprite, Is.Null, "Sprite created with null texture should be null"); + /// } + /// } + /// + /// Tip: Use `#if UNITY_EDITOR` if you want to access Editor only APIs, but the setup/cleanup is inside a **Play Mode** assembly. + /// + public PrebuildSetupAttribute(string targetClassName) + { + TargetClass = AttributeHelper.GetTargetClassFromName(targetClassName, typeof(IPrebuildSetup)); + } + + internal Type TargetClass { get; private set; } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PrebuildSceneSetupAttribute.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PrebuildSceneSetupAttribute.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7b6ae4a8343b4cd3534f3aa811cbf6104a740186 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/PrebuildSceneSetupAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d1b7ce919aa8864409412e809073cf96 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/QuaternionEqualityComparer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/QuaternionEqualityComparer.cs new file mode 100644 index 0000000000000000000000000000000000000000..fec8256ad9fccd99c2f6eb11fbc08a6c95e7076b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/QuaternionEqualityComparer.cs @@ -0,0 +1,80 @@ +using System.Collections.Generic; + +namespace UnityEngine.TestTools.Utils +{ + /// + /// Use this utility to compare two Quaternion objects for equality + /// with NUnit assertion constraints. + /// Use the static instance QuaternionEqualityComparer.Instance + /// to have the default calculation error value set to 0.00001f. + /// For any other custom error value, use the one argument constructor. + /// + public class QuaternionEqualityComparer : IEqualityComparer + { + private const float k_DefaultError = 0.00001f; + private readonly float AllowedError; + + private static readonly QuaternionEqualityComparer m_Instance = new QuaternionEqualityComparer(); + /// + ///A comparer instance with the default error value 0.00001f. + /// + public static QuaternionEqualityComparer Instance { get { return m_Instance; } } + + + private QuaternionEqualityComparer() : this(k_DefaultError) {} + /// + /// Creates an instance of the comparer with a custom allowed error value. + /// + /// Describes the custom allowed error value + public QuaternionEqualityComparer(float allowedError) + { + AllowedError = allowedError; + } + + /// + /// Compares the actual and expected Quaternion objects + /// for equality using the method. + /// + /// Expected Quaternion value used for comparison + /// Actual Quaternion value to test + /// True if the quaternion are equals, false otherwise. + /// + /// The following example shows how to verify if two Quaternion are equals + /// + /// [TestFixture] + /// public class QuaternionTest + /// { + /// [Test] + /// public void VerifyThat_TwoQuaternionsAreEqual() + /// { + /// var actual = new Quaternion(10f, 0f, 0f, 0f); + /// var expected = new Quaternion(1f, 10f, 0f, 0f); + /// var comparer = new QuaternionEqualityComparer(10e-6f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(comparer)); + /// + /// //Using default error 0.00001f + /// actual = new Quaternion(10f, 0f, 0.1f, 0f); + /// expected = new Quaternion(1f, 10f, 0.1f, 0f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(QuaternionEqualityComparer.Instance)); + /// } + /// } + /// + /// + public bool Equals(Quaternion expected, Quaternion actual) + { + return Mathf.Abs(Quaternion.Dot(expected, actual)) > (1.0f - AllowedError); + } + + /// + /// Serves as the default hash function. + /// + /// A not null Quaternion + /// Returns 0 + public int GetHashCode(Quaternion quaternion) + { + return 0; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/QuaternionEqualityComparer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/QuaternionEqualityComparer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..31faf0c3be298d731bf74a6892bb58da5493f76f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/QuaternionEqualityComparer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3b28913f21577de429da928d6d05219f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/StacktraceFilter.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/StacktraceFilter.cs new file mode 100644 index 0000000000000000000000000000000000000000..af431f3371642091eb8ddb1ab1d3ba74c9049252 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/StacktraceFilter.cs @@ -0,0 +1,43 @@ +using System.Linq; +using System.Text; + +namespace UnityEngine.TestTools.Utils +{ + internal static class StackTraceFilter + { + private static readonly string[] s_FilteredLogMessages = + { + @"UnityEngine.DebugLogHandler:Internal_Log", + @"UnityEngine.DebugLogHandler:Log", + @"UnityEngine.Logger:Log", + @"UnityEngine.Debug" + }; + + private static readonly string[] s_LastMessages = + { + @"System.Reflection.MonoMethod:InternalInvoke(Object, Object[], Exception&)", + @"UnityEditor.TestTools.TestRunner.EditModeRunner:InvokeDelegator" + }; + + public static string Filter(string inputStackTrace) + { + int idx; + foreach (var lastMessage in s_LastMessages) + { + idx = inputStackTrace.IndexOf(lastMessage); + if (idx != -1) + inputStackTrace = inputStackTrace.Substring(0, idx); + } + + var inputStackTraceLines = inputStackTrace.Split('\n'); + var result = new StringBuilder(); + foreach (var line in inputStackTraceLines) + { + if (s_FilteredLogMessages.Any(s => line.StartsWith(s))) + continue; + result.AppendLine(line); + } + return result.ToString(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/StacktraceFilter.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/StacktraceFilter.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4f837a1a28a47363df9fdf2a1782064f5bffa068 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/StacktraceFilter.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fc748d99f1f0d484a811a566fc7915ec +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackAttribute.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackAttribute.cs new file mode 100644 index 0000000000000000000000000000000000000000..bb98f9543aecdc88eb1b46399e74a1585eeb2d37 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackAttribute.cs @@ -0,0 +1,68 @@ +using System; +using UnityEngine.Scripting; + +namespace UnityEngine.TestRunner +{ + /// + /// An assembly level attribute that indicates that a given type should be subscribed for receiving updates on the test progress. + /// + /// + /// + /// using NUnit.Framework.Interfaces; + /// using UnityEngine; + /// using UnityEngine.TestRunner; + /// + /// [assembly:TestRunCallback(typeof(TestListener))] + /// + /// public class TestListener : ITestRunCallback + /// { + /// public void RunStarted(ITest testsToRun) + /// { + /// + /// } + /// + /// public void RunFinished(ITestResult testResults) + /// { + /// Debug.Log($"Run finished with result {testResults.ResultState}."); + /// } + /// + /// public void TestStarted(ITest test) + /// { + /// + /// } + /// + /// public void TestFinished(ITestResult result) + /// { + /// + /// } + ///} + /// + /// + [AttributeUsage(AttributeTargets.Assembly)] + public class TestRunCallbackAttribute : Attribute + { + private Type m_Type; + + /// + /// Constructs a new instance of the class. + /// + /// A target type that implements . + /// Throws an ArgumentException if the provided type does not implement . + public TestRunCallbackAttribute(Type type) + { + var interfaceType = typeof(ITestRunCallback); + if (!interfaceType.IsAssignableFrom(type)) + { + throw new ArgumentException(string.Format( + "Type {2} provided to {0} does not implement {1}. If the stripping level is set to high, the implementing class should have the {3}.", + this.GetType().Name, interfaceType.Name, type.Name, typeof(PreserveAttribute).Name)); + } + m_Type = type; + } + + internal ITestRunCallback ConstructCallback() + { + return Activator.CreateInstance(m_Type) as ITestRunCallback; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackAttribute.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackAttribute.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..06b201891a31e3138b018a3ab745c42b2f828527 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 76b3a3296de548f48b0c3d088fb4b490 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackListener.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackListener.cs new file mode 100644 index 0000000000000000000000000000000000000000..d4a8c40aa35a6e89a6f70396b505b90f160ae3b5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackListener.cs @@ -0,0 +1,63 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using NUnit.Framework.Interfaces; +using NUnit.Framework.Internal; +using UnityEngine.TestTools.TestRunner; + +namespace UnityEngine.TestRunner.Utils +{ + internal class TestRunCallbackListener : ScriptableObject, ITestRunnerListener + { + private ITestRunCallback[] m_Callbacks; + public void RunStarted(ITest testsToRun) + { + InvokeAllCallbacks(callback => callback.RunStarted(testsToRun)); + } + + private static ITestRunCallback[] GetAllCallbacks() + { + var allAssemblies = AppDomain.CurrentDomain.GetAssemblies(); + allAssemblies = allAssemblies.Where(x => x.GetReferencedAssemblies().Any(z => z.Name == "UnityEngine.TestRunner")).ToArray(); + var attributes = allAssemblies.SelectMany(assembly => assembly.GetCustomAttributes(typeof(TestRunCallbackAttribute), true).OfType()).ToArray(); + return attributes.Select(attribute => attribute.ConstructCallback()).ToArray(); + } + + private void InvokeAllCallbacks(Action invoker) + { + if (m_Callbacks == null) + { + m_Callbacks = GetAllCallbacks(); + } + + foreach (var testRunCallback in m_Callbacks) + { + try + { + invoker(testRunCallback); + } + catch (Exception e) + { + Debug.LogException(e); + throw; + } + } + } + + public void RunFinished(ITestResult testResults) + { + InvokeAllCallbacks(callback => callback.RunFinished(testResults)); + } + + public void TestStarted(ITest test) + { + InvokeAllCallbacks(callback => callback.TestStarted(test)); + } + + public void TestFinished(ITestResult result) + { + InvokeAllCallbacks(callback => callback.TestFinished(result)); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackListener.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackListener.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..77f82eed8fd99ce0e563db1523b15acaf93012a4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/TestRunCallbackListener.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 68f09f0f82599b5448579854e622a4c1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Utils.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Utils.cs new file mode 100644 index 0000000000000000000000000000000000000000..23c3324fde5307b52ef96b7657b93d69b8fcc076 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Utils.cs @@ -0,0 +1,94 @@ +using System; + +namespace UnityEngine.TestTools.Utils +{ + /// + /// This contains test utility functions for float value comparison and creating primitives. + /// + public static class Utils + { + /// + /// Relative epsilon comparison of two float values for equality. + /// The relative error is the absolute error divided by the magnitude of the exact value. + /// + /// The expected float value used to compare. + /// The actual float value to test. + /// Epsilon is the relative error to be used in relative epsilon comparison. + /// Returns true if the actual value is equivalent to the expected value. + /// + /// + /// [TestFixture] + /// class UtilsTests + /// { + /// [Test] + /// public void CheckThat_FloatsAreEqual() + /// { + /// float expected = 10e-8f; + /// float actual = 0f; + /// float allowedRelativeError = 10e-6f; + /// + /// Assert.That(Utils.AreFloatsEqual(expected, actual, allowedRelativeError), Is.True); + /// } + /// } + /// + /// + public static bool AreFloatsEqual(float expected, float actual, float epsilon) + { + // special case for infinity + if (expected == Mathf.Infinity || actual == Mathf.Infinity || expected == Mathf.NegativeInfinity || actual == Mathf.NegativeInfinity) + return expected == actual; + + // we cover both relative and absolute tolerance with this check + // which is better than just relative in case of small (in abs value) args + // please note that "usually" approximation is used [i.e. abs(x)+abs(y)+1] + // but we speak about test code so we dont care that much about performance + // but we do care about checks being more precise + return Math.Abs(actual - expected) <= epsilon * Mathf.Max(Mathf.Max(Mathf.Abs(actual), Mathf.Abs(expected)), 1.0f); + } + + /// + /// Compares two floating point numbers for equality under the given absolute tolerance. + /// + /// The expected float value used to compare. + /// The actual float value to test. + /// AllowedAbsoluteError is the permitted error tolerance. + /// Returns true if the actual value is equivalent to the expected value under the given tolerance. + /// + /// + /// + /// [TestFixture] + /// class UtilsTests + /// { + /// [Test] + /// public void ChechThat_FloatsAreAbsoluteEqual() + /// { + /// float expected = 0f; + /// float actual = 10e-6f; + /// float error = 10e-5f; + /// + /// Assert.That(Utils.AreFloatsEqualAbsoluteError(expected, actual, error), Is.True); + /// } + /// } + /// + /// + public static bool AreFloatsEqualAbsoluteError(float expected, float actual, float allowedAbsoluteError) + { + return Math.Abs(actual - expected) <= allowedAbsoluteError; + } + + /// + /// Analogous to GameObject.CreatePrimitive, but creates a primitive mesh renderer with fast shader instead of a default builtin shader. + /// Optimized for testing performance. + /// + /// A GameObject with primitive mesh renderer and collider. + /// The type of primitive object to create. + public static GameObject CreatePrimitive(PrimitiveType type) + { + var prim = GameObject.CreatePrimitive(type); + var renderer = prim.GetComponent(); + if (renderer) + renderer.sharedMaterial = new Material(Shader.Find("VertexLit")); + return prim; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Utils.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Utils.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..63b9c66cb6a166f6bd37fbb6431120e4d93ba3d3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Utils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9502550ba4785e3499d6c9251fa2114b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2ComparerWithEqualsOperator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2ComparerWithEqualsOperator.cs new file mode 100644 index 0000000000000000000000000000000000000000..94bdf26bed96691fbba9ee66b128b7b6dec9164f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2ComparerWithEqualsOperator.cs @@ -0,0 +1,53 @@ +using System.Collections.Generic; + +namespace UnityEngine.TestTools.Utils +{ + /// + /// Use these classes to compare two objects of the same type for equality within the range of a given tolerance using NUnit or custom constraints . Call Instance to apply the default calculation error value to the comparison. + /// + public class Vector2ComparerWithEqualsOperator : IEqualityComparer + { + private static readonly Vector2ComparerWithEqualsOperator m_Instance = new Vector2ComparerWithEqualsOperator(); + /// + /// A singleton instance of the comparer with a predefined default error value. + /// + public static Vector2ComparerWithEqualsOperator Instance { get { return m_Instance; } } + + private Vector2ComparerWithEqualsOperator() {} + /// + /// Compares the actual and expected objects for equality using a custom comparison mechanism. + /// + /// Expected Vector2 used to compare + /// Actual Vector2 value to test. + /// Returns true if expected and actual objects are equal, otherwise it returns false. + /// + /// + /// [TestFixture] + /// public class Vector2Test + /// { + /// [Test] + /// public void VerifyThat_TwoVector2ObjectsAreEqual() + /// { + /// var actual = new Vector2(10e-7f, 10e-7f); + /// var expected = new Vector2(0f, 0f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(Vector2ComparerWithEqualsOperator.Instance)); + /// } + /// } + /// + /// + public bool Equals(Vector2 expected, Vector2 actual) + { + return expected == actual; + } + /// + /// Serves as the default hash function. + /// + /// A not null Vector2 object + /// Returns 0 + public int GetHashCode(Vector2 vec2) + { + return 0; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2ComparerWithEqualsOperator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2ComparerWithEqualsOperator.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..07662bb3cc04301a70f896c694203114d47f1f80 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2ComparerWithEqualsOperator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 65701ebe8bada6b4785e9c7afe7f5bee +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2EqualityComparer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2EqualityComparer.cs new file mode 100644 index 0000000000000000000000000000000000000000..c8a23e2891aa7d99024919a76508ee1de991472d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2EqualityComparer.cs @@ -0,0 +1,82 @@ +using System.Collections.Generic; + +namespace UnityEngine.TestTools.Utils +{ + /// + /// Use this class to compare two Vector2 objects for + /// equality with NUnit constraints. Use the static + /// + /// to have the calculation error value set to default 0.0001f. + /// For any other error value, instantiate a new comparer + /// object with the one argument constructor. + /// + public class Vector2EqualityComparer : IEqualityComparer + { + private const float k_DefaultError = 0.0001f; + private readonly float AllowedError; + + private static readonly Vector2EqualityComparer m_Instance = new Vector2EqualityComparer(); + + /// + /// A comparer instance with the default error value set to 0.0001f. + /// + public static Vector2EqualityComparer Instance { get { return m_Instance; } } + + private Vector2EqualityComparer() : this(k_DefaultError) + { + } + /// + /// Initializes an instance of Vector2Equality comparer with custom allowed calculation error. + /// + /// This value identifies the calculation error allowed. + public Vector2EqualityComparer(float error) + { + this.AllowedError = error; + } + /// + /// Compares the actual and expected Vector2 objects for equality using the method. + /// + /// The expected Vector2 used for comparison + /// The actual Vector2 to test + /// True if the vectors are equals, false otherwise. + /// + /// The following example shows how to verify if two Vector2 are equals + /// + ///[TestFixture] + /// public class Vector2Test + /// { + /// [Test] + /// public void VerifyThat_TwoVector2ObjectsAreEqual() + /// { + /// // Custom calculation error + /// var actual = new Vector2(10e-7f, 10e-7f); + /// var expected = new Vector2(0f, 0f); + /// var comparer = new Vector2EqualityComparer(10e-6f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(comparer)); + /// + /// //Default error 0.0001f + /// actual = new Vector2(0.01f, 0.01f); + /// expected = new Vector2(0.01f, 0.01f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(Vector2EqualityComparer.Instance)); + /// } + /// } + /// + /// + public bool Equals(Vector2 expected, Vector2 actual) + { + return Utils.AreFloatsEqual(expected.x, actual.x, AllowedError) && + Utils.AreFloatsEqual(expected.y, actual.y, AllowedError); + } + /// + /// Serves as the default hash function. + /// + /// A not null Vector2 + /// Returns 0 + public int GetHashCode(Vector2 vec2) + { + return 0; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2EqualityComparer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2EqualityComparer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ed2951a10793c91b93c0059c11f23980eddac858 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector2EqualityComparer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 58ad09607a0d62d458a78d7174665566 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3ComparerWithEqualsOperator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3ComparerWithEqualsOperator.cs new file mode 100644 index 0000000000000000000000000000000000000000..403dd1372720adb40742252de20f524f7f00fe4e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3ComparerWithEqualsOperator.cs @@ -0,0 +1,53 @@ +using System.Collections.Generic; + +namespace UnityEngine.TestTools.Utils +{ + /// + /// Use these classes to compare two objects of the same type for equality within the range of a given tolerance using NUnit or custom constraints . Call Instance to apply the default calculation error value to the comparison. + /// + public class Vector3ComparerWithEqualsOperator : IEqualityComparer + { + private static readonly Vector3ComparerWithEqualsOperator m_Instance = new Vector3ComparerWithEqualsOperator(); + /// + /// A singleton instance of the comparer with a predefined default error value. + /// + public static Vector3ComparerWithEqualsOperator Instance { get { return m_Instance; } } + + private Vector3ComparerWithEqualsOperator() {} + /// + /// Compares the actual and expected objects for equality using a custom comparison mechanism. + /// + /// Expected Vector3 used to compare + /// Actual Vector3 value to test. + /// Returns true if expected and actual objects are equal, otherwise it returns false. + /// + /// + /// [TestFixture] + /// public class Vector3Test + /// { + /// [Test] + /// public void VerifyThat_TwoVector3ObjectsAreEqual() + /// { + /// var actual = new Vector2(10e-7f, 10e-7f, 10e-7f); + /// var expected = new Vector2(0f, 0f, 0f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(Vector3ComparerWithEqualsOperator.Instance)); + /// } + /// } + /// + /// + public bool Equals(Vector3 expected, Vector3 actual) + { + return expected == actual; + } + /// + /// Serves as the default hash function. + /// + /// A not null Vector3 object + /// Returns 0 + public int GetHashCode(Vector3 vec3) + { + return 0; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3ComparerWithEqualsOperator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3ComparerWithEqualsOperator.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..01662a497e82201fff36b16c148f50239c085531 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3ComparerWithEqualsOperator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5b994928117e3db418da69c821da7e19 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3EqualityComparer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3EqualityComparer.cs new file mode 100644 index 0000000000000000000000000000000000000000..1e18a1b08856a0a11ceca2b34e48376fdd416114 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3EqualityComparer.cs @@ -0,0 +1,82 @@ +using System.Collections.Generic; + + +namespace UnityEngine.TestTools.Utils +{ + /// + /// Use this class to compare two Vector3 objects for equality with NUnit constraints. Call Vector3EqualityComparer.Instance comparer to perform a comparison with the default calculation error value 0.0001f. To specify a different error value, use the one argument constructor to instantiate a new comparer. + /// + public class Vector3EqualityComparer : IEqualityComparer + { + private const float k_DefaultError = 0.0001f; + private readonly float AllowedError; + + private static readonly Vector3EqualityComparer m_Instance = new Vector3EqualityComparer(); + + /// + /// A comparer instance with the default calculation error value equal to 0.0001f. + /// + public static Vector3EqualityComparer Instance { get { return m_Instance; } } + + private Vector3EqualityComparer() : this(k_DefaultError) {} + + /// + /// Initializes an instance of Vector3Equality comparer with custom allowed calculation error. + /// + /// This value identifies the calculation error allowed. + public Vector3EqualityComparer(float allowedError) + { + this.AllowedError = allowedError; + } + /// + /// Compares the actual and expected Vector3 objects + /// for equality using to compare the x, y, and z attributes of Vector3. + /// + /// The expected Vector3 used for comparison + /// The actual Vector3 to test + /// True if the vectors are equals, false otherwise. + /// + /// The following example shows how to verify if two Vector3 are equals + /// + /// [TestFixture] + /// public class Vector3Test + /// { + /// [Test] + /// public void VerifyThat_TwoVector3ObjectsAreEqual() + /// { + /// //Custom error 10e-6f + /// var actual = new Vector3(10e-8f, 10e-8f, 10e-8f); + /// var expected = new Vector3(0f, 0f, 0f); + /// var comparer = new Vector3EqualityComparer(10e-6f); + /// + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(comparer)); + /// + /// //Default error 0.0001f + /// actual = new Vector3(0.01f, 0.01f, 0f); + /// expected = new Vector3(0.01f, 0.01f, 0f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(Vector3EqualityComparer.Instance)); + /// } + /// } + /// + /// + + public bool Equals(Vector3 expected, Vector3 actual) + { + return Utils.AreFloatsEqual(expected.x, actual.x, AllowedError) && + Utils.AreFloatsEqual(expected.y, actual.y, AllowedError) && + Utils.AreFloatsEqual(expected.z, actual.z, AllowedError); + } + + /// + /// Serves as the default hash function. + /// + /// A not null Vector3 + /// Returns 0 + public int GetHashCode(Vector3 vec3) + { + return 0; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3EqualityComparer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3EqualityComparer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..37e0a03ef6d068b4272d7f4f0778199c4f26ad16 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector3EqualityComparer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4bd2bc28ff24d5c488844851cb785db0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4ComparerWithEqualsOperator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4ComparerWithEqualsOperator.cs new file mode 100644 index 0000000000000000000000000000000000000000..3d265e3434e5cf4154bb770cbcc2e3a1fa9a5db1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4ComparerWithEqualsOperator.cs @@ -0,0 +1,53 @@ +using System.Collections.Generic; + +namespace UnityEngine.TestTools.Utils +{ + /// + /// Use these classes to compare two objects of the same type for equality within the range of a given tolerance using NUnit or custom constraints . Call Instance to apply the default calculation error value to the comparison. + /// + public class Vector4ComparerWithEqualsOperator : IEqualityComparer + { + private static readonly Vector4ComparerWithEqualsOperator m_Instance = new Vector4ComparerWithEqualsOperator(); + /// + /// A singleton instance of the comparer with a predefined default error value. + /// + public static Vector4ComparerWithEqualsOperator Instance { get { return m_Instance; } } + + private Vector4ComparerWithEqualsOperator() {} + /// + /// Compares the actual and expected objects for equality using a custom comparison mechanism. + /// + /// Expected Vector4 used to compare + /// Actual Vector4 value to test. + /// Returns true if expected and actual objects are equal, otherwise it returns false. + /// + /// + /// [TestFixture] + /// public class Vector4Test + /// { + /// [Test] + /// public void VerifyThat_TwoVector4ObjectsAreEqual() + /// { + /// var actual = new Vector4(10e-7f, 10e-7f, 10e-7f, 10e-7f); + /// var expected = new Vector4(0f, 0f, 0f, 0f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(Vector4ComparerWithEqualsOperator.Instance)); + /// } + /// } + /// + /// + public bool Equals(Vector4 expected, Vector4 actual) + { + return expected == actual; + } + /// + /// Serves as the default hash function. + /// + /// A not null Vector4 object + /// Returns 0 + public int GetHashCode(Vector4 vec4) + { + return 0; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4ComparerWithEqualsOperator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4ComparerWithEqualsOperator.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a23cf6632fe899a5e58547d7d4c942a732384d9c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4ComparerWithEqualsOperator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 44100f5f60f351348b9719b46d46cebe +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4EqualityComparer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4EqualityComparer.cs new file mode 100644 index 0000000000000000000000000000000000000000..a234413d2b23af745303052a878df4c37c990826 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4EqualityComparer.cs @@ -0,0 +1,77 @@ +using System.Collections.Generic; + +namespace UnityEngine.TestTools.Utils +{ + /// + /// Use this class to compare two Vector4 objects for equality with NUnit constraints. Call Vector4EqualityComparer.Instance to perform comparisons using default calculation error value 0.0001f. To set a custom test value, instantiate a new comparer using the one argument constructor. + /// + public class Vector4EqualityComparer : IEqualityComparer + { + private const float k_DefaultError = 0.0001f; + private readonly float AllowedError; + + private static readonly Vector4EqualityComparer m_Instance = new Vector4EqualityComparer(); + /// + /// A comparer instance with the default calculation error value set to 0.0001f. + /// + public static Vector4EqualityComparer Instance { get { return m_Instance; } } + + private Vector4EqualityComparer() : this(k_DefaultError) {} + /// + /// Initializes an instance of Vector4Equality comparer with custom allowed calculation error. + /// + /// This value identifies the calculation error allowed. + public Vector4EqualityComparer(float allowedError) + { + this.AllowedError = allowedError; + } + + /// + /// Compares the actual and expected Vector4 objects for equality using to compare the x, y, z, and w attributes of Vector4. + /// + /// The expected Vector4 used for comparison + /// The actual Vector4 to test + /// True if the vectors are equals, false otherwise. + /// + /// + ///[TestFixture] + /// public class Vector4Test + /// { + /// [Test] + /// public void VerifyThat_TwoVector4ObjectsAreEqual() + /// { + /// // Custom error 10e-6f + /// var actual = new Vector4(0, 0, 1e-6f, 1e-6f); + /// var expected = new Vector4(1e-6f, 0f, 0f, 0f); + /// var comparer = new Vector4EqualityComparer(10e-6f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(comparer)); + /// + /// // Default error 0.0001f + /// actual = new Vector4(0.01f, 0.01f, 0f, 0f); + /// expected = new Vector4(0.01f, 0.01f, 0f, 0f); + /// + /// Assert.That(actual, Is.EqualTo(expected).Using(Vector4EqualityComparer.Instance)); + /// } + /// } + /// + /// + public bool Equals(Vector4 expected, Vector4 actual) + { + return Utils.AreFloatsEqual(expected.x, actual.x, AllowedError) && + Utils.AreFloatsEqual(expected.y, actual.y, AllowedError) && + Utils.AreFloatsEqual(expected.z, actual.z, AllowedError) && + Utils.AreFloatsEqual(expected.w, actual.w, AllowedError); + } + + /// + /// Serves as the default hash function. + /// + /// A not null Vector4 object + /// Returns 0 + public int GetHashCode(Vector4 vec4) + { + return 0; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4EqualityComparer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4EqualityComparer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..149157d1858bc46ca5e2465b1bde0f9f0e59e1da --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/Vector4EqualityComparer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 32da81683c22faf458026716a2b821aa +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: