public CollectReportingInformationRunListener()
{
_currentAssemblyName = "";
_currentContext = null;
_contextsByAssembly = new Dictionary<string, List<ContextInfo>>();
_specificationsByContext = new Dictionary<ContextInfo, List<SpecificationInfo>>();
_resultsBySpecification = new Dictionary<SpecificationInfo, Result>();
}
public long GetContextTime(ContextInfo contextInfo)
{
if (_contextTimes.ContainsKey(contextInfo))
{
return _contextTimes[contextInfo];
}
return -1;
}
public void OnContextEnd(ContextInfo context)
{
if (!_concernsToContexts.ContainsKey(context.Concern))
{
_concernsToContexts[context.Concern] = new List<Context>();
}
_concernsToContexts[context.Concern].Add(context.ToNode(_specifications));
}
public void OnContextStart(ContextInfo context)
{
_specifications = 0;
_errors = 0;
_successes = 0;
var notify = CreateTaskNotificationFor(context);
notify(task => _server.TaskStarting(task));
}
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 void OnContextStart(ContextInfo context)
{
_specifications = 0;
_errors = 0;
_successes = 0;
// TODO: This sucks, but there's no better way unless we make behaviors first-class citizens.
_currentContext = context;
var notify = CreateTaskNotificationFor(context, context);
notify(task => _server.TaskStarting(task));
}
public override bool Matches(object infoFromRunner, ContextInfo maybeContext)
{
var context = infoFromRunner as ContextInfo;
if (context == null)
{
return false;
}
return ContainingType == context.TypeName;
}
public static void AddContextToOrganizedCollectionByConcern(ContextInfo context, Dictionary<string, List<ContextInfo>> organized)
{
if (context.Concern == null)
{
organized[noContextKey].Add(context);
return;
}
if(!organized.ContainsKey(context.Concern))
organized.Add(context.Concern, new List<ContextInfo>());
organized[context.Concern].Add(context);
}
public override bool Matches(object infoFromRunner, ContextInfo maybeContext)
{
var specification = infoFromRunner as SpecificationInfo;
if (specification == null)
{
return false;
}
return ContainingType == specification.ContainingType &&
FieldName == specification.FieldName;
}
public void OnContextStart(ContextInfo context)
{
if (context.Namespace != _currentNamespace)
{
if (!string.IsNullOrEmpty(_currentNamespace))
{
_writer.WriteTestSuiteFinished(_currentNamespace);
}
_currentNamespace = context.Namespace;
_writer.WriteTestSuiteStarted(_currentNamespace);
}
_currentContext = context.FullName;
}
protected override void Before_each_spec()
{
_contextInfo = new ContextInfo("Context", "Concern", "TypeName", "Namespace", "AssemblyName");
PropertyDictionary propertyDictionary = Mocks.Stub<PropertyDictionary>((Project) null);
_task = Mocks.DynamicMock<Task>();
SetupResult.For(_task.Properties).Return(propertyDictionary);
Mocks.Replay(_task);
_sut = new NAntRunListener(_task);
}
public void OnContextEnd(ContextInfo context)
{
var result = TaskResult.Inconclusive;
if (_specifications == _successes)
{
result = TaskResult.Success;
}
if (_errors > 0)
{
result = TaskResult.Error;
}
var notify = CreateTaskNotificationFor(context);
notify(task => _server.TaskFinished(task, null, result));
}
public override bool Matches(object infoFromRunner, ContextInfo maybeContext)
{
if (maybeContext == null)
{
return false;
}
var specification = infoFromRunner as SpecificationInfo;
if (specification == null)
{
return false;
}
return ContextTypeName == maybeContext.TypeName &&
ContainingType == new NormalizedTypeName(specification.ContainingType) &&
FieldName == specification.FieldName;
}
public void OnContextStart(ContextInfo context)
{
_listeners.Each(listener => listener.OnContextStart(context));
}
public void OnContextEnd(ContextInfo context)
{
_listeners.Reverse().Each(listener => listener.OnContextEnd(context));
}
public override void OnContextStart(ContextInfo context)
{
_listener.OnContextStart(context);
_testContext.LifecyclePhase = LifecyclePhases.Starting;
_progressMonitor.SetStatus(context.FullName);
}
public override void OnContextEnd(ContextInfo context)
{
_listener.OnContextEnd(context);
_testContext.LifecyclePhase = LifecyclePhases.Finishing;
}
public void OnContextEnd(ContextInfo context)
{
currentContext = null;
runListener.OnContextEnd(context);
}
public void OnContextStart(ContextInfo context)
{
currentContext = context;
runListener.OnContextStart(context);
}
public void OnContextStart(ContextInfo context)
{
WriteLineVerbose(context.FullName);
}
public void OnContextEnd(ContextInfo context)
{
WriteLineVerbose("");
_contextCount += 1;
}
public void OnContextEnd(ContextInfo context)
{
_contextTimer.Stop();
_contextTimes[context] = _contextTimer.ElapsedMilliseconds;
}
private void RenderSpecifications(XmlWriter reportBuilder, ContextInfo context)
{
foreach (var specification in _specificationsByContext[context])
{
var result = _resultsBySpecification[specification];
string status;
switch (result.Status)
{
case Status.Failing:
status = "failed";
break;
case Status.Passing:
status = "passed";
break;
case Status.NotImplemented:
status = "not-implemented";
break;
case Status.Ignored:
status = "ignored";
break;
default:
if (result.Exception != null)
{
status = "exception";
}
else
{
status = "failed";
}
break;
}
reportBuilder.WriteStartElement("specification");
reportBuilder.WriteAttributeString("name", specification.Name);
reportBuilder.WriteAttributeString("field-name", specification.FieldName);
reportBuilder.WriteAttributeString("status", status);
RenderError(reportBuilder, result.Exception);
reportBuilder.WriteEndElement();
}
}
public void OnContextEnd(ContextInfo context)
{
_server.TaskProgress(_contextTask, null);
}
public void OnContextStart(ContextInfo context)
{
listeners.Each(listener => listener.OnContextStart(context));
}
public void OnContextEnd(ContextInfo context)
{
listeners.Reverse().Each(listener => listener.OnContextEnd(context));
}
public void OnContextEnd(ContextInfo context)
{
_currentContext = "";
}
public override void OnContextEnd(ContextInfo context)
{
base.OnContextEnd (context);
}
public void OnContextStart(ContextInfo context)
{
_server.TaskProgress(_contextTask, "Running context");
}
public override void OnContextStart(ContextInfo context)
{
_console.Log.WriteLine (context.FullName);
base.OnContextStart (context);
}
Action<Action<RemoteTask>> CreateTaskNotificationFor(object infoFromRunner, ContextInfo maybeContext)
{
return actionToBePerformedForEachTask =>
{
bool invoked = false;
foreach (var notification in _taskNotifications)
{
if (notification.Matches(infoFromRunner, maybeContext))
{
Debug.WriteLine(String.Format("Invoking notification for {0}", notification.ToString()));
invoked = true;
foreach (var task in notification.RemoteTasks)
{
actionToBePerformedForEachTask(task);
}
}
}
if (!invoked)
{
Debug.WriteLine(String.Format("No matching notification for {0} received by the runner",
infoFromRunner.ToString()));
}
};
}
public void OnContextStart(ContextInfo context)
{
}
public void OnContextEnd(ContextInfo context)
{
LastContext = context;
}
public void OnContextStart(ContextInfo context)
{
_contextTimer.Restart();
_specificationTimer.Restart();
}
