public IEnumerable<TestNodeNamespace> CreateMutantTestTree(List<TmpTestNodeMethod> nodeMethods) { var list = nodeMethods.GroupBy(n => ExtractTypeName(n.Name)).ToList(); TestsRootNode root = new TestsRootNode(); var u = new Utilss(); u.GroupTypes<IGrouping<string, TmpTestNodeMethod>, TestTreeNode>( root, n => ExtractTypeName(n.Key), (parent, name) => new TestNodeNamespace(parent, name), (parent, collection) => { foreach (var grouping in collection) { var testNodeClass = new TestNodeClass(ExtractName(grouping.Key)); testNodeClass.Parent = parent; parent.Children.Add(testNodeClass); foreach (var tmpMethod in grouping) { var testNodeMethod = new TestNodeMethod(testNodeClass, ExtractName(tmpMethod.Name)); testNodeMethod.State = tmpMethod.State; testNodeMethod.Message = tmpMethod.Message; testNodeClass.Children.Add(testNodeMethod); } } }, list); return root.Children.Cast<TestNodeNamespace>(); }
public IEnumerable <TestNodeNamespace> CreateMutantTestTree(List <TmpTestNodeMethod> nodeMethods) { var list = nodeMethods.GroupBy(n => ExtractTypeName(n.Name)).ToList(); TestsRootNode root = new TestsRootNode(); var u = new Utilss(); u.GroupTypes <IGrouping <string, TmpTestNodeMethod>, TestTreeNode>( root, n => ExtractTypeName(n.Key), (parent, name) => new TestNodeNamespace(parent, name), (parent, collection) => { foreach (var grouping in collection) { var testNodeClass = new TestNodeClass(ExtractName(grouping.Key)); testNodeClass.Parent = parent; parent.Children.Add(testNodeClass); foreach (var tmpMethod in grouping) { var testNodeMethod = new TestNodeMethod(testNodeClass, ExtractName(tmpMethod.Name)); testNodeMethod.State = tmpMethod.State; testNodeMethod.Message = tmpMethod.Message; testNodeClass.Children.Add(testNodeMethod); } } }, list); return(root.Children.Cast <TestNodeNamespace>()); }
public async Task<TestsRootNode> LoadTests(IList<string> assembliesPaths) { _log.Info("Loading tests from: "+string.Join(",", assembliesPaths)); var tasks = new Dictionary<string, Task<May<TestNodeAssembly>>>(); var testsRootNode = new TestsRootNode(); foreach (var path in assembliesPaths) { string path1 = path; string assemblyName = Path.GetFileNameWithoutExtension(path); var testNodeAssembly = new TestNodeAssembly(testsRootNode, assemblyName); testNodeAssembly.AssemblyPath = path; var task = LoadFor(path1, testNodeAssembly); tasks.Add(path, task); } var assemblies = await Task.WhenAll(tasks.Values); testsRootNode.Children.AddRange(assemblies.WhereHasValue()); testsRootNode.State = TestNodeState.Inactive; testsRootNode.IsIncluded = true; return testsRootNode; }
public async Task <TestsRootNode> LoadTests(IList <string> assembliesPaths) { _log.Info("Loading tests from: " + string.Join(",", assembliesPaths)); var testsRootNode = new TestsRootNode(); await GetTestAssemblyNodes(assembliesPaths, testsRootNode); return(testsRootNode); }
private void SelectOnlyCoveredTests(TestsRootNode rootNode, List<MethodIdentifier> coveredTests) { rootNode.IsIncluded = false; var toSelect = rootNode.Children.SelectManyRecursive(n => n.Children, leafsOnly: true) .OfType<TestNodeMethod>() .Where(t => coveredTests.Contains(t.Identifier)); foreach (var testNodeMethod in toSelect) { testNodeMethod.IsIncluded = true; } }
private void SelectOnlyCoveredTests(TestsRootNode rootNode, List <MethodIdentifier> coveredTests) { rootNode.IsIncluded = false; var toSelect = rootNode.Children.SelectManyRecursive(n => n.Children, leafsOnly: true) .OfType <TestNodeMethod>() .Where(t => coveredTests.Contains(t.Identifier)); foreach (var testNodeMethod in toSelect) { testNodeMethod.IsIncluded = true; } }
private async Task LoadFor(IEnumerable <string> path1, TestsRootNode testsRootNode) { var contexts = await _testServiceManager.LoadTests(path1); foreach (var testContext in contexts.OrderBy(p => p.AssemblyName)) { var testNodeAssembly = new TestNodeAssembly(testsRootNode, testContext.AssemblyName); testNodeAssembly.TestsLoadContexts = new List <TestsLoadContext> { testContext }; var allClassNodes = testContext.ClassNodes; IEnumerable <TestNodeNamespace> testNamespaces = TestsLoadContext.GroupTestClasses(allClassNodes.ToList(), testNodeAssembly); testNodeAssembly.Children.AddRange(testNamespaces); testsRootNode.Children.Add(testNodeAssembly); } }
public async Task <TestsRootNode> LoadTests(IList <string> assembliesPaths) { _log.Info("Loading tests from: " + string.Join(",", assembliesPaths)); var tasks = new Dictionary <string, Task <May <TestNodeAssembly> > >(); var testsRootNode = new TestsRootNode(); foreach (var path in assembliesPaths) { string path1 = path; string assemblyName = Path.GetFileNameWithoutExtension(path); var testNodeAssembly = new TestNodeAssembly(testsRootNode, assemblyName); testNodeAssembly.AssemblyPath = path; var task = LoadFor(path1, testNodeAssembly); tasks.Add(path, task); } var assemblies = await Task.WhenAll(tasks.Values); testsRootNode.Children.AddRange(assemblies.WhereHasValue()); testsRootNode.State = TestNodeState.Inactive; testsRootNode.IsIncluded = true; return(testsRootNode); }
private async Task GetTestAssemblyNodes(IList <string> assembliesPaths, TestsRootNode testsRootNode) { await LoadFor(assembliesPaths, testsRootNode); }
private IEnumerator ProcessTestQueue() { Debug.LogFormat("[PlayModeTestRunner] ProcessTestQueueProcess: Mode {0}", RunTestsMode.Mode); ClassNode previousClassNode = null; ITestRunnerCallbackReceiver[] callbackables = TriggerBeforeTestRunEvent(Callbackables); List <MethodNode> methods = null; if (RunTestsMode.Mode == RunTestsMode.RunTestsModeEnum.DoubleClick) { if (!string.IsNullOrEmpty(RunTestsMode.NodeToRunFullName)) { var targetNodes = TestsRootNode.GetChildrenOfType <Node>(true, false, node => { return(node.FullName.Equals(RunTestsMode.NodeToRunFullName, StringComparison.Ordinal)); }); if (targetNodes.Count > 0) { var targetNode = targetNodes[0]; if (targetNode is MethodNode) { methods = new List <MethodNode> { (MethodNode)targetNode }; } else { methods = targetNode.GetChildrenOfType <MethodNode>(); } } } } if (methods == null || methods.Count == 0) { methods = TestsRootNode.GetChildrenOfType <MethodNode>(); } Debug.LogFormat("[PlayModeTestRunner] NonFilteredMethods: {0}", methods.Count); methods = methods.Where(methodNode => { Debug.LogFormat("method data: IsSmoke: {0} isSelected: {1}", methodNode.TestSettings.IsSmoke, methodNode.IsSelected); if (RunTestsMode.Mode == RunTestsMode.RunTestsModeEnum.Smoke && !methodNode.TestSettings.IsSmoke) { return(false); } if (RunTestsMode.Mode == RunTestsMode.RunTestsModeEnum.Selected && !methodNode.IsSelected) { return(false); } if (Namespaces != null && Namespaces.Length > 0) { var result = false; for (int i = 0; i < Namespaces.Length; i++) { var contains = methodNode.FullName.IndexOf(Namespaces[i], StringComparison.OrdinalIgnoreCase) != -1; result |= contains; } return(result); } return(true); }).ToList(); Debug.LogFormat("[PlayModeTestRunner] FilteredMethods: {0}", methods.Count); testInfoData.Total = methods.Count; for (int i = 0; i < methods.Count; i++) { var methodNode = methods[i]; TestStep.Reset(); ClassNode classNode = (ClassNode)methodNode.Parent; Debug.Log("QA: Process " + classNode.Type + " testClass.TestMethods #: " + classNode.Children.Count()); CurrentPlayingMethodNode.UpdateCurrentPlayingNode(methodNode); playModeLogger.Logs.Clear(); if (methodNode.TestSettings.IsIgnored) { ProcessIgnore(methodNode); continue; } for (int repeatTime = 0; repeatTime < RunTestsGivenAmountOfTimes; repeatTime++) { exceptionThrown = false; #if UNITY_EDITOR if (methodNode.TestSettings.EditorTargetResolution != null) { CustomResolution resolution = methodNode.TestSettings.EditorTargetResolution; if (resolution.Width != Screen.width || resolution.Height != Screen.height) { GameViewResizer.SetResolution(resolution.Width, resolution.Height); } } #endif if (!methodNode.TestSettings.ContainsTargetResolution(Screen.width, Screen.height)) { #if UNITY_EDITOR if (methodNode.TestSettings.EditorTargetResolution == null) { Debug.LogWarning(String.Format("PlayModeTestRunner: TARGET RESOLUTION {0}:{1}", methodNode.TestSettings.DefaultTargetResolution.Width, methodNode.TestSettings.DefaultTargetResolution.Height)); GameViewResizer.SetResolution(methodNode.TestSettings.DefaultTargetResolution.Width, methodNode.TestSettings.DefaultTargetResolution.Height); } #else ProcessIgnore(methodNode); continue; #endif } object testInstance = null; screenGUIDrawer.SetCurrentTest(methodNode.FullName); playModeLogger.StartLog(methodNode.FullName); try { testInstance = Activator.CreateInstance(classNode.Type); } catch (Exception ex) { if (classNode.Type == null) { Debug.LogErrorFormat("Can't instantiate class - class type is null." + " class probably was deleted "); } else { Debug.LogErrorFormat("Can't instantiate class \"{0}\". Exception: \"{1}\"", classNode.Type.FullName, ex.Message); } ProcessTestFail(methodNode); continue; } Time.timeScale = DefaultTimescale; Debug.Log("QA: Running testClass: " + classNode.Type); if (classNode != previousClassNode) { previousClassNode = classNode; yield return(RunMethods(classNode.OneTimeSetUpMethods, testInstance, true)); if (exceptionThrown) { Debug.LogError("Fail during executing set up methods."); ProcessTestFail(methodNode); continue; } } yield return(RunMethods(classNode.SetUpMethods, testInstance, true)); if (exceptionThrown) { Debug.LogError("Fail during executing set up methods."); ProcessTestFail(methodNode); continue; } yield return(InvokeTestMethod(testInstance, methodNode)); var exceptionDuringTestMethod = exceptionThrown; exceptionThrown = false; yield return(RunMethods(classNode.TearDownMethods, testInstance, false)); if (i + 1 == methods.Count || methods[i + 1].Parent != classNode) { yield return(RunMethods(classNode.OneTimeTearDownMethods, testInstance, true)); } if (!exceptionDuringTestMethod && exceptionThrown) { Debug.LogError("Fail during executing tear down methods."); ProcessTestFail(methodNode); continue; } if (exceptionDuringTestMethod) { ProcessTestFail(methodNode); continue; } testInfoData.AddSuccess(methodNode.FullName); playModeLogger.EndLog(methodNode.FullName); methodNode.SetTestState(TestState.Passed); methodNode.Logs = playModeLogger.LogsCopy; methodNode.SetStep(TestStep.CurrentIndex); if (OnMethodStateUpdated != null) { OnMethodStateUpdated(); } } } TriggerAfterTestRunEvent(callbackables); FinalizeTest(); }