public TdNetRunnerHelper(Assembly assembly, ITestListener testListener)
        {
            this.testListener = testListener;

            xunit = new Xunit2(new NullSourceInformationProvider(), assembly.GetLocalCodeBase());
            toDispose.Push(xunit);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="TextUI"/> class.
 /// </summary>
 /// <param name="writer">The TextWriter to use.</param>
 /// <param name="listener">The Test listener to use.</param>
 public TextUI(TextWriter writer, ITestListener listener)
 {
     // Set the default writer - may be overridden by the args specified
     this.writer = writer;
     this.runner = new NUnitLiteTestAssemblyRunner(new NUnitLiteTestAssemblyBuilder());
     this.listener = listener;
 }

        public AdapterFacadeTestListener(ITestListener testListener)
        {
            if (testListener == null)
                throw new ArgumentNullException("testListener");

            this.testListener = testListener;
        }

 private bool ValidateParameters(ITestListener listener, DataRow dataRow) {
    if(_expectedParameterNum == dataRow.Values.Length) {
       var parameters = MethodInfo.GetParameters();
       var paramValues = new object[parameters.Length];
       for(var i = 0; i < parameters.Length; i++) {
          try {
             paramValues[i] = Convert.ChangeType(dataRow.Values[i], parameters[i].ParameterType);
          }
          catch(InvalidCastException) {
             ReportError(listener, string.Format(
                "Parameter types don't match for DataRow({0}).",
                dataRow));
             return false;
          }
          catch(FormatException) {
             ReportError(listener, string.Format(
                "Parameter types don't match for DataRow({0}).",
                dataRow));
             return false;
          }
          catch(Exception ex) {
             ReportError(listener, "Failed to convert parameter." + ex.Message);
             return false;
          }
       }
       dataRow.Values = paramValues;
       return true;
    }
    ReportError(listener, string.Format("Each data row for {0} must have {1} values.",
                                        MethodInfo.Name, _expectedParameterNum));
    return false;
 }

		public void AddListener (ITestListener listener)
		{
			lock (listeners.SyncRoot)
			{
				listeners.Add (listener);
			}
		}

        TestRunState ITdNetTestRunner.RunMember(ITestListener listener, Assembly assembly, MemberInfo member)
        {
            try
            {
                using (ExecutorWrapper wrapper = new ExecutorWrapper(new Uri(assembly.CodeBase).LocalPath, null, false))
                {
                    TdNetLogger logger = new TdNetLogger(listener, assembly);
                    TestRunner runner = new TestRunner(wrapper, logger);

                    MethodInfo method = member as MethodInfo;
                    if (method != null)
                        return RunMethod(runner, method);

                    Type type = member as Type;
                    if (type != null)
                        return RunClassWithInnerTypes(runner, type);

                    return TestRunState.NoTests;
                }
            }
            catch (ArgumentException)
            {
                return TestRunState.NoTests;
            }
        }

        public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member)
        {
            var method = member as MethodInfo;
            if (method != null)
            {
                if (method.IsDispose())
                {
                    var listener = new TestDrivenListener(testListener);
                    listener.CaseSkipped(new SkipResult(new Case(method), "Dispose() is not a test."));
                    return TestRunState.Success;
                }

                return Run(testListener, runner => runner.RunMethods(assembly, method));
            }

            var type = member as Type;
            if (type != null)
            {
                var types = GetTypeAndNestedTypes(type).ToArray();

                return Run(testListener, runner => runner.RunTypes(assembly, types));
            }

            return TestRunState.Error;
        }

        TestRunState ITestRunner.RunNamespace(ITestListener testListener, Assembly assembly, string ns)
        {
            return TestRunState.NoTests;

            //TODO: Fix filter. ns is probably equal to NamespaceFilter in StoryRunnerFilter
            //return Run(assembly, null, testListener);
        }

    public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member)
    {
      var listener = new TDNetRunListener(testListener);
      var runner = new AppDomainRunner(listener, RunOptions.Default);
      runner.RunMember(assembly, member);

      return listener.TestRunState;
    }

    public TestRunState RunNamespace(ITestListener testListener, Assembly assembly, string ns)
    {
      var listener = new TDNetRunListener(testListener);
      var runner = new AppDomainRunner(listener, RunOptions.Default);
      runner.RunNamespace(assembly, ns);

      return listener.TestRunState;
    }

 public TestRunState RunNamespace(ITestListener testListener, Assembly assembly, string ns)
 {
     using (var helper = CreateHelper(testListener, assembly))
     {
         var testCases = helper.Discover().Where(tc => ns == null || tc.GetClass().Namespace == ns);
         return helper.Run(testCases);
     }
 }

 public virtual void Run(ITestListener listener)
 {
     listener.RunStarted();
     ITestExecutor executor = new _ITestExecutor_19(this, listener);
     Environments.RunWith(Environments.NewClosedEnvironment(new object[] {executor})
         , new _IRunnable_28(this, listener));
     listener.RunFinished();
 }

        public TdNetRunnerHelper(Assembly assembly, ITestListener testListener)
        {
            this.testListener = testListener;

            var assemblyFileName = assembly.GetLocalCodeBase();
            configuration = ConfigReader.Load(assemblyFileName);
            var diagnosticMessageSink = new DiagnosticMessageSink(testListener, Path.GetFileNameWithoutExtension(assemblyFileName), configuration.DiagnosticMessagesOrDefault);
            xunit = new Xunit2(configuration.AppDomainOrDefault, new NullSourceInformationProvider(), assemblyFileName, shadowCopy: false, diagnosticMessageSink: diagnosticMessageSink);
            toDispose.Push(xunit);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="TextUI"/> class.
        /// </summary>
        /// <param name="writer">The TextWriter to use.</param>
        /// <param name="listener">The Test listener to use.</param>
        public TextUI(TextWriter writer, ITestListener listener)
        {
            // Set the default writer - may be overridden by the args specified
            this.writer = writer;
            this.finallyDelegate = new FinallyDelegate();
            this.runner = new NUnitLiteTestAssemblyRunner(new NUnitLiteTestAssemblyBuilder(), this.finallyDelegate);
            this.listener = listener;


	    AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(this.TopLevelHandler);
        }

        public TestRunState Run(ITestListener testListener, string assemblyFile, string cref)
        {
            if (testListener == null)
                throw new ArgumentNullException("testListener");
            if (assemblyFile == null)
                throw new ArgumentNullException("assemblyFile");

            FacadeOptions options = FacadeOptions.ReadFromRegistry();
            FacadeTestRunState result = TestRunner.Run(new AdapterFacadeTestListener(testListener), assemblyFile, cref, options);
            return FacadeUtils.ToTestRunState(result);
        }

        public TestRunState RunAssembly(ITestListener testListener, Assembly assembly)
        {
            if (testListener == null)
                throw new ArgumentNullException("testListener");
            if (assembly == null)
                throw new ArgumentNullException("assembly");

            FacadeOptions options = FacadeOptions.ReadFromRegistry();
            FacadeTestRunState result = TestRunner.Run(new AdapterFacadeTestListener(testListener),
                GetAssemblyPath(assembly), null, options);
            return FacadeUtils.ToTestRunState(result);
        }

        public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member)
        {
            using (var helper = CreateHelper(testListener, assembly))
            {
                if (member is Type)
                    return helper.RunClass((Type)member);
                if (member is MethodInfo)
                    return helper.RunMethod((MethodInfo)member);

                return TestRunState.NoTests;
            }
        }

        public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member)
        {
            var method = member as MethodInfo;
            if (method != null)
                return Run(testListener, runner => runner.RunMethod(assembly, method));

            var type = member as Type;
            if (type != null)
                return Run(testListener, runner => runner.RunType(assembly, type));

            return TestRunState.Error;
        }

        public new TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member)
        {
            if (member.MemberType == MemberTypes.Constructor)
            {
                var where  = "(cat == '.current')";
                var result = this.Call<TestRunState>("run", testListener, assembly, where);
                if (result != TestRunState.NoTests) return result;

                return base.RunMember(testListener, assembly, member.DeclaringType);
            }

            return base.RunMember(testListener, assembly, member);
        }

        /// <summary>
        /// Run selected tests asynchronously, notifying the listener interface as it progresses.
        /// </summary>
        /// <param name="listener">Interface to receive EventListener notifications.</param>
        /// <returns></returns>
        public override void StartRun(ITestListener listener)
        {
#if !SILVERLIGHT && !NETCF
            _savedOut = Console.Out;
            _savedErr = Console.Error;

            Console.SetOut(new TextCapture(_savedOut));
            Console.SetError(new TextCapture(_savedErr));
#endif

            Context.Dispatcher = new SimpleWorkItemDispatcher();
            Context.Dispatcher.Dispatch(TopLevelWorkItem);
        }