private static Test CreateCompositePostTest(TestFilter filter, params PostTest[] tests)
 {
     return new CompositePostTest(
         (PostTest[])ArrayHelper.Narrow(
                          filter(tests),
                          typeof(PostTest)));
 }

 public TestExecutionTask(ITestEngineRunner runner, ITestEventListener listener, TestFilter filter, bool disposeRunner)
 {
     _disposeRunner = disposeRunner;
     _filter = filter;
     _listener = listener;
     _runner = runner;
 }

        public void TestCompositeFilterRemove()
        {
            List<int> priorities = new List<int>();

            ConsoleViewFilterBase filter1 = new TestFilter(1, delegate(ref ConsoleViewCellEntry e)
            {
                priorities.Add(1);
                return true;
            });

            ConsoleViewFilterBase filter2 = new TestFilter(2, delegate(ref ConsoleViewCellEntry e)
            {
                priorities.Add(2);
                return true;
            });

            ConsoleViewFilterBase filter3 = new TestFilter(3, delegate(ref ConsoleViewCellEntry e)
            {
                priorities.Add(3);
                return true;
            });

            ConsoleViewCompositeFilter compositeFilter = new ConsoleViewCompositeFilter();
            compositeFilter.AddFilter(filter1);
            compositeFilter.AddFilter(filter2);
            compositeFilter.AddFilter(filter3);

            compositeFilter.RemoveFilter(filter1);
            compositeFilter.RemoveFilter(filter3);

            ConsoleViewCellEntry entry = default(ConsoleViewCellEntry);
            compositeFilter.Apply(ref entry);

            AssertList(priorities, 2);
        }

        private TestResult runTests(string nameSpace, TestFilter filter)
        {
            TestSuiteBuilder builder = new TestSuiteBuilder();
			TestPackage package = new TestPackage( testAssembly );
			package.TestName = nameSpace;
            Test suite = builder.Build( package );
            return suite.Run(new NullListener(),filter);
        }

 // This constructor is called by the others and is used directly for testing
 public AssemblyRunner(TestLogger logger, string assemblyName)
 {
     this.logger = logger;
     this.assemblyName = assemblyName;
     testConverter = new TestConverter(logger, assemblyName);
     loadedTestCases = new List<TestCase>();
     nunitFilter = TestFilter.Empty;
 }

 private void ExecuteTestSuite( TestSuite suite, UnitTestRunner.ITestRunnerCallback testRunnerEventListener, TestFilter filter )
 {
     EventListener eventListener;
     if (testRunnerEventListener == null)
         eventListener = new NullListener ();
     else
         eventListener = new TestRunnerEventListener (testRunnerEventListener);
     suite.Run(eventListener, GetFilter(filter));
 }

        public void Equals()
        {
            Base.EqualReferencesComparer e = new EqualReferencesComparer();

              TestFilter a = new TestFilter();
              TestFilter b = new TestFilter();

              Assert.True(e.Equals(a, a));
              Assert.True(e.Equals(b, b));
              Assert.False(e.Equals(a, b));
        }

        /// <summary>
        /// Explore a TestPackage and return information about
        /// the tests found.
        /// </summary>
        /// <param name="package">The TestPackage to be explored</param>
        /// <returns>A TestEngineResult.</returns>
        protected override TestEngineResult ExploreTests(TestFilter filter)
        {
            TestEngineResult result = new TestEngineResult();

            foreach (IFrameworkDriver driver in _drivers)
                result.Add(driver.Explore(filter));

            return IsProjectPackage(this.TestPackage)
                ? result.MakePackageResult(TestPackage.Name, TestPackage.FullName)
                : result;
        }

 /// <summary>
 /// Explore a TestPackage and return information about
 /// the tests found.
 /// </summary>
 /// <param name="filter">A TestFilter used to select tests</param>
 /// <returns>A TestEngineResult.</returns>
 protected override TestEngineResult ExploreTests(TestFilter filter)
 {
     try
     {
         return _remoteRunner.Explore(filter);
     }
     catch (Exception e)
     {
         log.Error("Failed to run remote tests {0}", e.Message);
         return CreateFailedResult(e);
     }
 }

        /// <summary>
        /// Explores a previously loaded TestPackage and returns information
        /// about the tests found.
        /// </summary>
        /// <param name="filter">The TestFilter to be used to select tests</param>
        /// <returns>
        /// A TestEngineResult.
        /// </returns>
        protected override TestEngineResult ExploreTests(TestFilter filter)
        {
            var result = new TestEngineResult();

            foreach (IFrameworkDriver driver in _drivers)
                result.Add(driver.Explore(filter.Text));

            if (IsProjectPackage(TestPackage))
                result = result.MakePackageResult(TestPackage.Name, TestPackage.FullName);

            return result;
        }

        /// <summary>
        /// Explore a TestPackage and return information about
        /// the tests found.
        /// </summary>
        /// <param name="filter">A TestFilter used to select tests</param>
        /// <returns>A TestEngineResult.</returns>
        protected override TestEngineResult ExploreTests(TestFilter filter)
        {
            var results = new List<TestEngineResult>();

            foreach (ITestEngineRunner runner in _runners)
                results.Add(runner.Explore(filter));

            TestEngineResult result = ResultHelper.Merge(results);

            return IsProjectPackage(TestPackage)
                ? result.MakePackageResult(TestPackage.Name, TestPackage.FullName)
                : result;
        }

        public override Task<Filter> CreateFilter(Message request)
        {
            TestFilter filter = null;
            // resolve the "To" address as the matching entry
            foreach (var f in services)
            {
                if (f.Service.Uri.AbsolutePath == request.Headers.To.AbsolutePath)
                {
                    filter = new TestFilter();
                    filter.Initialize(request.Headers.To, new Uri[] { f.Uri });
                    break;
                }
            }

            return Task.FromResult<Filter>(filter);
        }

        public void RunTests(TestFilter filter, UnitTestRunner.ITestRunnerCallback testRunnerEventListener) {
            try {
                if (testRunnerEventListener != null)
                { testRunnerEventListener.RunStarted(testSuite.TestName.FullName, testSuite.TestCount); }

                ExecuteTestSuite(testSuite, testRunnerEventListener, filter);

                if (testRunnerEventListener != null)
                { testRunnerEventListener.RunFinished(); }

            } catch (Exception e) {
                Debug.LogException(e);

                if (testRunnerEventListener != null)
                { testRunnerEventListener.RunFinishedException(e); }
            }
        }

        private static void AddTests(List<Test> tests, TestFilter filter)
        {
            // New tests go here

            tests.AddRange(filter(
                new SupportsMultipleCategoriesTest(),
                new SupportsPostAsDraftTest(),
                new SupportsFuturePostTest(),
                new SupportsEmptyTitlesTest()
                ));

            tests.Add(CreateCompositePostTest(filter,
                new TitleEncodingTest(),
                new SupportsEmbedsTest(),
                new SupportsScriptsTest()
                ));
        }

 public void TestOperations()
 {
     // invalid operations
      using (var filter = new FilterStream(CreateStream("test", true)))
      {
     AssertException(() => filter.Seek(0, SeekOrigin.Current));
     AssertException(() => filter.Write(new Byte[10], 0, 10));
      }
      // filter read/write
      using (var reader = new TestFilter(CreateStream("test")))
      using (var writer = new TestFilter(new MemoryStream()))
      {
     reader.CopyTo(writer);
     Assert.IsTrue(AreEqual(reader.Log, writer.Log));
      }
      using (var reader = new TestFilter(CreateStream(String.Join("", Enumerable.Repeat("123", 1000)))))
      using (var writer = new TestFilter(new MemoryStream()))
      {
     reader.CopyTo(writer);
     Assert.IsTrue(AreEqual(reader.Log, writer.Log));
      }
      // filter flush/dispose
      using (var reader1 = new TestFilter(CreateStream("test")))
      using (var reader2 = new FilterStream(reader1))
      using (var writer1 = new TestFilter(new MemoryStream()))
      using (var writer2 = new FilterStream(writer1))
      {
     reader2.CopyTo(writer2);
     Assert.IsTrue(AreEqual(reader1.Log, writer1.Log));
     Assert.IsFalse(writer1.Flushed);
     writer2.Flush();
     Assert.IsTrue(writer1.Flushed);
     Assert.IsFalse(reader1.Disposed);
     Assert.IsFalse(writer1.Disposed);
     reader2.Dispose();
     writer2.Dispose();
     Assert.IsTrue(reader1.Disposed);
     Assert.IsTrue(writer1.Disposed);
      }
 }

 /// <summary>
 /// Run the tests in the TestPackage, loading the package
 /// if this has not already been done.
 /// </summary>
 /// <param name="listener">An ITestEventHandler to receive events</param>
 /// <param name="filter">A TestFilter used to select tests</param>
 /// <returns>A TestEngineResult giving the result of the test execution</returns>
 public TestEngineResult Run(ITestEventListener listener, TestFilter filter)
 {
     return RunTests(listener, filter);
 }

 /// <summary>
 /// Count the test cases that would be run under the specified
 /// filter, loading the TestPackage if it is not already loaded.
 /// </summary>
 /// <param name="filter">A TestFilter</param>
 /// <returns>The count of test cases.</returns>
 public int CountTestCases(TestFilter filter)
 {
     return CountTests(filter);
 }

 /// <summary>
 /// Explores the TestPackage and returns information about
 /// the tests found. Loads the package if not done previously.
 /// </summary>
 /// <param name="filter">The TestFilter to be used to select tests</param>
 /// <returns>A TestEngineResult.</returns>
 public TestEngineResult Explore(TestFilter filter)
 {
     return ExploreTests(filter);
 }

        /// <summary>
        /// Start a run of the tests in the loaded TestPackage, returning immediately.
        /// The tests are run asynchronously and the listener interface is notified 
        /// as it progresses.
        /// </summary>
        /// <param name="listener">An ITestEventHandler to receive events</param>
        /// <param name="filter">A TestFilter used to select tests</param>
        /// <returns>An <see cref="AsyncTestEngineResult"/> that will provide the result of the test execution</returns>
        protected virtual AsyncTestEngineResult RunTestsAsync(ITestEventListener listener, TestFilter filter)
        {
            var testRun = new AsyncTestEngineResult();

            using (var worker = new BackgroundWorker())
            {
                worker.DoWork += (s, ea) =>
                {
                    var result = RunTests(listener, filter);
                    testRun.SetResult(result);
                };
                worker.RunWorkerAsync();
            }

            return testRun;
        }

 /// <summary>
 /// Run the tests in the loaded TestPackage.
 /// </summary>
 /// <param name="listener">An ITestEventHandler to receive events</param>
 /// <param name="filter">A TestFilter used to select tests</param>
 /// <returns>A TestEngineResult giving the result of the test execution</returns>
 protected abstract TestEngineResult RunTests(ITestEventListener listener, TestFilter filter);