/// <summary> /// The actual method to get the test set/case/step data. /// </summary> /// <param name="testDataType"> 0 = testSetData, 1 = testCaseData, 2 = testStepData. </param> /// <param name="dataTypeName"> Name where to get the data from. </param> /// <param name="dataTypeLocation"> Arguments for the data. </param> /// <returns> The test data.</returns> private ITestData GetTestData(int testDataType, string dataTypeName, string dataTypeLocation) { ITestData testData = null; switch (testDataType) { case 0: testData = ReflectiveGetter.GetImplementationOfType <ITestSetData>(dataTypeLocation) .Find(x => x.Name.ToLower().Equals(dataTypeName.ToLower())); break; case 1: testData = ReflectiveGetter.GetImplementationOfType <ITestCaseData>(dataTypeLocation) .Find(x => x.Name.ToLower().Equals(dataTypeName.ToLower())); break; case 2: testData = ReflectiveGetter.GetImplementationOfType <ITestStepData>(dataTypeLocation) .Find(x => x.Name.ToLower().Equals(dataTypeName.ToLower())); break; default: throw new Exception("Not a valid testDataType"); } if (testData == null) { Console.WriteLine($"Sorry we do not currently support reading tests from: {dataTypeName}"); throw new Exception($"Cannot Find test data type {dataTypeName}"); } testData.SetUp(); return(testData); }
/// <summary> /// Opens given Open XML File and returns instance of the package /// </summary> /// <param name="entry">Test data entry</param> /// <param name="editable">Opens the file editable</param> /// <returns>Instance of the package</returns> private OpenXmlPackage OpenPackage(ITestData entry, bool editable) { OpenXmlPackage package = null; string localPath = entry.FilePath; this.Log.Comment("Opening ... {0}", localPath); if (File.Exists(localPath) == false) { this.Log.Warning("Skiped..."); return(package); } switch (entry.Type) { case FileType.Word: package = WordprocessingDocument.Open(entry.FilePath, editable); break; case FileType.PowerPoint: package = PresentationDocument.Open(entry.FilePath, editable); break; case FileType.Excel: package = SpreadsheetDocument.Open(entry.FilePath, editable); break; } return(package); }
public void Evolve_Success(ITestData testData) { var fileList = Directory.GetFiles(testData.FilePath).OrderBy(file => file); string arguments; if (testData.UseConfig) { WriteConfig(GetConnectionOptionsString(testData)); } foreach (var fileName in fileList) { arguments = $"{ GetAddArguments(fileName) } { GetConnectionOptionsString(testData) }"; Assert.Equal(0, Run(arguments)); } string targetEvolution; foreach (var fileName in fileList) { targetEvolution = fileName.Replace(".sql", string.Empty).Replace(testData.FilePath, string.Empty); arguments = $"{ GetExecArguments(targetEvolution) } { GetConnectionOptionsString(testData) }"; _outputHelper.WriteLine(arguments); Assert.Equal(0, Run(arguments)); } }
public FormSession(string path) { InitializeComponent(); _SESSION_PATH = path; TARGETS = new List <IPAddress>(); TEST_DATA = null; }
private void btTest_Click(object sender, EventArgs e) { btTest.Enabled = false; try { //check if compilation is needed _testData = null; IObjectTypeUnitTester uc = (IObjectTypeUnitTester)MathNode.GetService(typeof(IObjectTypeUnitTester)); if (uc != null) { _testData = uc.UseMemberTest(this); } if (_testData == null) { // CompileResult result = mathExpCtrl1.CreateMethodCompilerUnit("TestMathExpression", "Test", "TestMathExpression"); // thTest = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(test)); thTest.SetApartmentState(System.Threading.ApartmentState.STA); _testData = new TestData(result); //"Test", "TestMathExpression", variables, pointerList, code, imports); thTest.Start(_testData); } timer1.Enabled = true; } catch (Exception err) { MathNode.Log(this.FindForm(), err); } // timer1.Enabled = true; }
/// <summary> /// Initializes a new instance of the <see cref="OrderProcessor`1"/> class. /// </summary> /// <param name="testData">An instance of <see cref="ITestData`1"/> for order generation.</param> /// <param name="invoiceGenerator">An instance of <see cref="IInvoiceGenerator`1"/> for invoice files generation.</param> /// <param name="mailManager">An instance of <see cref="IMailManager`1"/> for invoice sending.</param> public OrderProcessor(ITestData testData, IInvoiceGenerator invoiceGenerator, IMailManager mailManager) { this.testData = testData; this.invoiceGenerator = invoiceGenerator; this.mailManager = mailManager; }
private void btTest_Click(object sender, EventArgs e) { btTest.Enabled = false; try { _testData = null; //generate the result result = root.Export(); // //check if compilation is needed IObjectTypeUnitTester uc = (IObjectTypeUnitTester)MathNode.GetService(typeof(IObjectTypeUnitTester)); if (uc != null) { _testData = uc.UseMemberTest(this); } if (_testData == null) { CompileResult compiled = result.CreateMethodCompilerUnit("TestMathExpression", "Test", "TestMathExpGroup"); // thTest = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(test)); thTest.SetApartmentState(System.Threading.ApartmentState.STA); _testData = new TestData(compiled); thTest.Start(_testData); } // timer1.Enabled = true; } catch (Exception err) { MathNode.Log(this.FindForm(), err); } }
/// <summary> /// Validate OOXML File with specified file format version /// </summary> /// <param name="entry">ITestData entry for OOXML File</param> /// <param name="fileFormatVersion">File Format Version</param> private void VerifyValidation(ITestData entry, FileFormatVersions fileFormatVersion) { using (var document = this.OpenPackage(entry, false)) { OpenXmlValidator isoValidator = new OpenXmlValidator(fileFormatVersion); var errorList = isoValidator.Validate(document); } }
private void runner_TestFailed(ITestData data, string message, string stackTrace) { context.BeginInvoke(() => { Runner.Runner_TestFailed(data, message, stackTrace); UpdateTestCounts(); }); }
private void runner_TestTimedOut(ITestData data) { context.BeginInvoke(() => { Runner.Runner_TestTimedOut(data); UpdateTestCounts(); }); }
public TestParameters(ITestData data) : this(data.RunState, data.Arguments) { TestName = data.TestName; foreach (string key in data.Properties.Keys) { this.Properties[key] = data.Properties[key]; } }
private static void TestOnSerializer(Dictionary<string, ISerDeser> serializers, ITestData original, Dictionary<string, Measurements[]> measurements, int repetition) { foreach (var serializer in serializers) { SingleTest(serializer, original, measurements, repetition); } GC.Collect(); // it has very little impact on speed for repetitions < 100 GC.WaitForFullGCComplete(); GC.Collect(); }
private void Verify(ITestData entry) { using (var document = this.OpenPackage(entry, false)) { if (this.IsIsoStrictFile(document) == true) { this.Log.Pass("Opened: {0}", entry.FilePath); } } }
/// <summary> /// Construct a ParameterSet from an object implementing ITestData /// </summary> /// <param name="data"></param> public TestParameters(ITestData data) { RunState = data.RunState; Properties = new PropertyBag(); TestName = data.TestName; OriginalArguments = Arguments = data.Arguments; foreach (string key in data.Properties.Keys) this.Properties[key] = data.Properties[key]; }
private string GetConnectionOptionsString(ITestData testData) { var connectionParams = $"--user {testData.User} " + $"--password {testData.Password} " + $"--server {testData.Server} " + $"--instance {testData.Instance} " + $"--port {testData.Port} " + $"--type {testData.Type}"; return(connectionParams); }
protected void InitializeTestDataInstance() { #if USE_INTERFACE TestData = container.Resolve <ITestData>(); #endif #if USE_CONFIGURATION TestData = container.Resolve <ITestData>(); #endif #if USE_OBJ_PROXY TestData = container.Resolve <TestData>(); #endif }
/// <summary> /// Construct a ParameterSet from an object implementing ITestData /// </summary> /// <param name="data"></param> public TestParameters(ITestData data) { RunState = data.RunState; Properties = new PropertyBag(); TestName = data.TestName; InitializeAguments(data.Arguments); foreach (string key in data.Properties.Keys) this.Properties[key] = data.Properties[key]; }
/// <summary> /// Construct a ParameterSet from an object implementing ITestData /// </summary> /// <param name="data"></param> public TestParameters(ITestData data) { RunState = data.RunState; Properties = new PropertyBag(); TestName = data.TestName; OriginalArguments = Arguments = data.Arguments; foreach (string key in data.Properties.Keys) { this.Properties[key] = data.Properties[key]; } }
public bool LoadData(ITestData test) { data = (MethodTestData)test; XmlDocument doc = new XmlDocument(); doc.LoadXml(data.FullContents); testData = doc.DocumentElement.SelectSingleNode(data.XPath); if (testData == null) { throw new MathException(string.Format(System.Globalization.CultureInfo.InvariantCulture, "Invalid xpath '{0}' for the test node", data.XPath)); } return(true); }
public IStepResult EnterData(ITestData data) { for (int i = 0; i < this.TestData.Numbers.Count - 1; i++) { this.MainForm.ClickNumber(this.TestData.Numbers[i]); this.MainForm.ClickPlus(); } this.MainForm.ClickNumber(this.TestData.Numbers.Last()); if (this.TestData.Mode == CalcMode.Statistic) { this.MainForm.ClickPlus(); } return(new StepResult()); }
/// <summary> /// Construct a ParameterSet from an object implementing ITestData /// </summary> /// <param name="data"></param> public TestParameters(ITestData data) { RunState = data.RunState; Properties = new PropertyBag(); TestName = data.TestName; InitializeAguments(data.Arguments); foreach (string key in data.Properties.Keys) { this.Properties[key] = data.Properties[key]; } }
public virtual IStepResult Precondition_OpenCalc(ITestData data) { base.AppWrapper = new ApplicationWrapper(this.TestData.AppPath); this.MainWindow = this.AppWrapper.GetWindow(title: this.TestData.MainWindowTitle); var result = new StepResult(); if (this.MainWindow == null) { LogicalFail("Window didn't open in specified time.", true); return(result); } InteractionTimeout.Wait(1000); return(result); }
public IStepResult CheckResult(ITestData data) { this.MainForm.ClickEquals(); var calcResult = this.MainForm.GetResult(); var sum = int.Parse(calcResult); var expectedSum = this.TestData.Numbers.Sum(); if (sum != expectedSum) { var message = string.Format("The sum is different. Expected: {0}, Actual: {1}", expectedSum, sum); LogicalFail(message, skipAll: false); } return(null); }
private static void SingleTest(KeyValuePair<string, ISerDeser> serializer, ITestData original, Dictionary<string, Measurements[]> measurements, int repetition) { var sw = Stopwatch.StartNew(); var serialized = serializer.Value.Serialize<Person>(original); measurements[serializer.Key][repetition].Size = serialized.Length; var processed = serializer.Value.Deserialize<Person>(serialized); sw.Stop(); measurements[serializer.Key][repetition].Time = sw.ElapsedTicks; Report.TimeAndDocument(serializer.Key, sw.ElapsedTicks, serialized); var errors = original.Compare(processed); errors[0] = serializer.Key + errors[0]; Report.Errors(errors); }
public override IStepResult Precondition_OpenCalc(ITestData data) { base.Precondition_OpenCalc(null); switch (this.TestData.Mode) { case CalcMode.Statistic: this.MainForm = new CalcStatForm(this.MainWindow); break; default: this.MainForm = new CalcStandardForm(this.MainWindow); break; } this.MainForm.InitializeFormControls(); return(null); }
public OpenXmlPackage OpenDocument(ITestData entry, bool isEditable) { switch (entry.Type) { case FileType.Word: return(WordprocessingDocument.Open(entry.FilePath, isEditable)); case FileType.Excel: return(SpreadsheetDocument.Open(entry.FilePath, isEditable)); case FileType.PowerPoint: return(PresentationDocument.Open(entry.FilePath, isEditable)); default: return(null); } }
public HomeController(ITestData test) { _test = test; }
public OpenXmlPackage OpenDocument(ITestData entry, bool isEditable) { switch (entry.Type) { case FileType.Word: return WordprocessingDocument.Open(entry.FilePath, isEditable); case FileType.Excel: return SpreadsheetDocument.Open(entry.FilePath, isEditable); case FileType.PowerPoint: return PresentationDocument.Open(entry.FilePath, isEditable); default: return null; } }
private readonly ITestData testData; // represents a bounded context public TestService(ITestData testData) { this.testData = testData; }
public bool LoadData(ITestData test) { try { _testData = (TestData)test; //provide drawing attributes for parameters mroot = new MathNodeRoot(); if (_testData.Parameters.Count > 2) { mroot.ChildNodeCount = _testData.Parameters.Count; } parameters.Properties.Clear(); for (int i = 0; i < _testData.Parameters.Count; i++) { mroot[i] = (MathNode)_testData.Parameters[i].CloneExp(mroot); parameters.Properties.Add(new PropertySpec(_testData.Parameters[i].VariableName + ":" + _testData.Parameters[i].CodeVariableName, _testData.Parameters[i].VariableType.Type)); } foreach (IPropertyPointer pp in _testData.Pointers) { parameters.Properties.Add(new PropertySpec(pp.ToString() + ":" + pp.CodeName, pp.ObjectType)); //.PointerDataType)); } // CodeGeneratorOptions o = new CodeGeneratorOptions(); o.BlankLinesBetweenMembers = false; o.BracingStyle = "C"; o.ElseOnClosing = false; o.IndentString = " "; // CSharpCodeProvider cs = new CSharpCodeProvider(); StringWriter sw; sw = new StringWriter(); cs.GenerateCodeFromCompileUnit(_testData.CU, sw, o); // string sCode = sw.ToString(); sw.Close(); // int pos = sCode.IndexOf("a tool."); if (pos > 0) { sCode = sCode.Substring(0, pos) + "Limnor Visual Object Builder." + sCode.Substring(pos + 7); } // textBox1.Text = sCode; // CompilerParameters cp = new CompilerParameters(); foreach (AssemblyRef ar in _testData.Assemblies) { MathNode.AddImportLocation(ar.Location); } foreach (string s in MathNode.ImportLocations) { cp.ReferencedAssemblies.Add(s); } cp.GenerateExecutable = false; CompilerResults crs = cs.CompileAssemblyFromDom(cp, new CodeCompileUnit[] { _testData.CU }); if (crs.Errors.HasErrors) { MathNode.Trace("Error compiling."); MathNode.IndentIncrement(); FormCompilerError dlg = new FormCompilerError(); for (int i = 0; i < crs.Errors.Count; i++) { MathNode.Trace(crs.Errors[i].ToString()); dlg.AddItem(crs.Errors[i]); } MathNode.IndentDecrement(); dlg.TopLevel = false; dlg.Parent = this; dlg.Show(); dlg.TopMost = true; dlg.BringToFront(); } else { Type[] types = crs.CompiledAssembly.GetExportedTypes(); if (types != null) { for (int i = 0; i < types.Length; i++) { if (types[i].Name == _testData.ClassName) { _mi = types[i].GetMethod(_testData.MethodName); if (_mi != null) { break; } } } } } textBox2.Text = MathNode.GetLogContents(); return(true); } catch (Exception err) { MathNode.Log(this, err); textBox2.Text = MathNode.GetLogContents(); } return(false); }
private void GetTestResultStatus(ITestData td) { //set the test status var results = LoadResults(Results); if (results != null) { //find our results in the results var mainSuite = results.testsuite; var ourSuite = results.testsuite.results.Items .Cast <testsuiteType>() .FirstOrDefault(s => s.name == td.Fixture.Name); var ourTest = ourSuite.results.Items .Cast <testcaseType>().FirstOrDefault(t => t.name == td.Name); switch (ourTest.result) { case "Cancelled": td.TestStatus = TestStatus.Cancelled; break; case "Error": td.TestStatus = TestStatus.Error; break; case "Failure": td.TestStatus = TestStatus.Failure; break; case "Ignored": td.TestStatus = TestStatus.Ignored; break; case "Inconclusive": td.TestStatus = TestStatus.Inconclusive; break; case "NotRunnable": td.TestStatus = TestStatus.NotRunnable; break; case "Skipped": td.TestStatus = TestStatus.Skipped; break; case "Success": td.TestStatus = TestStatus.Success; break; } if (ourTest.Item == null) { return; } var failure = ourTest.Item as failureType; if (failure == null) { return; } //if (_vm != null && _vm.UiDispatcher != null) //{ // _vm.UiDispatcher.BeginInvoke((Action)(() => td.ResultData.Add( // new ResultData() // { // StackTrace = failure.stacktrace, // Message = failure.message // }))); //} //Dispatcher.CurrentDispatcher.BeginInvoke((Action)(() => td.ResultData.Add( // new ResultData() // { // StackTrace = failure.stacktrace, // Message = failure.message // }))); td.ResultData.Add( new ResultData() { StackTrace = failure.stacktrace, Message = failure.message }); } }
public IStepResult Postcondition_Close(ITestData data) { this.AppWrapper.Dispose(); WrapperPool.ClearWrapperPool(); return(null); }
private void OnTestTimedOut(ITestData data) { if (TestTimedOut != null) { TestTimedOut(data); } }
private static void GetTestResultStatus(ITestData td) { //set the test status var results = LoadResults(_results); if (results != null) { //find our results in the results var mainSuite = results.testsuite; var ourSuite = results.testsuite.results.Items .Cast<testsuiteType>() .FirstOrDefault(s => s.name == td.Fixture.Name); var ourTest = ourSuite.results.Items .Cast<testcaseType>().FirstOrDefault(t => t.name == td.Name); switch (ourTest.result) { case "Cancelled": td.TestStatus = TestStatus.Cancelled; break; case "Error": td.TestStatus = TestStatus.Error; break; case "Failure": td.TestStatus = TestStatus.Failure; break; case "Ignored": td.TestStatus = TestStatus.Ignored; break; case "Inconclusive": td.TestStatus = TestStatus.Inconclusive; break; case "NotRunnable": td.TestStatus = TestStatus.NotRunnable; break; case "Skipped": td.TestStatus = TestStatus.Skipped; break; case "Success": td.TestStatus = TestStatus.Success; break; } if (ourTest.Item == null) return; var failure = ourTest.Item as failureType; if (failure == null) return; if (_vm != null && _vm.UiDispatcher != null) { _vm.UiDispatcher.BeginInvoke((Action)(()=> td.ResultData.Add( new ResultData() { StackTrace = failure.stacktrace, Message = failure.message }))); } } }
public static void RunTest(ITestData td) { var path = Path.Combine(_workingDirectory, td.Name + ".txt"); CreateJournal(path, td.Name, td.Fixture.Name, td.Fixture.Assembly.Path, _results, td.ModelPath); var startInfo = new ProcessStartInfo() { FileName = _revitPath, WorkingDirectory = _workingDirectory, Arguments = path, UseShellExecute = false }; Console.WriteLine("Running {0}", path); var process = new Process { StartInfo = startInfo }; process.Start(); var timedOut = false; if (_isDebug) { process.WaitForExit(); } else { var time = 0; while(!process.WaitForExit(1000)) //if (!process.WaitForExit(_timeout)) { Console.Write("."); time += 1000; if (time > _timeout) { Console.WriteLine("Test timed out."); td.TestStatus = TestStatus.TimedOut; timedOut = true; break; } } if (timedOut) { if(!process.HasExited) process.Kill(); } } if(!timedOut && _gui) GetTestResultStatus(td); _runCount --; if (_runCount == 0) { OnTestRunsComplete(); } }
void runner_TestFailed(ITestData data, string message, string stackTrace) { context.BeginInvoke(() => Runner.Runner_TestFailed(data, message, stackTrace)); }
void runner_TestTimedOut(ITestData data) { context.BeginInvoke(()=>Runner.Runner_TestTimedOut(data)); }
public Test(ITestData testData) { _testData = testData; }
private void OnTestComplete(ITestData data) { if (TestComplete != null) { TestComplete(new List<ITestData>(){data}, Results); } }
/// <summary> /// Setup the selected test. /// </summary> /// <param name="td"></param> /// <param name="continuous"></param> private void SetupIndividualTest(ITestData td, bool continuous = false) { if (td.ShouldRun == false) return; try { if (!File.Exists(td.ModelPath)) { throw new Exception(String.Format("Specified model path: {0} does not exist.", td.ModelPath)); } if (!File.Exists(td.Fixture.Assembly.Path)) { throw new Exception(String.Format("The specified assembly: {0} does not exist.", td.Fixture.Assembly.Path)); } if (!File.Exists(AssemblyPath)) { throw new Exception( String.Format("The specified RTF assembly does not exist: {0} does not exist.", td.Fixture.Assembly.Path)); } var journalPath = Path.Combine(WorkingDirectory, td.Name + ".txt"); // If we're running in continuous mode, then all tests will share // the same journal path if (continuous) { journalPath = batchJournalPath; } td.JournalPath = journalPath; if (continuous) { InitializeJournal(journalPath); AddToJournal(journalPath, td.Name, td.Fixture.Name, td.Fixture.Assembly.Path, Results, td.ModelPath); } else { CreateJournal(journalPath, td.Name, td.Fixture.Name, td.Fixture.Assembly.Path, Results, td.ModelPath); } } catch (Exception ex) { if (td == null) return; td.TestStatus = TestStatus.Failure; } }
private void OnTestFailed(ITestData data, string message, string stackTrace) { if (TestFailed != null) { TestFailed(data, message, stackTrace); } }
public static void Runner_TestTimedOut(ITestData data) { data.ResultData.Clear(); data.ResultData.Add(new ResultData() { Message = "Test timed out." }); }
private void ProcessTest(ITestData td, string journalPath) { var startInfo = new ProcessStartInfo() { FileName = RevitPath, WorkingDirectory = WorkingDirectory, Arguments = journalPath, UseShellExecute = false }; Console.WriteLine("Running {0}", journalPath); var process = new Process { StartInfo = startInfo }; process.Start(); var timedOut = false; if (IsDebug) { process.WaitForExit(); } else { var time = 0; while (!process.WaitForExit(1000)) { Console.Write("."); time += 1000; if (time > Timeout) { td.TestStatus = TestStatus.Failure; OnTestTimedOut(td); timedOut = true; break; } } if (timedOut) { if (!process.HasExited) process.Kill(); } } if (!timedOut) { OnTestComplete(td); } }
public void RunTest(ITestData td) { if (!File.Exists(AddinPath)) { CreateAddin(AddinPath, AssemblyPath); } var journalPath = Path.Combine(WorkingDirectory, td.Name + ".txt"); CreateJournal(journalPath, td.Name, td.Fixture.Name, td.Fixture.Assembly.Path, Results, td.ModelPath); var startInfo = new ProcessStartInfo() { FileName = RevitPath, WorkingDirectory = WorkingDirectory, Arguments = journalPath, UseShellExecute = false }; Console.WriteLine("Running {0}", journalPath); var process = new Process { StartInfo = startInfo }; process.Start(); var timedOut = false; if (IsDebug) { process.WaitForExit(); } else { var time = 0; while (!process.WaitForExit(1000)) { Console.Write("."); time += 1000; if (time > Timeout) { Console.WriteLine("Test timed out."); td.TestStatus = TestStatus.TimedOut; timedOut = true; break; } } if (timedOut) { if (!process.HasExited) process.Kill(); } } if (!timedOut && Gui) GetTestResultStatus(td); RunCount--; if (RunCount == 0) { OnTestRunsComplete(); } }
public static void Runner_TestFailed(ITestData data, string message, string stackTrace) { data.ResultData.Clear(); data.ResultData.Add(new ResultData() { Message = message, StackTrace = stackTrace }); }
public List<string> Compare(ITestData comparable) { return ComparePerson((Person)comparable); }
public IStepResult SwitchMode(ITestData data) { this.MainForm.SwitchMode(this.TestData.Mode); return(null); }
public void RunTest(ITestData td) { if (!File.Exists(AddinPath)) { CreateAddin(AddinPath, AssemblyPath); } var journalPath = Path.Combine(WorkingDirectory, td.Name + ".txt"); CreateJournal(journalPath, td.Name, td.Fixture.Name, td.Fixture.Assembly.Path, Results, td.ModelPath); var startInfo = new ProcessStartInfo() { FileName = RevitPath, WorkingDirectory = WorkingDirectory, Arguments = journalPath, UseShellExecute = false }; Console.WriteLine("Running {0}", journalPath); var process = new Process { StartInfo = startInfo }; process.Start(); var timedOut = false; if (IsDebug) { process.WaitForExit(); } else { var time = 0; while (!process.WaitForExit(1000)) { Console.Write("."); time += 1000; if (time > Timeout) { Console.WriteLine("Test timed out."); td.TestStatus = TestStatus.TimedOut; timedOut = true; break; } } if (timedOut) { if (!process.HasExited) { process.Kill(); } } } if (!timedOut && Gui) { GetTestResultStatus(td); } RunCount--; if (RunCount == 0) { OnTestRunsComplete(); } }
public static void RunTest(ITestData td) { var path = Path.Combine(_workingDirectory, td.Name + ".txt"); CreateJournal(path, td.Name, td.Fixture.Name, td.Fixture.Assembly.Path, _results, td.ModelPath); var startInfo = new ProcessStartInfo() { FileName = _revitPath, WorkingDirectory = _workingDirectory, Arguments = path }; Console.WriteLine("Running {0}", path); var process = new Process { StartInfo = startInfo }; process.Start(); if (_isDebug) process.WaitForExit(); else process.WaitForExit(120000); _runCount --; if (_runCount == 0) { OnTestRunsComplete(); } }
public ComplexTestData(ITestData data) { this.SimpleData = data; }