public void CaseSkipped(SkipResult result)
{
tdnet.TestFinished(new TestResult
{
Name = result.Case.Name,
State = TestState.Ignored
});
}
public void CaseSkipped(Case @case)
{
tdnet.TestFinished(new TestResult
{
Name = @case.Name,
State = TestState.Ignored
});
}
public void CasePassed(string @case)
{
tdnet.TestFinished(new TestResult
{
Name = @case,
State = TestState.Passed
});
}
public void CaseSkipped(SkipResult result)
{
tdnet.TestFinished(new TestResult
{
Name = result.Name,
State = TestState.Ignored,
Message = result.SkipReason
});
}
public ITestResult Run(ITestListener listener, ITestFilter filter)
{
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, filter);
while (true)
{
object message = formatter.Deserialize(stream);
if (message is TestStartedMessage tsmessage)
{
listener.TestStarted(tsmessage.Test);
}
else if (message is TestFinishedMessage tfmessage)
{
listener.TestFinished(tfmessage.TestResult);
}
else if (message is ExceptionMessage emessage)
{
throw emessage.Exception;
}
else if (message is ResultMessage rmessage)
{
return(rmessage.TestResult);
}
else
{
throw new Exception($"unknown message {message}");
}
}
adb.WaitForExit();
}
TestRunState executeConsoleRunner(ITestListener testListener, Assembly testAssembly, string where)
{
var exeFile = findConsoleRunner();
if (exeFile == null)
{
throw new Exception("Couldn't find NUnit.ConsoleRunner in NuGet packages.");
}
string assemblyFile = new Uri(testAssembly.EscapedCodeBase).LocalPath;
string arguments = quote(assemblyFile);
if (!string.IsNullOrEmpty(where))
{
arguments += " --where=" + quote(where);
}
arguments += " --process:InProcess";
var startInfo = new ProcessStartInfo(exeFile, arguments);
startInfo.UseShellExecute = false;
startInfo.CreateNoWindow = true;
startInfo.RedirectStandardOutput = true;
var process = Process.Start(startInfo);
process.WaitForExit();
string stdout = process.StandardOutput.ReadToEnd();
testListener.WriteLine(stdout, Category.Output);
var testResult = new TestResult();
switch (process.ExitCode)
{
case 0:
testResult.State = TestState.Passed;
testListener.TestFinished(testResult);
return(TestRunState.Success);
default:
testResult.State = TestState.Failed;
testListener.TestFinished(testResult);
return(TestRunState.Failure);
}
}
public void EndTest(Testing.TestRunner.ITest test)
{
lock ( _listener )
{
TestResult tr = new TestResult();
tr.FixtureType = test.Fixture.Instance.GetType();
StringBuilder sb = new StringBuilder();
if (test.Result.Message.Length > 0)
{
if (test.Result.Status != Testing.TestRunner.TestStatus.Ignore)
{
sb.Append("MESSAGE: ");
}
else
{
sb.Append("IGNORED: ");
}
sb.Append(test.Result.Message);
}
if (sb.Length > 0)
{
tr.Message = sb.ToString();
}
tr.TimeSpan = new TimeSpan(test.Result.TimeSpan);
tr.Method = test.TestMethod;
tr.StackTrace = test.Result.StackTrace;
tr.Name = test.Name;
switch (test.Result.Status)
{
case Testing.TestRunner.TestStatus.Untested:
tr.State = TestState.Ignored;
break;
case Testing.TestRunner.TestStatus.Pass:
tr.State = TestState.Passed;
break;
case Testing.TestRunner.TestStatus.Ignore:
tr.State = TestState.Ignored;
break;
case Testing.TestRunner.TestStatus.Fail:
tr.State = TestState.Failed;
break;
default:
break;
}
tr.TotalTests = test.TestCount;
_listener.TestFinished(tr);
// Write long output to the debug window.
if (test.Result.Output.Length > 0 && test.Result.Status != Testing.TestRunner.TestStatus.Pass)
{
sb.Append(test.Result.Output);
Console.WriteLine(sb.ToString());
}
}
}
/// <summary>
/// Called when a test has finished
/// </summary>
/// <param name="result">The result of the test</param>
public void TestFinished(ITestResult result)
{
if (_teamCity != null)
{
_teamCity.TestFinished(result);
}
_textUI.TestFinished(result);
}
void Log(CaseCompleted message, Action <TestResult> customize)
{
var testResult = new TestResult {
Name = message.Name
};
customize(testResult);
tdnet.TestFinished(testResult);
}
public override void ScenarioFinished(ScenarioResult result)
{
listener.WriteLine(string.Format("\t\tScenario: {0} - {1}", result.ScenarioTitle, result.Result), Category.Info);
listener.TestFinished(
new TestResult
{
Name = result.ScenarioTitle,
Message = result.Result.Message,
State = result.Result.ToTestState(),
StackTrace = result.StackTrace
});
}
public void TestFinished(ITestResult result)
{
if (!(result.Test is TestSuite))
{
Writer.Write(": [");
Writer.Write(result.ResultState.Status.ToString().ToUpperInvariant());
Writer.Write("]");
Writer.WriteLine();
}
innerListener.TestFinished(result);
}
public bool ClassFailed(string className, string exceptionType, string message, string stackTrace)
{
Type type = assembly.GetType(className);
TestResult testResult =
new TestResult
{
FixtureType = type,
Name = ("Fixture " + type.FullName),
TotalTests = 1,
State = TestState.Failed,
Message = message,
StackTrace = stackTrace
};
if (listener != null)
{
listener.TestFinished(testResult);
}
return(true);
}
private TestRunState Run(ITestListener testListener, Runner runner, TestFilter filter)
{
var state = TestRunState.NoTests;
runner.RunAll(result => {
testListener.TestFinished(new TestResult()
{
Name = String.Format("{0}.{1}", result.Test.Fixture.Name, result.Test.Name),
FixtureType = ((Fixture)result.Test.Fixture).Type,
StackTrace = result.Output,
Method = ((Test)result.Test).Method,
State = StateForResult(result.Kind),
TimeSpan = result.EndTime - result.StartTime,
});
if (state == TestRunState.NoTests)
{
switch (result.Kind)
{
case ResultKind.Fail:
state = TestRunState.Failure;
break;
case ResultKind.Error:
state = TestRunState.Error;
break;
default:
state = TestRunState.Success;
break;
}
}
else if (state == TestRunState.Success || state == TestRunState.Failure)
{
switch (result.Kind)
{
case ResultKind.Fail:
state = TestRunState.Failure;
break;
case ResultKind.Error:
state = TestRunState.Error;
break;
}
}
}, filter);
return(state);
}
public void TestFinished(FacadeTestResult result)
{
if (result == null)
{
throw new ArgumentNullException("result");
}
try
{
testListener.TestFinished(FacadeUtils.ToTestResult(result));
}
catch (Exception ex)
{
throw ServerExceptionUtils.Wrap(ex);
}
}
public void OnRunEnd()
{
if (testResults.Count == 0)
{
return;
}
bool failure = false;
foreach (var testResult in testResults)
{
testListener.TestFinished(testResult);
failure |= testResult.State == TestState.Failed;
}
testRunState = failure ? TestRunState.Failure : TestRunState.Success;
}
/// <summary>
/// Called when a test has finished
/// </summary>
/// <param name="result">The result of the test</param>
public void TestFinished(ITestResult result)
{
if (_teamCity != null)
{
_teamCity.TestFinished(result);
}
#if !SILVERLIGHT
_textUI.TestFinished(result);
#else
// For Silverlight, we can't display the results
// until the run is completed. We don't save anything
// unless there is associated output, since that's
// the only time we display anything in Silverlight.
if (result.Output.Length > 0)
{
_results.Add(result);
}
#endif
}
/// <summary>
/// A test has just finished
/// </summary>
/// <param name="result">The result of the test</param>
public void TestFinished(ITestResult result)
{
listener.TestFinished(result);
}
public TestResult Run(ITestListener listener)
{
listener.TestStarted(this);
TestResult result = new TestResult(this);
Run(result, listener);
listener.TestFinished(result);
return result;
}
public TestResult Run(ITestListener listener)
{
int count = 0, failures = 0, errors = 0;
listener.TestStarted(this);
TestResult result = new TestResult(this);
switch (this.RunState)
{
case RunState.NotRunnable:
result.Error(this.IgnoreReason);
break;
case RunState.Ignored:
result.NotRun(this.IgnoreReason);
break;
case RunState.Runnable:
foreach (ITest test in tests)
{
++count;
TestResult r = test.Run(listener);
result.AddResult(r);
switch (r.ResultState)
{
case ResultState.Error:
++errors;
break;
case ResultState.Failure:
++failures;
break;
default:
break;
}
}
if (count == 0)
result.NotRun("Class has no tests");
else if (errors > 0 || failures > 0)
result.Failure("One or more component tests failed");
else
result.Success();
break;
}
listener.TestFinished(result);
return result;
}
/// <summary>
/// Calls TestFinished on the specified listener.
/// </summary>
/// <param name="listener">The listener.</param>
public override void Send(ITestListener listener)
{
listener.TestFinished(this.result);
}
/// <summary>
/// Calls TestFinished on the specified listener.
/// </summary>
/// <param name="listener">The listener.</param>
public override void Send(ITestListener listener)
{
listener.TestFinished(_result);
}
private TestRunState Run( ITestListener testListener, Runner runner, TestFilter filter)
{
var state = TestRunState.NoTests;
runner.RunAll(result =>{
testListener.TestFinished( new TestResult()
{
Name = String.Format("{0}.{1}",result.Test.Fixture.Name, result.Test.Name),
FixtureType = ((Fixture)result.Test.Fixture).Type,
StackTrace = result.Output,
Method = ((Test)result.Test).Method,
State = StateForResult(result.Kind),
TimeSpan = result.EndTime - result.StartTime,
});
if(state == TestRunState.NoTests){
switch (result.Kind)
{
case ResultKind.Fail:
state = TestRunState.Failure;
break;
case ResultKind.Error:
state = TestRunState.Error;
break;
default:
state = TestRunState.Success;
break;
}
} else if(state == TestRunState.Success || state == TestRunState.Failure){
switch (result.Kind)
{
case ResultKind.Fail:
state = TestRunState.Failure;
break;
case ResultKind.Error:
state = TestRunState.Error;
break;
}
}
}, filter);
return state;
}
