private void OnTestFailed(TestFailedInfo obj)
{
var(startTime, endTime) = GetTestExecutionTime(obj.TestDisplayName, obj.ExecutionTime);
OnTestCaseEnd(new TestEnd(obj.MethodName, obj.TypeName.Split('.').Last(), obj.TestDisplayName,
obj.TestCollectionDisplayName, TestOutcome.Failed, startTime, endTime));
LogError(obj.ExceptionMessage);
}
protected void AssertsTestAddFailedTest(TestFailedInfo info)
{
var assemblyLocation = "abc.dll";
var sut = new Result(assemblyLocation);
Assert.Empty(sut.FailedTests);
sut.AddFailedTest(info);
Assert.Equal(1, sut.Failed);
#if NET35
Assert.Equal(1, sut.FailedTests.Count);
#else
Assert.Single(sut.FailedTests);
#endif
Assert.Contains(info, sut.FailedTests);
var actual = sut.FailedTests.First();
Assert.Equal(info.MethodName, actual.MethodName);
Assert.Equal(info.Output, actual.Output);
Assert.Equal(info.TestCollectionDisplayName, actual.TestCollectionDisplayName);
Assert.Equal(info.TestDisplayName, actual.TestDisplayName);
Assert.Equal(info.TypeName, actual.TypeName);
Assert.Equal(info.ExceptionMessage, actual.ExceptionMessage);
Assert.Equal(info.ExceptionStackTrace, actual.ExceptionStackTrace);
Assert.Equal(info.ExceptionType, actual.ExceptionType);
}
private static void OnTestFailed(TestFailedInfo info)
{
Log.Error($"[FAIL] {info.TestDisplayName}: {info.ExceptionMessage}");
if (info.ExceptionStackTrace != null)
{
Log.Error(info.ExceptionStackTrace);
}
_result = 1;
}
void TestFailedHandler(TestFailedInfo obj)
{
anyFailed = true;
adapter.AddResult(new TestResultInfo
{
Passed = false,
DisplayName = obj.TestDisplayName
});
}
private void TestFailedHandler(TestFailedInfo info)
{
// Commented out in order not to affect execution time
//logger.DebugFormat("### TEST METHOD FINISHED: {0} ###", info.TestDisplayName);
//logger.InfoFormat("### TEST METHOD FAILED: {0} ###", info.TestDisplayName);
//logger.Debug("Exception Message: " + info.ExceptionMessage);
//logger.Debug("Exception Type: " + info.ExceptionType);
//logger.Debug("Stack Trace: " + info.ExceptionStackTrace);
}
private void OnTestFailed(TestFailedInfo info)
{
_results.Add(new TestResult
{
FullName = $"{info.TypeName}.{info.MethodName}",
InnerText = info.ExceptionMessage,
IsSuccess = false,
Name = info.MethodName
});
}
/// <summary>
/// 单项测试失败时
/// </summary>
public void OnTestFailed(TestFailedInfo info)
{
var assemblyName = info.Runner.Assembly.GetName().Name;
var webTesterManager = Application.Ioc.Resolve <WebTesterManager>();
webTesterManager.UpdateInformation(assemblyName, testInfo => {
testInfo.Counter.Failed += 1;
testInfo.FailedMessage += string.Format(
"Test {0} failed:\r\n{1}\r\n\r\n", info.Method.GetFullName(), info.Exception);
testInfo.Updated();
});
}
static void OnTestFailed(TestFailedInfo info)
{
lock (consoleLock)
{
telemetryClient.TrackTrace($"[FAIL] {info.TestDisplayName}: {info.ExceptionMessage}", SeverityLevel.Warning);
if (info.ExceptionStackTrace != null)
{
telemetryClient.TrackTrace(info.ExceptionStackTrace, SeverityLevel.Information);
}
}
result = 1;
}
private void OnTestFailed(TestFailedInfo info)
{
lock (this.announcementLock)
{
this.announcer(Invariant($" ! [FAIL] {info.TestDisplayName}: {info.ExceptionMessage}."));
if (info.ExceptionStackTrace != null)
{
this.announcer(info.ExceptionStackTrace);
}
}
this.seenFailures = true;
}
static void OnTestFailed(TestFailedInfo info)
{
lock (_ConsoleLock) {
Console.ForegroundColor = ConsoleColor.Red;
R($"[FAIL] {info.TestDisplayName}: {info.ExceptionMessage}");
if (info.ExceptionStackTrace != null)
{
R(info.ExceptionStackTrace);
}
Console.ResetColor();
}
_Result = 1;
}
protected virtual void OnTestFailed(TestFailedInfo info)
{
lock (sync)
{
Console.WriteLine("[FAIL] {0}: {1}", info.TestDisplayName, info.ExceptionMessage);
if (info.ExceptionStackTrace != null)
{
Console.WriteLine(info.ExceptionStackTrace);
}
}
result = 1;
}
public void OnTestFailed(TestFailedInfo info)
{
Console.ForegroundColor = ConsoleColor.Red;
if (info.Exception is AssertException ||
info.Exception is ScenarioException)
{
Console.WriteLine($"failed: {info.Exception.Message}");
}
else
{
Console.WriteLine($"failed: {info.Exception}");
}
Console.ResetColor();
}
internal static MethodTestResult FromFail(TestFailedInfo info, HashSet <string>?points = default)
{
return(new MethodTestResult()
{
Passed = false,
Name = info.TestDisplayName,
Points = points ?? MethodTestResult.EMPTY_HASH_SET,
Message = info.ExceptionMessage,
ErrorStackTrace = StackTraceToList(info.ExceptionStackTrace)
});
public void OnTestFailed(TestFailedInfo testFailedInfo)
{
var testResult = new TestResult()
{
PartitionKey = _partitionKey,
RowKey = testFailedInfo.TestDisplayName,
ExecutionTime = (double)testFailedInfo.ExecutionTime,
Status = "Failed",
ExceptionType = testFailedInfo.ExceptionType,
ExceptionMessage = testFailedInfo.ExceptionMessage,
ExceptionStackTrace = testFailedInfo.ExceptionStackTrace
};
_collector.Add(testResult);
}
public void OnTestFailed(TestFailedInfo info)
{
var item = new ReportItem
{
ThreadName = _threadName,
Duration = (double)info.ExecutionTime,
TestCase = info.MethodName,
TestSuite = info.TypeName,
ErrorMessage = info.ExceptionMessage,
ErrorTrace = info.ExceptionStackTrace,
Status = "FAILED"
};
_reportWriter.AddItemToReport(item);
}
private void OnTestFailed(TestFailedInfo info)
{
lock (consoleLock)
{
Console.ForegroundColor = ConsoleColor.Red;
LambdaLogger.Log($"[FAIL] {info.TestDisplayName}: {info.ExceptionMessage}\n");
if (info.ExceptionStackTrace != null)
{
LambdaLogger.Log(info.ExceptionStackTrace);
}
Console.ResetColor();
}
}
private static void OnTestFailed(TestFailedInfo info)
{
lock (LoggerLock)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"[FAIL] {info.TestDisplayName}: {info.ExceptionMessage}");
if (info.ExceptionStackTrace != null)
{
Console.WriteLine(info.ExceptionStackTrace);
}
Console.ResetColor();
}
}
static void OnTestFailed(TestFailedInfo info)
{
lock (consoleLock)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[FAIL] {0}: {1}", info.TestDisplayName, info.ExceptionMessage);
if (info.ExceptionStackTrace != null)
{
Console.WriteLine(info.ExceptionStackTrace);
}
Console.ResetColor();
}
result = 1;
}
private static void OnTestFailed(TestFailedInfo info)
{
lock (ConsoleLock)
{
++_testsRun;
Console.ForegroundColor = FailColor;
WriteLineError(
$"\n... {_testsRun,3}/{_discoveryInfo.TestCasesToRun} [FAIL] {info.TestDisplayName}: {info.ExceptionMessage}");
if (info.ExceptionStackTrace != null)
{
Console.ForegroundColor = StackTraceColor;
WriteLineError(info.ExceptionStackTrace + "\n");
}
}
_mainExitCode = 1;
}
void OnTestFailed(TestFailedInfo info)
{
if (settingEnv.Console)
{
lock (consoleLock)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("[FAIL] {0}: {1}", info.TestDisplayName, info.ExceptionMessage);
if (info.ExceptionStackTrace != null)
{
Console.WriteLine(info.ExceptionStackTrace);
}
Console.ResetColor();
}
}
//
failed.Add(info.TestDisplayName);
}
void TestFailed(TestFailedInfo tfi)
{
if (verbose)
{
ConsoleEx.writeLine(ConsoleColor.Red, "{0} - failed :-(", tfi.TestDisplayName);
}
else
{
ConsoleEx.write(ConsoleColor.Red, "F");
}
if (stopOnErrors)
{
ConsoleEx.silent = true;
completed.Set();
if (Debugger.IsAttached)
{
Debugger.Break();
}
}
}
private static void TestFailed(TestFailedInfo info)
{
Console.WriteLine("TestFailed.");
}
private static void OnTestFailed(TestFailedInfo obj)
{
Console.WriteLine("Test failure: " + obj.ExceptionMessage);
}
public void OnTestFailed(TestFailedInfo info)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"failed: {info.Exception}");
Console.ResetColor();
}
void OnTestFailed(TestFailedInfo obj) => Result.Add(new TestExecutionViewModel(obj.TypeName, TestExecutionStatus.Failed(obj.Output)));
public void TestAddFailedTest(TestFailedInfo info)
{
this.AssertsTestAddFailedTest(info);
}
