public void OnSpecificationStart(SpecificationInfo specification)
{
if (!_specificationTimer.IsRunning)
{
_specificationTimer.Restart();
}
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
_specificationRunCounter.IncrementSpecificationCount();
if(result.Supplements.Any())
{
_outputAction(IndicateSupplement.ToString());
return;
}
switch (result.Status)
{
case Status.Passing:
_specificationRunCounter.IncrementPasses();
_outputAction(IndicatePass.ToString());
break;
case Status.Ignored:
_outputAction(IndicateIgnored.ToString());
break;
case Status.NotImplemented:
_outputAction(IndicateNotImplemented.ToString());
break;
default:
if(!_contextMap.ContainsKey(_currentContextName))
{
_contextMap.Add(_currentContextName, new List<SpecificationFailureDetails>());
}
var failedSpecName = specification != null ? specification.Name : "UNDEFINED SPECIFICATION";
var details = new SpecificationFailureDetails(failedSpecName, result.Exception.Message);
_specificationRunCounter.IncrementFailures();
_outputAction(IndicateFailure.ToString());
_contextMap[_currentContextName].Add(details);
break;
}
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
var formatter = resultFormatterFactory.GetResultFormatterFor(result);
testListener.WriteLine(formatter.FormatResult(specification), Category.Output);
var testResult = new TestResult();
testResult.Name = specification.Name;
if (result.Passed)
testResult.State = TestState.Passed;
else if (result.Status == Status.Ignored)
{
testResult.State = TestState.Ignored;
testResult.Message = "Ignored";
}
else if (result.Status == Status.NotImplemented)
{
testResult.State = TestState.Ignored;
testResult.Message = "Not Implemented";
}
else
{
testResult.State = TestState.Failed;
if (result.Exception != null)
testResult.StackTrace = result.Exception.ToString();
}
testResults.Add(testResult);
}
public void OnSpecificationStart(SpecificationInfo specification)
{
_specifications += 1;
var notify = CreateTaskNotificationFor(specification);
notify(task => _server.TaskStarting(task));
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
if (listenFor != null && !listenFor.Equals(specification.ToVisualStudioTestIdentifier(currentContext)))
return;
runListener.OnSpecificationEnd(specification, result);
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
switch (result.Status)
{
case Status.Passing:
_writer.WriteTestFinished(GetSpecificationName(specification), TimeSpan.Zero);
break;
case Status.NotImplemented:
_writer.WriteTestIgnored(GetSpecificationName(specification), "(Not Implemented)");
break;
case Status.Ignored:
_writer.WriteTestIgnored(GetSpecificationName(specification), "(Ignored)");
break;
default:
if (result.Exception != null)
{
_writer.WriteTestFailed(GetSpecificationName(specification),
result.Exception.Message, result.Exception.StackTrace);
}
else
{
_writer.WriteTestFailed(GetSpecificationName(specification), "FAIL", "");
}
_failureOccured = true;
break;
}
}
public void OnSpecificationStart(SpecificationInfo specification)
{
if (listenFor != null && !listenFor.Equals(specification.ToVisualStudioTestIdentifier(currentContext)))
return;
runListener.OnSpecificationStart(specification);
}
public void OnSpecificationStart(SpecificationInfo specification)
{
var notify = CreateTaskNotificationFor(specification);
notify(task => _server.TaskStarting(task));
notify(task => _server.TaskProgress(task, "Running specification"));
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
switch (result.Status)
{
case Status.Passing:
break;
case Status.NotImplemented:
_writer.WriteTestIgnored(GetSpecificationName(specification), "(Not Implemented)");
break;
case Status.Ignored:
_writer.WriteTestIgnored(GetSpecificationName(specification), "(Ignored)");
break;
default:
if (result.Exception != null)
{
_writer.WriteTestFailed(GetSpecificationName(specification),
result.Exception.Message,
result.Exception.ToString());
}
else
{
_writer.WriteTestFailed(GetSpecificationName(specification), "FAIL", "");
}
_failureOccurred = true;
break;
}
var duration = TimeSpan.FromMilliseconds(_timingListener.GetSpecificationTime(specification));
_writer.WriteTestFinished(GetSpecificationName(specification), duration);
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
string specName = GetContextSpecName(_currentContext, specification);
switch (result.Status)
{
case Status.Passing:
break;
case Status.Failing:
_messageProvider.TestFailed(specName,
result.Exception.Message,
result.Exception.StackTrace,
result.Exception.FullTypeName);
break;
case Status.Ignored:
_messageProvider.TestIgnored(specName, null);
break;
case Status.NotImplemented:
_messageProvider.TestIgnored(specName, "Not implemented");
break;
default:
break;
}
_messageProvider.TestFinished(specName);
}
private TestCase ConvertSpecificationToTestCase(SpecificationInfo specification, Settings settings)
{
VisualStudioTestIdentifier vsTestId = specification.ToVisualStudioTestIdentifier(currentContext);
return new TestCase(vsTestId.FullyQualifiedName, this.executorUri, this.assemblyPath) {
DisplayName = settings.DisableFullTestNameInOutput ? specification.Name : $"{this.currentContext?.TypeName}.{specification.FieldName}",
};
}
public void Failed(SpecificationInfo specification, Result result)
{
Color(ConsoleColor.Red, () =>
{
_inner.SpecificationStart(specification);
_inner.Failed(specification, result);
});
}
public void Ignored(SpecificationInfo specification)
{
Color(ConsoleColor.Yellow, () =>
{
_inner.SpecificationStart(specification);
_inner.Ignored(specification);
});
}
public void NotImplemented(SpecificationInfo specification)
{
Color(ConsoleColor.Gray, () =>
{
_inner.SpecificationStart(specification);
_inner.NotImplemented(specification);
});
}
public void Passing(SpecificationInfo specification)
{
Color(ConsoleColor.Green, () =>
{
_inner.SpecificationStart(specification);
_inner.Passing(specification);
});
}
public void OnSpecificationStart(SpecificationInfo specification)
{
string specificationName = specification.FieldName;
string fullyQualifiedName = string.Format("{0}::{1}", specification.ContainingType, (object)specificationName);
string displayName = specificationName.Replace("_", " ");
this.RecordStart(fullyQualifiedName, displayName);
this.currentRunStats = new RunStats();
}
public long GetSpecificationTime(SpecificationInfo specificationInfo)
{
if (specificationTimes.ContainsKey(specificationInfo))
{
return(specificationTimes[specificationInfo]);
}
return(-1);
}
public long GetSpecificationTime(SpecificationInfo specificationInfo)
{
if (_specificationTimes.ContainsKey(specificationInfo))
{
return _specificationTimes[specificationInfo];
}
return -1;
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
if (this.currentRunStats != null)
this.currentRunStats.Stop();
TestCase testCase = ConvertSpecificationToTestCase(specification, this.settings);
this.frameworkHandle.RecordEnd(testCase, MapSpecificationResultToTestOutcome(result));
this.frameworkHandle.RecordResult(ConverResultToTestResult(testCase, result, this.currentRunStats));
}
public void RecordFailure(ContextInfo context, SpecificationInfo specification, Result result)
{
if (!_failures.ContainsKey(context))
{
_failures.Add(context, new List<FailedSpecification>());
}
var entry = _failures[context];
entry.Add(new FailedSpecification {Specification = specification, Result = result});
}
public static XElement ToXml(this SpecificationInfo specificationInfo)
{
return(new XElement(
"specificationinfo",
new XElement("leader", specificationInfo.Leader),
new XElement("name", specificationInfo.Name),
new XElement("containingtype", specificationInfo.ContainingType),
new XElement("fieldname", specificationInfo.FieldName),
new XElement("capturedoutput", specificationInfo.CapturedOutput)));
}
public void OnSpecificationStart(SpecificationInfo specification)
{
RemoteTask task = FindTaskFor(specification);
if (task == null)
{
return;
}
_server.TaskStarting(task);
_server.TaskProgress(task, "Running specification");
}
public override void OnSpecificationStart(SpecificationInfo specification)
{
_listener.OnSpecificationStart(specification);
ITestCommand specCommand = _commandsBySpec[specification.Name];
ITestContext specContext = specCommand.StartPrimaryChildStep(_testContext.TestStep);
_contextsBySpec.Add(specification.Name, specContext);
specContext.LifecyclePhase = LifecyclePhases.Starting;
_progressMonitor.SetStatus("» " + specification.Name);
}
protected override void Before_each_spec()
{
_specificationInfo = new SpecificationInfo("Spec", "Type");
PropertyDictionary propertyDictionary = Mocks.Stub<PropertyDictionary>((Project) null);
_task = Mocks.StrictMock<Task>();
SetupResult.For(_task.Properties).Return(propertyDictionary);
Mocks.Replay(_task);
_sut = new NAntRunListener(_task);
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
this.currentRunStats.Stop();
string specificationName = specification.FieldName;
string fullyQualifiedName = string.Format("{0}::{1}", specification.ContainingType, (object)specificationName);
string displayName = specificationName.Replace("_", " ");
int testResult = this.GetVSTestOutcomeFromMSpecResult(result);
this.RecordEnd(fullyQualifiedName, displayName, testResult);
this.RecordResult(fullyQualifiedName, displayName, this.currentRunStats.StartTime, this.currentRunStats.EndTime,
result.Exception != null ? result.Exception.Message : string.Empty, result.Exception != null ? result.Exception.StackTrace : null, testResult);
this.currentRunStats = null;
}
public override void OnSpecificationEnd(SpecificationInfo specification, Machine.Specifications.Result result)
{
_console.Log.WriteLine (" It " + specification.Name);
if (!result.Passed)
{
if (result.Exception != null)
{
_console.Log.WriteLine ("Exception : " + result.Exception.Message);
_console.Log.WriteLine ("StackTrace : " + result.Exception.StackTrace);
} else if (!string.IsNullOrEmpty (result.ConsoleError))
{
Console.WriteLine(result.ConsoleError);
}
}
base.OnSpecificationEnd (specification, result);
}
public void OnSpecificationEnd(SpecificationInfo specification, Machine.Specifications.Result result)
{
var test = new TestResult(
"MSpec",
_assembly,
specification.ContainingType,
DateTime.Now.Subtract(_start).TotalMilliseconds,
specification.ContainingType,
specification.ContainingType,
getState(result.Status),
getMessage(result.Exception));
test.AddStackLines(getStackLines(result.Exception));
_results.Add(test);
if (_feedback != null)
_feedback.TestFinished(test);
}
public override void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
_listener.OnSpecificationEnd(specification, result);
ITestContext testContext = _contextsBySpec[specification.Name];
testContext.LifecyclePhase = LifecyclePhases.Finishing;
TestOutcome outcome;
TimeSpan? span = null;
if (result.Status == Status.NotImplemented)
{
TestLog.Warnings.WriteLine("{0} ({1})", specification.Name, "NOT IMPLEMENTED");
TestLog.Warnings.Flush();
outcome = TestOutcome.Pending;
span = new TimeSpan(0);
}
else if (result.Status == Status.Ignored)
{
TestLog.Warnings.WriteLine("{0} ({1})", specification.Name, "IGNORED");
TestLog.Warnings.Flush();
outcome = TestOutcome.Ignored;
span = new TimeSpan(0);
}
else if (result.Passed)
{
outcome = TestOutcome.Passed;
}
else
{
TestLog.Failures.WriteException( Convert( result.Exception));
TestLog.Failures.Flush();
outcome = TestOutcome.Failed;
}
testContext.FinishStep(outcome, span);
_outcome = _outcome.CombineWith(outcome);
_progressMonitor.Worked(1);
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
RemoteTask task = FindTaskFor(specification);
if (task == null)
{
return;
}
_server.TaskProgress(task, null);
_server.TaskOutput(task, result.ConsoleOut, TaskOutputType.STDOUT);
_server.TaskOutput(task, result.ConsoleError, TaskOutputType.STDERR);
TaskResult taskResult = TaskResult.Success;
string message = null;
switch (result.Status)
{
case Status.Failing:
_server.TaskExplain(task, result.Exception.Message);
_server.TaskException(task, new[] { new TaskException(result.Exception.ToSpecException()) });
message = result.Exception.Message;
taskResult = TaskResult.Exception;
break;
case Status.Passing:
taskResult = TaskResult.Success;
break;
case Status.NotImplemented:
_server.TaskExplain(task, "Not implemented");
message = "Not implemented";
taskResult = TaskResult.Skipped;
break;
case Status.Ignored:
_server.TaskExplain(task, "Ignored");
taskResult = TaskResult.Skipped;
break;
}
_server.TaskFinished(task, message, taskResult);
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
var notify = CreateTaskNotificationFor(specification);
notify(task => _server.TaskProgress(task, null));
notify(task => _server.TaskOutput(task, result.ConsoleOut, TaskOutputType.STDOUT));
notify(task => _server.TaskOutput(task, result.ConsoleError, TaskOutputType.STDERR));
TaskResult taskResult = TaskResult.Success;
string message = null;
switch (result.Status)
{
case Status.Failing:
_errors += 1;
notify(task => _server.TaskExplain(task, result.Exception.Message));
notify(task => _server.TaskException(task,
ExceptionResultConverter.ConvertExceptions(result.Exception, out message)));
taskResult = TaskResult.Exception;
break;
case Status.Passing:
_successes += 1;
taskResult = TaskResult.Success;
break;
case Status.NotImplemented:
notify(task => _server.TaskExplain(task, "Not implemented"));
message = "Not implemented";
taskResult = TaskResult.Inconclusive;
break;
case Status.Ignored:
notify(task => _server.TaskExplain(task, "Ignored"));
taskResult = TaskResult.Skipped;
break;
}
notify(task => _server.TaskFinished(task, message, taskResult));
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
var notify = CreateTaskNotificationFor(specification, _currentContext);
NotifyRedirectedOutput(notify, _specificationOutput);
var taskResult = TaskResult.Success;
string message = null;
switch (result.Status)
{
case Status.Failing:
_errors += 1;
notify(task => _server.TaskExplain(task, result.Exception.Message));
notify(task => _server.TaskException(task,
ExceptionResultConverter.ConvertExceptions(result.Exception, out message)));
taskResult = TaskResult.Exception;
break;
case Status.Passing:
_successes += 1;
taskResult = TaskResult.Success;
break;
case Status.NotImplemented:
notify(task => _server.TaskExplain(task, "Not implemented"));
message = "Not implemented";
taskResult = TaskResult.Inconclusive;
break;
case Status.Ignored:
notify(task => _server.TaskExplain(task, "Ignored"));
taskResult = TaskResult.Skipped;
break;
}
notify(task => _server.TaskFinished(task, message, taskResult));
}
public void OnSpecificationStart(SpecificationInfo specification)
{
_specifications += 1;
_specificationOutput = new RedirectOutput();
var notify = CreateTaskNotificationFor(specification, _currentContext);
notify(task => _server.TaskStarting(task));
}
public void OnSpecificationStart(SpecificationInfo specification)
{
_listeners.Each(listener => listener.OnSpecificationStart(specification));
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
_listeners.Reverse().Each(listener => listener.OnSpecificationEnd(specification, result));
}
public void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
_specificationTimer.Stop();
_specificationTimes[specification] = _specificationTimer.ElapsedMilliseconds;
}
