コード例 #1
1
		internal UnitTestResult RunUnitTest (UnitTest test, string suiteName, string pathName, string testName, TestContext testContext)
		{
			var runnerExe = GetCustomConsoleRunnerCommand ();
			if (runnerExe != null)
				return RunWithConsoleRunner (runnerExe, test, suiteName, pathName, testName, testContext);

			ExternalTestRunner runner = (ExternalTestRunner)Runtime.ProcessService.CreateExternalProcessObject (typeof(ExternalTestRunner), testContext.ExecutionContext, UserAssemblyPaths);
			LocalTestMonitor localMonitor = new LocalTestMonitor (testContext, test, suiteName, testName != null);

			ITestFilter filter = null;
			if (test != null) {
				if (test is UnitTestGroup) {
					var categoryOptions = (NUnitCategoryOptions) test.GetOptions (typeof(NUnitCategoryOptions));
					if (categoryOptions.EnableFilter && categoryOptions.Categories.Count > 0) {
						string[] cats = new string [categoryOptions.Categories.Count];
						categoryOptions.Categories.CopyTo (cats, 0);
						filter = new CategoryFilter (cats);
						if (categoryOptions.Exclude)
							filter = new NotFilter (filter);
					} else {
						filter = new TestNameFilter (CollectTests ((UnitTestGroup)test));
					}
				} else {
					filter = new TestNameFilter (test.TestId);
				}
			}

			RunData rd = new RunData ();
			rd.Runner = runner;
			rd.Test = this;
			rd.LocalMonitor = localMonitor;
			testContext.Monitor.CancelRequested += new TestHandler (rd.Cancel);

			UnitTestResult result;
			var crashLogFile = Path.GetTempFileName ();

			try {
				if (string.IsNullOrEmpty (AssemblyPath)) {
					string msg = GettextCatalog.GetString ("Could not get a valid path to the assembly. There may be a conflict in the project configurations.");
					throw new Exception (msg);
				}
				System.Runtime.Remoting.RemotingServices.Marshal (localMonitor, null, typeof (IRemoteEventListener));

				string testRunnerAssembly, testRunnerType;
				GetCustomTestRunner (out testRunnerAssembly, out testRunnerType);

				result = runner.Run (localMonitor, filter, AssemblyPath, "", new List<string> (SupportAssemblies), testRunnerType, testRunnerAssembly, crashLogFile);
				if (testName != null)
					result = localMonitor.SingleTestResult;
				
				ReportCrash (testContext, crashLogFile);
				
			} catch (Exception ex) {
				if (ReportCrash (testContext, crashLogFile)) {
					result = UnitTestResult.CreateFailure (GettextCatalog.GetString ("Unhandled exception"), null);
				}
				else if (!localMonitor.Canceled) {
					LoggingService.LogError (ex.ToString ());
					if (localMonitor.RunningTest != null) {
						RuntimeErrorCleanup (testContext, localMonitor.RunningTest, ex);
					} else {
						testContext.Monitor.ReportRuntimeError (null, ex);
						throw;
					}
					result = UnitTestResult.CreateFailure (ex);
				} else {
					result = UnitTestResult.CreateFailure (GettextCatalog.GetString ("Canceled"), null);
				}
			} finally {
				File.Delete (crashLogFile);
				testContext.Monitor.CancelRequested -= new TestHandler (rd.Cancel);
				runner.Dispose ();
				System.Runtime.Remoting.RemotingServices.Disconnect (localMonitor);
			}
			
			return result;
		}
コード例 #2
1
		internal UnitTestResult RunUnitTest (UnitTest test, string suiteName, string testName, TestContext testContext)
		{
			ExternalTestRunner runner = (ExternalTestRunner) Runtime.ProcessService.CreateExternalProcessObject (typeof(ExternalTestRunner), testContext.ExecutionContext);
			LocalTestMonitor localMonitor = new LocalTestMonitor (testContext, runner, test, suiteName, testName != null);
			
			ITestFilter filter = null;
			
			if (testName != null) {
				filter = new TestNameFilter (suiteName + "." + testName);
			} else {
				NUnitCategoryOptions categoryOptions = (NUnitCategoryOptions) test.GetOptions (typeof(NUnitCategoryOptions));
				if (categoryOptions.EnableFilter && categoryOptions.Categories.Count > 0) {
					string[] cats = new string [categoryOptions.Categories.Count];
					categoryOptions.Categories.CopyTo (cats, 0);
					filter = new CategoryFilter (cats);
					if (categoryOptions.Exclude)
						filter = new NotFilter (filter);
				}
			}
			
			RunData rd = new RunData ();
			rd.Runner = runner;
			rd.Test = this;
			rd.LocalMonitor = localMonitor;
			testContext.Monitor.CancelRequested += new TestHandler (rd.Cancel);
			
			UnitTestResult result;
			
			try {
				if (string.IsNullOrEmpty (AssemblyPath)) {
					string msg = GettextCatalog.GetString ("Could not get a valid path to the assembly. There may be a conflict in the project configurations.");
					throw new Exception (msg);
				}
				System.Runtime.Remoting.RemotingServices.Marshal (localMonitor, null, typeof (IRemoteEventListener));
				result = runner.Run (localMonitor, filter, AssemblyPath, suiteName, new List<string> (SupportAssemblies));
				if (testName != null)
					result = localMonitor.SingleTestResult;
			} catch (Exception ex) {
				if (!localMonitor.Canceled) {
					LoggingService.LogError (ex.ToString ());
					if (localMonitor.RunningTest != null) {
						RuntimeErrorCleanup (testContext, localMonitor.RunningTest, ex);
					} else {
						testContext.Monitor.ReportRuntimeError (null, ex);
						throw ex;
					}
					result = UnitTestResult.CreateFailure (ex);
				} else {
					result = UnitTestResult.CreateFailure (GettextCatalog.GetString ("Canceled"), null);
				}
			} finally {
				testContext.Monitor.CancelRequested -= new TestHandler (rd.Cancel);
				runner.Dispose ();
				System.Runtime.Remoting.RemotingServices.Disconnect (localMonitor);
			}
			
			return result;
		}
