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 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);
}
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);
}
/// <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 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);
}
public void Stop()
{
project.ParseInformationUpdated -= project_ParseInformationUpdated;
// Remove old testProject
if (testProject != null) {
testSolution.NestedTestCollection.Remove(testProject);
testProject = null;
}
}
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;
}
