AblativeAbsolute/rimworld-animation-studio
1
0
Fork 0
mirror of https://gitgud.io/AbstractConcept/rimworld-animation-studio.git synced 2024-08-15 00:43:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Initial commit

Browse source
This commit is contained in:
AbstractConcept 2022-09-13 00:36:34 -05:00
commit 3c7cc0c973
8391 changed files with 704313 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

186
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/EditModeRunnerCallback.cs Normal file
View file

@ -0,0 +1,186 @@
using System;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using NUnit.Framework.Interfaces;
using NUnit.Framework.Internal;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.TestTools.TestRunner;
namespace UnityEditor.TestTools.TestRunner
{
internal class EditModeRunnerCallback : ScriptableObject, ITestRunnerListener
{
private EditModeLauncherContextSettings m_Settings;
public SceneSetup[] previousSceneSetup;
public EditModeRunner runner;
private bool m_Canceled;
private ITest m_CurrentTest;
private int m_TotalTests;
[SerializeField]
private List<string> m_PendingTests;
[SerializeField]
private string m_LastCountedTestName;
[SerializeField]
private bool m_RunRestarted;
public void OnDestroy()
{
CleanUp();
}
public void RunStarted(ITest testsToRun)
{
Setup();
if (m_PendingTests == null)
{
m_PendingTests = GetTestsExpectedToRun(testsToRun, runner.GetFilter());
m_TotalTests = m_PendingTests.Count;
}
}
public void OnEnable()
{
if (m_RunRestarted)
{
Setup();
}
}
private void Setup()
{
m_Settings = new EditModeLauncherContextSettings();
Application.logMessageReceivedThreaded += LogReceived;
EditorApplication.playModeStateChanged += WaitForExitPlaymode;
EditorApplication.update += DisplayProgressBar;
AssemblyReloadEvents.beforeAssemblyReload += BeforeAssemblyReload;
}
private void BeforeAssemblyReload()
{
if (m_CurrentTest != null)
{
m_LastCountedTestName = m_CurrentTest.FullName;
m_RunRestarted = true;
}
}
private void DisplayProgressBar()
{
if (m_CurrentTest == null)
return;
if (!m_Canceled && EditorUtility.DisplayCancelableProgressBar("Test Runner", "Running test " + m_CurrentTest.Name, Math.Min(1.0f, (float)(m_TotalTests - m_PendingTests.Count) / m_TotalTests)))
{
EditorApplication.update -= DisplayProgressBar;
m_Canceled = true;
EditorUtility.ClearProgressBar();
runner.OnRunCancel();
}
}
private static void LogReceived(string message, string stacktrace, LogType type)
{
if (TestContext.Out != null)
TestContext.Out.WriteLine(message);
}
private static void WaitForExitPlaymode(PlayModeStateChange state)
{
if (state == PlayModeStateChange.EnteredEditMode)
{
EditorApplication.playModeStateChanged -= WaitForExitPlaymode;
//because logMessage is reset on Enter EditMode
//we remove and add the callback
//because Unity
Application.logMessageReceivedThreaded -= LogReceived;
Application.logMessageReceivedThreaded += LogReceived;
}
}
public void RunFinished(ITestResult result)
{
if (previousSceneSetup != null && previousSceneSetup.Length > 0)
{
try
{
EditorSceneManager.RestoreSceneManagerSetup(previousSceneSetup);
}
catch (ArgumentException e)
{
Debug.LogWarning(e.Message);
}
}
else
{
foreach (var obj in FindObjectsOfType<GameObject>())
{
if (obj != null && obj.transform.parent != null && (obj.transform.parent.hideFlags & HideFlags.DontSaveInEditor) == HideFlags.DontSaveInEditor && obj.transform.parent.gameObject != null)
{
DestroyImmediate(obj.transform.parent.gameObject);
}
}
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
}
CleanUp();
}
private void CleanUp()
{
m_CurrentTest = null;
EditorUtility.ClearProgressBar();
if (m_Settings != null)
{
m_Settings.Dispose();
}
Application.logMessageReceivedThreaded -= LogReceived;
EditorApplication.update -= DisplayProgressBar;
}
public void TestStarted(ITest test)
{
if (test.IsSuite || !(test is TestMethod))
{
return;
}
m_CurrentTest = test;
if (m_RunRestarted)
{
if (test.FullName == m_LastCountedTestName)
m_RunRestarted = false;
}
}
public void TestFinished(ITestResult result)
{
if (result.Test is TestMethod)
{
m_PendingTests.Remove(result.Test.FullName);
}
}
private static List<string> GetTestsExpectedToRun(ITest test, ITestFilter filter)
{
var expectedTests = new List<string>();
if (filter.Pass(test))
{
if (test.IsSuite)
{
expectedTests.AddRange(test.Tests.SelectMany(subTest => GetTestsExpectedToRun(subTest, filter)));
}
else
{
expectedTests.Add(test.FullName);
}
}
return expectedTests;
}
}
}