コード例 #3
0
ファイル: NUnitRunner.cs プロジェクト: gtejeda/AutoTest.Net
        private TestFilter getTestFilter(Options options)
        {
            TestFilter testFilter = TestFilter.Empty;
            if (options.Tests != null && options.Tests != string.Empty)
                testFilter = new SimpleNameFilter(options.Tests);

            if (options.Categories != null && options.Categories != string.Empty)
            {
                TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.Categories).Filter);
                if (testFilter.IsEmpty)
                    testFilter = excludeFilter;
                else if (testFilter is AndFilter)
                    ((AndFilter)testFilter).Add(excludeFilter);
                else
                    testFilter = new AndFilter(testFilter, excludeFilter);
            }

            if (testFilter is NotFilter)
                ((NotFilter)testFilter).TopLevel = true;
            return testFilter;
        }
コード例 #4
0
ファイル: ConsoleUi.cs プロジェクト: fotisp/conqat
        public int Execute( ConsoleOptions options )
        {
            XmlTextReader transformReader = GetTransformReader(options);
            if(transformReader == null) return 3;

            TextWriter outWriter = Console.Out;
            if ( options.isOut )
            {
                StreamWriter outStreamWriter = new StreamWriter( options.output );
                outStreamWriter.AutoFlush = true;
                outWriter = outStreamWriter;
            }

            TextWriter errorWriter = Console.Error;
            if ( options.isErr )
            {
                StreamWriter errorStreamWriter = new StreamWriter( options.err );
                errorStreamWriter.AutoFlush = true;
                errorWriter = errorStreamWriter;
            }

            TestRunner testRunner = MakeRunnerFromCommandLine( options );

            try
            {
                if (testRunner.Test == null)
                {
                    testRunner.Unload();
                    Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
                    return 2;
                }

                EventCollector collector = new EventCollector( options, outWriter, errorWriter );

                TestFilter catFilter = TestFilter.Empty;

                if (options.HasInclude)
                {
                    Console.WriteLine( "Included categories: " + options.include );
                    catFilter = new CategoryFilter( options.IncludedCategories );
                }

                if ( options.HasExclude )
                {
                    Console.WriteLine( "Excluded categories: " + options.exclude );
                    TestFilter excludeFilter = new NotFilter( new CategoryFilter( options.ExcludedCategories ) );
                    if ( catFilter.IsEmpty )
                        catFilter = excludeFilter;
                    else
                        catFilter = new AndFilter( catFilter, excludeFilter );
                }

                TestResult result = null;
                string savedDirectory = Environment.CurrentDirectory;
                TextWriter savedOut = Console.Out;
                TextWriter savedError = Console.Error;

                try
                {
                    result = testRunner.Run( collector, catFilter );
                }
                finally
                {
                    outWriter.Flush();
                    errorWriter.Flush();

                    if ( options.isOut )
                        outWriter.Close();
                    if ( options.isErr )
                        errorWriter.Close();

                    Environment.CurrentDirectory = savedDirectory;
                    Console.SetOut( savedOut );
                    Console.SetError( savedError );
                }

                Console.WriteLine();

                string xmlOutput = CreateXmlOutput( result );

                if (options.xmlConsole)
                {
                    Console.WriteLine(xmlOutput);
                }
                else
                {
                    try
                    {
                        //CreateSummaryDocument(xmlOutput, transformReader );
                        XmlResultTransform xform = new XmlResultTransform( transformReader );
                        xform.Transform( new StringReader( xmlOutput ), Console.Out );
                    }
                    catch( Exception ex )
                    {
                        Console.WriteLine( "Error: {0}", ex.Message );
                        return 3;
                    }
                }

                // Write xml output here
                string xmlResultFile = options.IsXml ? options.xml : "TestResult.xml";

                using ( StreamWriter writer = new StreamWriter( xmlResultFile ) )
                {
                    writer.Write(xmlOutput);
                }

                //if ( testRunner != null )
                //    testRunner.Unload();

                if ( collector.HasExceptions )
                {
                    collector.WriteExceptions();
                    return 2;
                }

                return result.IsFailure ? 1 : 0;
            }
            finally
            {
                testRunner.Unload();
            }
        }
コード例 #5
0
        private TestFilter getTestFilter(Options options)
        {
            var testFilter = TestFilter.Empty;
            if (!string.IsNullOrEmpty(options.Tests))
                testFilter = new SimpleNameFilter(options.Tests);

            if (!string.IsNullOrEmpty(options.Categories))
            {
                TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.Categories).Filter);
                if (testFilter.IsEmpty)
                    testFilter = excludeFilter;
                else if (testFilter is AndFilter)
                    ((AndFilter)testFilter).Add(excludeFilter);
                else
                    testFilter = new AndFilter(testFilter, excludeFilter);
            }

            var notFilter = testFilter as NotFilter;
            if (notFilter != null)
                notFilter.TopLevel = true;
            return testFilter;
        }
