public override void FetchData()
{
var sceneName = SceneManager.GetActiveScene().name;
if (sceneName.StartsWith("InitTestScene"))
{
sceneName = PlaymodeTestsController.GetController().settings.originalScene;
}
var testListBuilder = new TestTreeViewBuilder(m_RootTest, m_TestListGUI.newResultList, m_TestListGUI.m_TestRunnerUIFilter);
m_RootItem = testListBuilder.BuildTreeView(null, false, sceneName);
SetExpanded(m_RootItem, true);
if (m_RootItem.hasChildren && m_RootItem.children.Count == 1)
{
SetExpanded(m_RootItem.children[0], true);
}
if (m_ExpandTreeOnCreation)
{
SetExpandedWithChildren(m_RootItem, true);
}
m_TestListGUI.newResultList = new List <TestRunnerResult>(testListBuilder.results);
m_TestListGUI.m_TestRunnerUIFilter.availableCategories = testListBuilder.AvailableCategories;
m_NeedRefreshRows = true;
}
internal static T AddEventHandlerMonoBehaviour <T>(this PlaymodeTestsController controller) where T : MonoBehaviour, ITestRunnerListener
{
var eventHandler = controller.gameObject.AddComponent <T>();
SetListeners(controller, eventHandler);
return(eventHandler);
}
private static void SetListeners(PlaymodeTestsController controller, ITestRunnerListener eventHandler)
{
UnityEventTools.AddPersistentListener(controller.testStartedEvent, eventHandler.TestStarted);
UnityEventTools.AddPersistentListener(controller.testFinishedEvent, eventHandler.TestFinished);
UnityEventTools.AddPersistentListener(controller.runStartedEvent, eventHandler.RunStarted);
UnityEventTools.AddPersistentListener(controller.runFinishedEvent, eventHandler.RunFinished);
}
internal static T AddEventHandlerScriptableObject <T>(this PlaymodeTestsController controller) where T : ScriptableObject, ITestRunnerListener
{
var eventListener = ScriptableObject.CreateInstance <T>();
AddEventHandlerScriptableObject(controller, eventListener);
return(eventListener);
}
private static void OnPlayModeStateChanged(PlayModeStateChange state)
{
if (!PlaymodeTestsController.IsControllerOnScene())
{
return;
}
var runner = PlaymodeTestsController.GetController();
if (runner == null)
{
return;
}
if (state == PlayModeStateChange.ExitingPlayMode)
{
AssetDatabase.DeleteAsset(runner.settings.bootstrapScene);
ExecutePostBuildCleanupMethods(runner.m_Runner.LoadedTest, runner.settings.BuildNUnitFilter(), Application.platform);
IsRunning = false;
}
else if (state == PlayModeStateChange.EnteredEditMode)
{
ConsoleWindow.SetConsoleErrorPause(runner.settings.consoleErrorPaused);
Application.runInBackground = runner.settings.runInBackgroundValue;
//reopen the original scene once we exit playmode
ReopenOriginalScene(runner);
}
}
public void UpdateCallback()
{
if (m_IsTestSetupPerformed)
{
if (m_Scene.IsValid())
{
SceneManager.SetActiveScene(m_Scene);
}
EditorApplication.update -= UpdateCallback;
EditorApplication.isPlaying = true;
}
else
{
testFilter = m_Settings.BuildNUnitFilter();
var runner = LoadTests(testFilter);
var exceptionThrown = ExecutePreBuildSetupMethods(runner.LoadedTest, testFilter);
if (exceptionThrown)
{
EditorApplication.update -= UpdateCallback;
IsRunning = false;
var controller = PlaymodeTestsController.GetController();
ReopenOriginalScene(controller);
AssetDatabase.DeleteAsset(controller.settings.bootstrapScene);
CallbacksDelegator.instance.RunFailed("Run Failed: One or more errors in a prebuild setup. See the editor log for details.");
return;
}
m_IsTestSetupPerformed = true;
}
}
private static void SetListeners <T>(PlaymodeTestsController controller, TestRunnerListener eventHandler)
{
UnityEventTools.AddPersistentListener <string>(controller.testStartedEvent, new UnityAction <string>(eventHandler.TestStarted));
UnityEventTools.AddPersistentListener <TestResult>(controller.testFinishedEvent, new UnityAction <TestResult>(eventHandler.TestFinished));
UnityEventTools.AddPersistentListener <string, List <string> >(controller.runStartedEvent, new UnityAction <string, List <string> >(eventHandler.RunStarted));
UnityEventTools.AddPersistentListener <List <TestResult> >(controller.runFinishedEvent, new UnityAction <List <TestResult> >(eventHandler.RunFinished));
}
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 override void RunFinished(List <TestResult> testResults)
{
if (string.IsNullOrEmpty(base.resultDirectory))
{
base.resultDirectory = PlaymodeTestsController.GetController().settings.resultFilePath;
}
if (string.IsNullOrEmpty(base.resultFileName))
{
base.resultFileName = "TestResults-PlayMode";
}
base.RunFinished(testResults);
}
protected void ExecuteSceneSetupMethods(TestRunnerFilter testRunnerFilter)
{
PlaymodeTestsController controller = PlaymodeTestsController.GetController();
foreach (MethodInfo info in GetSceneSetupMethods(controller.settings.filter))
{
Debug.Log("Executing setup in " + info.DeclaringType.Name);
try
{
info.Invoke(null, null);
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
}
internal static T AddEventHandlerScriptableObject <T>(this PlaymodeTestsController controller) where T : ScriptableObject, TestRunnerListener
{
T local = ScriptableObject.CreateInstance <T>();
T local1 = local;
UnityEventTools.AddPersistentListener <string>(controller.testStartedEvent, new UnityAction <string>(local1.TestStarted));
T local3 = local;
UnityEventTools.AddPersistentListener <TestResult>(controller.testFinishedEvent, new UnityAction <TestResult>(local3.TestFinished));
T local4 = local;
UnityEventTools.AddPersistentListener <string, List <string> >(controller.runStartedEvent, new UnityAction <string, List <string> >(local4.RunStarted));
T local5 = local;
UnityEventTools.AddPersistentListener <List <TestResult> >(controller.runFinishedEvent, new UnityAction <List <TestResult> >(local5.RunFinished));
return(local);
}
public override void FetchData()
{
string name = SceneManager.GetActiveScene().name;
if (name.StartsWith("InitTestScene"))
{
name = PlaymodeTestsController.GetController().settings.originalScene;
}
TestTreeViewBuilder builder = new TestTreeViewBuilder(this.m_TestListGUI.GetTestList(), this.m_TestListGUI.newResultList);
base.m_RootItem = builder.BuildTreeView(null, false, name);
this.SetExpanded(base.m_RootItem, true);
if (this.m_ExpandTreeOnCreation)
{
this.SetExpandedWithChildren(base.m_RootItem, true);
}
this.m_TestListGUI.newResultList = new List <TestResult>(builder.results);
base.m_NeedRefreshRows = true;
}
internal static void AddEventHandlerScriptableObject(this PlaymodeTestsController controller, ITestRunnerListener obj)
{
SetListeners(controller, obj);
}
protected static void ReopenOriginalScene(PlaymodeTestsController runner)
{
ReopenOriginalScene(runner.settings.originalScene);
}
public static void Fail()
{
PlaymodeTestsController.GetController().FailPlaymodeTest();
}
public static void Pass()
{
PlaymodeTestsController.GetController().PassPlaymodeTest();
}
