Add files using upload-large-folder tool

benchmark/IOL/ioling_hf/reports/ioling_hint_diversity/Qwen_Qwen3-4B-Instruct-2507__qwen3_4b_trainval_hints_groot_4k.md

@@ -0,0 +1,126 @@
+# IOLing Hint Diversity Probe
+
+- generated: `2026-07-10T23:20:51.241026+00:00`
+- model: `Qwen/Qwen3-4B-Instruct-2507`
+- samples: `375`
+- positive samples: `9`
+- exact samples: `3`
+
+## Method Summary
+
+| split | method | records | samples | records + | records exact | sample + | sample exact | mean best | format | unique boxes |
+| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| train | anti_nearmiss | 9 | 36 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.056 | 3 |
+| train | groot_1x4 | 9 | 36 | 2 | 0 | 0.083 | 0.000 | 0.056 | 0.278 | 11 |
+| train | groot_anchor_iid | 9 | 9 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.111 | 2 |
+| train | iid | 9 | 36 | 1 | 0 | 0.028 | 0.000 | 0.037 | 0.139 | 7 |
+| train | redacted_solution_hint_mask0 | 1 | 4 | 1 | 1 | 1.000 | 0.750 | 1.000 | 1.000 | 2 |
+| train | redacted_solution_hint_mask1 | 2 | 8 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.125 | 2 |
+| train | redacted_solution_hint_mask3 | 1 | 4 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.000 | 1 |
+| train | redacted_solution_hint_mask4 | 1 | 4 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.000 | 1 |
+| train | redacted_solution_hint_mask5 | 2 | 8 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.250 | 3 |
+| train | redacted_solution_hint_mask6 | 2 | 8 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.000 | 1 |
+| train | solver_checklist | 9 | 36 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.139 | 6 |
+| train | unit_audit | 9 | 36 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.222 | 9 |
+| val | anti_nearmiss | 6 | 24 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.042 | 2 |
+| val | groot_1x4 | 6 | 24 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.083 | 3 |
+| val | groot_anchor_iid | 6 | 6 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.000 | 1 |
+| val | iid | 6 | 24 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.042 | 2 |
+| val | redacted_solution_hint_mask2 | 2 | 8 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.125 | 2 |
+| val | redacted_solution_hint_mask4 | 1 | 4 | 1 | 0 | 0.250 | 0.000 | 0.200 | 0.250 | 2 |
+| val | redacted_solution_hint_mask5 | 3 | 12 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.000 | 1 |
+| val | solver_checklist | 6 | 24 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.083 | 3 |
+| val | unit_audit | 6 | 24 | 0 | 0 | 0.000 | 0.000 | 0.000 | 0.042 | 2 |
+
+## Positive Samples
+
+### `train` `iol-2011-individual-p1-sub-b` `redacted_solution_hint_mask0` sample `0`
+
+- score: `1.0`
+- matched: `b.1, b.2, b.3, b.4`
+- missed: ``
+
+```text
+b.1: new¯æpahtan; b.2: kek¯awenæq; b.3: taw¯anæhkæw; b.4: ket¯ohnæw
+```
+
+### `train` `iol-2011-individual-p1-sub-b` `redacted_solution_hint_mask0` sample `2`
+
+- score: `1.0`
+- matched: `b.1, b.2, b.3, b.4`
+- missed: ``
+
+```text
+b.1: new¯æpahtan; b.2: kek¯awenæq; b.3: taw¯anæhkæw; b.4: ket¯ohnæw
+```
+
+### `train` `iol-2011-individual-p1-sub-b` `redacted_solution_hint_mask0` sample `3`
+
+- score: `1.0`
+- matched: `b.1, b.2, b.3, b.4`
+- missed: ``
+
+```text
+b.1: new¯æpahtan; b.2: kek¯awenæq; b.3: taw¯anæhkæw; b.4: ket¯ohnæw
+```
+
+### `train` `iol-2011-individual-p1-sub-b` `redacted_solution_hint_mask0` sample `1`
+
+- score: `0.75`
+- matched: `b.1, b.2, b.4`
+- missed: `b.3`
+
+```text
+b.1: new¯æpahtan; b.2: kek¯awenæq; b.3: k¯anæhkæ; b.4: ket¯ohnæw
+```
+
+### `train` `iol-2016-individual-p5-sub-a` `groot_1x4` sample `0`
+
+- score: `0.3333333333333333`
+- matched: `a.1`
+- missed: `a.2, a.3`
+
+```text
+a.1: is it in my house; a.2: the field too; a.3: the field too
+```
+
+### `train` `iol-2016-individual-p5-sub-a` `groot_1x4` sample `2`
+
+- score: `0.3333333333333333`
+- matched: `a.1`
+- missed: `a.2, a.3`
+
+```text
+a.1: is it in my house?; a.2: the field too; a.3: the field too
+```
+
+### `train` `iol-2016-individual-p5-sub-a` `iid` sample `0`
+
+- score: `0.3333333333333333`
+- matched: `a.1`
+- missed: `a.2, a.3`
+
+```text
+a.1: is it in my house?; a.2: the field too; a.3: the field too
+```
+
+### `val` `iol-2021-individual-p3-sub-a` `redacted_solution_hint_mask4` sample `3`
+
+- score: `0.2`
+- matched: `a.4`
+- missed: `a.1, a.2, a.3, a.5`
+
+```text
+a.1: How many things will this man catch?; a.2: Two things will eat these fish.; a.3: Which child is this?; a.4: How many men will see the wild children?; How many men will the wild children see?; a.5: That man saw those things.
+```
+
+### `train` `iol-2008-individual-p5-sub-a` `groot_1x4` sample `0`
+
+- score: `0.16666666666666666`
+- matched: `a.5`
+- missed: `a.1, a.2, a.3, a.4, a.6`
+
+```text
+a.1: The hunter came and saw; a.2: Your boy hurt you; a.3: The hunter cured; a.4: The dog hurt and shot; a.5: You came; a.6: The hunter cured a polar bear
+```
+

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

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3f9202a39620f51418046c7754f215f0
+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/UnityEditor.TestRunner/RequireApiProfileAttribute.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+
+namespace UnityEditor.TestTools
+{
+    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]
+    internal class RequireApiProfileAttribute : NUnitAttribute, IApplyToTest
+    {
+        public ApiCompatibilityLevel[] apiProfiles { get; private set; }
+
+        public RequireApiProfileAttribute(params ApiCompatibilityLevel[] apiProfiles)
+        {
+            this.apiProfiles = apiProfiles;
+        }
+
+        void IApplyToTest.ApplyToTest(Test test)
+        {
+            test.Properties.Add(PropertyNames.Category, string.Format("ApiProfile({0})", string.Join(", ", apiProfiles.Select(p => p.ToString()).OrderBy(p => p).ToArray())));
+            ApiCompatibilityLevel testProfile = PlayerSettings.GetApiCompatibilityLevel(EditorUserBuildSettings.activeBuildTargetGroup);
+
+            if (!apiProfiles.Contains(testProfile))
+            {
+                string skipReason = "Skipping test as it requires a compatible api profile set: " + string.Join(", ", apiProfiles.Select(p => p.ToString()).ToArray());
+                test.RunState = RunState.Skipped;
+                test.Properties.Add(PropertyNames.SkipReason, skipReason);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a667f6654ad7a9548b8c8e68b51c8895
+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/UnityEditor.TestRunner/RequirePlatformSupportAttribute.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Linq;
+using NUnit.Framework;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+
+namespace UnityEditor.TestTools
+{
+    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]
+    public class RequirePlatformSupportAttribute : NUnitAttribute, IApplyToTest
+    {
+        public RequirePlatformSupportAttribute(params BuildTarget[] platforms)
+        {
+            this.platforms = platforms;
+        }
+
+        public BuildTarget[] platforms { get; private set; }
+
+        void IApplyToTest.ApplyToTest(Test test)
+        {
+            test.Properties.Add(PropertyNames.Category, string.Format("RequirePlatformSupport({0})", string.Join(", ", platforms.Select(p => p.ToString()).OrderBy(p => p).ToArray())));
+
+            if (!platforms.All(p => BuildPipeline.IsBuildTargetSupported(BuildTargetGroup.Unknown, p)))
+            {
+                var missingPlatforms = platforms.Where(p => !BuildPipeline.IsBuildTargetSupported(BuildTargetGroup.Unknown, p)).Select(p => p.ToString()).ToArray();
+                string skipReason = "Test cannot be run as it requires support for the following platforms to be installed: " + string.Join(", ", missingPlatforms);
+
+                test.RunState = RunState.Skipped;
+                test.Properties.Add(PropertyNames.SkipReason, skipReason);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d2146428d3f1ad54eb7326c9a44b3284
+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/UnityEditor.TestRunner/TestBuildAssemblyFilter.cs

@@ -0,0 +1,22 @@
+using System.Linq;
+using UnityEditor.Build;
+
+namespace UnityEditor.TestRunner
+{
+    // This class is invoked from native, during build
+    internal class TestBuildAssemblyFilter : IFilterBuildAssemblies
+    {
+        private const string nunitAssemblyName = "nunit.framework";
+        private const string unityTestRunnerAssemblyName = "UnityEngine.TestRunner";
+
+        public int callbackOrder { get; }
+        public string[] OnFilterAssemblies(BuildOptions buildOptions, string[] assemblies)
+        {
+            if ((buildOptions & BuildOptions.IncludeTestAssemblies) == BuildOptions.IncludeTestAssemblies || PlayerSettings.playModeTestRunnerEnabled)
+            {
+                return assemblies;
+            }
+            return assemblies.Where(x => !x.Contains(nunitAssemblyName) && !x.Contains(unityTestRunnerAssemblyName)).ToArray();
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3411e19edd44cfd46b548b058c3bc36c
+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/UnityEditor.TestRunner/TestLaunchers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d64d92e4f04a13e4b99ea8d48e9e8ae9
+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/UnityEditor.TestRunner/TestResultSerializer.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Reflection;
+using System.Text;
+using NUnit.Framework.Interfaces;
+using NUnit.Framework.Internal;
+using UnityEngine;
+using UnityEngine.TestRunner.NUnitExtensions;
+
+namespace UnityEditor.TestTools.TestRunner
+{
+    [Serializable]
+    internal class TestResultSerializer
+    {
+        private static readonly BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Public |
+            BindingFlags.Instance | BindingFlags.FlattenHierarchy;
+
+        [SerializeField] public string id;
+
+        [SerializeField] public string fullName;
+
+        [SerializeField] private double duration;
+
+        [SerializeField] private string label;
+
+        [SerializeField] private string message;
+
+        [SerializeField] private string output;
+
+        [SerializeField] private string site;
+
+        [SerializeField] private string stacktrace;
+
+        [SerializeField] private double startTimeAO;
+
+        [SerializeField] private double endTimeAO;
+
+        [SerializeField] private string status;
+
+        [SerializeField] public string uniqueName;
+
+        public static TestResultSerializer MakeFromTestResult(ITestResult result)
+        {
+            var wrapper = new TestResultSerializer();
+            wrapper.id = result.Test.Id;
+            wrapper.fullName = result.FullName;
+            wrapper.status = result.ResultState.Status.ToString();
+            wrapper.label = result.ResultState.Label;
+            wrapper.site = result.ResultState.Site.ToString();
+            wrapper.output = result.Output;
+            wrapper.duration = result.Duration;
+            wrapper.stacktrace = result.StackTrace;
+            wrapper.message = result.Message;
+            wrapper.startTimeAO = result.StartTime.ToOADate();
+            wrapper.endTimeAO = result.EndTime.ToOADate();
+            wrapper.uniqueName = result.Test.GetUniqueName();
+            return wrapper;
+        }
+
+        public void RestoreTestResult(TestResult result)
+        {
+            var resultState = new ResultState((TestStatus)Enum.Parse(typeof(TestStatus), status), label,
+                (FailureSite)Enum.Parse(typeof(FailureSite), site));
+            var baseType = result.GetType().BaseType;
+            baseType.GetField("_resultState", flags).SetValue(result, resultState);
+            baseType.GetField("_output", flags).SetValue(result, new StringBuilder(output));
+            baseType.GetField("_duration", flags).SetValue(result, duration);
+            baseType.GetField("_message", flags).SetValue(result, message);
+            baseType.GetField("_stackTrace", flags).SetValue(result, stacktrace);
+            baseType.GetProperty("StartTime", flags)
+                .SetValue(result, DateTime.FromOADate(startTimeAO), null);
+            baseType.GetProperty("EndTime", flags)
+                .SetValue(result, DateTime.FromOADate(endTimeAO), null);
+        }
+
+        public bool IsPassed()
+        {
+            return status == TestStatus.Passed.ToString();
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 559482fe33c79e44882d3a6cedc55fb5
+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/UnityEditor.TestRunner/TestRun.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8721cb2237d4a564a94a51f56243bdac
+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/UnityEditor.TestRunner/TestRunner.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 49d4c2ab7ff0f4442af256bad7c9d57c
+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/UnityEditor.TestRunner/TestRunnerWindow.cs

@@ -0,0 +1,266 @@
+using System;
+using UnityEditor.Callbacks;
+using UnityEditor.TestTools.TestRunner.Api;
+using UnityEditor.TestTools.TestRunner.GUI;
+using UnityEngine;
+
+namespace UnityEditor.TestTools.TestRunner
+{
+    /// <summary>
+    /// The TestRunnerWindow class is repsonsible for drawing the Test Runner window.
+    /// </summary>
+    [Serializable]
+    public class TestRunnerWindow : EditorWindow, IHasCustomMenu
+    {
+        internal static class Styles
+        {
+            public static GUIStyle info;
+            public static GUIStyle testList;
+
+            static Styles()
+            {
+                info = new GUIStyle(EditorStyles.wordWrappedLabel);
+                info.wordWrap = false;
+                info.stretchHeight = true;
+                info.margin.right = 15;
+
+                testList = new GUIStyle("CN Box");
+                testList.margin.top = 0;
+                testList.padding.left = 3;
+            }
+        }
+
+        private readonly GUIContent m_GUIHorizontalSplit = EditorGUIUtility.TrTextContent("Horizontal layout");
+        private readonly GUIContent m_GUIVerticalSplit = EditorGUIUtility.TrTextContent("Vertical layout");
+        private readonly GUIContent m_GUIDisablePlaymodeTestsRunner = EditorGUIUtility.TrTextContent("Disable playmode tests for all assemblies");
+        private readonly GUIContent m_GUIRunPlayModeTestAsEditModeTests = EditorGUIUtility.TrTextContent("Run playmode tests as editmode tests");
+
+        internal static TestRunnerWindow s_Instance;
+        private bool m_IsBuilding;
+        [NonSerialized]
+        private bool m_Enabled;
+        internal TestFilterSettings filterSettings;
+
+        [SerializeField]
+        private SplitterState m_Spl = new SplitterState(new float[] { 75, 25 }, new[] { 32, 32 }, null);
+
+        private TestRunnerWindowSettings m_Settings;
+
+        private enum TestRunnerMenuLabels
+        {
+            PlayMode = 0,
+            EditMode = 1
+        }
+        [SerializeField]
+        private int m_TestTypeToolbarIndex = (int)TestRunnerMenuLabels.EditMode;
+        [SerializeField]
+        private PlayModeTestListGUI m_PlayModeTestListGUI;
+        [SerializeField]
+        private EditModeTestListGUI m_EditModeTestListGUI;
+
+        internal TestListGUI m_SelectedTestTypes;
+
+        private ITestRunnerApi m_testRunnerApi;
+
+        private WindowResultUpdater m_WindowResultUpdater;
+
+        /// <summary>
+        /// Launches the Test Runner window.
+        /// </summary>
+        [MenuItem("Window/General/Test Runner", false, 201, false)]
+        public static void ShowWindow()
+        {
+            s_Instance = GetWindow<TestRunnerWindow>("Test Runner");
+            s_Instance.Show();
+        }
+
+        static TestRunnerWindow()
+        {
+            InitBackgroundRunners();
+        }
+
+        private static void InitBackgroundRunners()
+        {
+            EditorApplication.playModeStateChanged -= OnPlayModeStateChanged;
+            EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+        }
+
+        [DidReloadScripts]
+        private static void CompilationCallback()
+        {
+            UpdateWindow();
+        }
+
+        private static void OnPlayModeStateChanged(PlayModeStateChange state)
+        {
+            if (s_Instance && state == PlayModeStateChange.EnteredEditMode && s_Instance.m_SelectedTestTypes.HasTreeData())
+            {
+                //repaint message details after exit playmode
+                s_Instance.m_SelectedTestTypes.TestSelectionCallback(s_Instance.m_SelectedTestTypes.m_TestListState.selectedIDs.ToArray());
+                s_Instance.Repaint();
+            }
+        }
+
+        internal void OnDestroy()
+        {
+            EditorApplication.playModeStateChanged -= OnPlayModeStateChanged;
+        }
+
+        private void OnEnable()
+        {
+            s_Instance = this;
+            SelectTestListGUI(m_TestTypeToolbarIndex);
+
+            m_testRunnerApi = ScriptableObject.CreateInstance<TestRunnerApi>();
+            m_WindowResultUpdater = new WindowResultUpdater();
+            m_testRunnerApi.RegisterCallbacks(m_WindowResultUpdater);
+        }
+
+        private void Enable()
+        {
+            m_Settings = new TestRunnerWindowSettings("UnityEditor.PlaymodeTestsRunnerWindow");
+            filterSettings = new TestFilterSettings("UnityTest.IntegrationTestsRunnerWindow");
+
+            if (m_SelectedTestTypes == null)
+            {
+                SelectTestListGUI(m_TestTypeToolbarIndex);
+            }
+
+            StartRetrieveTestList();
+            m_SelectedTestTypes.Reload();
+            m_Enabled = true;
+        }
+
+        private void SelectTestListGUI(int testTypeToolbarIndex)
+        {
+            if (testTypeToolbarIndex == (int)TestRunnerMenuLabels.PlayMode)
+            {
+                if (m_PlayModeTestListGUI == null)
+                {
+                    m_PlayModeTestListGUI = new PlayModeTestListGUI();
+                }
+                m_SelectedTestTypes = m_PlayModeTestListGUI;
+            }
+            else if (testTypeToolbarIndex == (int)TestRunnerMenuLabels.EditMode)
+            {
+                if (m_EditModeTestListGUI == null)
+                {
+                    m_EditModeTestListGUI = new EditModeTestListGUI();
+                }
+                m_SelectedTestTypes = m_EditModeTestListGUI;
+            }
+        }
+
+        private void StartRetrieveTestList()
+        {
+            if (!m_SelectedTestTypes.HasTreeData())
+            {
+                var listToInit = m_SelectedTestTypes;
+                m_testRunnerApi.RetrieveTestList(m_SelectedTestTypes.TestMode, (rootTest) =>
+                {
+                    listToInit.Init(this, rootTest);
+                    listToInit.Reload();
+                });
+            }
+        }
+
+        internal void OnGUI()
+        {
+            if (!m_Enabled)
+            {
+                Enable();
+            }
+
+            if (BuildPipeline.isBuildingPlayer)
+            {
+                m_IsBuilding = true;
+            }
+            else if (m_IsBuilding)
+            {
+                m_IsBuilding = false;
+                Repaint();
+            }
+
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.FlexibleSpace();
+            var selectedIndex = m_TestTypeToolbarIndex;
+            m_TestTypeToolbarIndex = GUILayout.Toolbar(m_TestTypeToolbarIndex, Enum.GetNames(typeof(TestRunnerMenuLabels)), "LargeButton", UnityEngine.GUI.ToolbarButtonSize.FitToContents);
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+
+            if (selectedIndex != m_TestTypeToolbarIndex)
+            {
+                SelectTestListGUI(m_TestTypeToolbarIndex);
+                StartRetrieveTestList();
+            }
+
+            EditorGUILayout.BeginVertical();
+            using (new EditorGUI.DisabledScope(EditorApplication.isPlayingOrWillChangePlaymode))
+            {
+                m_SelectedTestTypes.PrintHeadPanel();
+            }
+            EditorGUILayout.EndVertical();
+
+            if (m_Settings.verticalSplit)
+                SplitterGUILayout.BeginVerticalSplit(m_Spl);
+            else
+                SplitterGUILayout.BeginHorizontalSplit(m_Spl);
+
+            EditorGUILayout.BeginVertical();
+            EditorGUILayout.BeginVertical(Styles.testList);
+            m_SelectedTestTypes.RenderTestList();
+            EditorGUILayout.EndVertical();
+            EditorGUILayout.EndVertical();
+
+            m_SelectedTestTypes.RenderDetails();
+
+            if (m_Settings.verticalSplit)
+                SplitterGUILayout.EndVerticalSplit();
+            else
+                SplitterGUILayout.EndHorizontalSplit();
+        }
+
+        /// <summary>
+        /// Adds additional menu items to the Test Runner window.
+        /// </summary>
+        /// <param name="menu">The <see cref="GenericMenu"/></param>
+        public void AddItemsToMenu(GenericMenu menu)
+        {
+            menu.AddItem(m_GUIVerticalSplit, m_Settings.verticalSplit, m_Settings.ToggleVerticalSplit);
+            menu.AddItem(m_GUIHorizontalSplit, !m_Settings.verticalSplit, m_Settings.ToggleVerticalSplit);
+
+            menu.AddSeparator(null);
+            
+            if (EditorPrefs.GetBool("InternalMode", false))
+            {
+                menu.AddItem(m_GUIRunPlayModeTestAsEditModeTests, PlayerSettings.runPlayModeTestAsEditModeTest, () =>
+                {
+                    PlayerSettings.runPlayModeTestAsEditModeTest = !PlayerSettings.runPlayModeTestAsEditModeTest;
+                });
+            }
+
+            if (PlayerSettings.playModeTestRunnerEnabled)
+            {
+                PlayerSettings.playModeTestRunnerEnabled = false;
+                EditorUtility.DisplayDialog(m_GUIDisablePlaymodeTestsRunner.text, "You need to restart the editor now", "Ok");
+            }
+        }
+
+        internal void RebuildUIFilter()
+        {
+            if (m_SelectedTestTypes != null && m_SelectedTestTypes.HasTreeData())
+            {
+                m_SelectedTestTypes.RebuildUIFilter();
+            }
+        }
+
+        internal static void UpdateWindow()
+        {
+            if (s_Instance != null && s_Instance.m_SelectedTestTypes != null)
+            {
+                s_Instance.m_SelectedTestTypes.Repaint();
+                s_Instance.Repaint();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4dfcd3a631f61d248b7cc0b845d40345
+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/UnityEditor.TestRunner/TestRunnerWindowSettings.cs

@@ -0,0 +1,26 @@
+namespace UnityEditor.TestTools.TestRunner
+{
+    internal class TestRunnerWindowSettings
+    {
+        public bool verticalSplit;
+
+        private readonly string m_PrefsKey;
+
+        public TestRunnerWindowSettings(string prefsKey)
+        {
+            m_PrefsKey = prefsKey;
+            verticalSplit = EditorPrefs.GetBool(m_PrefsKey + ".verticalSplit", true);
+        }
+
+        public void ToggleVerticalSplit()
+        {
+            verticalSplit = !verticalSplit;
+            Save();
+        }
+
+        private void Save()
+        {
+            EditorPrefs.SetBool(m_PrefsKey + ".verticalSplit", verticalSplit);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2b301b727225f1941974d69e61a55620
+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/UnityEditor.TestRunner/TestSettings.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 95b719082a664ea45bb56759eed1f271
+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/UnityEditor.TestRunner/UnityEditor.TestRunner.asmdef

@@ -0,0 +1,21 @@
+{
+    "name": "UnityEditor.TestRunner",
+    "references": [
+        "UnityEngine.TestRunner"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll",
+        "Mono.Cecil.dll",
+        "Mono.Cecil.Pdb.dll",
+        "Mono.Cecil.Mdb.dll",
+        "Mono.Cecil.Rocks.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": []
+}

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

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 0acc523941302664db1f4e527237feb3
+AssemblyDefinitionImporter:
+  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/UnityEditor.TestRunner/UnityTestProtocol.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 936c6340f3468444ebb1785b4c311126
+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/AssemblyInfo.cs

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

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

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

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

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1ad55f5ad04d1d045a1f287409c650dd
+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/Assertions/AllocatingGCMemoryConstraint.cs

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

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

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

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

@@ -0,0 +1,14 @@
+using NUnit.Framework.Constraints;
+
+namespace UnityEngine.TestTools.Constraints
+{
+    public static class ConstraintExtensions
+    {
+        public static AllocatingGCMemoryConstraint AllocatingGCMemory(this ConstraintExpression chain)
+        {
+            var constraint = new AllocatingGCMemoryConstraint();
+            chain.Append(constraint);
+            return constraint;
+        }
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+namespace UnityEngine.TestTools.Constraints
+{
+    public class Is : NUnit.Framework.Is
+    {
+        public static AllocatingGCMemoryConstraint AllocatingGCMemory()
+        {
+            return new AllocatingGCMemoryConstraint();
+        }
+    }
+}

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

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

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

@@ -0,0 +1,78 @@
+using System.Text.RegularExpressions;
+using UnityEngine.TestTools.Logging;
+
+namespace UnityEngine.TestTools
+{
+    /// <summary>
+    /// A test fails if Unity logs a message other than a regular log or warning message. Use `LogAssert` to check for an expected message in the log so that the test does not fail when Unity logs the message.
+    /// Use `LogAssert.Expect` before running the code under test, as the check for expected logs runs at the end of each frame.
+    /// A test also reports a failure, if an expected message does not appear, or if Unity does not log any regular log or warning messages.
+    /// 
+    /// `LogAssert` lets you expect Unity log messages that would otherwise cause the test to fail.
+    /// </summary>
+    public static class LogAssert
+    {
+        /// <summary>
+        /// Verifies that a log message of a specified type appears in the log. A test won't fail from an expected error, assertion, or exception log message. It does fail if an expected message does not appear in the log.
+        /// </summary>
+        /// <param name="type">A type of log to expect. It can take one of the [LogType enum](https://docs.unity3d.com/ScriptReference/LogType.html) values.</param>
+        /// <param name="message">A string value that should equate to the expected message.</param>
+        /// <example>
+        /// <code>
+        /// [Test]
+        /// public void LogAssertExample()
+        /// {
+        ///     // Expect a regular log message
+        ///     LogAssert.Expect(LogType.Log, "Log message");
+        /// 
+        ///     // The test fails without the following expected log message     
+        ///     Debug.Log("Log message");
+        /// 
+        ///     // An error log
+        ///     Debug.LogError("Error message");
+        /// 
+        ///     // Without expecting an error log, the test would fail
+        ///     LogAssert.Expect(LogType.Error, "Error message");
+        /// }
+        /// 
+        /// </code>
+        /// </example>
+        public static void Expect(LogType type, string message)
+        {
+            LogScope.Current.ExpectedLogs.Enqueue(new LogMatch() { LogType = type, Message = message });
+        }
+        /// <summary>
+        /// Verifies that a log message of a specified type appears in the log. A test won't fail from an expected error, assertion, or exception log message. It does fail if an expected message does not appear in the log.
+        /// </summary>
+        /// <param name="type">A type of log to expect. It can take one of the [LogType enum](https://docs.unity3d.com/ScriptReference/LogType.html) values.</param>
+        /// <param name="message">A regular expression pattern to match the expected message.</param>
+        public static void Expect(LogType type, Regex message)
+        {
+            LogScope.Current.ExpectedLogs.Enqueue(new LogMatch() { LogType = type, MessageRegex = message });
+        }
+        /// <summary>
+        /// Triggers an assertion when receiving any log messages and fails the test if some are unexpected messages. If multiple tests need to check for no received unexpected logs, consider using the <see cref="TestMustExpectAllLogsAttribute"/> attribute instead.
+        /// </summary>
+        public static void NoUnexpectedReceived()
+        {
+            LogScope.Current.NoUnexpectedReceived();
+        }
+        /// <summary>Set this property to `true` to prevent unexpected error log messages from triggering an assertion. By default, it is `false`.</summary>
+        /// <returns>The value of the ignoreFailingMessages boolean property.</returns>
+        public static bool ignoreFailingMessages
+        {
+            get
+            {
+                return LogScope.Current.IgnoreFailingMessages;
+            }
+            set
+            {
+                if (value != LogScope.Current.IgnoreFailingMessages)
+                {
+                    Debug.LogFormat(LogType.Log, LogOption.NoStacktrace, null, "\nIgnoreFailingMessages:" + (value? "true":"false"));
+                }
+                LogScope.Current.IgnoreFailingMessages = value;
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b1d8465ba1376b148bdab58965101f47
+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/Assertions/UnexpectedLogMessageException.cs

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3e8d6af343b383544ba5743d119f4062
+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/ActionDelegator.cs

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

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

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

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

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0cb14878543cf3d4f8472b15f7ecf0e3
+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.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1ddb9e1c877ea80479d1eab4ddaa5d0d
+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/UnityEngine.TestRunner.asmdef

@@ -0,0 +1,13 @@
+{
+    "name": "UnityEngine.TestRunner",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": []
+}

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

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 27619889b8ba8c24980f49ee34dbb44a
+AssemblyDefinitionImporter:
+  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.meta

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