NUnitLite.Runner.TextUI.Execute C# (CSharp) Method

        public void Execute(string[] args)
        {
            // NOTE: Execute must be directly called from the
            // test assembly in order for the mechanism to work.
            Assembly callingAssembly = Assembly.GetCallingAssembly();

            this.commandLineOptions = new CommandLineOptions();
            commandLineOptions.Parse(args);

            if (commandLineOptions.OutFile != null)
                this.writer = new StreamWriter(commandLineOptions.OutFile);

            if (!commandLineOptions.NoHeader)
                WriteHeader(this.writer);

            if (commandLineOptions.ShowHelp)
                writer.Write(commandLineOptions.HelpText);
            else if (commandLineOptions.Error)
            {
                writer.WriteLine(commandLineOptions.ErrorMessage);
                writer.WriteLine(commandLineOptions.HelpText);
            }
            else
            {
                WriteRuntimeEnvironment(this.writer);

                if (commandLineOptions.Wait && commandLineOptions.OutFile != null)
                    writer.WriteLine("Ignoring /wait option - only valid for Console");

#if SILVERLIGHT
                IDictionary loadOptions = new System.Collections.Generic.Dictionary<string, string>();
#else
                IDictionary loadOptions = new Hashtable();
#endif
                //if (options.Load.Count > 0)
                //    loadOptions["LOAD"] = options.Load;

                //IDictionary runOptions = new Hashtable();
                //if (commandLineOptions.TestCount > 0)
                //    runOptions["RUN"] = commandLineOptions.Tests;

                ITestFilter filter = commandLineOptions.TestCount > 0
                    ? new SimpleNameFilter(commandLineOptions.Tests)
                    : TestFilter.Empty;

                try
                {
                    foreach (string name in commandLineOptions.Parameters) {
                        try {
                            assemblies.Add(Assembly.LoadFrom(name));
                        } 
			catch (FileNotFoundException/* e*/) {
                            assemblies.Add(Assembly.Load(name));
			}
                    }

                    if (assemblies.Count == 0)
                        assemblies.Add(callingAssembly);

                    // TODO: For now, ignore all but first assembly
                    Assembly assembly = assemblies[0] as Assembly;

                    Randomizer.InitialSeed = commandLineOptions.InitialSeed;

                    if (!runner.Load(assembly, loadOptions))
                    {
                        AssemblyName assemblyName = AssemblyHelper.GetAssemblyName(assembly);
                        Console.WriteLine("No tests found in assembly {0}", assemblyName.Name);
                        return;
                    }

                    if (commandLineOptions.Explore)
                        ExploreTests();
                    else
                    {
                        if (commandLineOptions.Include != null && commandLineOptions.Include != string.Empty)
                        {
                            TestFilter includeFilter = new SimpleCategoryExpression(commandLineOptions.Include).Filter;

                            if (filter.IsEmpty)
                                filter = includeFilter;
                            else
                                filter = new AndFilter(filter, includeFilter);
                        }

                        if (commandLineOptions.Exclude != null && commandLineOptions.Exclude != string.Empty)
                        {
                            TestFilter excludeFilter = new NotFilter(new SimpleCategoryExpression(commandLineOptions.Exclude).Filter);

                            if (filter.IsEmpty)
                                filter = excludeFilter;
                            else if (filter is AndFilter)
                                ((AndFilter)filter).Add(excludeFilter);
                            else
                                filter = new AndFilter(filter, excludeFilter);
                        }

#if MONO
                        filter = Xamarin.BabysitterSupport.AddBabysitterFilter(filter);
#endif
                        RunTests(filter);
                    }
                }
                catch (FileNotFoundException ex)
                {
                    writer.WriteLine(ex.Message);
                }
                catch (Exception ex)
                {
                    writer.WriteLine(ex.ToString());
                }
                finally
                {
                    if (commandLineOptions.OutFile == null)
                    {
                        if (commandLineOptions.Wait)
                        {
                            Console.WriteLine("Press Enter key to continue . . .");
                            Console.ReadLine();
                        }
                    }
                    else
                    {
                        writer.Close();
                    }
                }
            }
        }

 // The main program executes the tests. Output may be routed to
 // various locations, depending on the arguments passed.
 //
 // Arguments:
 //
 //  Arguments may be names of assemblies or options prefixed with '/'
 //  or '-'. Normally, no assemblies are passed and the calling
 //  assembly (the one containing this Main) is used. The following
 //  options are accepted:
 //
 //    -test:<testname>  Provides the name of a test to be exected.
 //                      May be repeated. If this option is not used,
 //                      all tests are run.
 //
 //    -out:PATH         Path to a file to which output is written.
 //                      If omitted, Console is used, which means the
 //                      output is lost on a platform with no Console.
 //
 //    -full             Print full report of all tests.
 //
 //    -result:PATH      Path to a file to which the XML test result is written.
 //
 //    -explore[:Path]   If specified, list tests rather than executing them. If a
 //                      path is given, an XML file representing the tests is written
 //                      to that location. If not, output is written to tests.xml.
 //
 //    -noheader,noh     Suppress display of the initial message.
 //
 //    -wait             Wait for a keypress before exiting.
 //
 //    -include:categorylist 
 //             If specified, nunitlite will only run the tests with a category 
 //             that is in the comma separated list of category names. 
 //             Example usage: -include:category1,category2 this command can be used
 //             in combination with the -exclude option also note that exlude takes priority
 //             over all includes.
 //
 //    -exclude:categorylist 
 //             If specified, nunitlite will not run any of the tests with a category 
 //             that is in the comma separated list of category names. 
 //             Example usage: -exclude:category1,category2 this command can be used
 //             in combination with the -include option also note that exclude takes priority
 //             over all includes
 public static int Main(string[] args)
 {
     var runner = new TextUI();
     runner.Execute(args);
     
     return (runner.Failure ? 1 : 0);
 }