/// <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; }