public void Initialize(ISequenceFlowContainer sequenceData) { _stateManageContext = new StateManageContext(_globalInfo, sequenceData); if (sequenceData is ITestProject) { ITestProject testProject = (ITestProject)sequenceData; SessionStateHandle testProjectStateHandle = new SessionStateHandle(testProject, _stateManageContext); _sessionStateHandles.Add(testProjectStateHandle.Session, testProjectStateHandle); for (int index = 0; index < testProject.SequenceGroups.Count; index++) { SessionStateHandle stateHandle = new SessionStateHandle(index, testProject.SequenceGroups[index], _stateManageContext); _sessionStateHandles.Add(stateHandle.Session, stateHandle); } } else { SessionStateHandle stateHandle = new SessionStateHandle(0, (ISequenceGroup)sequenceData, _stateManageContext); _sessionStateHandles.Add(stateHandle.Session, stateHandle); } _globalInfo.EventDispatcher = _stateManageContext.EventDispatcher; }
public void Initialize(ISequenceFlowContainer sequenceData) { if (sequenceData is ITestProject) { ITestProject testProject = (ITestProject)sequenceData; IList <ITypeData> callBackRelatedType = GetCallBackRelatedType(testProject); IList <IAssemblyInfo>[] assemblyInfoCollections = new IList <IAssemblyInfo> [testProject.SequenceGroups.Count + 1]; IList <IAssemblyInfo> callBackRelatedAssembly = GetCallBackRelatedAssembly(callBackRelatedType, assemblyInfoCollections); //AssemblyInvoker加载程序集和类型 _typeInvoker = new AssemblyInvoker(_globalInfo, callBackRelatedAssembly, callBackRelatedType); _typeInvoker.LoadAssemblyAndType(); foreach (ISequenceGroup sequenceGroup in testProject.SequenceGroups) { SequenceGroupFindCallBack(sequenceGroup); } } else { ISequenceGroup sequenceGroup = (ISequenceGroup)sequenceData; IList <ITypeData> callBackRelatedType = GetCallBackRelatedType(sequenceGroup); IList <IAssemblyInfo> callBackRelatedAssembly = GetCallBackRelatedAssembly(callBackRelatedType, sequenceGroup.Assemblies); //AssemblyInvoker加载程序集和类型 _typeInvoker = new AssemblyInvoker(_globalInfo, callBackRelatedAssembly, callBackRelatedType); _typeInvoker.LoadAssemblyAndType(); SequenceGroupFindCallBack(sequenceGroup); } }
public static void ValidateParent(ITestProject testProject) { testProject.Parent = null; ValidateParent(testProject.Variables, testProject); ValidateParent(testProject.SetUp, testProject); ValidateParent(testProject.TearDown, testProject); }
public void StartTestGeneration() { _testsMaintainer.StartHost(); ISequenceManager sequenceManager = _globalInfo.TestflowRunner.SequenceManager; if (_sequenceData is ITestProject) { ITestProject testProject = _sequenceData as ITestProject; _testsMaintainer.SendTestGenMessage(CoreConstants.TestProjectSessionId, sequenceManager.RuntimeSerialize(testProject)); foreach (ISequenceGroup sequenceGroup in testProject.SequenceGroups) { _testsMaintainer.SendTestGenMessage(ModuleUtils.GetSessionId(testProject, sequenceGroup), sequenceManager.RuntimeSerialize(sequenceGroup)); } // 初始化每个模块的监听变量 foreach (int session in _testsMaintainer.TestContainers.Keys) { _debugManager?.SendInitBreakPointMessage(session); } } else { _testsMaintainer.SendTestGenMessage(0, sequenceManager.RuntimeSerialize(_sequenceData as ISequenceGroup)); _debugManager?.SendInitBreakPointMessage(0); } // 等待远程生成结束 _blockHandle.Wait(Constants.RmtGenState); }
public static CallStack GetStack(ISequenceStep step) { CallStack callStack = new CallStack(); ISequence sequence = null; ISequenceGroup sequenceGroup = null; while (null != step) { callStack.StepStack.Add(step.Index); ISequenceFlowContainer parent = step.Parent; if (parent is ISequence) { sequence = parent as ISequence; } step = parent as ISequenceStep; } if (null == sequence) { return(callStack); } callStack.Session = sequence.Index; sequenceGroup = sequence.Parent as ISequenceGroup; if (!(sequenceGroup?.Parent is ITestProject)) { return(callStack); } ITestProject testProject = (ITestProject)sequenceGroup.Parent; callStack.SessionIndex = testProject.SequenceGroups.IndexOf(sequenceGroup); return(callStack); }
public NUnitTestMethod(ITestProject parentProject, IUnresolvedMethod method, FullTypeName derivedFixture = default(FullTypeName)) { if (parentProject == null) throw new ArgumentNullException("parentProject"); this.parentProject = parentProject; UpdateTestMethod(method, derivedFixture); }
public static SDTask Create(TestResult result, ITestProject project) { TaskType taskType = TaskType.Warning; FileLineReference lineRef = null; string message = String.Empty; if (result.IsFailure) { taskType = TaskType.Error; if (!result.StackTraceFilePosition.IsEmpty) { lineRef = new FileLineReference(result.StackTraceFilePosition.FileName, result.StackTraceFilePosition.BeginLine - 1, result.StackTraceFilePosition.BeginColumn - 1); } message = GetTestFailedMessage(result); } else if (result.IsIgnored) { message = GetTestIgnoredMessage(result); } if (lineRef == null) { lineRef = FindTest(result.Name, project); } FileName fileName = null; if (lineRef != null) { fileName = new FileName(Path.GetFullPath(lineRef.FileName)); int line = lineRef.Line + 1; return new SDTask(fileName, message, lineRef.Column, line, taskType); } return new SDTask(fileName, message, 0, 0, taskType); }
internal void CheckTestFramework() { ITestFramework newTestFramework = testSolution.testService.GetTestFrameworkForProject(project); if (newTestFramework == oldTestFramework) { return; // test framework is unchanged } // Remove old testProject if (testProject != null) { testSolution.NestedTestCollection.Remove(testProject); testProject = null; } // Create new testProject if (newTestFramework != null) { testProject = newTestFramework.CreateTestProject(testSolution, project); if (testProject == null) { throw new InvalidOperationException("CreateTestProject() returned null"); } testSolution.NestedTestCollection.Add(testProject); } oldTestFramework = newTestFramework; }
/// <summary> /// 初始化变量和参数的类型数据 /// </summary> public bool VerifyVariableType(ISequenceFlowContainer flowContainer, IVariable variable, TypeDataCollection typeDatas) { if (flowContainer is ITestProject) { ITestProject testProject = flowContainer as ITestProject; return(VerifyVariableInSequence(testProject.SetUp, variable, typeDatas) || VerifyVariableInSequence(testProject.TearDown, variable, typeDatas)); } else if (flowContainer is ISequenceGroup) { ISequenceGroup sequenceGroup = flowContainer as ISequenceGroup; if (VerifyVariableInSequence(sequenceGroup.SetUp, variable, typeDatas) || VerifyVariableInSequence(sequenceGroup.TearDown, variable, typeDatas)) { return(true); } return(sequenceGroup.Sequences.Any(sequence => VerifyVariableInSequence(sequence, variable, typeDatas))); } else if (flowContainer is ISequence) { return(VerifyVariableInSequence(flowContainer as ISequence, variable, typeDatas)); } else if (flowContainer is ISequenceStep) { return(VerifyVariableInSequenceStep(flowContainer as ISequenceStep, variable, typeDatas)); } return(false); }
public VariableMapper(SlaveContext context) { ISequenceFlowContainer sequenceData = context.Sequence; this._variables = new Dictionary <string, object>(512); this._keyVariables = new HashSet <string>(); this._syncVariables = new HashSet <string>(); this._context = context; _fullTraceVariables = new List <string>(Constants.DefaultRuntimeSize); if (context.SequenceType == RunnerType.TestProject) { ITestProject testProject = (ITestProject)sequenceData; AddVariables(testProject.Variables, false); AddVariables(testProject.SetUp.Variables, false); AddVariables(testProject.TearDown.Variables, false); } else { bool addSessionVarToSyncSet = ExecutionModel.ParallelExecution == context.ExecutionModel; ISequenceGroup sequenceGroup = (ISequenceGroup)sequenceData; AddVariables(sequenceGroup.Variables, addSessionVarToSyncSet); AddVariables(sequenceGroup.SetUp.Variables, false); AddVariables(sequenceGroup.TearDown.Variables, false); foreach (ISequence sequence in sequenceGroup.Sequences) { AddVariables(sequence.Variables, false); } } this._keyVarLock = new SpinLock(false); this._syncVarLock = new ReaderWriterLockSlim(); }
public ITestProject GetCallBackTestProjectData2() { ITestProject testProject = _sequenceManager.CreateTestProject(); //testProject.SetUp.Steps.Add(CreateStaticWaitStep()); //testProject.TearDown.Steps.Add(CreateStaticWaitStep()); _sequenceManager.ValidateSequenceData(testProject); ISequenceGroup sequenceGroup = _sequenceManager.CreateSequenceGroup(); sequenceGroup.ExecutionModel = ExecutionModel.SequentialExecution; sequenceGroup.Description = "SequenceGroup Description"; ISequence sequence1 = _sequenceManager.CreateSequence(); sequence1.Behavior = RunBehavior.Normal; sequence1.Description = "Sequence Description"; sequence1.Steps.Add(CreateCallBackStep(100, 200)); sequenceGroup.Sequences.Add(sequence1); _sequenceManager.ValidateSequenceData(sequenceGroup, testProject); testProject.SequenceGroups.Add(sequenceGroup); return(testProject); }
public static string GetRuntimeVariableString(WatchDataObject watchDataObj, ISequenceFlowContainer sequenceData) { const char delim = '.'; string[] watchElem = watchDataObj.WatchData.Split(delim); string variableName = watchElem[0]; int sequenceIndex = watchDataObj.Sequence; IVariable variable = null; if (sequenceData is ITestProject) { ITestProject testProject = sequenceData as ITestProject; if (watchDataObj.Session == CommonConst.TestGroupSession) { variable = GetVariableByNameAndSequence(testProject, sequenceIndex, variableName); } else { variable = GetVariableByNameAndSequence(testProject.SequenceGroups[watchDataObj.Session], sequenceIndex, variableName); } } else if (sequenceData is ISequenceGroup) { ISequenceGroup sequenceGroup = sequenceData as ISequenceGroup; variable = GetVariableByNameAndSequence(sequenceGroup, sequenceIndex, variableName); } if (null == variable) { return(null); } watchElem[0] = CoreUtils.GetRuntimeVariableName(watchDataObj.Session, variable); return(string.Join(delim.ToString(), watchElem)); }
public SessionTaskEntity(SlaveContext context) { this._context = context; ISequenceFlowContainer sequenceData = _context.Sequence; switch (context.SequenceType) { case RunnerType.TestProject: ITestProject testProject = (ITestProject)sequenceData; _setUp = new SequenceTaskEntity(testProject.SetUp, _context); _tearDown = new SequenceTaskEntity(testProject.TearDown, _context); _sequenceEntities = new List <SequenceTaskEntity>(1); break; case RunnerType.SequenceGroup: ISequenceGroup sequenceGroup = (ISequenceGroup)sequenceData; _setUp = new SequenceTaskEntity(sequenceGroup.SetUp, _context); _tearDown = new SequenceTaskEntity(sequenceGroup.TearDown, _context); _sequenceEntities = new List <SequenceTaskEntity>(sequenceGroup.Sequences.Count); foreach (ISequence sequence in sequenceGroup.Sequences) { _sequenceEntities.Add(new SequenceTaskEntity(sequence, _context)); } break; default: throw new InvalidOperationException(); } }
private static bool HasVariableInSequence(ISequenceFlowContainer sequenceData, string variable) { if (null == sequenceData) { return(false); } if (sequenceData is ISequence) { ISequence sequence = sequenceData as ISequence; // 如果存在则返回true if (sequence.Variables.Any(item => item.Name.Equals(variable))) { return(true); } // 不存在时向上级查找 return(HasVariableInSequence(sequence.Parent, variable)); } else if (sequenceData is ISequenceGroup) { ISequenceGroup sequenceGroup = sequenceData as ISequenceGroup; return(sequenceGroup.Variables.Any(item => item.Name.Equals(variable))); } else if (sequenceData is ITestProject) { ITestProject testProject = sequenceData as ITestProject; return(testProject.Variables.Any(item => item.Name.Equals(variable))); } return(false); }
public void RefreshUsedAssemblyAndType(ITestProject testProject) { HashSet <ITypeData> typeDatas = new HashSet <ITypeData>(); AddVariableTypeDatas(typeDatas, testProject.Variables); AddSequenceTypeDatas(typeDatas, testProject.SetUp); AddSequenceTypeDatas(typeDatas, testProject.TearDown); RefreshUsedTypeDatas(testProject.TypeDatas, typeDatas); HashSet <string> assemblyNames = new HashSet <string>(); foreach (ITypeData typeData in typeDatas) { assemblyNames.Add(typeData.AssemblyName); } RefreshUsedAssemblies(testProject.Assemblies, assemblyNames); foreach (ISequenceGroup sequenceGroup in testProject.SequenceGroups) { if (null != sequenceGroup && sequenceGroup.Available) { RefreshUsedAssemblyAndType(sequenceGroup); } } }
public void ValidateSequenceData(ISequenceGroup sequenceGroup, ITestProject parent = null) { ModuleUtils.ValidateParent(sequenceGroup, parent); _typeMaintainer.VerifyVariableTypes(sequenceGroup); _typeMaintainer.RefreshUsedAssemblyAndType(sequenceGroup); ((SequenceGroup)sequenceGroup).RefreshSignature(); }
public bool StartTestGeneration() { _testsMaintainer.StartHost(_sequenceData); ISequenceManager sequenceManager = _globalInfo.TestflowRunner.SequenceManager; if (_sequenceData is ITestProject) { ITestProject testProject = _sequenceData as ITestProject; _testsMaintainer.SendRmtGenMessage(CoreConstants.TestProjectSessionId, sequenceManager.RuntimeSerialize(testProject)); foreach (ISequenceGroup sequenceGroup in testProject.SequenceGroups) { _testsMaintainer.SendRmtGenMessage(ModuleUtils.GetSessionId(testProject, sequenceGroup), sequenceManager.RuntimeSerialize(sequenceGroup)); } } else { _testsMaintainer.SendRmtGenMessage(0, sequenceManager.RuntimeSerialize(_sequenceData as ISequenceGroup)); } // 等待远程生成结束 _blockHandle.Timeout = _globalInfo.ConfigData.GetProperty <int>("TestGenTimeout"); bool isNotTimeout = _blockHandle.Wait(Constants.RmtGenState); if (!isNotTimeout) { _globalInfo.LogService.Print(LogLevel.Error, CommonConst.PlatformLogSession, "Test generation timeout."); _globalInfo.StateMachine.State = RuntimeState.Timeout; throw new TestflowRuntimeException(ModuleErrorCode.OperationTimeout, _globalInfo.I18N.GetStr("TestGenTimeout")); } // 如果是异常状态则返回false return(_globalInfo.StateMachine.State < RuntimeState.Abort); }
public void Initialize(ISequenceFlowContainer parent) { ITestProject testProject = parent as ITestProject; this.Parent = testProject; ModuleUtils.SetElementName(this, testProject?.SequenceGroups); Info.Modified = true; if (null != testProject) { Info.Version = testProject.ModelVersion; } this.Available = true; // 该参数只在序列化时生成 this.Parameters = null; this.ExecutionModel = ExecutionModel.SequentialExecution; this.SetUp = new Sequence() { Name = "SetUp", Index = CommonConst.SetupIndex }; this.TearDown = new Sequence() { Name = "TearDown", Index = CommonConst.TeardownIndex }; RefreshSignature(); }
public void CallBackWithParameters() { ITestProject testProjectData = _sequenceCreator.GetCallBackTestProjectData2(); TestflowRunner runnerInstance = TestflowRunner.GetInstance(); runnerInstance.EngineController.SetSequenceData(testProjectData); runnerInstance.EngineController.Start(); }
public void SetToAbsolutePath(ITestProject testProject) { SetToAbsolutePath(testProject.Assemblies); foreach (ISequenceGroup sequenceGroup in testProject.SequenceGroups) { SetToAbsolutePath(sequenceGroup); } }
public static int GetSessionId(ITestProject testProject, ISequenceGroup sequenceGroup) { if (null == testProject) { return(0); } return(testProject.SequenceGroups.IndexOf(sequenceGroup)); }
public RuntimeContainer Generate(ITestProject testProject, RuntimePlatform platform, params object[] param) { RuntimeContainer runtimeContainer = RuntimeContainer.CreateContainer(Constants.TestProjectSessionId, platform, _globalInfo, param); _runtimeContainers.Add(runtimeContainer.Session, runtimeContainer); return(runtimeContainer); }
public SessionGenerationInfo(ITestProject testProject) { this.Session = CommonConst.TestGroupSession; this.Status = GenerationStatus.Idle; this.SequenceStatus = new SerializableMap <int, GenerationStatus>(2); SequenceStatus.Add(CommonConst.SetupIndex, GenerationStatus.Idle); SequenceStatus.Add(CommonConst.TeardownIndex, GenerationStatus.Idle); }
public void SequenceGroupSequentialTest() { ITestProject testProjectData = _sequenceCreator.GetSequencialTestProjectData(); TestflowRunner runnerInstance = TestflowRunner.GetInstance(); runnerInstance.EngineController.SetSequenceData(testProjectData.SequenceGroups[0]); runnerInstance.EngineController.Start(); }
public ITestProject Load(ITestProject testProject) { TestProject = testProject; foreach (ISequenceGroup sequenceGroup in testProject.SequenceGroups) { AddSequenceGroup(sequenceGroup); } return(TestProject); }
private static void FillParameterDataToSequenceData(ITestProject testProject) { FillParameterDataToSequenceData(testProject.SetUp, testProject.SetUpParameters); for (int i = 0; i < testProject.Variables.Count; i++) { testProject.VariableValues[i].Value = testProject.Variables[i].Value; } FillParameterDataToSequenceData(testProject.TearDown, testProject.TearDownParameters); }
public NUnitTestMethod(ITestProject parentProject, IUnresolvedMethod method, FullTypeName derivedFixture = default(FullTypeName)) { if (parentProject == null) { throw new ArgumentNullException("parentProject"); } this.parentProject = parentProject; UpdateTestMethod(method, derivedFixture); }
public void TestProjectDeserialize() { ITestProject testProject = _sequenceManager.LoadTestProject(SerializationTarget.File, TestProjectPath); Assert.AreEqual(testProject.Name, "TestProject1"); Assert.AreEqual(testProject.SetUp.Name, "SetUp"); Assert.AreEqual(testProject.SetUp.Index, CommonConst.SetupIndex); Assert.AreEqual(testProject.TearDown.Name, "TearDown"); Assert.AreEqual(testProject.TearDown.Index, CommonConst.TeardownIndex); }
/// <summary> /// Returns the location of the specified test member in the /// project being tested. /// </summary> static FileLineReference FindTest(string memberName, ITestProject testProject) { // if (testProject != null) { // TestMember testMember = testProject.TestClasses.GetTestMember(memberName); // if (testMember != null) { // return FindTest(testMember); // } // } return null; }
public void Stop() { project.ParseInformationUpdated -= project_ParseInformationUpdated; // Remove old testProject if (testProject != null) { testSolution.NestedTestCollection.Remove(testProject); testProject = null; } }
private async Task <string> AddTestFile(OmniSharpTestHost host, ITestProject testProject, TestFile testfile) { var filePath = testProject.AddDisposableFile(testfile.FileName, testfile.Content.Text.ToString()); await host.Workspace.BufferManager.UpdateBufferAsync(new Request() { FileName = filePath, Buffer = testfile.Content.Text.ToString() }); return(filePath); }
public TestNamespace(ITestProject project, string namespaceName, string displayName = null) { if (project == null) throw new ArgumentNullException("project"); if (namespaceName == null) throw new ArgumentNullException("namespaceName"); this.project = project; this.namespaceName = namespaceName; if (displayName != null) { this.displayName = displayName; } else { this.displayName = namespaceName.Substring(namespaceName.LastIndexOf('.') + 1); } BindResultToCompositeResultOfNestedTests(); }
public async Task RunTestsAsync(IEnumerable<ITest> selectedTests, TestExecutionOptions options, CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; GroupTestsByProject(selectedTests); ClearTasks(); ShowUnitTestsPad(); ShowOutputPad(); ResetTestResults(); saveAllFilesCommand.SaveAllFiles(); // Run the build, if necessary: var projectsToBuild = testsByProject.Keys.Where(p => p.IsBuildNeededBeforeTestRun).Select(p => p.Project).ToList(); if (projectsToBuild.Count > 0) { using (cancellationToken.Register(buildService.CancelBuild)) { var buildOptions = new BuildOptions(BuildTarget.Build); buildOptions.BuildDetection = BuildOptions.BuildOnExecute; var buildResults = await buildService.BuildAsync(projectsToBuild, buildOptions); if (buildResults.Result != BuildResultCode.Success) return; } } cancellationToken.ThrowIfCancellationRequested(); using (IProgressMonitor progressMonitor = statusBarService.CreateProgressMonitor(cancellationToken)) { int projectsLeftToRun = testsByProject.Count; foreach (IGrouping<ITestProject, ITest> g in testsByProject.OrderBy(g => g.Key.DisplayName)) { currentProjectBeingTested = g.Key; progressMonitor.TaskName = GetProgressMonitorLabel(currentProjectBeingTested); progressMonitor.Progress = GetProgress(projectsLeftToRun); using (testProgressMonitor = progressMonitor.CreateSubTask(1.0 / testsByProject.Count)) { using (ITestRunner testRunner = currentProjectBeingTested.CreateTestRunner(options)) { testRunner.TestFinished += testRunner_TestFinished; var writer = new MessageViewCategoryTextWriter(testService.UnitTestMessageView); await testRunner.RunAsync(g, testProgressMonitor, writer, testProgressMonitor.CancellationToken); } } projectsLeftToRun--; progressMonitor.CancellationToken.ThrowIfCancellationRequested(); } } ShowErrorList(); }
string GetProgressMonitorLabel(ITestProject project) { StringTagPair tagPair = new StringTagPair("Name", project.DisplayName); return StringParser.Parse("${res:ICSharpCode.UnitTesting.StatusBarProgressLabel}", tagPair); }
internal void CheckTestFramework() { ITestFramework newTestFramework = testSolution.testService.GetTestFrameworkForProject(project); if (newTestFramework == oldTestFramework) return; // test framework is unchanged // Remove old testProject if (testProject != null) { testSolution.NestedTestCollection.Remove(testProject); testProject = null; } // Create new testProject if (newTestFramework != null) { testProject = newTestFramework.CreateTestProject(testSolution, project); if (testProject == null) throw new InvalidOperationException("CreateTestProject() returned null"); testSolution.NestedTestCollection.Add(testProject); } oldTestFramework = newTestFramework; }