Add files using upload-large-folder tool

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

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: 

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: 

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
+{
+    /// <summary>
+    /// Specialization of BaseDelegator that makes sure objects are created on the MainThread.
+    /// It also deals with ScriptableObjects so that tests can survive assembly reload.
+    /// </summary>
+    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);
+        }
+    }
+}

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: 

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: 

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<ITest> BuildAsync(Assembly[] assemblies, TestPlatform[] testPlatforms, IDictionary<string, object> options);
+    }
+}

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: 

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

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: 

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: 

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<string> GetTestCategories(this ITest test)
+        {
+            var categories = test.Properties[PropertyNames.Category].Cast<string>().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<string>().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<string> 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<string, int>();
+            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;
+        }
+    }
+}

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: 

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

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: 

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<string, object> options)
+        {
+            var test = BuildAsync(assemblies, testPlatforms, options);
+            while (test.MoveNext())
+            {
+            }
+
+            return test.Current;
+        }
+
+        public IEnumerator<ITest> BuildAsync(Assembly[] assemblies, TestPlatform[] testPlatforms, IDictionary<string, object> 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<string, object> GetNUnitTestBuilderSettings(TestPlatform testPlatform)
+        {
+            var emptySettings = new Dictionary<string, object>();
+            emptySettings.Add(FrameworkPackageSettings.TestParameters, "platform=" + testPlatform);
+            return emptySettings;
+        }
+    }
+}

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: 

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: 

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<ITestResult> {}
+
+    [Serializable]
+    internal class TestStartedEvent : UnityEvent<ITest> {}
+
+    [Serializable]
+    internal class RunFinishedEvent : UnityEvent<ITestResult> {}
+
+    [Serializable]
+    internal class RunStartedEvent : UnityEvent<ITest> {}
+}

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: 

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: 

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<string> m_AssembliesWithTests;
+        public List<string> 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<PlaymodeTestsController>();
+        }
+
+        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();
+            }
+        }
+    }
+}

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: 

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

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: 

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: 

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<ITestFilter>();
+
+            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<ITestFilter> filters, string[] values, Func<string, TestFilter> 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));
+            }
+        }
+    }
+}

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: 

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

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: 

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

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: 

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

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: 

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

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: 

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

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: 

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

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: 

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

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: 

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

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: 

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

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: 

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<string> m_AssembliesToLoad;
+
+        //Cached until domain reload
+        private static List<IAssemblyWrapper> m_LoadedAssemblies;
+
+        internal PlayerTestAssemblyProvider(IAssemblyLoadProxy assemblyLoadProxy, List<string> assembliesToLoad)
+        {
+            m_AssemblyLoadProxy = assemblyLoadProxy;
+            m_AssembliesToLoad = assembliesToLoad;
+            LoadAssemblies();
+        }
+
+        public ITest GetTestsWithNUnit()
+        {
+            return BuildTests(TestPlatform.PlayMode, m_LoadedAssemblies.ToArray());
+        }
+
+        public List<IAssemblyWrapper> 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<IAssemblyWrapper>();
+
+            foreach (var userAssembly in m_AssembliesToLoad)
+            {
+                IAssemblyWrapper a;
+                try
+                {
+                    a = m_AssemblyLoadProxy.Load(userAssembly);
+                }
+                catch (FileNotFoundException)
+                {
+                    continue;
+                }
+                if (a != null)
+                    m_LoadedAssemblies.Add(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

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

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

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
+{
+    /// <summary>
+    /// 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.
+    /// </summary>
+    [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; }
+    }
+}