public CollectReportingInformationRunListener()
 {
   _currentAssemblyName = "";
   _currentContext = null;
   _contextsByAssembly = new Dictionary<string, List<ContextInfo>>();
   _specificationsByContext = new Dictionary<ContextInfo, List<SpecificationInfo>>();
   _resultsBySpecification = new Dictionary<SpecificationInfo, Result>();
 }

    public void OnContextEnd(ContextInfo context)
    {
      if (!_concernsToContexts.ContainsKey(context.Concern))
      {
        _concernsToContexts[context.Concern] = new List<Context>();
      }

      _concernsToContexts[context.Concern].Add(context.ToNode(_specifications));
    }

        public long GetContextTime(ContextInfo contextInfo)
        {
            if (_contextTimes.ContainsKey(contextInfo))
            {
                return _contextTimes[contextInfo];
            }

            return -1;
        }

    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 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 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 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 OnContextEnd(ContextInfo context)
 {
   _server.TaskProgress(_contextTask, null);
 }

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

 public void OnContextEnd(ContextInfo context)
 {
   _currentContext = "";
 }

 public void OnContextStart(ContextInfo context)
 {
   _listeners.Each(listener => listener.OnContextStart(context));
 }