C# Util.ResultSummarizer类代码示例

        public void HandleErrorInFixtureSetup()
        {
            MisbehavingFixture fixture = new MisbehavingFixture();
            fixture.blowUpInSetUp = true;
            TestSuiteResult result = (TestSuiteResult)RunTestOnFixture( fixture );

            Assert.AreEqual( 1, fixture.setUpCount, "setUpCount" );
            Assert.AreEqual( 0, fixture.tearDownCount, "tearDownCOunt" );

            // should have one suite and one fixture
            ResultSummarizer summ = new ResultSummarizer(result);
            Assert.AreEqual(1, summ.ResultCount);
            Assert.AreEqual(0, summ.TestsNotRun);
            Assert.AreEqual(0, summ.SuitesNotRun);

            Assert.IsTrue(result.Executed, "Suite should have executed");
            Assert.IsTrue(result.IsFailure, "Suite should have failed");
            Assert.AreEqual("System.Exception : This was thrown from fixture setup", result.Message, "TestSuite Message");
            Assert.IsNotNull(result.StackTrace, "TestSuite StackTrace should not be null");

            TestResult testResult = ((TestResult)result.Results[0]);
            Assert.IsTrue(testResult.Executed, "Testcase should have executed");
            Assert.AreEqual("TestFixtureSetUp failed in MisbehavingFixture", testResult.Message, "TestSuite Message");
            Assert.AreEqual(FailureSite.Parent, testResult.FailureSite);
            Assert.AreEqual(testResult.StackTrace, testResult.StackTrace, "TestCase stackTrace should match TestSuite stackTrace" );
        }

		public void RunExplicitTestByCategory()
		{
			CategoryFilter filter = new CategoryFilter( "Special" );
			TestResult result = mockTestFixture.Run( NullListener.NULL, filter );
			ResultSummarizer summarizer = new ResultSummarizer( result );
			Assert.AreEqual( 1, summarizer.TestsRun );
		}

		private void InitializeXmlFile(TestResult result) 
		{
			ResultSummarizer summaryResults = new ResultSummarizer(result);

			xmlWriter.Formatting = Formatting.Indented;
			xmlWriter.WriteStartDocument(false);
			xmlWriter.WriteComment("This file represents the results of running a test suite");

			xmlWriter.WriteStartElement("test-results");

			xmlWriter.WriteAttributeString("name", summaryResults.Name);
			xmlWriter.WriteAttributeString("total", summaryResults.TestsRun.ToString());
            xmlWriter.WriteAttributeString("errors", summaryResults.Errors.ToString());
            xmlWriter.WriteAttributeString("failures", summaryResults.Failures.ToString());
            xmlWriter.WriteAttributeString("not-run", summaryResults.TestsNotRun.ToString());
            xmlWriter.WriteAttributeString("inconclusive", summaryResults.Inconclusive.ToString());
            xmlWriter.WriteAttributeString("ignored", summaryResults.Ignored.ToString());
            xmlWriter.WriteAttributeString("skipped", summaryResults.Skipped.ToString());
            xmlWriter.WriteAttributeString("invalid", summaryResults.NotRunnable.ToString());

			DateTime now = DateTime.Now;
			xmlWriter.WriteAttributeString("date", XmlConvert.ToString( now, "yyyy-MM-dd" ) );
			xmlWriter.WriteAttributeString("time", XmlConvert.ToString( now, "HH:mm:ss" ));
			WriteEnvironment();
			WriteCultureInfo();
		}

		public void RunExplicitTestDirectly()
		{
			Test test = TestFinder.Find( "ExplicitlyRunTest", mockTestFixture, true );
			Assert.IsNotNull( test, "Cannot find ExplicitlyRunTest" );
			Assert.AreEqual( RunState.Explicit, test.RunState );
            TestResult result = test.Run(NullListener.NULL, TestFilter.Empty);
			ResultSummarizer summarizer = new ResultSummarizer( result );
			Assert.AreEqual( 1, summarizer.TestsRun );
		}

 public void AssemblySetupFixtureWrapsExecutionOfTest()
 {
     TestResult result = runTests(null, new Filters.SimpleNameFilter("SomeTestFixture"));
     ResultSummarizer summ = new ResultSummarizer(result);
     Assert.AreEqual(1, summ.TestsRun);
     Assert.IsTrue(result.IsSuccess);
     TestUtilities.SimpleEventRecorder.Verify("RootNamespaceSetup",
                             "Test",
                           "RootNamespaceTearDown");
 }

        public void RunIgnoredTestCase()
        {
            Type fixtureType = typeof(MockTestFixture);
            TestCase testCase = TestBuilder.MakeTestCase( fixtureType, "MockTest4" );
            Assert.AreEqual(1, testCase.TestCount);

            TestResult result = testCase.Run(NullListener.NULL);
            ResultSummarizer summarizer = new ResultSummarizer(result);
            Assert.AreEqual(0, summarizer.ResultCount);
            Assert.AreEqual(1, summarizer.TestsNotRun);
        }

		public void RunTestsInFixture()
		{
            TestResult result = mockTestFixture.Run(NullListener.NULL, TestFilter.Empty);
			ResultSummarizer summarizer = new ResultSummarizer( result );
			Assert.AreEqual( MockTestFixture.TestsRun, summarizer.TestsRun, "TestsRun" );
            Assert.AreEqual( MockTestFixture.NotRunnable, summarizer.NotRunnable, "NotRunnable");
            Assert.AreEqual(MockTestFixture.Ignored, summarizer.Ignored, "Ignored");
            Assert.AreEqual(MockTestFixture.Errors, summarizer.Errors, "Errors");
            Assert.AreEqual(MockTestFixture.Failures, summarizer.Failures, "Failures");

			result = TestFinder.Find( "ExplicitlyRunTest", result, true );
			Assert.IsNull( result, "ExplicitlyRunTest should not be in results" );

			// TODO: Decide if we want to include Explicit tests that are not run in results
			//			Assert.IsNotNull( result, "Cannot find ExplicitlyRunTest result" );
			//			Assert.IsFalse( result.Executed, "ExplicitlyRunTest should not be executed" );
			//			Assert.AreEqual( "Explicit selection required", result.Message );
		}

		protected void LoadAndRunTestAssembly( fit.Parse cell, string testAssembly )
		{
			testRunner = new TestDomain();

			if ( !testRunner.Load( new TestPackage(testAssembly) ) )
			{
				this.wrong(cell);
				cell.addToBody( string.Format( 
					"<font size=-1 color=\"#c08080\"> <i>Failed to load {0}</i></font>", testAssembly ) );

				return;
			}

			testResult = testRunner.Run(NullListener.NULL);
			testSummary = new ResultSummarizer( testResult );

			this.right( cell );
		}

		private void Initialize(TestResult result) 
		{
			ResultSummarizer summaryResults = new ResultSummarizer(result);

			xmlWriter.Formatting = Formatting.Indented;
			xmlWriter.WriteStartDocument(false);
			xmlWriter.WriteComment("This file represents the results of running a test suite");

			xmlWriter.WriteStartElement("test-results");

			xmlWriter.WriteAttributeString("name", summaryResults.Name);
			xmlWriter.WriteAttributeString("total", summaryResults.ResultCount.ToString());
			xmlWriter.WriteAttributeString("failures", summaryResults.Failures.ToString());
			xmlWriter.WriteAttributeString("not-run", summaryResults.TestsNotRun.ToString());

			DateTime now = DateTime.Now;
			xmlWriter.WriteAttributeString("date", now.ToShortDateString());
			xmlWriter.WriteAttributeString("time", now.ToShortTimeString());
		}

        public int Execute()
        {
            try
            {
                var result = RunTesterBlocking();
                var summary = new ResultSummarizer(result);

                return summary.Errors + summary.Failures + summary.NotRunnable;
            }
            catch (FileNotFoundException ex)
            {
                Console.WriteLine(ex.Message);
                return ConsoleUi.FILE_NOT_FOUND;
            }
            catch (Exception ex)
            {
                //TODO need to expand on error cases better... mimic console runner
                Console.WriteLine(ex);
                return ConsoleUi.UNEXPECTED_ERROR;
            }
        }

        public static int Main(string[] args)
        {
            var result = RunTests(args);

            var total = (from object r in result.Results select r as TestResult).Count();

            var results = new ResultSummarizer(result);

            Console.WriteLine(
                @"total={0} run={1} passed={2} failures={3} errors={4} not-run={5} inconclusive={6} ignored={7} skipped={8} invalid={9}",
                total,
                results.TestsRun,
                results.Passed,
                results.Failures,
                results.Errors,
                results.TestsNotRun,
                results.Inconclusive,
                results.Ignored,
                results.Skipped,
                results.NotRunnable);

            // will return "0" if no tests failed
            return results.ErrorsAndFailures;
        }

		private static void WriteSummaryReport( ResultSummarizer summary )
		{
            Console.WriteLine(
                "Tests run: {0}, Errors: {1}, Failures: {2}, Inconclusive: {3}, Time: {4} seconds",
                summary.TestsRun, summary.Errors, summary.Failures, summary.Inconclusive, summary.Time);
            Console.WriteLine(
                "  Not run: {0}, Invalid: {1}, Ignored: {2}, Skipped: {3}",
                summary.TestsNotRun, summary.NotRunnable, summary.Ignored, summary.Skipped);
            Console.WriteLine();
        }

        public void RunTestsInFixture()
        {
            TestResult result = mockTestFixture.Run( NullListener.NULL );
            ResultSummarizer summarizer = new ResultSummarizer( result );
            Assert.AreEqual( MockTestFixture.Tests - MockTestFixture.NotRun, summarizer.ResultCount );
            Assert.AreEqual( MockTestFixture.Ignored, summarizer.TestsNotRun );

            result = TestFinder.Find( "ExplicitlyRunTest", result );
            Assert.IsNull( result, "ExplicitlyRunTest should not be in results" );

            // TODO: Decide if we want to include Explicitly run tests
            //			Assert.IsNotNull( result, "Cannot find ExplicitlyRunTest result" );
            //			Assert.IsFalse( result.Executed, "ExplicitlyRunTest should not be executed" );
            //			Assert.AreEqual( "Explicit selection required", result.Message );
        }

        public void RunNoTestSuite()
        {
            Assert.AreEqual(0, noTestSuite.TestCount);

            TestResult result = noTestSuite.Run(NullListener.NULL);

            ResultSummarizer summarizer = new ResultSummarizer(result);
            Assert.AreEqual(0, summarizer.ResultCount);
            Assert.AreEqual(0, summarizer.TestsNotRun);
            Assert.AreEqual(1, summarizer.SuitesNotRun);
        }

        public void RunExplicitTestByName()
        {
            Test test = TestFinder.Find( "ExplicitlyRunTest", mockTestFixture );
            Assert.IsNotNull( test, "Cannot find ExplicitlyRunTest" );
            Assert.AreEqual( RunState.Explicit, test.RunState );

            NameFilter filter = new NameFilter( test.TestName );
            TestResult result = mockTestFixture.Run( NullListener.NULL, filter );
            ResultSummarizer summarizer = new ResultSummarizer( result );
            Assert.AreEqual( 1, summarizer.ResultCount );
        }