public void SetUp()
{
_test = new TestMethod(new MethodWrapper(typeof(DummySuite), "DummyMethod"));
_testResult = _test.MakeTestResult();
_suite = new TestSuite(typeof(DummySuite));
_suiteResult = (TestSuiteResult)_suite.MakeTestResult();
}
public void SaveTestResults(TestSuiteResult testSuiteResult)
{
if (testSuiteResult == null)
{
throw new ArgumentException("The parameter 'testSuiteResult' cannot be null");
}
//
// Turn off current performance test on this thread so we don't log the
// statistics for this save -- the added TimingData records will cause
// problems in the save to the database since the IDs won't be set
//
TestResult tr = GetCurrentTestResult();
SetCurrentTestResult(null);
// Save test results
perfTestDAL.SaveTestResults(testSuiteResult);
// Resume any performance testing
SetCurrentTestResult(tr);
}
private TestSuiteResult MockSuiteResult(string suiteName, bool failure)
{
TestSuiteResult result = new TestSuiteResult(suiteName);
result.Time = time;
result.RunState = RunState.Executed;
TestSuiteResult level1SuiteA = new TestSuiteResult("level 1 A");
result.AddResult(level1SuiteA);
level1SuiteA.RunState = RunState.Executed;
TestSuiteResult level1SuiteB = new TestSuiteResult("level 1 B");
result.AddResult(level1SuiteB);
level1SuiteB.RunState = RunState.Executed;
testCase = new TestCaseResult("a test case");
if (failure)
{
testCase.Failure("argument exception", null);
}
else
{
testCase.Success();
}
level1SuiteA.AddResult(testCase);
testCase = new TestCaseResult("a successful test");
testCase.Success();
level1SuiteB.AddResult(testCase);
testCase = new TestCaseResult("a not run test");
testCase.Ignore("test not run");
level1SuiteB.AddResult(testCase);
return(result);
}
/// <inheritDoc/>
public virtual void SaveTestResults(TestSuiteResult testSuiteResult)
{
// Set parent objects in children if not already set
foreach (TestResult testResult in testSuiteResult.TestResultList)
{
if (testResult.TestSuiteResult == null) testResult.TestSuiteResult = testSuiteResult;
foreach (TimingData timingData in testResult.TimingDataList.Where(
timingData => timingData.TestResult == null))
{
timingData.TestResult = testResult;
}
}
foreach (SystemInfo systemInfo in testSuiteResult.SystemInfoList.Where(
systemInfo => systemInfo.TestSuiteResult == null))
{
systemInfo.TestSuiteResult = testSuiteResult;
}
// Cascades save to persist/update children performance test data as well
ISession session = sessionFactory.GetCurrentSession();
session.Save(testSuiteResult);
}
private TestSuiteTreeNode AddTreeNodes(IList nodes, TestResult rootResult, bool highlight)
{
TestSuiteTreeNode node = new TestSuiteTreeNode(rootResult);
AddToMap(node);
nodes.Add(node);
TestSuiteResult suiteResult = rootResult as TestSuiteResult;
if (suiteResult != null)
{
foreach (TestResult result in suiteResult.Results)
{
AddTreeNodes(node.Nodes, result, highlight);
}
}
node.UpdateImageIndex();
return(node);
}
public bool Run(TestInfo test, TestSuiteResult suite_result, string test_name, EventListener listener, ITestFilter filter, int timeout)
{
listener = new ProxyListener(listener);
TestRunnerDelegate runner = new TestRunnerDelegate(delegate {
return(server.Run(test_name, listener, filter));
});
IAsyncResult ar = runner.BeginInvoke(test_name, null, filter, null, null);
if (!ar.AsyncWaitHandle.WaitOne(timeout) || !ar.IsCompleted)
{
TestCaseResult error = new TestCaseResult(test);
string msg = String.Format("Timeout after {0} ms", timeout);
error.Failure(msg, null, FailureSite.Parent);
suite_result.AddResult(error);
return(false);
}
try {
TestResult result = runner.EndInvoke(ar);
if (result != null)
{
suite_result.AddResult(result);
return(true);
}
TestCaseResult error = new TestCaseResult(test);
error.Failure("Unknown error", null, FailureSite.Parent);
suite_result.AddResult(error);
return(false);
} catch (Exception ex) {
TestCaseResult error = new TestCaseResult(test);
string msg = String.Format("Unknown exception: {0}", ex);
error.Failure(msg, null, FailureSite.Parent);
suite_result.AddResult(error);
return(false);
}
}
void OutputSuiteResult(TestSuiteResult result)
{
if (!(result.Test is TestFixture))
{
return;
}
var label = new Label {
Text = $"{result.Name} Finished.", LineBreakMode = LineBreakMode.HeadTruncation
};
var counts = new Label {
Text = $"Passed: {result.PassCount}; Failed: {result.FailCount}; Inconclusive: {result.InconclusiveCount}"
};
if (result.FailCount > 0)
{
label.TextColor = _failColor;
_runFailed = true;
}
else if (result.InconclusiveCount > 0)
{
label.TextColor = _inconclusiveColor;
_runInconclusive = true;
}
else
{
label.TextColor = _successColor;
SetupPassedLabelBindings(label);
SetupPassedLabelBindings(counts);
}
counts.TextColor = label.TextColor;
Device.BeginInvokeOnMainThread(() =>
{
Results.Children.Add(label);
Results.Children.Add(counts);
});
}
public Task <TestSuiteResult> RunTestsAsync(string dllPath)
{
var directoryPath = Path.GetDirectoryName(dllPath);
return(Task.Run(() =>
{
using (var command = Command.Run(
GetDotNetExe(),
new[] { "vstest", dllPath, $"--logger:trx;LogFileName={_resultId}", $"--ResultsDirectory:{directoryPath}" },
o =>
{
o.StartInfo(si =>
{
si.CreateNoWindow = true;
si.UseShellExecute = false;
si.RedirectStandardError = true;
si.RedirectStandardInput = true;
si.RedirectStandardOutput = true;
});
o.DisposeOnExit();
}))
{
var success = ReadToEnd(command.StandardError, out var error);
if (!success)
{
command.Kill();
}
if (!success || (!command.Result.Success && !error.ToLower().Contains("test run failed")))
{
return TestSuiteResult.Error(error, TimeSpan.Zero);
}
return CreateResult(Path.GetFileNameWithoutExtension(dllPath), directoryPath);
}
}));
}
public static TestResult Find(string name, TestResult result)
{
if (result.Test.TestName.Name == name)
{
return(result);
}
TestSuiteResult suiteResult = result as TestSuiteResult;
if (suiteResult != null)
{
foreach (TestResult r in suiteResult.Results)
{
TestResult myResult = Find(name, r);
if (myResult != null)
{
return(myResult);
}
}
}
return(null);
}
public void Visit(TestSuiteResult suiteResult)
{
xmlWriter.WriteStartElement("test-suite");
xmlWriter.WriteAttributeString("name", suiteResult.Name);
if (suiteResult.Description != null)
{
xmlWriter.WriteAttributeString("description", suiteResult.Description);
}
xmlWriter.WriteAttributeString("success", suiteResult.IsSuccess.ToString());
xmlWriter.WriteAttributeString("time", suiteResult.Time.ToString());
xmlWriter.WriteAttributeString("asserts", suiteResult.AssertCount.ToString());
WriteCategories(suiteResult);
xmlWriter.WriteStartElement("results");
foreach (TestResult result in suiteResult.Results)
{
result.Accept(this);
}
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
}
private TestResult findResult(string name, TestResult result)
{
if (result.Test.Name == name)
{
return(result);
}
TestSuiteResult suiteResult = result as TestSuiteResult;
if (suiteResult != null)
{
foreach (TestResult r in suiteResult.Results)
{
TestResult myResult = findResult(name, r);
if (myResult != null)
{
return(myResult);
}
}
}
return(null);
}
private void MarkTestFailed(
Test test, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter)
{
if (test is TestSuite)
{
listener.SuiteStarted(test.TestName);
TestSuiteResult result = new TestSuiteResult(new TestInfo(test), test.TestName.FullName);
string msg = string.Format("Parent SetUp failed in {0}", this.FixtureType.Name);
result.Failure(msg, null, FailureSite.Parent);
MarkTestsFailed(test.Tests, suiteResult, listener, filter);
suiteResult.AddResult(result);
listener.SuiteFinished(result);
}
else
{
listener.TestStarted(test.TestName);
TestCaseResult result = new TestCaseResult(new TestInfo(test));
string msg = string.Format("TestFixtureSetUp failed in {0}", this.FixtureType.Name);
result.Failure(msg, null, FailureSite.Parent);
suiteResult.AddResult(result);
listener.TestFinished(result);
}
}
public virtual TestResult Run(EventListener listener, ITestFilter filter)
{
// Save active listener for derived classes
this.listener = listener;
ITest[] tests = new ITest[runners.Length];
for (int index = 0; index < runners.Length; index++)
{
tests[index] = runners[index].Test;
}
this.listener.RunStarted(this.Test.TestName.Name, this.CountTestCases(filter));
this.listener.SuiteStarted(this.Test.TestName);
long startTime = DateTime.Now.Ticks;
TestSuiteResult result = new TestSuiteResult(new TestInfo(testName, tests), projectName);
result.RunState = RunState.Executed;
foreach (TestRunner runner in runners)
{
result.Results.Add(runner.Run(this, filter));
}
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
result.Time = time;
this.listener.SuiteFinished(result);
this.listener.RunFinished(result);
this.testResult = result;
return(result);
}
/// <inheritdoc />
public async Task <ITestResult> GetTestResultsAsync(Assembly assembly)
{
if (assembly == null)
{
throw ExceptionHelper.ThrowArgumentNullException(nameof(assembly));
}
Task <ITestResult> task = Task.Run(() =>
{
lock (TestSuite)
{
TestSuiteResult results = new TestSuiteResult(TestSuite);
ITestAssemblyRunner runner = TestSuite.GetTestAssemblyRunner(assembly);
if (runner?.Result != null)
{
results.AddResult(runner.Result);
}
return((ITestResult)results);
}
});
return(await task.ConfigureAwait(false));
}
public void HandleExceptionInFixtureConstructor()
{
TestSuite suite = TestBuilder.MakeFixture(typeof(ExceptionInConstructor));
TestSuiteResult result = (TestSuiteResult)suite.Run(NullListener.NULL);
// should have one suite and one fixture
ResultSummarizer summ = new ResultSummarizer(result);
Assert.AreEqual(1, summ.ResultCount);
Assert.AreEqual(0, summ.TestsNotRun);
Assert.AreEqual(0, summ.SuitesNotRun);
Assert.IsTrue(result.Executed, "Suite should have executed");
Assert.IsTrue(result.IsFailure, "Suite should have failed");
Assert.AreEqual("System.Exception : This was thrown in constructor", result.Message, "TestSuite Message");
Assert.IsNotNull(result.StackTrace, "TestSuite StackTrace should not be null");
TestResult testResult = ((TestResult)result.Results[0]);
Assert.IsTrue(testResult.Executed, "Testcase should have executed");
Assert.AreEqual("TestFixtureSetUp failed in ExceptionInConstructor", testResult.Message, "TestSuite Message");
Assert.AreEqual(FailureSite.Parent, testResult.FailureSite);
Assert.AreEqual(testResult.StackTrace, testResult.StackTrace, "TestCase stackTrace should match TestSuite stackTrace");
}
public void RerunFixtureAfterTearDownFixed()
{
MisbehavingFixtureTearDown testFixture = new MisbehavingFixtureTearDown();
TestSuite suite = new TestSuite("ASuite");
suite.Add(testFixture);
TestSuiteResult result = (TestSuiteResult)suite.Run(NullListener.NULL);
Assert.AreEqual(1, result.Results.Count);
// should have one suite and one fixture
ResultSummarizer summ = new ResultSummarizer(result);
Assert.AreEqual(1, summ.ResultCount);
Assert.AreEqual(0, summ.TestsNotRun);
Assert.AreEqual(0, summ.SuitesNotRun);
testFixture.blowUp = false;
result = (TestSuiteResult)suite.Run(NullListener.NULL);
summ = new ResultSummarizer(result);
Assert.AreEqual(1, summ.ResultCount);
Assert.AreEqual(0, summ.TestsNotRun);
Assert.AreEqual(0, summ.SuitesNotRun);
}
public void HandleErrorInFixtureTearDown()
{
MisbehavingFixtureTearDown testFixture = new MisbehavingFixtureTearDown();
TestSuite suite = new TestSuite("ASuite");
suite.Add(testFixture);
TestSuiteResult result = (TestSuiteResult)suite.Run(NullListener.NULL);
Assert.AreEqual(1, result.Results.Count);
TestResult failedResult = ((TestResult)result.Results[0]);
Assert.IsTrue(failedResult.Executed, "Suite should have executed");
Assert.IsTrue(failedResult.IsFailure, "Suite should have failed");
Assert.AreEqual("This was thrown from fixture teardown", failedResult.Message);
Assert.IsNotNull(failedResult.StackTrace, "StackTrace should not be null");
// should have one suite and one fixture
ResultSummarizer summ = new ResultSummarizer(result);
Assert.AreEqual(1, summ.ResultCount);
Assert.AreEqual(0, summ.TestsNotRun);
Assert.AreEqual(0, summ.SuitesNotRun);
}
private static TestResult ExecuteSuiteCommand(TestSuiteCommand command, TestExecutionContext context)
{
TestSuiteResult testSuiteResult = context.CurrentResult as TestSuiteResult;
Debug.Assert(testSuiteResult != null);
bool flag = false;
try
{
ApplyTestSettingsToExecutionContext(command.Test, context);
command.DoOneTimeSetUp(context);
flag = true;
context.Update();
testSuiteResult = RunChildCommands(command, context);
}
catch (Exception innerException)
{
if (innerException is NUnitException || innerException is TargetInvocationException)
{
innerException = innerException.InnerException;
}
if (flag)
{
testSuiteResult.RecordException(innerException);
}
else
{
testSuiteResult.RecordException(innerException, FailureSite.SetUp);
}
}
finally
{
command.DoOneTimeTearDown(context);
}
return(testSuiteResult);
}
//private TestCaseResult testCase;
private TestSuiteResult MockSuiteResult(bool failure)
{
TestCaseResult testCaseResult = new TestCaseResult("a test case");
if (failure)
{
testCaseResult.Failure("case failed", null);
}
TestSuiteResult level1SuiteA = new TestSuiteResult("level 1 A");
level1SuiteA.AddResult(testCaseResult);
TestSuiteResult level1SuiteB = new TestSuiteResult("level 1 B");
level1SuiteB.AddResult(new TestCaseResult("a successful test"));
TestSuiteResult result = new TestSuiteResult("base");
result.AddResult(level1SuiteA);
result.AddResult(level1SuiteB);
return(result);
}
public void HandleErrorInFixtureTearDown()
{
MisbehavingFixture fixture = new MisbehavingFixture();
fixture.blowUpInTearDown = true;
TestSuiteResult result = RunTestOnFixture(fixture);
Assert.AreEqual(1, result.Results.Count);
Assert.IsTrue(result.Executed, "Suite should have executed");
Assert.IsTrue(result.IsFailure, "Suite should have failed");
Assert.AreEqual(1, fixture.setUpCount, "setUpCount");
Assert.AreEqual(1, fixture.tearDownCount, "tearDownCOunt");
Assert.AreEqual("This was thrown from fixture teardown", result.Message);
Assert.IsNotNull(result.StackTrace, "StackTrace should not be null");
// should have one suite and one fixture
ResultSummarizer summ = new ResultSummarizer(result);
Assert.AreEqual(1, summ.ResultCount);
Assert.AreEqual(0, summ.TestsNotRun);
Assert.AreEqual(0, summ.SuitesNotRun);
}
private TestSuiteResult CreateTestSuiteResult(string annotation)
{
// Create object to hold test run results
TestSuiteResult testSuiteResult = new TestSuiteResult(currentUserSvc.GetCurrentUserData().UserId);
// Set user-supplied annotation for test run
testSuiteResult.Annotation = annotation;
// Set system info for this test run
SetSystemInfo(testSuiteResult);
// Set start time after getting system info so it doesn't affect results
testSuiteResult.StartTime = DateTime.Now;
return testSuiteResult;
}
public void SuiteFinished(TestSuiteResult result)
{
this.listener.SuiteFinished(result);
}
public void SuiteFinished(TestSuiteResult result)
{
Console.Out.WriteLine();
}
private static void SetSystemInfo(TestSuiteResult testSuiteResult)
{
const string componentCpu = "CPU";
const string componentRam = "RAM";
IDictionary<string, IDictionary<string, string[]>> systemInfoKeys =
new Dictionary<string, IDictionary<string, string[]>>();
systemInfoKeys["Win32_ComputerSystem"] = new Dictionary<string, string[]>
{
{ componentRam, new string[] { "TotalPhysicalMemory" } }
};
systemInfoKeys["Win32_Processor"] = new Dictionary<string, string[]>
{
{ componentCpu, new string[] {"Manufacturer","AddressWidth","Description","Name","MaxClockSpeed"} },
};
systemInfoKeys["Win32_PerfFormattedData_PerfOS_Processor"] = new Dictionary<string, string[]>
{
{ componentCpu, new string[] {"PercentIdleTime"} },
};
foreach (string key in systemInfoKeys.Keys)
{
IDictionary<string, string[]> wmiKeys = systemInfoKeys[key];
ManagementObjectSearcher search = new ManagementObjectSearcher("select * from " + key);
foreach (ManagementObject wmiObj in search.Get())
{
foreach (string key2 in wmiKeys.Keys)
{
foreach (string key3 in wmiKeys[key2])
{
try
{
testSuiteResult.SystemInfoList.Add(new SystemInfo(key2, key3,
wmiObj[key3].ToString()));
}
catch
{
// Ignore exception -- probably means data is not available
}
}
}
}
}
// Get current CPU utilization
PerformanceCounter cpuCounter = new PerformanceCounter();
cpuCounter.CategoryName = "Processor";
cpuCounter.CounterName = "% Processor Time";
cpuCounter.InstanceName = "_Total";
testSuiteResult.SystemInfoList.Add(new SystemInfo(componentCpu, "CPU Usage",
cpuCounter.NextValue() + "%"));
// Get current available RAM
PerformanceCounter ramCounter = new PerformanceCounter("Memory", "Available MBytes");
testSuiteResult.SystemInfoList.Add(new SystemInfo("RAM", "Available RAM",
ramCounter.NextValue() + "MB"));
}
public void SuiteFinished(TestSuiteResult result)
{
suiteFinished++;
}
public override void Run(IList <TestAssemblyInfo> testAssemblies)
{
if (testAssemblies == null)
{
throw new ArgumentNullException(nameof(testAssemblies));
}
if (AssemblyFilters == null || AssemblyFilters.Count == 0)
{
runAssemblyByDefault = true;
}
else
{
runAssemblyByDefault = AssemblyFilters.Values.Any(v => !v);
}
var builder = new NUnitLiteTestAssemblyBuilder();
var runner = new NUnitLiteTestAssemblyRunner(builder, new FinallyDelegate());
var testSuite = new TestSuite(NSBundle.MainBundle.BundleIdentifier);
results = new TestSuiteResult(testSuite);
TotalTests = 0;
foreach (TestAssemblyInfo assemblyInfo in testAssemblies)
{
if (assemblyInfo == null || assemblyInfo.Assembly == null || !ShouldRunAssembly(assemblyInfo))
{
continue;
}
if (!runner.Load(assemblyInfo.Assembly, builderSettings))
{
OnWarning($"Failed to load tests from assembly '{assemblyInfo.Assembly}");
continue;
}
if (runner.LoadedTest is NUnitTest tests)
{
TotalTests += tests.TestCaseCount;
testSuite.Add(tests);
}
// Messy API. .Run returns ITestResult which is, in reality, an instance of TestResult since that's
// what WorkItem returns and we need an instance of TestResult to add it to TestSuiteResult. So, cast
// the return to TestResult and hope for the best.
ITestResult result = null;
try {
OnAssemblyStart(assemblyInfo.Assembly);
result = runner.Run(this, Filter);
} finally {
OnAssemblyFinish(assemblyInfo.Assembly);
}
if (result == null)
{
continue;
}
var testResult = result as TestResult;
if (testResult == null)
{
throw new InvalidOperationException($"Unexpected test result type '{result.GetType ()}'");
}
results.AddResult(testResult);
}
// NUnitLite doesn't report filtered tests at all, but we can calculate here
FilteredTests = TotalTests - ExecutedTests;
LogFailureSummary();
}
public void SuiteFinished(TestSuiteResult result)
{
foreach( EventListener listener in extensions )
listener.SuiteFinished( result );
}
/// <summary>
/// Trigger event when each suite finishes
/// </summary>
/// <param name="result">Result of the suite that finished</param>
void EventListener.SuiteFinished(TestSuiteResult result)
{
events.FireSuiteFinished(result);
}
private void writeTestSuiteResultToFile(TestSuiteResult testSuiteResult)
{
TestSuiteResult.SerializeToFile(testSuiteResult, string.Format("{0}\\{1} - {2}.xml", _metricsFolder,
testSuiteResult.VirtualUser, testSuiteResult.TestVerdict));
}
public void Visit(TestSuiteResult suiteResult)
{
Console.WriteLine(suiteResult.Name);
if(suiteResult.Name.Equals(name))
Assert.AreEqual(description, suiteResult.Description);
foreach (TestResult result in suiteResult.Results)
{
result.Accept(this);
}
}
public void SuiteFinished(TestSuiteResult result)
{
wrapped.SuiteFinished(GetTestName(result.Test.TestName), GetLocalTestResult(result));
}
public override void OnTestSuiteExecutionComplete(TestSuite testSuite, TestSuiteResult testSuiteResult)
{
throw new NotImplementedException();
}
/// <summary>
/// Construct a CompositeWorkItem for executing a test suite
/// using a filter to select child tests.
/// </summary>
/// <param name="suite">The TestSuite to be executed</param>
/// <param name="childFilter">A filter used to select child tests</param>
public CompositeWorkItem(TestSuite suite, ITestFilter childFilter)
: base(suite, childFilter)
{
_suite = suite;
_suiteResult = Result as TestSuiteResult;
}
private void RunTestsInAssembly(string assemblyName, TestSuiteResult testSuiteResult)
{
// Load given assembly
Assembly assembly = Assembly.Load(assemblyName);
// Pass empty object to performance test methods
object[] parms = new object[] { };
// Loop through non-abstract types in given assembly
foreach (Type type in assembly.GetTypes().Where(type => !type.IsAbstract))
{
// Create instance of type
object instance;
try
{
instance = Activator.CreateInstance(type);
}
catch (Exception e)
{
logger.Error("Caught exception in creating type " + type
+ " in assembly " + assemblyName, e);
// Continue on to next type
continue;
}
// Make sure instance implements required interface
IPerfTestApp perfTestApp = instance as IPerfTestApp;
if (perfTestApp == null)
{
logger.Warn("Type does not support required interface: " + type
+ " in assembly " + assemblyName);
// Continue on to next type
continue;
}
// Run setup method
try
{
perfTestApp.Setup();
}
catch (Exception e)
{
logger.Error("Caught exception in running setup for " + type
+ " in assembly " + assemblyName, e);
// Continue on to next type
continue;
}
// Run all performance tests
foreach (MethodInfo method in type.GetMethods().Where(
method => HasAttribute(method, typeof(PerfTestAttribute))))
{
//
// Create new test result data and set in thread local storage so it
// can be accessed anywhere in stack
//
DateTime endTime = default(DateTime);
TestResult testResult = SetupCurrentTest(testSuiteResult, string.Empty,
type.Name, method.Name);
try
{
// Run performance test for this method
method.Invoke(instance, parms);
// Gather end time before running stats so it doesn't affect perf time
endTime = DateTime.Now;
// Gather stats
try
{
testResult.Annotation = (string.IsNullOrEmpty(testResult.Annotation)) ? "" : ", ";
testResult.Annotation += perfTestApp.GetStats();
}
catch (Exception e)
{
logger.Error("Caught exception in gathering stats for " + type
+ " in assembly " + assemblyName, e);
}
}
catch (Exception e)
{
logger.Error("Caught exception in running perf test for " + type
+ " in assembly " + assemblyName, e);
// Test failed
testResult.IsSuccess = false;
}
finally
{
ClearCurrentTest(testResult, endTime);
}
}
// Run tear down method
try
{
perfTestApp.TearDown();
}
catch (Exception e)
{
logger.Error("Caught exception in running tear down for " + type
+ " in assembly " + assemblyName, e);
}
}
}
public void AddNewTestSuiteResult(TestSuiteResult testsuiteResult)
{
_testSuiteResults.Add(testsuiteResult);
}
private void SaveTestSuiteResult(TestSuiteResult testSuiteResult)
{
//
// Put mutex on this instance of test suite results in case multiple threads
// are trying to persist it
//
lock (testSuiteResult)
{
perfTestSvc.SaveTestResults(testSuiteResult);
}
}
public override void OnTestSuiteExecutionComplete(TestSuite testSuite, TestSuiteResult testSuiteResult)
{
Debug.WriteLine("SampleTestListener2 method: " + MethodInfo.GetCurrentMethod().Name);
}
private TestResult SetupCurrentTest(TestSuiteResult testSuiteResult, string annotation,
string typeName, string methodName)
{
// Add a new test data instance to test run results for this perf test
TestResult testResult = new TestResult(typeName, methodName);
testResult.Annotation = annotation;
//
// Put mutex on this instance of test suite results in case multiple threads
// are trying to access it
//
lock (testSuiteResult)
{
testSuiteResult.TestResultList.Add(testResult);
}
//
// Set current test data results object in thread local storage so it
// can be accessed anywhere in stack
//
perfTestSvc.SetCurrentTestResult(testResult);
return testResult;
}
public void SuiteFinished(TestSuiteResult result)
{
suiteFinished.Add(result.Name);
}
public Task <TestSuiteResult> RunTestsAsync(string runner, string dllPath, string dotNetPath, TimeSpan maxTime)
{
return(Task.Run(() =>
{
var allArguments = new List <string>
{
runner,
dllPath,
dotNetPath
};
try
{
using (var command = Command.Run(
"Unima.TestRunner.Console.exe",
allArguments,
o =>
{
o.StartInfo(si =>
{
si.CreateNoWindow = true;
si.UseShellExecute = false;
si.RedirectStandardError = true;
si.RedirectStandardInput = true;
si.RedirectStandardOutput = true;
});
o.Timeout(maxTime);
o.DisposeOnExit();
}))
{
var output = command.StandardOutput.ReadToEnd();
var error = command.StandardError.ReadToEnd();
try
{
if (!command.Result.Success)
{
LogTo.Info($"Message from test client - {output}.");
LogTo.Info($"Error from test client - {error}.");
return new TestSuiteResult
{
IsSuccess = false,
Name = $"ERROR - {error}",
ExecutionTime = TimeSpan.Zero,
TestResults = new List <TestResult>()
};
}
}
catch (TimeoutException)
{
LogTo.Info("Test client timed out. Infinit loop?");
return TestSuiteResult.Error("TIMEOUT", maxTime);
}
return JsonConvert.DeserializeObject <TestSuiteResult>(output);
}
}
catch (Win32Exception ex)
{
LogTo.ErrorException("Unknown expcetion from test client process", ex);
throw;
}
}));
}
public void SuiteFinished(TestSuiteResult suiteResult)
{
}
void EventListener.SuiteFinished(TestSuiteResult nunitResult)
