public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
 {
     fixtureResult.failed();
     fixtureResult.hasTest("when in some context, then there is some text")
     .withFailureMessage("System.TimeZoneNotFoundException : no time!")
     .thatFailsInAnUnspecifiedManner();
 }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("has a valid test").thatErrors()
            .withFailureMessage("System.InvalidOperationException : Called it() within beforeEach().");
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("broken describe").thatFails()
                .withFailureMessage("Attempted to divide by zero.");
        }
예제 #4
0
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("outer test").thatFailsInAnUnspecifiedManner()
            .withFailureMessage("System.InvalidOperationException : Called it() within it().");
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("broken describe").thatFails()
            .withFailureMessage("Attempted to divide by zero.");
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTestWithFullName("NJasmineTests.Specs.report_test_failures_usefully.reports_exception_at_outermost_scope").thatFails()
                .withFailureMessage("Attempted to divide by zero.");
        }
예제 #7
0
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();
            fixtureResult.hasTrace(@"
failure_in_setup_doesnt_prevent_cleanup_in_same_scope
failure_in_setup_doesnt_prevent_cleanup");
        }
 public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
 {
     fixtureResult.failed();
     fixtureResult.hasTrace(@"
     failure_in_setup_doesnt_prevent_cleanup_in_same_scope
     failure_in_setup_doesnt_prevent_cleanup");
 }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("has a valid test").thatErrors()
                .withFailureMessage("System.InvalidOperationException : Called it() within beforeEach().");
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTestWithFullName("NJasmineTests.Specs.report_test_failures_usefully.reports_exception_at_outermost_scope").thatFails()
            .withFailureMessage("Attempted to divide by zero.");
        }
 public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
 {
     fixtureResult.failed();
     fixtureResult.hasTest("when in some context, then there is some text")
         .withFailureMessage("System.TimeZoneNotFoundException : no time!")
         .thatFailsInAnUnspecifiedManner();
 }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("outer test").thatFailsInAnUnspecifiedManner()
                .withFailureMessage("System.InvalidOperationException : Called it() within it().");
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            var stackTrace = fixtureResult.withStackTraces().Single();
            Assert.That(stackTrace, Is.Not.StringContaining("NJasmine.Core"));
            Assert.That(stackTrace, Is.Not.StringContaining("NJasmine.NUnit"));
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("passes the test if the condition passes").thatSucceeds();
            fixtureResult.hasTest("fails the test if if the condition fails").thatErrors();
            fixtureResult.hasTest("expections can be set during discovery, fails this test").thatErrors();
        }
예제 #15
0
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("passes the test if the condition passes").thatSucceeds();
            fixtureResult.hasTest("fails the test if if the condition fails").thatErrors();
            fixtureResult.hasTest("expections can be set during discovery, fails this test").thatErrors();
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            var stackTrace = fixtureResult.withStackTraces().Single();

            Assert.That(stackTrace, Is.Not.StringContaining("NJasmine.Core"));
            Assert.That(stackTrace, Is.Not.StringContaining("NJasmine.NUnit"));
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            var stackTrace = fixtureResult.withStackTraces().Single();
            Assert.That(stackTrace, Is.StringContaining("NJasmine.Core"));

            //Assert.That(TestResultUtil.PatternForNJasmineAnonymousMethod.IsMatch(stackTrace));
        }