11
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/EditModeRunnerCallback.cs.meta Normal file
View file

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

86
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/RerunCallback.cs Normal file
View file

@ -0,0 +1,86 @@
using UnityEditor.TestTools.TestRunner.Api;
using UnityEditor.TestTools.TestRunner.CommandLineTest;
using UnityEditor.TestTools.TestRunner.GUI;
using UnityEngine;
namespace UnityEditor.TestTools.TestRunner
{
internal class RerunCallback : ScriptableObject, ICallbacks
{
public static bool useMockRunFilter = false;
public static UITestRunnerFilter mockRunFilter = null;
public void RunFinished(ITestResultAdaptor result)
{
if (RerunCallbackData.instance.runFilters == null || RerunCallbackData.instance.runFilters.Length == 0)
RerunCallbackData.instance.runFilters = new[] {new UITestRunnerFilter()};
var runFilter = RerunCallbackData.instance.runFilters[0];
if (useMockRunFilter)
{
runFilter = mockRunFilter;
}
runFilter.testRepetitions--;
if (runFilter.testRepetitions <= 0 || result.TestStatus != TestStatus.Passed)
{
ExitCallbacks.preventExit = false;
return;
}
ExitCallbacks.preventExit = true;
if (EditorApplication.isPlaying)
{
EditorApplication.playModeStateChanged += WaitForExitPlaymode;
return;
}
if (!useMockRunFilter)
{
ExecuteTestRunnerAPI();
}
}
private static void WaitForExitPlaymode(PlayModeStateChange state)
{
if (state == PlayModeStateChange.EnteredEditMode)
{
ExecuteTestRunnerAPI();
}
}
private static void ExecuteTestRunnerAPI()
{
var runFilter = RerunCallbackData.instance.runFilters[0];
var testMode = RerunCallbackData.instance.testMode;
var testRunnerApi = ScriptableObject.CreateInstance<TestRunnerApi>();
testRunnerApi.Execute(new Api.ExecutionSettings()
{
filters = new[]
{
new Filter()
{
categoryNames = runFilter.categoryNames,
groupNames = runFilter.groupNames,
testMode = testMode,
testNames = runFilter.testNames
}
}
});
}
public void TestStarted(ITestAdaptor test)
{
}
public void TestFinished(ITestResultAdaptor result)
{
}
public void RunStarted(ITestAdaptor testsToRun)
{
}
}
}

11
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/RerunCallback.cs.meta Normal file
View file

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

15
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/RerunCallbackData.cs Normal file
View file

@ -0,0 +1,15 @@
using UnityEditor.TestTools.TestRunner.Api;
using UnityEditor.TestTools.TestRunner.GUI;
using UnityEngine;
namespace UnityEditor.TestTools.TestRunner
{
internal class RerunCallbackData : ScriptableSingleton<RerunCallbackData>
{
[SerializeField]
internal UITestRunnerFilter[] runFilters;
[SerializeField]
internal TestMode testMode;
}
}

11
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/RerunCallbackData.cs.meta Normal file
View file

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

17
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/RerunCallbackInitializer.cs Normal file
View file

