private static void RunEditorTests(string resultFilePath, string verboseLog, string[] nameFilter, string[] categoryFilter)
{
object[] args = new object[] { string.Join(", ", nameFilter), string.Join(", ", categoryFilter) };
Debug.LogFormat("Running editor tests...\nName filter: {0}\nCategory filter: {1}", args);
TestRunnerFilter filter = new TestRunnerFilter {
names = nameFilter,
categories = categoryFilter
};
if (string.IsNullOrEmpty(resultFilePath))
{
resultFilePath = Path.Combine(Directory.GetCurrentDirectory(), "EditorTestResults.xml");
}
else if (Directory.Exists(resultFilePath))
{
resultFilePath = Path.Combine(resultFilePath, "EditorTestResults.xml");
}
if (!Directory.Exists(Path.GetDirectoryName(resultFilePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(resultFilePath));
}
EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
NUnitTestEngine engine = new NUnitTestEngine();
new TestListBuilder().GetTests(engine.testSuite, null);
engine.RunTests(filter, new TestRunnerEventListener(resultFilePath, GetVerboseTestLogger(verboseLog)));
}
private static void RunEditorTests(string resultFilePath, string verboseLog, string[] nameFilter, string[] categoryFilter)
{
object[] args = new object[] { string.Join(", ", nameFilter), string.Join(", ", categoryFilter) };
Debug.LogFormat("Running editor tests...\nName filter: {0}\nCategory filter: {1}", args);
TestRunnerFilter filter = new TestRunnerFilter {
names = nameFilter,
categories = categoryFilter
};
if (string.IsNullOrEmpty(resultFilePath))
{
resultFilePath = Path.Combine(Directory.GetCurrentDirectory(), "EditorTestResults.xml");
}
else if (Directory.Exists(resultFilePath))
{
resultFilePath = Path.Combine(resultFilePath, "EditorTestResults.xml");
}
if (!Directory.Exists(Path.GetDirectoryName(resultFilePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(resultFilePath));
}
EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
NUnitTestEngine engine = new NUnitTestEngine();
new TestListBuilder().GetTests(engine.testSuite, null);
engine.RunTests(filter, new TestRunnerEventListener(resultFilePath, GetVerboseTestLogger(verboseLog)));
}
public virtual void PrintHeadPanel()
{
EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
using (new EditorGUI.DisabledScope(IsBusy()))
{
if (GUILayout.Button(s_GUIRunAllTests, EditorStyles.toolbarButton))
{
var filter = new TestRunnerFilter {
categoryNames = m_TestRunnerUIFilter.CategoryFilter
};
RunTests(filter);
GUIUtility.ExitGUI();
}
}
using (new EditorGUI.DisabledScope(m_TestListTree == null || !m_TestListTree.HasSelection() || IsBusy()))
{
if (GUILayout.Button(s_GUIRunSelectedTests, EditorStyles.toolbarButton))
{
RunTests(GetSelectedTestsAsFilter(m_TestListTree.GetSelection()));
GUIUtility.ExitGUI();
}
}
using (new EditorGUI.DisabledScope(m_TestRunnerUIFilter.FailedCount == 0 || IsBusy()))
{
if (GUILayout.Button(s_GUIRerunFailedTests, EditorStyles.toolbarButton))
{
var failedTestnames = new List <string>();
foreach (var result in newResultList)
{
if (result.isSuite)
{
continue;
}
if (result.resultStatus == TestRunnerResult.ResultStatus.Failed ||
result.resultStatus == TestRunnerResult.ResultStatus.Inconclusive)
{
failedTestnames.Add(result.fullName);
}
}
RunTests(new TestRunnerFilter()
{
testNames = failedTestnames.ToArray(), categoryNames = m_TestRunnerUIFilter.CategoryFilter
});
GUIUtility.ExitGUI();
}
}
using (new EditorGUI.DisabledScope(IsBusy()))
{
if (GUILayout.Button(s_GUIClearResults, EditorStyles.toolbarButton))
{
foreach (var result in newResultList)
{
result.Clear();
}
GUIUtility.ExitGUI();
}
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
}
protected override void RunTests(TestRunnerFilter filter)
{
// Give user chance to save the changes to their currently open scene because we close it and load our own
var cancelled = !EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo();
if (cancelled)
{
return;
}
filter.ClearResults(newResultList.OfType <TestRunnerFilter.IClearableResult>().ToList());
RerunCallbackData.instance.runFilter = filter;
RerunCallbackData.instance.testMode = TestMode.PlayMode;
var testRunnerApi = ScriptableObject.CreateInstance <TestRunnerApi>();
testRunnerApi.Execute(new ExecutionSettings()
{
filter = new Filter()
{
categoryNames = filter.categoryNames,
groupNames = filter.groupNames,
testMode = TestMode,
testNames = filter.testNames
}
});
}
protected override void RunTests(TestRunnerFilter filter)
{
if (EditorUtility.scriptCompilationFailed)
{
Debug.LogError("Fix compilation issues before running tests");
return;
}
filter.ClearResults(newResultList.OfType <TestRunnerFilter.IClearableResult>().ToList());
RerunCallbackData.instance.runFilter = filter;
RerunCallbackData.instance.testMode = TestMode.EditMode;
var testRunnerApi = ScriptableObject.CreateInstance <TestRunnerApi>();
testRunnerApi.Execute(new ExecutionSettings()
{
filter = new Filter()
{
categoryNames = filter.categoryNames,
groupNames = filter.groupNames,
testMode = TestMode,
testNames = filter.testNames
}
});
}
protected void RunTestsInPlayer(TestRunnerFilter filter)
{
var settings = PlaymodeTestsControllerSettings.CreateRunnerSettings(filter);
var testExecutor = new PlayerLauncher(settings, null, null);
testExecutor.Run();
GUIUtility.ExitGUI();
}
public void Init(TestRunnerFilter filter, TestPlatform platform)
{
m_Filter = filter;
m_TestPlatform = platform;
m_AlreadyStartedTests = new List <string>();
m_ExecutedTests = new List <TestResultSerializer>();
InitRunner();
}
// provided for backward compatibility with Rider UnitTesting prior to Rider package v.1.1.1
public EditModeLauncher(TestRunnerFilter filter, TestPlatform platform) : this(new[]
{
new Filter()
{
testNames = filter.testNames,
categoryNames = filter.categoryNames,
groupNames = filter.groupNames,
assemblyNames = filter.assemblyNames
}
}, platform)
{
}
public static PlaymodeTestsControllerSettings CreateRunnerSettings(TestRunnerFilter filter)
{
var settings = new PlaymodeTestsControllerSettings
{
filter = filter,
sceneBased = false,
originalScene = SceneManager.GetActiveScene().path,
bootstrapScene = null
};
return(settings);
}
protected override void RunTests(TestRunnerFilter filter)
{
foreach (TestResult result in base.newResultList)
{
if (filter.Matches(result))
{
result.resultType = TestResult.ResultType.NotRun;
}
}
EditModeLauncher launcher = new EditModeLauncher(filter);
launcher.AddEventHandler <WindowResultUpdater>();
launcher.Run();
}
private TestRunnerFilter GetSelectedTestsAsFilter(IEnumerable <int> selectedIDs)
{
var namesToRun = new List <string>();
var exactNamesToRun = new List <string>();
var assembliesToRun = new List <string>();
foreach (var lineId in selectedIDs)
{
var line = m_TestListTree.FindItem(lineId);
if (line is TestTreeViewItem)
{
var testLine = line as TestTreeViewItem;
if (testLine.IsGroupNode && !testLine.FullName.Contains("+"))
{
if (testLine.parent != null && testLine.parent.displayName == "Invisible Root Item")
{
//Root node selected. Use an empty TestRunnerFilter to run every test
namesToRun.Clear();
exactNamesToRun.Clear();
assembliesToRun.Clear();
break;
}
if (testLine.FullName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
{
assembliesToRun.Add(TestRunnerFilter.AssemblyNameFromPath(testLine.FullName));
}
else
{
namesToRun.Add(string.Format("^{0}$", testLine.FullName));
}
}
else
{
exactNamesToRun.Add(testLine.FullName);
}
}
}
var filter = new TestRunnerFilter
{
assemblyNames = assembliesToRun.ToArray(),
groupNames = namesToRun.ToArray(),
testNames = exactNamesToRun.ToArray(),
categoryNames = m_TestRunnerUIFilter.CategoryFilter
};
return(filter);
}
/// <summary>
/// <para>Execute editor tests run.</para>
/// </summary>
/// <param name="testRunnerCallback">Test runner callback.</param>
/// <param name="nameFilter">Test names to run.</param>
/// <param name="categoryFilter">Categories to run.</param>
public static void RunTests(ITestRunnerCallback testRunnerCallback, string[] nameFilter, string[] categoryFilter)
{
TestRunnerFilter filter = new TestRunnerFilter {
names = nameFilter,
categories = categoryFilter
};
NUnitTestEngine engine = new NUnitTestEngine();
if (engine.testSuite == null)
{
Debug.Log("No tests were found. Compilation error?");
EditorApplication.Exit(3);
}
new TestListBuilder().GetTests(engine.testSuite, null);
engine.RunTests(filter, testRunnerCallback);
}
protected override void RunTests(TestRunnerFilter filter)
{
foreach (TestResult result in base.newResultList)
{
if (filter.Matches(result))
{
result.resultType = TestResult.ResultType.NotRun;
}
}
PlaymodeTestsControllerSettings settings = PlaymodeTestsControllerSettings.CreateRunnerSettings(filter);
settings.bootstrapScene = SceneManager.GetActiveScene().path;
settings.originalScene = SceneManager.GetActiveScene().path;
new PlaymodeLauncher(settings).Run();
GUIUtility.ExitGUI();
}
// provided for backward compatibility with Rider UnitTesting prior to Rider package v.1.1.1
public EditModeLauncher(TestRunnerFilter filter, TestPlatform platform)
{
var apiFilter = new[]
{
new Filter()
{
testMode = TestMode.EditMode,
testNames = filter.testNames,
categoryNames = filter.categoryNames,
groupNames = filter.groupNames,
assemblyNames = filter.assemblyNames
}
};
ScriptableObject.CreateInstance <TestRunnerApi>().Execute(new ExecutionSettings(apiFilter));
}
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);
}
}
}
protected virtual void TestDoubleClickCallback(int id)
{
TreeViewItem item = this.m_TestListTree.FindItem(id);
if (item is TestLineTreeViewItem)
{
TestLineTreeViewItem item2 = item as TestLineTreeViewItem;
Event current = Event.current;
if (current.control || current.command)
{
GuiHelper.OpenInEditor(item2.type, item2.method);
return;
}
TestRunnerFilter filter = new TestRunnerFilter(item2.fullName);
this.RunTests(filter);
}
GUIUtility.ExitGUI();
}
private TestRunnerFilter[] GetSelectedTestsAsFilter(IEnumerable <int> selectedIDs)
{
var namesToRun = new List <string>();
var exactNamesToRun = new List <string>();
var assembliesToRun = new List <string>();
foreach (var lineId in selectedIDs)
{
var line = m_TestListTree.FindItem(lineId);
if (line is TestTreeViewItem)
{
var testLine = line as TestTreeViewItem;
if (testLine.IsGroupNode && !testLine.FullName.Contains("+"))
{
if (testLine.parent != null && testLine.parent.displayName == "Invisible Root Item")
{
//Root node selected. Use an empty TestRunnerFilter to run every test
return(new[] { new TestRunnerFilter() });
}
if (testLine.FullName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
{
assembliesToRun.Add(TestRunnerFilter.AssemblyNameFromPath(testLine.FullName));
}
else
{
namesToRun.Add(string.Format("^{0}$", Regex.Escape(testLine.FullName)));
}
}
else
{
exactNamesToRun.Add(testLine.FullName);
}
}
}
var filters = new List <TestRunnerFilter>();
if (assembliesToRun.Count > 0)
{
filters.Add(new TestRunnerFilter()
{
assemblyNames = assembliesToRun.ToArray()
});
}
if (namesToRun.Count > 0)
{
filters.Add(new TestRunnerFilter()
{
groupNames = namesToRun.ToArray()
});
}
if (exactNamesToRun.Count > 0)
{
filters.Add(new TestRunnerFilter()
{
testNames = exactNamesToRun.ToArray()
});
}
if (filters.Count == 0)
{
filters.Add(new TestRunnerFilter());
}
var categories = m_TestRunnerUIFilter.CategoryFilter.ToArray();
if (categories.Length > 0)
{
foreach (var filter in filters)
{
filter.categoryNames = categories;
}
}
return(filters.ToArray());
}
public EditModeLauncher(TestRunnerFilter filter)
{
this.m_Filter = filter;
}
private static IEnumerable <MethodInfo> GetSceneSetupMethods(TestRunnerFilter filter)
{
public EditModeLauncher(TestRunnerFilter filter, TestPlatform platform)
{
m_EditModeRunner = ScriptableObject.CreateInstance <EditModeRunner>();
m_EditModeRunner.UnityTestAssemblyRunnerFactory = new UnityTestAssemblyRunnerFactory();
m_EditModeRunner.Init(filter, platform);
}
protected void RunTestsInPlayer(TestRunnerFilter filter)
{
new PlayerLauncher(PlaymodeTestsControllerSettings.CreateRunnerSettings(filter)).Run();
GUIUtility.ExitGUI();
}
/// <summary>
/// <para>Execute editor tests run.</para>
/// </summary>
/// <param name="testRunnerCallback">Test runner callback.</param>
/// <param name="nameFilter">Test names to run.</param>
/// <param name="categoryFilter">Categories to run.</param>
public static void RunTests(ITestRunnerCallback testRunnerCallback, string[] nameFilter, string[] categoryFilter)
{
TestRunnerFilter filter = new TestRunnerFilter {
names = nameFilter,
categories = categoryFilter
};
NUnitTestEngine engine = new NUnitTestEngine();
if (engine.testSuite == null)
{
Debug.Log("No tests were found. Compilation error?");
EditorApplication.Exit(3);
}
new TestListBuilder().GetTests(engine.testSuite, null);
engine.RunTests(filter, testRunnerCallback);
}
protected virtual void RunTests(TestRunnerFilter filter)
{
throw new NotImplementedException();
}