예제 #18
0
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            var stackTrace = fixtureResult.withStackTraces().Single();

            Assert.That(stackTrace, Is.StringContaining("NJasmine.Core"));

            //Assert.That(TestResultUtil.PatternForNJasmineAnonymousMethod.IsMatch(stackTrace));
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("when the arrange code tries to re-enter, has a valid test that will now fail")
            .thatErrors()
            .withFailureMessage("System.InvalidOperationException : Called it() within arrange().");

            fixtureResult.hasTest("when the arrange cleanup code tries to re-enter, has a valid test that will now fail")
            .thatErrors()
            .withFailureMessage("System.InvalidOperationException : Called it() within arrange().");
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("when the arrange code tries to re-enter, has a valid test that will now fail")
                .thatErrors()
                .withFailureMessage("System.InvalidOperationException : Called it() within arrange().");

            fixtureResult.hasTest("when the arrange cleanup code tries to re-enter, has a valid test that will now fail")
                .thatErrors()
                .withFailureMessage("System.InvalidOperationException : Called it() within arrange().");
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("repeated outer test").thatErrors();
            fixtureResult.hasTest("repeated outer test`2").thatErrors();
            fixtureResult.hasTest("repeated outer test`3").thatErrors();

            fixtureResult.hasTest("repeated unimplemented outer test").thatIsNotRunnable();
            fixtureResult.hasTest("repeated unimplemented outer test`2").thatIsNotRunnable();
            fixtureResult.hasTest("repeated unimplemented outer test`3").thatIsNotRunnable();

            fixtureResult.hasTest("repeated describe, repeated inner describe").thatFails();
            fixtureResult.hasTest("repeated describe, repeated inner describe`2").thatFails();
            fixtureResult.hasTest("repeated describe, repeated inner describe`3").thatFails();
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("then reports the test with the correct count")
                .withFailureMessage("Failed with TotalRuns: 1");

            fixtureResult.hasTest("then reports the test with the correct count`2")
                .withFailureMessage("Failed with TotalRuns: 1");

            fixtureResult.hasTest("then reports the test with the correct count`3")
                .withFailureMessage("Failed with TotalRuns: 1");

            fixtureResult.hasTest("then reports the test with the correct count`4")
                .withFailureMessage("Failed with TotalRuns: 1");
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("then reports the test with the correct count")
            .withFailureMessage("Failed with TotalRuns: 1");

            fixtureResult.hasTest("then reports the test with the correct count`2")
            .withFailureMessage("Failed with TotalRuns: 1");

            fixtureResult.hasTest("then reports the test with the correct count`3")
            .withFailureMessage("Failed with TotalRuns: 1");

            fixtureResult.hasTest("then reports the test with the correct count`4")
            .withFailureMessage("Failed with TotalRuns: 1");
        }
예제 #24
0
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("repeated outer test").thatErrors();
            fixtureResult.hasTest("repeated outer test`2").thatErrors();
            fixtureResult.hasTest("repeated outer test`3").thatErrors();

            fixtureResult.hasTest("repeated unimplemented outer test").thatIsNotRunnable();
            fixtureResult.hasTest("repeated unimplemented outer test`2").thatIsNotRunnable();
            fixtureResult.hasTest("repeated unimplemented outer test`3").thatIsNotRunnable();

            fixtureResult.hasTest("repeated describe, repeated inner describe").thatFails();
            fixtureResult.hasTest("repeated describe, repeated inner describe`2").thatFails();
            fixtureResult.hasTest("repeated describe, repeated inner describe`3").thatFails();
        }
예제 #25
0
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, given a condition that eventually evaluates to true, a normal expect works when no waits are left")
            .thatSucceeds();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, given a condition that eventually evaluates to true, a normal expect fails when waits are left")
            .thatErrors();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, given a condition that eventually evaluates to true, waitUntil will try multiple times")
            .thatSucceeds();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, given a condition that eventually evaluates to true, expectEventually will try multiple times")
            .thatSucceeds();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, waitUntil can be called during discovery, doesnt prevent discovery")
            .thatErrors();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, expectEventually can be called during discovery, doesnt prevent discovery")
            .thatErrors();
        }
        public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
        {
            fixtureResult.failed();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, given a condition that eventually evaluates to true, a normal expect works when no waits are left")
                .thatSucceeds();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, given a condition that eventually evaluates to true, a normal expect fails when waits are left")
                .thatErrors();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, given a condition that eventually evaluates to true, waitUntil will try multiple times")
                .thatSucceeds();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, given a condition that eventually evaluates to true, expectEventually will try multiple times")
                .thatSucceeds();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, waitUntil can be called during discovery, doesnt prevent discovery")
                .thatErrors();

            fixtureResult.hasTest("waitUntil() or expectEventually() can be used to have the test wait until a condition passes, expectEventually can be called during discovery, doesnt prevent discovery")
                .thatErrors();
        }
 public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
 {
     fixtureResult.failed();
     fixtureResult.hasTest("works").thatSucceeds();
     fixtureResult.hasTest("when using expect within beforeAll, fails").thatErrors();
 }
예제 #28
0
 public void Verify_NJasmine_implementation(IFixtureResult fixtureResult)
 {
     fixtureResult.failed();
     fixtureResult.hasTest("works").thatSucceeds();
     fixtureResult.hasTest("when using expect within beforeAll, fails").thatErrors();
 }