/// <summary>
/// Executes the test method, failing if it takes too long.
/// </summary>
/// <returns>Returns information about the test run</returns>
public override MethodResult Execute(object testClass)
{
WorkerThreadHandler timedMethod = () => { return InnerCommand.Execute(testClass); };
IAsyncResult asyncResult = timedMethod.BeginInvoke(null, null);
MethodResult methodResult;
if (!asyncResult.AsyncWaitHandle.WaitOne(Timeout, false))
methodResult = new FailedResult(testMethod, new TimeoutException(Timeout), DisplayName);
else
methodResult = timedMethod.EndInvoke(asyncResult);
return methodResult;
}
public void InitializeFailedResult()
{
Type stubType = typeof(StubClass);
MethodInfo method = stubType.GetMethod("StubMethod");
StubException stubException = new StubException("Message", "StackTrace");
FailedResult result = new FailedResult(Reflector.Wrap(method), stubException, null);
result.ExecutionTime = 1.2;
Assert.Equal("StubMethod", result.MethodName);
Assert.Equal(stubType.FullName, result.TypeName);
Assert.Equal(typeof(StubException).FullName + " : Message", result.Message);
Assert.Equal(1.2, result.ExecutionTime);
Assert.Equal("StackTrace", result.StackTrace);
}
public override MethodResult Execute(object testClass)
{
MethodResult result = null;
try
{
result = InnerCommand.Execute(testClass);
}
catch (Exception ex)
{
result = new FailedResult(_method, ex, DisplayName);
}
return result;
}
public void FailedResultIsReturnedIfInnerCommandFails([Frozen] string displayName, [Frozen] ITestCommand innerCommand, ParadigmTestCommand sut, FailedResult innerCommandResult)
{
Mock.Get(innerCommand).Setup(x => x.Execute(It.IsAny<object>()))
.Returns(innerCommandResult);
var result = sut.Execute(null);
Assert.That(result, Describe.Object<MethodResult>()
.Cast<FailedResult>(c => c.Property(x => x.DisplayName, Is.EqualTo(displayName))
.Property(x => x.ExceptionType, Is.EqualTo(innerCommandResult.ExceptionType))
.Property(x => x.MethodName, Is.EqualTo(innerCommandResult.MethodName))
.Property(x => x.TypeName, Is.EqualTo(innerCommandResult.TypeName))
.Property(x => x.Traits, Is.EqualTo(innerCommandResult.Traits))
.Property(x => x.Message, Is.EqualTo(innerCommandResult.Message))
.Property(x => x.StackTrace, Is.EqualTo(innerCommandResult.StackTrace))));
}
/// <inheritdoc/>
public override MethodResult Execute(object testClass)
{
MethodResult result = null;
List <TraceListener> oldListeners = new List <TraceListener>();
TextWriter oldOut = Console.Out;
TextWriter oldError = Console.Error;
using (StringWriter outputWriter = new StringWriter())
{
try
{
foreach (TraceListener oldListener in Trace.Listeners)
{
oldListeners.Add(oldListener);
}
Trace.Listeners.Clear();
Trace.Listeners.Add(new AssertTraceListener());
Trace.Listeners.Add(new TextWriterTraceListener(outputWriter));
Console.SetOut(outputWriter);
Console.SetError(outputWriter);
result = InnerCommand.Execute(testClass);
}
catch (Exception ex)
{
result = new FailedResult(method, ex, DisplayName);
}
finally
{
Console.SetOut(oldOut);
Console.SetError(oldError);
try
{
Trace.Listeners.Clear();
Trace.Listeners.AddRange(oldListeners.ToArray());
}
catch (Exception) { }
}
result.Output = outputWriter.ToString();
return(result);
}
}
public void InitializeFailedResultWithMultipleInnerExceptions()
{
Type stubType = typeof(StubClass);
MethodInfo method = stubType.GetMethod("StubMethod");
Exception thrownException = null;
Exception innerException = null;
try
{
try
{
throw new InvalidOperationException();
}
catch (Exception ex)
{
innerException = ex;
throw new Exception("message", ex);
}
}
catch (Exception ex)
{
thrownException = ex;
}
FailedResult result = new FailedResult(Reflector.Wrap(method), thrownException, null);
result.ExecutionTime = 1.2;
string expectedMessage = string.Format("{0} : {1}{2}---- {3} : {4}",
thrownException.GetType().FullName,
thrownException.Message,
Environment.NewLine,
innerException.GetType().FullName,
innerException.Message);
Assert.Equal(expectedMessage, result.Message);
string expectedStackTrace =
string.Format("{0}{1}----- Inner Stack Trace -----{1}{2}",
thrownException.StackTrace,
Environment.NewLine,
innerException.StackTrace);
Assert.Equal(expectedStackTrace, result.StackTrace);
}
/// <summary>
/// Executes the test method, failing if it takes too long.
/// </summary>
/// <returns>Returns information about the test run</returns>
public override MethodResult Execute(object testClass)
{
WorkerThreadHandler timedMethod = () => { return(InnerCommand.Execute(testClass)); };
IAsyncResult asyncResult = timedMethod.BeginInvoke(null, null);
MethodResult methodResult;
if (!asyncResult.AsyncWaitHandle.WaitOne(Timeout, false))
{
methodResult = new FailedResult(testMethod, new TimeoutException(Timeout), DisplayName);
}
else
{
methodResult = timedMethod.EndInvoke(asyncResult);
}
return(methodResult);
}
/// <inheritdoc/>
public override MethodResult Execute(object testClass)
{
MethodResult result = null;
List<TraceListener> oldListeners = new List<TraceListener>();
TextWriter oldOut = Console.Out;
TextWriter oldError = Console.Error;
using (StringWriter outputWriter = new StringWriter())
{
try
{
foreach (TraceListener oldListener in Trace.Listeners)
oldListeners.Add(oldListener);
Trace.Listeners.Clear();
Trace.Listeners.Add(new AssertTraceListener());
Trace.Listeners.Add(new TextWriterTraceListener(outputWriter));
Console.SetOut(outputWriter);
Console.SetError(outputWriter);
result = InnerCommand.Execute(testClass);
}
catch (Exception ex)
{
result = new FailedResult(method, ex, DisplayName);
}
finally
{
Console.SetOut(oldOut);
Console.SetError(oldError);
try
{
Trace.Listeners.Clear();
Trace.Listeners.AddRange(oldListeners.ToArray());
}
catch (Exception) { }
}
result.Output = outputWriter.ToString();
return result;
}
}
public void ToXml_WithChildren()
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode parentNode = doc.ChildNodes[0];
PassedResult passedResult = new PassedResult("foo", "bar", null, null);
passedResult.ExecutionTime = 1.1;
FailedResult failedResult = new FailedResult("foo", "bar", null, null, "extype", "message", "stack");
failedResult.ExecutionTime = 2.2;
SkipResult skipResult = new SkipResult("foo", "bar", null, null, "reason");
ClassResult classResult = new ClassResult(typeof(object));
classResult.Add(passedResult);
classResult.Add(failedResult);
classResult.Add(skipResult);
AssemblyResult assemblyResult = new AssemblyResult(filename);
assemblyResult.Add(classResult);
XmlNode resultNode = assemblyResult.ToXml(parentNode);
Assert.Equal("3.300", resultNode.Attributes["time"].Value);
Assert.Equal("3", resultNode.Attributes["total"].Value);
Assert.Equal("1", resultNode.Attributes["passed"].Value);
Assert.Equal("1", resultNode.Attributes["failed"].Value);
Assert.Equal("1", resultNode.Attributes["skipped"].Value);
Assert.Single(resultNode.SelectNodes("class"));
}
public void FailedResultIsReturnedIfInnerCommandThrows([Frozen] string displayName, [Frozen] ITestCommand innerCommand, [Frozen] IMethodInfo methodInfo, ParadigmTestCommand sut, Exception ex)
{
Mock.Get(innerCommand).Setup(x => x.Execute(It.IsAny<object>()))
.Throws(ex);
var result = sut.Execute(null);
MethodResult expected = new FailedResult(methodInfo, ex, displayName);
Assert.That(result, Is.StructurallyEqualTo(expected));
}
public void FailedResultIsReturnedIfInstanceCreationThrows([Frozen] string displayName, [Frozen] IObjectFactory instanceFactory, [Frozen] IMethodInfo methodInfo, ParadigmTestCommand sut, Exception ex)
{
Mock.Get(instanceFactory).Setup(x => x.CreateInstance())
.Throws(ex);
var result = sut.Execute(null);
MethodResult expected = new FailedResult(methodInfo, ex, displayName);
Assert.That(result, Is.StructurallyEqualTo(expected));
}
/// <summary>
/// Executes the test case method.
/// </summary>
/// <param name="testClass">An instance of the class that contains the test case method.</param>
/// <returns>The <see cref="MethodResult"/> of executing the test case method.</returns>
public override MethodResult Execute(object testClass)
{
ITestClass theTestClass = testClass as ITestClass;
if (null != theTestClass)
{
MethodResult result = null;
try
{
theTestClass.TestInitialize(this.Namespace, this.Class, this.Method);
result = base.Execute(testClass);
}
catch (Exception ex)
{
// Return test failure to avoid extra break when debugging.
result = new FailedResult(this.testMethod, ex, null);
}
finally
{
theTestClass.TestUninitialize(result);
}
return result;
}
return base.Execute(testClass);
}
public void ToXml()
{
Exception ex = new Exception();
try
{
ThrowAnException();
}
catch (Exception e)
{
ex = e;
}
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode parentNode = doc.ChildNodes[0];
MethodInfo method = typeof(StubClass).GetMethod("StubMethod");
FailedResult failedResult = new FailedResult(Reflector.Wrap(method), ex, null);
failedResult.ExecutionTime = 1.2;
XmlNode resultNode = failedResult.ToXml(parentNode);
Assert.Equal("Fail", resultNode.Attributes["result"].Value);
Assert.Equal("1.200", resultNode.Attributes["time"].Value);
XmlNode failureXmlNode = resultNode.SelectSingleNode("failure");
Assert.NotNull(failureXmlNode);
Assert.Equal(ex.GetType().FullName, failureXmlNode.Attributes["exception-type"].Value);
Assert.Equal(ex.GetType().FullName + " : " + ex.Message, failureXmlNode.SelectSingleNode("message").InnerText);
Assert.Equal(ex.StackTrace, failureXmlNode.SelectSingleNode("stack-trace").InnerText);
Assert.Null(resultNode.SelectSingleNode("reason"));
}
public void ToXmlTwiceDoesNotDoubleCounts()
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode parentNode = doc.ChildNodes[0];
ClassResult classResult = new ClassResult(typeof(object));
PassedResult passedResult = new PassedResult("foo", "bar", null, null);
passedResult.ExecutionTime = 1.1;
FailedResult failedResult = new FailedResult("foo", "bar", null, null, "extype", "message", "stack");
failedResult.ExecutionTime = 2.2;
SkipResult skipResult = new SkipResult("foo", "bar", null, null, "reason");
classResult.Add(passedResult);
classResult.Add(failedResult);
classResult.Add(skipResult);
XmlNode resultNode1 = classResult.ToXml(parentNode);
XmlNode resultNode2 = classResult.ToXml(parentNode);
Assert.Equal(resultNode1.Attributes["time"].Value, resultNode2.Attributes["time"].Value);
Assert.Equal(resultNode1.Attributes["total"].Value, resultNode2.Attributes["total"].Value);
Assert.Equal(resultNode1.Attributes["passed"].Value, resultNode2.Attributes["passed"].Value);
Assert.Equal(resultNode1.Attributes["failed"].Value, resultNode2.Attributes["failed"].Value);
Assert.Equal(resultNode1.Attributes["skipped"].Value, resultNode2.Attributes["skipped"].Value);
Assert.Equal(resultNode1.SelectNodes("test").Count, resultNode2.SelectNodes("test").Count);
}
private MethodResult ExecuteInternal(object testClass)
{
Exception exception = null;
MethodResult result = null;
MethodResult failedResult = null;
string retryMessage = null;
for (int i = 0; i < _retries + 1; ++i)
{
try
{
result = InnerCommand.Execute(testClass);
if (result is FailedResult)
{
TraceIf(_retries > 0, "Retry {0}/{1} failed.", i, _retries);
failedResult = (FailedResult)result;
}
else
{
retryMessage = String.Format("Retry {0}/{1} passed successfully.", i, _retries);
TraceIf(_retries > 0 && i > 0, retryMessage);
break;
}
}
catch (Exception ex)
{
TraceIf(_retries > 0, "Retry {0}/{1} failed with {2}", i, _retries, ex);
// optimize to preserve stacktrace
if (i >= _retries)
{
throw;
}
if (exception == null)
{
exception = ex;
}
}
}
if (_suppressError && result is PassedResult)
{
return result;
}
if (exception != null)
{
if (String.IsNullOrEmpty(retryMessage))
{
ExceptionUtility.RethrowWithNoStackTraceLoss(exception);
}
if (failedResult == null)
{
failedResult = new FailedResult(_testMethod, new RetrySuccessfulException(retryMessage, exception), DisplayName);
}
}
return failedResult ?? result;
}