コード例 #6
0
ファイル: ConsoleUi.cs プロジェクト: rmterra/AutoTest.Net
		public int Execute( ConsoleOptions options )
		{
            this.workDir = options.work;
            if (workDir == null || workDir == string.Empty)
                workDir = Environment.CurrentDirectory;
            else
            {
                workDir = Path.GetFullPath(workDir);
                if (!Directory.Exists(workDir))
                    Directory.CreateDirectory(workDir);
            }

			TextWriter outWriter = Console.Out;
			bool redirectOutput = options.output != null && options.output != string.Empty;
			if ( redirectOutput )
			{
				StreamWriter outStreamWriter = new StreamWriter( Path.Combine(workDir, options.output) );
				outStreamWriter.AutoFlush = true;
				outWriter = outStreamWriter;
			}

			TextWriter errorWriter = Console.Error;
			bool redirectError = options.err != null && options.err != string.Empty;
			if ( redirectError )
			{
				StreamWriter errorStreamWriter = new StreamWriter( Path.Combine(workDir, options.err) );
				errorStreamWriter.AutoFlush = true;
				errorWriter = errorStreamWriter;
			}

            TestPackage package = MakeTestPackage(options);

            ProcessModel processModel = package.Settings.Contains("ProcessModel")
                ? (ProcessModel)package.Settings["ProcessModel"]
                : ProcessModel.Default;

            DomainUsage domainUsage = package.Settings.Contains("DomainUsage")
                ? (DomainUsage)package.Settings["DomainUsage"]
                : DomainUsage.Default;

            RuntimeFramework framework = package.Settings.Contains("RuntimeFramework")
                ? (RuntimeFramework)package.Settings["RuntimeFramework"]
                : RuntimeFramework.CurrentFramework;

#if CLR_2_0 || CLR_4_0
            Console.WriteLine("ProcessModel: {0}    DomainUsage: {1}", processModel, domainUsage);

            Console.WriteLine("Execution Runtime: {0}", framework);
#else
            Console.WriteLine("DomainUsage: {0}", domainUsage);

            if (processModel != ProcessModel.Default && processModel != ProcessModel.Single)
                Console.WriteLine("Warning: Ignoring project setting 'processModel={0}'", processModel);

            if (!RuntimeFramework.CurrentFramework.Supports(framework))
                Console.WriteLine("Warning: Ignoring project setting 'runtimeFramework={0}'", framework);
#endif

            using (TestRunner testRunner = new DefaultTestRunnerFactory().MakeTestRunner(package))
			{
                testRunner.Load(package);

                if (testRunner.Test == null)
				{
					testRunner.Unload();
					Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
					return FIXTURE_NOT_FOUND;
				}

				EventCollector collector = new EventCollector( options, outWriter, errorWriter );

				TestFilter testFilter = TestFilter.Empty;
                SimpleNameFilter nameFilter = new SimpleNameFilter();

				if ( options.run != null && options.run != string.Empty )
				{
					Console.WriteLine( "Selected test(s): " + options.run );
                    foreach (string name in TestNameParser.Parse(options.run))
                        nameFilter.Add(name);
                    testFilter = nameFilter;
				}

                if (options.runlist != null && options.runlist != string.Empty)
                {
                    Console.WriteLine("Run list: " + options.runlist);
                    using (StreamReader rdr = new StreamReader(options.runlist))
                    {
                        // NOTE: We can't use rdr.EndOfStream because it's
                        // not present in .NET 1.x.
                        string line = rdr.ReadLine();
                        while (line != null)
                        {
                            if (line[0] != '#')
                                nameFilter.Add(line);
                            line = rdr.ReadLine();
                        }
                    }
                    testFilter = nameFilter;
                }

				if ( options.include != null && options.include != string.Empty )
				{
					TestFilter includeFilter = new CategoryExpression( options.include ).Filter;
                    Console.WriteLine("Included categories: " + includeFilter.ToString());

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

				if ( options.exclude != null && options.exclude != string.Empty )
				{
					TestFilter excludeFilter = new NotFilter( new CategoryExpression( options.exclude ).Filter );
                    Console.WriteLine("Excluded categories: " + excludeFilter.ToString());

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

                if (testFilter is NotFilter)
                    ((NotFilter)testFilter).TopLevel = true;

				TestResult result = null;
				string savedDirectory = Environment.CurrentDirectory;
				TextWriter savedOut = Console.Out;
				TextWriter savedError = Console.Error;

				try
				{
					result = testRunner.Run( collector, testFilter, false, LoggingThreshold.Off );
				}
				finally
				{
					outWriter.Flush();
					errorWriter.Flush();

					if ( redirectOutput )
						outWriter.Close();
					if ( redirectError )
						errorWriter.Close();

					Environment.CurrentDirectory = savedDirectory;
					Console.SetOut( savedOut );
					Console.SetError( savedError );
				}

				Console.WriteLine();

                int returnCode = UNEXPECTED_ERROR;

                if (result != null)
                {
                    string xmlOutput = CreateXmlOutput(result);
                    ResultSummarizer summary = new ResultSummarizer(result);

                    if (options.xmlConsole)
                    {
                        Console.WriteLine(xmlOutput);
                    }
                    else
                    {
                        WriteSummaryReport(summary);
                        if (summary.ErrorsAndFailures > 0 || result.IsError || result.IsFailure)
                        {
                            if (options.stoponerror)
                            {
                                Console.WriteLine("Test run was stopped after first error, as requested.");
                                Console.WriteLine();
                            }

                            WriteErrorsAndFailuresReport(result);
                        }
                        if (summary.TestsNotRun > 0)
                            WriteNotRunReport(result);

                        if (!options.noresult)
                        {
                            // Write xml output here
                            string xmlResultFile = options.result == null || options.result == string.Empty
                                ? "TestResult.xml" : options.result;

                            using (StreamWriter writer = new StreamWriter(Path.Combine(workDir, xmlResultFile)))
                            {
                                writer.Write(xmlOutput);
                            }
                        }
                    }

                    returnCode = summary.ErrorsAndFailures;
                }

				if ( collector.HasExceptions )
				{
					collector.WriteExceptions();
					returnCode = UNEXPECTED_ERROR;
				}
            
				return returnCode;
			}
		}
コード例 #7
0
ファイル: NUnit2Task.cs プロジェクト: julianhaslinger/nant
        /// <summary>
        /// Runs the tests and sets up the formatters.
        /// </summary>
        protected override void ExecuteTask()
        {
            if (FormatterElements.Count == 0) {
                FormatterElement defaultFormatter = new FormatterElement();
                defaultFormatter.Project = Project;
                defaultFormatter.NamespaceManager = NamespaceManager;
                defaultFormatter.Type = FormatterType.Plain;
                defaultFormatter.UseFile = false;
                FormatterElements.Add(defaultFormatter);

                Log(Level.Warning, "No <formatter .../> element was specified." +
                    " A plain-text formatter was added to prevent losing output of the" +
                    " test results.");

                Log(Level.Warning, "Add a <formatter .../> element to the" +
                    " <nunit2> task to prevent this warning from being output and" +
                    " to ensure forward compatibility with future revisions of NAnt.");
            }

            LogWriter logWriter = new LogWriter(this, Level.Info, CultureInfo.InvariantCulture);
            EventListener listener = GetListener(logWriter);

            foreach (NUnit2Test testElement in Tests) {
                // Setup the test filter var to setup include/exclude filters.
                ITestFilter testFilter = null;

                // If the include categories contains values, setup the category
                // filter with the include categories.
                string includes = testElement.Categories.Includes.ToString();
                if (!String.IsNullOrEmpty(includes))
                {
                    testFilter = new CategoryFilter(includes.Split(','));
                }
                else
                {
                    // If the include categories does not have includes but
                    // contains excludes, setup the category filter with the excludes
                    // and use the Not filter to tag the categories for exclude.
                    string excludes = testElement.Categories.Excludes.ToString();
                    if (!String.IsNullOrEmpty(excludes))
                    {
                        ITestFilter excludeFilter = new CategoryFilter(excludes.Split(','));
                        testFilter = new NotFilter(excludeFilter);
                    }
                    else
                    {
                        // If the categories do not contain includes or excludes,
                        // assign the testFilter var with an empty filter.
                        testFilter = TestFilter.Empty;
                    }
                }

                foreach (string testAssembly in testElement.TestAssemblies) {
                    // Setup the NUnit2TestDomain var.
                    NUnit2TestDomain domain = new NUnit2TestDomain();
                    // Setup the TestPackage var to use with the testrunner var
                    TestPackage package = new TestPackage(testAssembly);

                    try {
                        // Create the TestRunner var
                        TestRunner runner = domain.CreateRunner(
                            new FileInfo(testAssembly),
                            testElement.AppConfigFile,
                            testElement.References.FileNames);

                        // If the name of the current test element is not null,
                        // use it for the package test name.
                        if (!String.IsNullOrEmpty(testElement.TestName))
                        {
                            package.TestName = testElement.TestName;
                        }

                        // Bool var containing the result of loading the test package
                        // in the TestRunner var.
                        bool successfulLoad = runner.Load(package);

                        // If the test package load was successful, proceed with the
                        // testing.
                        if (successfulLoad)
                        {
                            // If the runner does not contain any tests, proceed
                            // to the next assembly.
                            if (runner.Test == null) {
                                Log(Level.Warning, "Assembly \"{0}\" contains no tests.",
                                    testAssembly);
                                continue;
                            }

                            // Setup and run tests
                            TestResult result = runner.Run(listener, testFilter,
                                    true, GetLoggingThreshold());

                            // flush test output to log
                            logWriter.Flush();

                            // format test results using specified formatters
                            FormatResult(testElement, result);

                            if (result.IsFailure &&
                                (testElement.HaltOnFailure || HaltOnFailure)) {
                                throw new BuildException("Tests Failed.", Location);
                            }
                        }
                        else
                        {
                            // If the package load failed, throw a build exception.
                            throw new BuildException("Test Package Load Failed.", Location);
                        }
                    } catch (BuildException) {
                        // re-throw build exceptions
                        throw;
                    } catch (Exception ex) {
                        if (!FailOnError) {
                            // just log error and continue with next test

                            // TODO: (RMB) Need to make sure that this is the correct way to proceed with displaying NUnit errors.
                            string logMessage =
                                String.Concat("[", Name, "] NUnit Error: ", ex.ToString());

                            Log(Level.Error, logMessage.PadLeft(Project.IndentationSize));
                            continue;
                        }

                        Version nunitVersion = typeof(TestResult).Assembly.GetName().Version;

                        throw new BuildException(string.Format(CultureInfo.InvariantCulture,
                            "Failure executing test(s). If you assembly is not built using"
                            + " NUnit version {0}, then ensure you have redirected assembly"
                            + " bindings. Consult the documentation of the <nunit2> task"
                            + " for more information.", nunitVersion), Location, ex);
                    } finally {
                        domain.Unload();

                        // flush test output to log
                        logWriter.Flush();
                    }
                }
            }
        }
コード例 #8
0
		public int Execute( ConsoleOptions options )
		{
			TextWriter outWriter = Console.Out;
			bool redirectOutput = options.output != null && options.output != string.Empty;
			if ( redirectOutput )
			{
				StreamWriter outStreamWriter = new StreamWriter( options.output );
				outStreamWriter.AutoFlush = true;
				outWriter = outStreamWriter;
			}

			TextWriter errorWriter = Console.Error;
			bool redirectError = options.err != null && options.err != string.Empty;
			if ( redirectError )
			{
				StreamWriter errorStreamWriter = new StreamWriter( options.err );
				errorStreamWriter.AutoFlush = true;
				errorWriter = errorStreamWriter;
			}

            TestPackage package = MakeTestPackage(options);

            Console.WriteLine("ProcessModel: {0}    DomainUsage: {1}", 
                package.Settings.Contains("ProcessModel")
                    ? package.Settings["ProcessModel"]
                    : "Default", 
                package.Settings.Contains("DomainUsage")
                    ? package.Settings["DomainUsage"]
                    : "Default");

            Console.WriteLine("Execution Runtime: {0}", 
                package.Settings.Contains("RuntimeFramework")
                    ? package.Settings["RuntimeFramework"]
                    : "Default");

            using (TestRunner testRunner = new DefaultTestRunnerFactory().MakeTestRunner(package))
			{
                testRunner.Load(package);

                if (testRunner.Test == null)
				{
					testRunner.Unload();
					Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
					return FIXTURE_NOT_FOUND;
				}

				EventCollector collector = new EventCollector( options, outWriter, errorWriter );

				TestFilter testFilter = TestFilter.Empty;
				if ( options.run != null && options.run != string.Empty )
				{
					Console.WriteLine( "Selected test(s): " + options.run );
					testFilter = new SimpleNameFilter( options.run );
				}

				if ( options.include != null && options.include != string.Empty )
				{
					Console.WriteLine( "Included categories: " + options.include );
					TestFilter includeFilter = new CategoryExpression( options.include ).Filter;
					if ( testFilter.IsEmpty )
						testFilter = includeFilter;
					else
						testFilter = new AndFilter( testFilter, includeFilter );
				}

				if ( options.exclude != null && options.exclude != string.Empty )
				{
					Console.WriteLine( "Excluded categories: " + options.exclude );
					TestFilter excludeFilter = new NotFilter( new CategoryExpression( options.exclude ).Filter );
					if ( testFilter.IsEmpty )
						testFilter = excludeFilter;
					else if ( testFilter is AndFilter )
						((AndFilter)testFilter).Add( excludeFilter );
					else
						testFilter = new AndFilter( testFilter, excludeFilter );
				}

                if (testFilter is NotFilter)
                    ((NotFilter)testFilter).TopLevel = true;

				TestResult result = null;
				string savedDirectory = Environment.CurrentDirectory;
				TextWriter savedOut = Console.Out;
				TextWriter savedError = Console.Error;

				try
				{
					result = testRunner.Run( collector, testFilter );
				}
				finally
				{
					outWriter.Flush();
					errorWriter.Flush();

					if ( redirectOutput )
						outWriter.Close();
					if ( redirectError )
						errorWriter.Close();

					Environment.CurrentDirectory = savedDirectory;
					Console.SetOut( savedOut );
					Console.SetError( savedError );
				}

				Console.WriteLine();

                int returnCode = UNEXPECTED_ERROR;

                if (result != null)
                {
                    string xmlOutput = CreateXmlOutput(result);
                    ResultSummarizer summary = new ResultSummarizer(result);

                    if (options.xmlConsole)
                    {
                        Console.WriteLine(xmlOutput);
                    }
                    else
                    {
                        WriteSummaryReport(summary);
                        if (summary.ErrorsAndFailures > 0)
                            WriteErrorsAndFailuresReport(result);
                        if (summary.TestsNotRun > 0)
                            WriteNotRunReport(result);
                    }

                    // Write xml output here
                    string xmlResultFile = options.xml == null || options.xml == string.Empty
                        ? "TestResult.xml" : options.xml;

                    using (StreamWriter writer = new StreamWriter(xmlResultFile))
                    {
                        writer.Write(xmlOutput);
                    }

                    returnCode = summary.ErrorsAndFailures;
                }

				if ( collector.HasExceptions )
				{
					collector.WriteExceptions();
					returnCode = UNEXPECTED_ERROR;
				}
            
				return returnCode;
			}
		}
コード例 #9
0
ファイル: VisualState.cs プロジェクト: rmterra/AutoTest.Net
        public void Restore(TestSuiteTreeView treeView)
        {
            treeView.CheckBoxes = this.ShowCheckBoxes;

            foreach (VisualTreeNode visualNode in this.Nodes)
            {
                TestSuiteTreeNode treeNode = treeView[visualNode.UniqueName];
                if (treeNode != null)
                {
                    if (treeNode.IsExpanded != visualNode.Expanded)
                        treeNode.Toggle();

                    treeNode.Checked = visualNode.Checked;
                }
            }

            if (this.SelectedNode != null)
            {
                TestSuiteTreeNode treeNode = treeView[this.SelectedNode];
                if (treeNode != null)
                    treeView.SelectedNode = treeNode;
            }

            if (this.TopNode != null)
            {
                TestSuiteTreeNode treeNode = treeView[this.TopNode];
                if (treeNode != null)
                    treeView.TopNode = treeNode;
            }

            if (this.SelectedCategories != null)
            {
                TestFilter filter = new CategoryFilter(this.SelectedCategories.Split(new char[] { ',' }));
                if (this.ExcludeCategories)
                    filter = new NotFilter(filter);
                treeView.CategoryFilter = filter;
            }

            treeView.Select();
        }
コード例 #10
0
ファイル: TestSuiteTreeView.cs プロジェクト: scottwis/eddie
        private void RestoreVisualState( VisualState visualState )
        {
            this.CheckBoxes = visualState.ShowCheckBoxes;

            foreach (VisualTreeNode visualNode in visualState.Nodes)
            {
                TestSuiteTreeNode treeNode = this[visualNode.UniqueName];
                if (treeNode != null)
                {
                    if (treeNode.IsExpanded != visualNode.Expanded)
                        treeNode.Toggle();

                    treeNode.Checked = visualNode.Checked;
                }
            }

            if (visualState.SelectedNode != null)
            {
                TestSuiteTreeNode treeNode = this[visualState.SelectedNode];
                if (treeNode != null)
                    this.SelectedNode = treeNode;
            }

            if (visualState.TopNode != null)
            {
                TestSuiteTreeNode treeNode = this[visualState.TopNode];
                if (treeNode != null)
                    TryToSetTopNode(treeNode);
            }

            if (visualState.SelectedCategories != null)
            {
                TestFilter filter = new CategoryFilter(visualState.SelectedCategories.Split(new char[] { ',' }));
                if (visualState.ExcludeCategories)
                    filter = new NotFilter(filter);
                this.CategoryFilter = filter;
            }

            this.Select();
        }
コード例 #11
0
ファイル: TestSuiteTest.cs プロジェクト: taoxiease/asegrp
 public void ExcludingCategoryDoesNotRunExplicitTestCases()
 {
     TestFilter filter = new NotFilter( new CategoryFilter( "MockCategory" ) );
     TestResult result = mockTestFixture.Run( NullListener.NULL, filter );
     ResultSummarizer summarizer = new ResultSummarizer( result );
     Assert.AreEqual( 2, summarizer.ResultCount );
 }
コード例 #12
0
ファイル: ConsoleUi.cs プロジェクト: kurman/mt-nunit-console
        public int Execute(ConsoleOptions options)
        {
            var outWriter = System.Console.Out;
            var redirectOutput = options.output != null && options.output != string.Empty;
            if (redirectOutput)
            {
                var outStreamWriter = new StreamWriter(options.output);
                outStreamWriter.AutoFlush = true;
                outWriter = outStreamWriter;
            }

            var errorWriter = System.Console.Error;
            var redirectError = options.err != null && options.err != string.Empty;
            if (redirectError)
            {
                var errorStreamWriter = new StreamWriter(options.err);
                errorStreamWriter.AutoFlush = true;
                errorWriter = errorStreamWriter;
            }

            var package = MakeTestPackage(options);

            System.Console.WriteLine("ProcessModel: {0}    DomainUsage: {1}",
                package.Settings.Contains("ProcessModel")
                    ? package.Settings["ProcessModel"]
                    : "Default",
                package.Settings.Contains("DomainUsage")
                    ? package.Settings["DomainUsage"]
                    : "Default");

            System.Console.WriteLine("Execution Runtime: {0}",
                package.Settings.Contains("RuntimeFramework")
                    ? package.Settings["RuntimeFramework"]
                    : "Default");

            var collector = new EventCollector(options, outWriter, errorWriter);

            var testFilter = TestFilter.Empty;
            if (options.run != null && options.run != string.Empty)
            {
                System.Console.WriteLine("Selected test(s): " + options.run);
                testFilter = new SimpleNameFilter(options.run);
            }

            if (options.include != null && options.include != string.Empty)
            {
                System.Console.WriteLine("Included categories: " + options.include);
                var includeFilter = new CategoryExpression(options.include).Filter;
                if (testFilter.IsEmpty)
                    testFilter = includeFilter;
                else
                    testFilter = new AndFilter(testFilter, includeFilter);
            }

            if (options.exclude != null && options.exclude != string.Empty)
            {
                System.Console.WriteLine("Excluded categories: " + options.exclude);
                TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
                if (testFilter.IsEmpty)
                    testFilter = excludeFilter;
                else if (testFilter is AndFilter)
                    ((AndFilter)testFilter).Add(excludeFilter);
                else
                    testFilter = new AndFilter(testFilter, excludeFilter);
            }

            if (testFilter is NotFilter)
                ((NotFilter)testFilter).TopLevel = true;
            TestResult result;

            var returnCode = DoRun(options, redirectOutput, redirectError, package, outWriter, errorWriter, testFilter, out result, collector);
            if (returnCode != 0)
                return returnCode;

            returnCode = UNEXPECTED_ERROR;

            if (result != null)
            {
                var xmlOutput = CreateXmlOutput(result);
                var summary = new ResultSummarizer(result);

                if (options.xmlConsole)
                {
                    System.Console.WriteLine(xmlOutput);
                }
                else
                {
                    WriteSummaryReport(summary);
                    if (summary.ErrorsAndFailures > 0)
                        WriteErrorsAndFailuresReport(result);
                    if (summary.TestsNotRun > 0)
                        WriteNotRunReport(result);
                }

                // Write xml output here
                var xmlResultFile = options.xml == null || options.xml == string.Empty
                                        ? "TestResult.xml" : options.xml;

                using (var writer = new StreamWriter(xmlResultFile))
                {
                    writer.Write(xmlOutput);
                }

                returnCode = summary.ErrorsAndFailures;
            }

            if (collector.HasExceptions)
            {
                collector.WriteExceptions();
                returnCode = UNEXPECTED_ERROR;
            }

            return returnCode;
        }
コード例 #13
0
ファイル: ConsoleUi.cs プロジェクト: EndScene/serverOne
		internal static bool CreateTestFilter(ConsoleOptions options, out TestFilter testFilter)
		{
			testFilter = TestFilter.Empty;

			SimpleNameFilter nameFilter = new SimpleNameFilter();

			if (options.run != null && options.run != string.Empty)
			{
				Console.WriteLine("Selected test(s): " + options.run);

				foreach (string name in TestNameParser.Parse(options.run))
					nameFilter.Add(name);

				testFilter = nameFilter;
			}

			if (options.runlist != null && options.runlist != string.Empty)
			{
				Console.WriteLine("Run list: " + options.runlist);
				
				try
				{
					using (StreamReader rdr = new StreamReader(options.runlist))
					{
						// NOTE: We can't use rdr.EndOfStream because it's
						// not present in .NET 1.x.
						string line = rdr.ReadLine();
						while (line != null && line.Length > 0)
						{
							if (line[0] != '#')
								nameFilter.Add(line);
							line = rdr.ReadLine();
						}
					}
				}
				catch (Exception e)
				{
					if (e is FileNotFoundException || e is DirectoryNotFoundException)
					{
						Console.WriteLine("Unable to locate file: " + options.runlist);
						return false;
					}
					throw;
				}

				testFilter = nameFilter;
			}

			if (options.include != null && options.include != string.Empty)
			{
				TestFilter includeFilter = new CategoryExpression(options.include).Filter;
				Console.WriteLine("Included categories: " + includeFilter.ToString());

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

			if (options.exclude != null && options.exclude != string.Empty)
			{
				TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
				Console.WriteLine("Excluded categories: " + excludeFilter.ToString());

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

			if (testFilter is NotFilter)
				((NotFilter) testFilter).TopLevel = true;

			return true;
		}
コード例 #14
0
ファイル: TestSuiteTest.cs プロジェクト: fotisp/conqat
 public void ExcludingCategoryDoesNotRunExplicitTestFixtures()
 {
     TestFilter filter = new NotFilter( new CategoryFilter( "MockCategory" ) );
     TestAssemblyBuilder builder = new TestAssemblyBuilder();
     TestSuite suite = builder.Build( "mock-assembly.dll", true );
     TestResult result = suite.Run( NullListener.NULL, filter );
     ResultSummarizer summarizer = new ResultSummarizer( result );
     Assert.AreEqual( MockAssembly.Tests - MockAssembly.NotRun - 2, summarizer.ResultCount );
     Console.WriteLine( "{0} ignored, {1} explicit, {2} not run",
         MockAssembly.Ignored, MockAssembly.Explicit, MockAssembly.NotRun );
     Console.WriteLine( "{0} tests were run out of {1}",
         MockAssembly.Tests - MockAssembly.NotRun - 2, MockAssembly.Tests );
 }
コード例 #15
0
ファイル: NUnit2Task.cs プロジェクト: Sectoid/debian-nant
        /// <summary>
        /// Runs the tests and sets up the formatters.
        /// </summary>
        protected override void ExecuteTask()
        {
            if (FormatterElements.Count == 0) {
                FormatterElement defaultFormatter = new FormatterElement();
                defaultFormatter.Project = Project;
                defaultFormatter.NamespaceManager = NamespaceManager;
                defaultFormatter.Type = FormatterType.Plain;
                defaultFormatter.UseFile = false;
                FormatterElements.Add(defaultFormatter);

                Log(Level.Warning, "No <formatter .../> element was specified." +
                    " A plain-text formatter was added to prevent losing output of the" +
                    " test results.");

                Log(Level.Warning, "Add a <formatter .../> element to the" +
                    " <nunit2> task to prevent this warning from being output and" +
                    " to ensure forward compatibility with future revisions of NAnt.");
            }

            LogWriter logWriter = new LogWriter(this, Level.Info, CultureInfo.InvariantCulture);
            EventListener listener = new EventCollector(logWriter, logWriter);

            foreach (NUnit2Test testElement in Tests) {
                ITestFilter categoryFilter = null;

                // include or exclude specific categories
                string categories = testElement.Categories.Includes.ToString();
                if (!StringUtils.IsNullOrEmpty(categories)) {
                    categoryFilter = new CategoryFilter(categories.Split(','));
                } else {
                    categories = testElement.Categories.Excludes.ToString();
                    if (!StringUtils.IsNullOrEmpty(categories)) {
                        categoryFilter = new NotFilter(new CategoryFilter(categories.Split(',')));
                    }
                }

                foreach (string testAssembly in testElement.TestAssemblies) {
                    NUnit2TestDomain domain = new NUnit2TestDomain();

                    try {
                        TestRunner runner = domain.CreateRunner(
                            new FileInfo(testAssembly),
                            testElement.AppConfigFile,
                            testElement.References.FileNames);
                        TestPackage package = new TestPackage(testAssembly);

                        bool test = runner.Load(package);
                        if (!test) {
                            Log(Level.Warning, "Assembly \"{0}\" contains no tests.",
                                testAssembly);
                            continue;
                        }

                        // run test
                        TestResult result;

                        if(categoryFilter != null) {
                          result = runner.Run(listener, categoryFilter);
                        } else {
                          result = runner.Run(listener);
                        }

                        // flush test output to log
                        logWriter.Flush();

                        // format test results using specified formatters
                        FormatResult(testElement, result);

                        if (result.IsFailure && (testElement.HaltOnFailure || HaltOnFailure)) {
                            throw new BuildException("Tests Failed.", Location);
                        }
                    } catch (BuildException) {
                        // re-throw build exceptions
                        throw;
                    } catch (Exception ex) {
                        if (!FailOnError) {
                            // just log error and continue with next test
                            Log(Level.Error, LogPrefix + "NUnit Error: " + ex.ToString());
                            continue;
                        }

                        Version nunitVersion = typeof(TestResult).Assembly.GetName().Version;

                        throw new BuildException(string.Format(CultureInfo.InvariantCulture,
                            "Failure executing test(s). If you assembly is not built using"
                            + " NUnit version {0}, then ensure you have redirected assembly"
                            + " bindings. Consult the documentation of the <nunit2> task"
                            + " for more information.", nunitVersion), Location, ex);
                    } finally {
                        domain.Unload();

                        // flush test output to log
                        logWriter.Flush();
                    }
                }
            }
        }
コード例 #16
0
ファイル: VisualState.cs プロジェクト: taoxiease/asegrp
        public void Restore(TestSuiteTreeView tree)
        {
            if (ShowCheckBoxes != tree.CheckBoxes)
                tree.CheckBoxes = ShowCheckBoxes;

            foreach (VisualTreeNode visualNode in Nodes)
                visualNode.Restore(tree);

            if (SelectedNode != null)
            {
                TestSuiteTreeNode treeNode = tree[SelectedNode];
                if (treeNode != null)
                    tree.SelectedNode = treeNode;
            }

            if (TopNode != null)
            {
                TestSuiteTreeNode treeNode = tree[TopNode];
                if (treeNode != null)
                    tree.TryToSetTopNode(treeNode);
            }

            if (this.SelectedCategories != null)
            {
                TestFilter filter = new CategoryFilter( this.SelectedCategories.Split( new char[] { ',' } ) );
                if ( this.ExcludeCategories )
                    filter = new NotFilter( filter );
                tree.CategoryFilter = filter;
            }

            tree.Select();
        }
コード例 #17
0
		public void ExcludingCategoryDoesNotRunExplicitTestFixtures()
		{
			NotFilter filter = new NotFilter( new CategoryFilter( "MockCategory" ) );
            filter.TopLevel = true;
			TestAssemblyBuilder builder = new TestAssemblyBuilder();
			TestSuite suite = builder.Build( MockAssembly.AssemblyPath, true );
			TestResult result = suite.Run( NullListener.NULL, filter );
			ResultSummarizer summarizer = new ResultSummarizer( result );
			Assert.AreEqual( MockAssembly.TestsRun - 2, summarizer.TestsRun );
		}
コード例 #18
0
ファイル: TestSuiteTest.cs プロジェクト: taoxiease/asegrp
 public void ExcludingCategoryDoesNotRunExplicitTestFixtures()
 {
     TestFilter filter = new NotFilter( new CategoryFilter( "MockCategory" ) );
     TestAssemblyBuilder builder = new TestAssemblyBuilder();
     TestSuite suite = builder.Build( "mock-assembly.dll", true );
     TestResult result = suite.Run( NullListener.NULL, filter );
     ResultSummarizer summarizer = new ResultSummarizer( result );
     Assert.AreEqual( MockAssembly.Tests - MockAssembly.NotRun - 2, summarizer.ResultCount );
 }
コード例 #19
0
 public void ExcludingCategoryDoesNotRunExplicitTestCases()
 {
     NotFilter filter = new NotFilter( new CategoryFilter( "MockCategory" ) );
     filter.TopLevel = true;
     TestResult result = mockTestFixture.Run( NullListener.NULL, filter );
     ResultSummarizer summarizer = new ResultSummarizer( result );
     Assert.AreEqual( MockTestFixture.TestsRun - MockTestFixture.MockCategoryTests, summarizer.TestsRun );
 }
コード例 #20
0
ファイル: ConsoleUi.cs プロジェクト: nobled/mono
		public int Execute( ConsoleOptions options )
		{
			XmlTextReader transformReader = GetTransformReader(options);
			if(transformReader == null) return FILE_NOT_FOUND;

			TextWriter outWriter = Console.Out;
			bool redirectOutput = options.output != null && options.output != string.Empty;
			if ( redirectOutput )
			{
				StreamWriter outStreamWriter = new StreamWriter( options.output );
				outStreamWriter.AutoFlush = true;
				outWriter = outStreamWriter;
			}

			TextWriter errorWriter = Console.Error;
			bool redirectError = options.err != null && options.err != string.Empty;
			if ( redirectError )
			{
				StreamWriter errorStreamWriter = new StreamWriter( options.err );
				errorStreamWriter.AutoFlush = true;
				errorWriter = errorStreamWriter;
			}

			TestRunner testRunner = MakeRunnerFromCommandLine( options );

			try
			{
				if (testRunner.Test == null)
				{
					testRunner.Unload();
					Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
					return FIXTURE_NOT_FOUND;
				}

				EventCollector collector = new EventCollector( options, outWriter, errorWriter );

				TestFilter testFilter = TestFilter.Empty;
				if ( options.run != null && options.run != string.Empty )
				{
					Console.WriteLine( "Selected test: " + options.run );
					testFilter = new SimpleNameFilter( options.run );
				}

				if ( options.include != null && options.include != string.Empty )
				{
					Console.WriteLine( "Included categories: " + options.include );
					TestFilter includeFilter = new CategoryExpression( options.include ).Filter;
					if ( testFilter.IsEmpty )
						testFilter = includeFilter;
					else
						testFilter = new AndFilter( testFilter, includeFilter );
				}

				if ( options.exclude != null && options.exclude != string.Empty )
				{
					Console.WriteLine( "Excluded categories: " + options.exclude );
					TestFilter excludeFilter = new NotFilter( new CategoryExpression( options.exclude ).Filter );
					if ( testFilter.IsEmpty )
						testFilter = excludeFilter;
					else if ( testFilter is AndFilter )
						((AndFilter)testFilter).Add( excludeFilter );
					else
						testFilter = new AndFilter( testFilter, excludeFilter );
				}

				TestResult result = null;
				string savedDirectory = Environment.CurrentDirectory;
				TextWriter savedOut = Console.Out;
				TextWriter savedError = Console.Error;

				try
				{
					result = testRunner.Run( collector, testFilter );
				}
				finally
				{
					outWriter.Flush();
					errorWriter.Flush();

					if ( redirectOutput )
						outWriter.Close();
					if ( redirectError )
						errorWriter.Close();

					Environment.CurrentDirectory = savedDirectory;
					Console.SetOut( savedOut );
					Console.SetError( savedError );
				}

				Console.WriteLine();

				string xmlOutput = CreateXmlOutput( result );
			
				if (options.xmlConsole)
				{
					Console.WriteLine(xmlOutput);
				}
				else
				{
					try
					{
						//CreateSummaryDocument(xmlOutput, transformReader );
						XmlResultTransform xform = new XmlResultTransform( transformReader );
						xform.Transform( new StringReader( xmlOutput ), Console.Out );
					}
					catch( Exception ex )
					{
						Console.WriteLine( "Error: {0}", ex.Message );
						return TRANSFORM_ERROR;
					}
				}

				// Write xml output here
				string xmlResultFile = options.xml == null || options.xml == string.Empty
					? "TestResult.xml" : options.xml;

				using ( StreamWriter writer = new StreamWriter( xmlResultFile ) ) 
				{
					writer.Write(xmlOutput);
				}

				//if ( testRunner != null )
				//    testRunner.Unload();

				if ( collector.HasExceptions )
				{
					collector.WriteExceptions();
					return UNEXPECTED_ERROR;
				}
            
				if ( !result.IsFailure ) return OK;

				ResultSummarizer summ = new ResultSummarizer( result );
				return summ.FailureCount;
			}
			finally
			{
				testRunner.Unload();
			}
		}
コード例 #21
0
        public void RunTestExcludingCategory()
        {
            TestSuite testSuite = new TestSuite("Mock Test Suite");
            testSuite.Add(mockTestFixture);

            CategoryFilter filter = new CategoryFilter();
            filter.AddCategory("MockCategory");
            RecordingListener listener = new RecordingListener();
            NotFilter notFilter = new NotFilter(filter);
            notFilter.TopLevel = true;
            testSuite.Run(listener, notFilter);
            CollectionAssert.AreEquivalent(
                new string[] { "MockTest1", "MockTest4", "MockTest5",
                    "TestWithManyProperties", "NotRunnableTest", "FailingTest",
                    "TestWithException", "InconclusiveTest" },
                listener.testStarted );
        }