/// <summary> /// Executes the test method. Creates a new instance of the class /// under tests and passes it to the inner command. Also catches /// any exceptions and converts them into <see cref="FailedResult"/>s. /// </summary> /// <param name="testClass">The instance of the test class</param> /// <returns>Returns information about the test run</returns> public override MethodResult Execute(object testClass) { try { if (testClass == null) { testClass = method.CreateInstance(); } } catch (TargetInvocationException ex) { ExceptionUtility.RethrowWithNoStackTraceLoss(ex.InnerException); } try { return(InnerCommand.Execute(testClass)); } finally { IDisposable disposable = testClass as IDisposable; if (disposable != null) { disposable.Dispose(); } } }
public override MethodResult Execute(object testClass) { try { return(InnerCommand.Execute(testClass)); } catch { owner.OnFailure(); throw; } }
/// <summary> /// Executes the inner test method, gathering the amount of time it takes to run. /// </summary> /// <returns>Returns information about the test run</returns> public override MethodResult Execute(object testClass) { TestTimer timer = new TestTimer(); timer.Start(); MethodResult methodResult = InnerCommand.Execute(testClass); timer.Stop(); methodResult.ExecutionTime = timer.ElapsedMilliseconds / 1000.00; return(methodResult); }
private MethodResult ExecuteInternal(object testClass) { Exception exception = null; MethodResult result = null; MethodResult failedResult = 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 { TraceIf(_retries > 0 && i > 0, "Retry {0}/{1} passed successfully.", i, _retries); 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) { ExceptionUtility.RethrowWithNoStackTraceLoss(exception); } return(failedResult ?? result); }
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 override MethodResult Execute(object testClass) { var task = Task.Factory.StartNew(() => { try { using (testClass as IDisposable) return(InnerCommand.Execute(testClass)); } catch (Exception ex) { return(new FailedResult(_testMethod, ex, DisplayName)); } }); return(task.Result); }
/// <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); } }
/// <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 override MethodResult Execute(object testClass) { MethodResult result; try { result = InnerCommand.Execute(testClass); } catch (TargetInvocationException ex) { result = new ExceptionResult(method, ex.InnerException, DisplayName); } catch (Exception ex) { result = new ExceptionResult(method, ex, DisplayName); } return(result); }
public override MethodResult Execute(object testClass) { List <BeforeAfterTestAttribute> beforeCalled = new List <BeforeAfterTestAttribute>(); bool testExceptionThrown = false; try { foreach (BeforeAfterTestAttribute attr in testMethod.GetCustomAttributes(typeof(BeforeAfterTestAttribute), true)) { attr.Before(testMethod); beforeCalled.Add(attr); } return(InnerCommand.Execute(testClass)); } catch { testExceptionThrown = true; throw; } finally { List <Exception> afterExceptions = new List <Exception>(); beforeCalled.Reverse(); foreach (BeforeAfterTestAttribute attr in beforeCalled) { try { attr.After(testMethod); } catch (Exception ex) { afterExceptions.Add(ex); } } if (!testExceptionThrown && afterExceptions.Count > 0) { throw new AfterTestException(afterExceptions); } } }
/// <summary> /// Sets the fixtures on the test class by calling SetFixture, then /// calls the inner command. /// </summary> /// <param name="testClass">The instance of the test class</param> /// <returns>Returns information about the test run</returns> public override MethodResult Execute(object testClass) { try { if (testClass != null) { foreach (KeyValuePair <MethodInfo, object> fixture in fixtures) { fixture.Key.Invoke(testClass, new object[] { fixture.Value }); } } } catch (TargetInvocationException ex) { ExceptionUtility.RethrowWithNoStackTraceLoss(ex.InnerException); } return(InnerCommand.Execute(testClass)); }
public override MethodResult Execute(object testClass) { /* * We have to do timeout ourselves, because xunit can't handle the fact that it's own TimeOutCommand returns exceptions with null stack traces * It also leaves the method executing, which hangs the build. */ return(WithRetry(3, 6, delegate { try { return ManualTimeout.ExecuteWithTimeout(() => InnerCommand.Execute(testClass)); } finally { GC.Collect(); GC.WaitForPendingFinalizers(); } })); }
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); }