@ -0,0 +1,17 @@
using UnityEngine;
using UnityEditor.TestTools.TestRunner.Api;
namespace UnityEditor.TestTools.TestRunner
{
[InitializeOnLoad]
static class RerunCallbackInitializer
{
static RerunCallbackInitializer()
{
var testRunnerApi = ScriptableObject.CreateInstance<TestRunnerApi>();
var rerunCallback = ScriptableObject.CreateInstance<RerunCallback>();
testRunnerApi.RegisterCallbacks<RerunCallback>(rerunCallback);
}
}
}

11
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/RerunCallbackInitializer.cs.meta Normal file
View file

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

37
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/TestRunnerCallback.cs Normal file
View file

@ -0,0 +1,37 @@
using NUnit.Framework.Interfaces;
using UnityEngine;
using UnityEngine.TestTools.TestRunner;
namespace UnityEditor.TestTools.TestRunner
{
internal class TestRunnerCallback : ScriptableObject, ITestRunnerListener
{
public void RunStarted(ITest testsToRun)
{
EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
}
private void OnPlayModeStateChanged(PlayModeStateChange state)
{
if (state == PlayModeStateChange.ExitingPlayMode)
{
EditorApplication.playModeStateChanged -= OnPlayModeStateChanged;
//We need to make sure we don't block NUnit thread in case we exit PlayMode earlier
PlaymodeTestsController.TryCleanup();
}
}
public void RunFinished(ITestResult testResults)
{
EditorApplication.isPlaying = false;
}
public void TestStarted(ITest testName)
{
}
public void TestFinished(ITestResult test)
{
}
}
}

11
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/TestRunnerCallback.cs.meta Normal file
View file

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

59
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/WindowResultUpdater.cs Normal file
View file

@ -0,0 +1,59 @@
using System.Linq;
using TestRunner.Callbacks;
using UnityEditor.TestTools.TestRunner.Api;
namespace UnityEditor.TestTools.TestRunner.GUI
{
internal class WindowResultUpdater : ICallbacks, ITestTreeRebuildCallbacks
{
public WindowResultUpdater()
{
var cachedResults = WindowResultUpdaterDataHolder.instance.CachedResults;
var testList = TestRunnerWindow.s_Instance.m_SelectedTestTypes;
foreach (var result in cachedResults)
{
testList.UpdateResult(result);
}
cachedResults.Clear();
}
public void RunStarted(ITestAdaptor testsToRun)
{
}
public void RunFinished(ITestResultAdaptor testResults)
{
if (TestRunnerWindow.s_Instance != null)
{
TestRunnerWindow.s_Instance.RebuildUIFilter();
}
}
public void TestStarted(ITestAdaptor testName)
{
}
public void TestFinished(ITestResultAdaptor test)
{
var result = new TestRunnerResult(test);
if (TestRunnerWindow.s_Instance == null)
{
WindowResultUpdaterDataHolder.instance.CachedResults.Add(result);
return;
}
TestRunnerWindow.s_Instance.m_SelectedTestTypes.UpdateResult(result);
}
public void TestTreeRebuild(ITestAdaptor test)
{
if (TestRunnerWindow.s_Instance == null)
{
return;
}
TestRunnerWindow.s_Instance.m_SelectedTestTypes.UpdateTestTree(test);
}
}
}

11
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/WindowResultUpdater.cs.meta Normal file
View file

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

11
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/WindowResultUpdaterDataHolder.cs Normal file
View file

@ -0,0 +1,11 @@
using System.Collections.Generic;
using UnityEditor;
using UnityEditor.TestTools.TestRunner.GUI;
namespace TestRunner.Callbacks
{
internal class WindowResultUpdaterDataHolder : ScriptableSingleton<WindowResultUpdaterDataHolder>
{
public List<TestRunnerResult> CachedResults = new List<TestRunnerResult>();
}
}

11
Library/PackageCache/com.unity.test-framework@1.1.22/UnityEditor.TestRunner/TestRunner/Callbacks/WindowResultUpdaterDataHolder.cs.meta Normal file
View file

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