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/TestRunner/TestPlatform.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// A flag indicating the targeted test platforms.
+    /// </summary>
+    [Flags]
+    [Serializable]
+    public enum TestPlatform : byte
+    {
+        /// <summary>
+        /// Both platforms.
+        /// </summary>
+        All = 0xFF,
+        /// <summary>
+        /// The EditMode test platform.
+        /// </summary>
+        EditMode = 1 << 1,
+        /// <summary>
+        /// The PlayMode test platform.
+        /// </summary>
+        PlayMode = 1 << 2
+    }
+
+    internal static class TestPlatformEnumExtensions
+    {
+        public static bool IsFlagIncluded(this TestPlatform flags, TestPlatform flag)
+        {
+            return (flags & flag) == flag;
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/TestRunner/TestPlatform.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 743879b4db4bc1a4b829aae4386f4acf
+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.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 51557afa652635743b264a309f0a5c60
+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/Utils/AttributeHelper.cs

@@ -0,0 +1,45 @@
+using System;
+using System.IO;
+using System.Linq;
+
+namespace UnityEngine.TestTools
+{
+    internal static class AttributeHelper
+    {
+        internal static Type GetTargetClassFromName(string targetClassName, Type attributeInterface)
+        {
+            Type targetClass = null;
+            foreach (var assemblyName in ScriptingRuntime.GetAllUserAssemblies())
+            {
+                // we need to pass the assembly name without the .dll extension, so removing that first
+                var name = Path.GetFileNameWithoutExtension(assemblyName);
+                targetClass = Type.GetType(targetClassName + "," + name);
+                if (targetClass != null)
+                    break;
+            }
+
+            if (targetClass == null)
+            {
+                Debug.LogWarningFormat("Class type not found: " + targetClassName);
+                return null;
+            }
+
+            ValidateTargetClass(targetClass, attributeInterface);
+            return targetClass;
+        }
+
+        private static void ValidateTargetClass(Type targetClass, Type attributeInterface)
+        {
+            var constructorInfos = targetClass.GetConstructors();
+            if (constructorInfos.All(constructor => constructor.GetParameters().Length != 0))
+            {
+                Debug.LogWarningFormat("{0} does not implement default constructor", targetClass.Name);
+            }
+
+            if (!attributeInterface.IsAssignableFrom(targetClass))
+            {
+                Debug.LogWarningFormat("{0} does not implement {1}", targetClass.Name, attributeInterface.Name);
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/AttributeHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ae8ce3ffe04ac2c42945fd27e0291fc3
+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/ColorEqualityComparer.cs

@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+
+namespace UnityEngine.TestTools.Utils
+{
+    /// <summary>
+    /// Use this class to compare two Color objects. ColorEqualityComparer.Instance has default calculation error value set to 0.01f. To set a test specific error value instantiate a comparer instance using the one argument constructor.
+    /// </summary>
+    public class ColorEqualityComparer : IEqualityComparer<Color>
+    {
+        private const float k_DefaultError = 0.01f;
+        private readonly float AllowedError;
+
+
+        private static readonly ColorEqualityComparer m_Instance = new ColorEqualityComparer();
+        /// <summary>
+        ///A singleton instance of the comparer with a default error value set to 0.01f.
+        /// </summary>
+        public static ColorEqualityComparer Instance { get { return m_Instance; } }
+
+        private ColorEqualityComparer() : this(k_DefaultError)
+        {
+        }
+        /// <summary>
+        /// Creates an instance of the comparer with a custom error value.
+        /// </summary>
+        /// <param name="error">The custom error value.</param>
+        public ColorEqualityComparer(float error)
+        {
+            this.AllowedError = error;
+        }
+
+        /// <summary>
+        /// Compares the actual and expected Color objects for equality using <see cref="Utils.AreFloatsEqualAbsoluteError"/> to compare the RGB and Alpha attributes of Color. Returns true if expected and actual objects are equal otherwise, it returns false.
+        /// </summary>
+        /// <param name="expected">The expected Color value used to compare.</param>
+        /// <param name="actual">The actual Color value to test.</param>
+        /// <returns>True if actual and expected are equal, false otherwise</returns>
+        /// <example>
+        ///<code>
+        /// [TestFixture]
+        /// public class ColorEqualityTest
+        /// {
+        ///     [Test]
+        ///     public void GivenColorsAreEqual_WithAllowedCalculationError()
+        ///     {
+        ///         // Using default error
+        ///         var firstColor = new Color(0f, 0f, 0f, 0f);
+        ///         var secondColor = new Color(0f, 0f, 0f, 0f);
+        /// 
+        ///         Assert.That(firstColor, Is.EqualTo(secondColor).Using(ColorEqualityComparer.Instance));
+        /// 
+        ///         // Allowed error 10e-5f
+        ///         var comparer = new ColorEqualityComparer(10e-5f);
+        ///         firstColor = new Color(0f, 0f, 0f, 1f);
+        ///         secondColor = new Color(10e-6f, 0f, 0f, 1f);
+        /// 
+        ///         Assert.That(firstColor, Is.EqualTo(secondColor).Using(comparer));
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        public bool Equals(Color expected, Color actual)
+        {
+            return Utils.AreFloatsEqualAbsoluteError(expected.r, actual.r, AllowedError) &&
+                Utils.AreFloatsEqualAbsoluteError(expected.g, actual.g, AllowedError) &&
+                Utils.AreFloatsEqualAbsoluteError(expected.b, actual.b, AllowedError) &&
+                Utils.AreFloatsEqualAbsoluteError(expected.a, actual.a, AllowedError);
+        }
+
+        /// <summary>
+        /// Serves as the default hash function.
+        /// </summary>
+        /// <param name="color">A not null Color object.</param>
+        /// <returns>Returns 0.</returns>
+        public int GetHashCode(Color color)
+        {
+            return 0;
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/ColorEqualityComparer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d6105bc8cf5ce544487daca4cbc62583
+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/CoroutineRunner.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections;
+using NUnit.Framework.Internal;
+using UnityEngine.TestRunner.NUnitExtensions.Runner;
+using UnityEngine.TestTools.TestRunner;
+
+namespace UnityEngine.TestTools.Utils
+{
+    internal class CoroutineRunner
+    {
+        private bool m_Running;
+        private bool m_Timeout;
+        private readonly MonoBehaviour m_Controller;
+        private readonly UnityTestExecutionContext m_Context;
+        private Coroutine m_TimeOutCoroutine;
+        private IEnumerator m_TestCoroutine;
+
+        internal const int k_DefaultTimeout = 1000 * 180;
+
+        public CoroutineRunner(MonoBehaviour playmodeTestsController, UnityTestExecutionContext context)
+        {
+            m_Controller = playmodeTestsController;
+            m_Context = context;
+        }
+
+        public IEnumerator HandleEnumerableTest(IEnumerator testEnumerator)
+        {
+            if (m_Context.TestCaseTimeout == 0)
+            {
+                m_Context.TestCaseTimeout = k_DefaultTimeout;
+            }
+            do
+            {
+                if (!m_Running)
+                {
+                    m_Running = true;
+                    m_TestCoroutine = ExMethod(testEnumerator, m_Context.TestCaseTimeout);
+                    m_Controller.StartCoroutine(m_TestCoroutine);
+                }
+                if (m_Context.ExecutionStatus == TestExecutionStatus.StopRequested || m_Context.ExecutionStatus == TestExecutionStatus.AbortRequested)
+                {
+                    StopAllRunningCoroutines();
+                    yield break;
+                }
+                yield return null;
+            }
+            while (m_Running);
+        }
+
+        private void StopAllRunningCoroutines()
+        {
+            if (m_TimeOutCoroutine != null)
+            {
+                m_Controller.StopCoroutine(m_TimeOutCoroutine);
+            }
+
+            if (m_TestCoroutine != null)
+            {
+                m_Controller.StopCoroutine(m_TestCoroutine);
+            }
+        }
+
+        private IEnumerator ExMethod(IEnumerator e, int timeout)
+        {
+            m_TimeOutCoroutine = m_Controller.StartCoroutine(StartTimer(e, timeout,
+                () =>
+                {
+                    m_Timeout = true;
+                    m_Running = false;
+                }));
+
+            yield return m_Controller.StartCoroutine(e);
+            m_Controller.StopCoroutine(m_TimeOutCoroutine);
+            m_Running = false;
+        }
+
+        private IEnumerator StartTimer(IEnumerator coroutineToBeKilled, int timeout, Action onTimeout)
+        {
+            yield return new WaitForSecondsRealtime(timeout / 1000f);
+            if (coroutineToBeKilled != null)
+                m_Controller.StopCoroutine(coroutineToBeKilled);
+            if (onTimeout != null)
+            {
+                onTimeout();
+                StopAllRunningCoroutines();
+                m_Context.CurrentResult.RecordException(new UnityTestTimeoutException(m_Context.TestCaseTimeout));
+            }
+        }
+
+        public bool HasFailedWithTimeout()
+        {
+            return m_Timeout;
+        }
+
+        public int GetDefaultTimeout()
+        {
+            return k_DefaultTimeout;
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/CoroutineRunner.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 24a158219395ebf44a60547b97784ddc
+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/FloatEqualityComparer.cs

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+
+namespace UnityEngine.TestTools.Utils
+{
+    /// <summary>
+    /// Use this class to compare two float values for equality with NUnit constraints. Use FloatEqualityComparer.Instance comparer to have the default error value set to 0.0001f. For any other error, use the one argument constructor to create a comparer.
+    /// </summary>
+    public class FloatEqualityComparer : IEqualityComparer<float>
+    {
+        private const float k_DefaultError = 0.0001f;
+        private readonly float AllowedError;
+
+        private static readonly  FloatEqualityComparer m_Instance = new FloatEqualityComparer();
+        /// <summary>
+        ///A singleton instance of the comparer with a default error value set to 0.0001f.
+        /// </summary>
+        public static FloatEqualityComparer Instance { get { return m_Instance; } }
+
+        private FloatEqualityComparer() : this(k_DefaultError) {}
+
+        /// <summary>
+        /// Initializes an instance of a FloatEqualityComparer with a custom error value instead of the default 0.0001f.
+        /// </summary>
+        /// <param name="allowedError">The custom error value</param>
+        public FloatEqualityComparer(float allowedError)
+        {
+            this.AllowedError = allowedError;
+        }
+
+        /// <summary>
+        /// Compares the actual and expected float values for equality using <see cref="Utils.AreFloatsEqual"/>.
+        /// </summary>
+        /// <param name="expected">The expected float value used to compare.</param>
+        /// <param name="actual">The actual float value to test.</param>
+        /// <returns>True if the values are equals, false otherwise.</returns>
+        /// <example>
+        /// <code>
+        /// [TestFixture]
+        /// public class FloatsTest
+        ///{
+        ///    [Test]
+        ///    public void VerifyThat_TwoFloatsAreEqual()
+        ///    {
+        ///        var comparer = new FloatEqualityComparer(10e-6f);
+        ///        var actual = -0.00009f;
+        ///        var expected = 0.00009f;
+        ///
+        ///        Assert.That(actual, Is.EqualTo(expected).Using(comparer));
+        ///
+        ///        // Default relative error 0.0001f
+        ///        actual = 10e-8f;
+        ///        expected = 0f;
+        ///
+        ///        Assert.That(actual, Is.EqualTo(expected).Using(FloatEqualityComparer.Instance));
+        ///    }
+        ///}
+        /// </code>
+        /// </example>
+        public bool Equals(float expected, float actual)
+        {
+            return Utils.AreFloatsEqual(expected, actual, AllowedError);
+        }
+
+        /// <summary>
+        /// Serves as the default hash function.
+        /// </summary>
+        /// <param name="value">A not null float number.</param>
+        /// <returns>Returns 0.</returns>
+        public int GetHashCode(float value)
+        {
+            return 0;
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/FloatEqualityComparer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: af5042802f06c804c8abddd544b77a4a
+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/IOuterUnityTestAction.cs

@@ -0,0 +1,21 @@
+using System.Collections;
+using NUnit.Framework.Interfaces;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// When implemented by an attribute, this interface implemented to provide actions to execute before setup and after teardown of tests.
+    /// </summary>
+    public interface IOuterUnityTestAction
+    {
+        /// <summary>Executed before each test is run</summary>
+        /// <param name="test">The test that is going to be run.</param>
+        /// <returns>Enumerable collection of actions to perform before test setup.</returns>
+        IEnumerator BeforeTest(ITest test);
+
+        /// <summary>Executed after each test is run</summary>
+        /// <param name="test">The test that has just been run.</param>
+        /// <returns>Enumerable collection of actions to perform after test teardown.</returns>
+        IEnumerator AfterTest(ITest test);
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/IOuterUnityTestAction.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b9c2a6302985d3846b7b9f6fd9e2da9a
+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/IPostBuildCleanup.cs

@@ -0,0 +1,13 @@
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// Implement this interface if you want to define a set of actions to execute as a post-build step. Cleanup runs right away for a standalone test run, but only after all the tests run within the Editor.
+    /// </summary>
+    public interface IPostBuildCleanup
+    {
+        /// <summary>
+        /// Implement this method to specify actions that should run as a post-build cleanup step.
+        /// </summary>
+        void Cleanup();
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/IPostBuildCleanup.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ff67c526455160f4690a44f74dee4cbe
+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/IPrebuildSceneSetup.cs

@@ -0,0 +1,59 @@
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// Implement this interface if you want to define a set of actions to run as a pre-build step.
+    /// </summary>
+    public interface IPrebuildSetup
+    {
+        /// <summary>
+        /// Implement this method to call actions automatically before the build process.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// [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&lt;Texture2D&gt;("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.height), new Vector2(0.5f, 0.5f));
+        /// 
+        ///         Assert.That(m_Sprite, Is.Null, "Sprite created with null texture should be null");
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        void Setup();
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/IPrebuildSceneSetup.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: acc16f0c684508f44813662a300c574b
+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/ITestRunCallback.cs

@@ -0,0 +1,31 @@
+using NUnit.Framework.Interfaces;
+
+namespace UnityEngine.TestRunner
+{
+    /// <summary>
+    /// Interface for getting callsbacks on test progress directly from NUnit. This is available both in the editor and directly in the runtime. It is registered by using <see cref="TestRunCallbackAttribute"/>.
+    /// </summary>
+    public interface ITestRunCallback
+    {
+        /// <summary>
+        /// A callback invoked when a test run is started.
+        /// </summary>
+        /// <param name="testsToRun">The full loaded test tree.</param>
+        void RunStarted(ITest testsToRun);
+        /// <summary>
+        /// A callback invoked when a test run is finished.
+        /// </summary>
+        /// <param name="testResults">The result of the test run.</param>
+        void RunFinished(ITestResult testResults);
+        /// <summary>
+        /// A callback invoked when each individual node of the test tree has started executing.
+        /// </summary>
+        /// <param name="test">The test node currently executed.</param>
+        void TestStarted(ITest test);
+        /// <summary>
+        /// A callback invoked when each individual node of the test tree has finished executing.
+        /// </summary>
+        /// <param name="result">The result of the test tree node after it had been executed.</param>
+        void TestFinished(ITestResult result);
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.test-framework@1.1.22/UnityEngine.TestRunner/Utils/ITestRunCallback.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 38d0b8a87b967304da08a2ae9b955066
+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/MonoBehaviourTest.meta

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