private int ProcessTestCases(ITest test, ITestCaseDiscoverySink discoverySink, TestConverter testConverter)
        {
            int cases = 0;

            if (test.IsSuite)
            {
                foreach (ITest child in test.Tests)
                    cases += ProcessTestCases(child, discoverySink,testConverter);
            }
            else
            {
                try
                {
            #if LAUNCHDEBUGGER
            Debugger.Launch();
            #endif
                    TestCase testCase = testConverter.ConvertTestCase(test);

                    discoverySink.SendTestCase(testCase);
                    cases += 1;
                }
                catch (System.Exception ex)
                {
                    testLog.SendErrorMessage("Exception converting " + test.TestName.FullName, ex);
                }
            }

            return cases;
        }

        protected static void RunTest(ITest test)
        {
            int loops = Calibrate(test, TimeSpan.FromMilliseconds(1000));

            var sw = new Stopwatch();

            GC.Collect();
            GC.WaitForPendingFinalizers();

            var c1 = GC.CollectionCount(0);
            var c2 = GC.CollectionCount(1);
            var c3 = GC.CollectionCount(2);

            sw.Start();
            test.DoTest(loops);
            sw.Stop();

            c1 = GC.CollectionCount(0) - c1;
            c2 = GC.CollectionCount(1) - c2;
            c3 = GC.CollectionCount(2) - c3;

            var lps = (int)(loops / (sw.ElapsedMilliseconds / 1000.0));

            Console.WriteLine("{0,-40} {1,20} loops/s, collections {2}/{3}/{4}",
                test.GetType().Name, lps,
                c1, c2, c3);
        }

        private static string BuildStackTrace(Exception exception, ITest test, IEnumerable<string> traceMessages)
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendLine("SPECIFICATION:");
            if (test.Properties.Contains(TestExtensions.MultilineNameProperty))
            {
                foreach (var line in ((string)test.Properties[TestExtensions.MultilineNameProperty]).Split('\n'))
                    sb.AppendLine("    " + line);
            }

            sb.AppendLine();

            if (traceMessages.Count() > 0)
            {
                foreach (var line in traceMessages)
                    sb.AppendLine(line);

                sb.AppendLine();
            }

            sb.AppendLine(GetStackTrace(exception));

            for (Exception innerException = exception.InnerException; innerException != null; innerException = innerException.InnerException)
            {
                sb.Append(Environment.NewLine);
                sb.Append("--");
                sb.Append(innerException.GetType().Name);
                sb.Append(Environment.NewLine);
                sb.Append(GetStackTrace(innerException));
            }
            return sb.ToString();
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="TestUnitWithMetadata"/> class.
 /// </summary>
 /// <param name="testRun">The test run.</param>
 /// <param name="test"></param>
 /// <param name="assemblyName">Name of the assembly.</param>
 /// <param name="children">The children.</param>
 public TestUnitWithMetadata(TestRun testRun, ITest test, string assemblyName, List<TestUnitWithMetadata> children = null)
 {
     Children = children ?? new List<TestUnitWithMetadata>();
     Test = new TestUnit(test, testRun, assemblyName);
     Results = new List<TestResult>();
     AttachedData = new TestUnitAttachedData();
 }

		public void AddCategories( ITest test )
		{
            if (test.Categories != null)
                foreach (string name in test.Categories)
                    if (NUnitFramework.IsValidCategoryName(name))
                        Add(name);
		}

 public static ITestResult Failed(
     ITest		test,
     string		message,
     Exception	t)
 {
     return new SimpleTestResult(false, test.Name + ": " + message, t);
 }

 /// <summary>
 /// Writes test info to a file
 /// </summary>
 /// <param name="test">The test to be written</param>
 /// <param name="outputPath">Path to the file to which the test info is written</param>
 public void WriteTestFile(ITest test, string outputPath)
 {
     using (StreamWriter writer = new StreamWriter(outputPath, false, Encoding.UTF8))
     {
         WriteTestFile(test, writer);
     }
 }

        public static void Queue(
            this IMessageBus messageBus,
            ITest test,
            Func<ITest, IMessageSinkMessage> createTestResultMessage,
            CancellationTokenSource cancellationTokenSource)
        {
            Guard.AgainstNullArgument("messageBus", messageBus);
            Guard.AgainstNullArgument("createTestResultMessage", createTestResultMessage);
            Guard.AgainstNullArgument("cancellationTokenSource", cancellationTokenSource);

            if (!messageBus.QueueMessage(new TestStarting(test)))
            {
                cancellationTokenSource.Cancel();
            }
            else
            {
                if (!messageBus.QueueMessage(createTestResultMessage(test)))
                {
                    cancellationTokenSource.Cancel();
                }
            }

            if (!messageBus.QueueMessage(new TestFinished(test, 0, null)))
            {
                cancellationTokenSource.Cancel();
            }
        }

 /// <summary>
 /// Forwards the TestStarted event to all listeners.
 /// </summary>
 /// <param name="test">The test that just started.</param>
 public void TestStarted(ITest test)
 {
     System.Diagnostics.Debug.WriteLine(test.Name + " TEST STARTED");
     System.Threading.Thread.Sleep(2000);
     foreach (TestListener listener in listeners)
         listener.TestStarted(test);
 }

        public OrganizationService(ITest test)
        {
            if(test == null)
                throw new ArgumentNullException("test");

            this._test = test;
        }

		public void AddAllCategories( ITest test )
		{
			AddCategories( test );
			if ( test.IsSuite )
				foreach( ITest child in test.Tests )
					AddAllCategories( child );
		}

 public NewTestResultSummaryEventArgs(ITest test, ITestResult result, ITestOutcomeFilter outcomeFilter, ITestResultSummary summary)
 {
     Test = test;
     Result = result;
     OutcomeFilter = outcomeFilter;
     Summary = summary;
 }

        public static void RunTest(TestType type, int ThreadCount, CallbackFunction callBack, ITest target)
        {
            for (int i = 0; i < ThreadCount; i++)
            {
                BackgroundWorker worker = new BackgroundWorker();
                worker.DoWork += (object sender, DoWorkEventArgs e) =>
                {
                    bool result = target.Test();
                    e.Result = result;

                };

                worker.RunWorkerCompleted += (object sender, RunWorkerCompletedEventArgs e) =>
                    {
                        if (callBack != null)
                        {
                            if (e.Error != null)
                            {
                                callBack(type, (bool)e.Result);
                            }
                            else
                            {
                                callBack(type, false);
                            }
                        }
                    };
                worker.RunWorkerAsync();
            }
        }

 public void TestStarted(ITest test)
 {
     level++;
     prefix = new string('>', level);
     if(options.DisplayTestLabels == "On" || options.DisplayTestLabels == "All")
         outWriter.WriteLine("{0} {1}", prefix, test.Name);
 }

        public void BeforeTest(ITest test)
        {
            //Log.Write("START:" + test.FullName);
            if (!_configuration.GenerateReport) return;

            _start = DateTime.Now;
        }

        public void AddTest(ITest test)
        {
            if(test == null) throw new ArgumentNullException("test");

            tests.Add(test);
            test.TestCompleted += TestOnTestCompleted;
        }

 /// <summary>
 /// Called when a test has just started
 /// </summary>
 /// <param name="test">The test that is starting</param>
 public void TestStarted(ITest test)
 {
     if (test.IsSuite)
         TC_TestSuiteStarted(test.Name);
     else
         TC_TestStarted(test.Name);
 }

        private void Execute(ITest test, string methodPrefix)
        {
            var method = Reflect.GetNamedMethod(_ActionInterfaceType, methodPrefix + "Test");
            var details = CreateTestDetails(test);

            Reflect.InvokeMethod(method, _Action, details);
        }

		/// <summary>
		/// Check whether the filter matches a test
		/// </summary>
		/// <param name="test">The test to be matched</param>
		/// <returns>True if it matches, otherwise false</returns>
		public override bool Match( ITest test )
		{
            if (topLevel && test.RunState == RunState.Explicit)
                return false;

			return !baseFilter.Pass( test );
		}

    //public AlgorithmEvaluator(AlgorithmExecutor executor, ICollection<ITest> tests, IAnswerEvaluator answerEvaluator, TimeSpan timeLimit) : this(tests, answerEvaluator, timeLimit)
    //{
    //    this.executor = executor;
    //}
    //public AlgorithmEvaluator(string algorithmFolder, ICollection<ITest> tests, IAnswerEvaluator answerEvaluator, TimeSpan timeLimit)
    //    : this(new AlgorithmExecutor(algorithmFolder), tests, answerEvaluator, timeLimit)
    //{
    //}
    //public void SetAlgorithm(AlgorithmExecutor newAlg)
    //{
    //    this.executor = newAlg;
    //}
    public int EvaluateWithTest(AlgorithmExecutor algorithm, ITest test, bool allowTimeLimit = false)
    {
        this.logWriter.WriteLine();
        this.logWriter.WriteLine("Evaluating {0} with test {1}", algorithm.AlgorithmOwner, test.Name);

        try
        {
            algorithm.StartAlgorithm();
        }
        catch (Win32Exception)
        {
            this.logWriter.WriteLine("--couldn't start algorithm");
            return 0;
        }

        DateTime start = DateTime.Now;

        string algorithmAnswer = "";
        try
        {
            Task<string> algorithmAnswerTask = Task.Run(() => algorithm.GetAnswerToInput(test.Input));

            bool timeLimitReached = false;
            //Console.WriteLine("press enter");
            //Console.ReadLine();
            System.Threading.Thread.Sleep(timeLimit - TimeSpan.FromMilliseconds(100));
            while (!algorithmAnswerTask.IsCompleted)
            {
                TimeSpan elapsed = DateTime.Now - start;
                if (elapsed > timeLimit)
                {
                    this.logWriter.WriteLine("--time limit reached, killing algorithm");
                    algorithm.KillAlgorithm();
                    timeLimitReached = true;
                    break;
                }
            }

            if (!timeLimitReached || allowTimeLimit)
            {
                this.logWriter.WriteLine("--attempting to retrieve output from algorithm");
                algorithmAnswerTask.Wait();
                algorithmAnswer += algorithmAnswerTask.Result;
            }
            else
            {
                return 0;
            }

            algorithm.KillAlgorithm(); //just in case
        }
        catch (Exception e)
        {
            this.logWriter.WriteLine("--unexpected error while evaluating: {0}", e.Message);
        }

        this.logWriter.Write("--algorithm output:\r\n{0}\r\n", algorithmAnswer);
        return this.evaluator.EvaluateAnswer(algorithmAnswer, test.Input, test.ExpectedOutput);
    }