public void Verify_NJasmine_implementation(FixtureResult fixtureResult)
        {
            fixtureResult.succeeds();

            fixtureResult.hasSuite("given an outer block").thatsInconclusive().thatHasNoResults();

            fixtureResult.hasSuite("when ignore is set after a test").thatSucceeds()
                .hasTest("then the earlier test runs")
                .thatSucceeds();
        }
        public void Verify_NJasmine_implementation(FixtureResult fixtureResult)
        {
            fixtureResult.succeeds();

            fixtureResult.hasSuite("given an outer block").thatsInconclusive().thatHasNoResults();

            fixtureResult.hasSuite("when ignore is set after a test").thatSucceeds()
                .ShouldHaveTest("NJasmineTests.Specs.can_mark_tests_as_ignored, when ignore is set after a test, then the earlier test runs")
                .thatSucceeds();
        }
        public void Verify_NJasmine_implementation(FixtureResult fixtureResult)
        {
            fixtureResult.succeeds();

            fixtureResult.hasSuite("when using category Foo then Bar").withCategories();

            fixtureResult.hasTest("when using category Foo then Bar, then tests have Foo")
                .withCategories("Foo");

            fixtureResult.hasTest("when using category Foo then Bar, then tests have Foo")
                .withCategories("Foo");

            fixtureResult.hasTest("when using category Foo then Bar, then tests have For and Bar")
                .withCategories("Foo", "Bar");

            fixtureResult.hasSuite("when in a nested block and using a category")
                .withCategories("Foo", "Bar");

            fixtureResult.hasTest("when using category Foo then Bar, when in a nested block and using a category, then the test only has category Baz")
                .withCategories("Baz");
        }
        public override void Specify()
        {
            describe("succeeds()", delegate
            {
                it("allows a passing test result", delegate
                {
                    new FixtureResult(_expectedFixtureName, FixtureResult.GetSampleXmlResult(1)).succeeds();
                });

                var cases = new Dictionary<string, TestDelegate>();

                cases.Add("running against error", delegate
                {
                    var sut = new FixtureResult(_expectedFixtureName, FixtureResult.GetSampleXmlResult(1, 1));
                    sut.succeeds();
                });

                cases.Add("running against failure", delegate
                {
                    var sut = new FixtureResult(_expectedFixtureName, FixtureResult.GetSampleXmlResult(1, 0, 1));
                    sut.succeeds();
                });

                cases.Add("running against no tests", delegate
                {
                    var sut = new FixtureResult(_expectedFixtureName, FixtureResult.GetSampleXmlResult(0));
                    sut.succeeds();
                });

                CheckScenariosCauseErrorWithMessageContaining(cases, _expectedFixtureName);
            });

            describe("failed()", delegate
            {
                it("allows test results with errors or failures", delegate
                {
                    new FixtureResult(_expectedFixtureName, FixtureResult.GetSampleXmlResult(1, 1)).failed();
                    new FixtureResult(_expectedFixtureName, FixtureResult.GetSampleXmlResult(1, 0, 1)).failed();
                });

                CheckScenario("running against no tests", delegate
                {
                    var sut = new FixtureResult(_expectedFixtureName, FixtureResult.GetSampleXmlResult(0), "");
                    sut.failed();
                }, _expectedFixtureName);
            });

            describe("containsTrace", delegate
            {
                var originalXml = "<xml></xml>";

                string originalConsole = @"
            NUnit version 2.5.9.10348
            Copyright (C) 2002-2009 Charlie Poole.
            Copyright (C) 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov.
            Copyright (C) 2000-2002 Philip Craig.
            All Rights Reserved.

            Runtime Environment -
               OS Version: Microsoft Windows NT 6.1.7601 Service Pack 1
              CLR Version: 2.0.50727.5446 ( Net 2.0 )

            ProcessModel: Default    DomainUsage: Single
            Execution Runtime: Default
            <<{{test started, before include of a}}>>
            <<{{after include of a}}>>
            <<{{first describe, before include of b}}>>
            <<{{after include of b}}>>
            <<{{before include of c}}>>
            <<{{after include of c}}>>
            Selected test(s): NJasmineTests.Specs.beforeAll.beforeAll_and_afterAll_are_applied_to_the_correct_scope
            .{{<<RESET>>}}
            <<{{BEFORE ALL}}>>
            <<{{first test}}>>
            .<<{{SECOND BEFORE ALL}}>>
            <<{{INNER BEFORE ALL}}>>
            <<{{second test}}>>
            .<<{{third test}}>>
            <<{{INNER AFTER ALL}}>>
            <<{{DISPOSING INNER BEFORE ALL}}>>
            <<{{SECOND AFTER ALL}}>>
            <<{{DISPOSING SECOND BEFORE ALL}}>>
            <<{{AFTER ALL}}>>
            <<{{DISPOSING BEFORE ALL}}>>

            Tests run: 3, Errors: 0, Failures: 0, Inconclusive: 0, Time: 0.0820047 seconds
            ";

                it("allows tests with the expected trace", delegate
                {
                    new FixtureResult(_expectedFixtureName, originalXml, originalConsole).containsTrace(@"
            BEFORE ALL
            first test
            SECOND BEFORE ALL
            INNER BEFORE ALL
            second test
            third test
            INNER AFTER ALL
            DISPOSING INNER BEFORE ALL
            SECOND AFTER ALL
            DISPOSING SECOND BEFORE ALL
            AFTER ALL
            DISPOSING BEFORE ALL
            ");
                });

                it("fails tests without the expected trace", delegate
                {
                    var sut = new FixtureResult(_expectedFixtureName, originalXml, originalConsole);

                    var exception = Assert.Throws(ExpectedAssertionType, delegate
                    {
                        sut.containsTrace(@"
            ONE
            TWO
            THREE
            ");
                    });

                    var message = exception.Message;

                    expect(() => message.IndexOf("ONE") < message.IndexOf("TWO"));
                    expect(() => message.IndexOf("TWO") < message.IndexOf("THREE"));

                    expect(() => message.IndexOf("BEFORE ALL") < message.IndexOf("INNER AFTER ALL"));
                    expect(() => message.IndexOf("INNER AFTER ALL") < message.IndexOf("DISPOSING BEFORE ALL"));

                    expect(() => message.Contains(_expectedFixtureName));
                });
            });

            describe("hasTest", delegate
            {
                var expectedTestName = "one_two_test";

                var xmlOutput = FixtureResult.GetSampleXmlResult(aTestName: _expectedFixtureName + ", " + expectedTestName);

                var sut = arrange(() => new FixtureResult(_expectedFixtureName, xmlOutput));

                it("returns a test by name", delegate
                {
                    expect(() => sut.hasTest(expectedTestName) != null);
                });

                it("gives a useful error message if the test is not found", delegate
                {
                    string wrongTestName = "fsadf325m";

                    var exception = Assert.Throws(ExpectedAssertionType, delegate
                    {
                        sut.hasTestWithFullName(wrongTestName);
                    });

                    expect(() => exception.Message.Contains("Expected test not found, expected test named " + wrongTestName));
                });
            });

            describe("hasSuite", delegate
            {
                var expectedSuiteName = "one_two_test";

                var xmlOutput = FixtureResult.GetSampleXmlResult(aSuiteName: expectedSuiteName);

                var sut = arrange(() => new FixtureResult(_expectedFixtureName, xmlOutput));

                it("returns a test suite by name", delegate
                {
                    expect(() => sut.hasSuite(expectedSuiteName) != null);
                });

                it("gives a useful error message if the test suite is not found", delegate
                {
                    string wrongSuiteName = "9vasjf9d";

                    var exception = Assert.Throws(ExpectedAssertionType, delegate
                    {
                        sut.hasSuite(wrongSuiteName);
                    });

                    expect(() => exception.Message.Contains("Expected test suite not found, expected suite named '" + wrongSuiteName));
                });
            });

            describe("withStackTraces()", delegate
            {
                string fullTrace = "foo bar baz";

                it("it returns the stacktraces in a fixture result", delegate
                {
                    var sut = arrange(() => new FixtureResult(_expectedFixtureName,
                                                FixtureResult.GetSampleXmlResult(aStackTrace: fullTrace)));

                    expect(() => sut.withStackTraces().Single() == fullTrace);
                });
            });
        }