How to use MethodAfterAllThrowsSpecClass class of NSpec.Tests.WhenRunningSpecs.Exceptions package

1using System;
2using System.Linq;
3using NSpec.Domain;
4using NUnit.Framework;
5using FluentAssertions;
6using System.Collections.Generic;
7
8namespace NSpec.Tests.WhenRunningSpecs.Exceptions
9{
10    [TestFixture]
11    [Category("RunningSpecs")]
12    public class when_method_level_after_all_contains_exception : when_running_specs
13    {
14        class MethodAfterAllThrowsSpecClass : nspec
15        {
16            void after_all()
17            {
18                throw new AfterAllException();
19            }
20
21            void should_fail_this_example()
22            {
23                it["should fail"] = () =>
24                {
25                    ExamplesRun.Add("should fail");
26                    Assert.That(true, Is.True);
27                };
28            }
29
30            void should_also_fail_this_example()
31            {
32                it["should also fail"] = () =>
33                {
34                    ExamplesRun.Add("should also fail");
35                    Assert.That(true, Is.True);
36                };
37            }
38
39            public static List<string> ExamplesRun = new List<string>();
40        }
41
42        [SetUp]
43        public void setup()
44        {
45            Run(typeof(MethodAfterAllThrowsSpecClass));
46        }
47
48        [Test]
49        public void examples_should_fail_with_framework_exception()
50        {
51            classContext.AllExamples().Should().OnlyContain(e => e.Exception is ExampleFailureException);
52        }
53
54        [Test]
55        public void examples_with_only_after_all_failure_should_fail_because_of_that()
56        {
57           classContext.AllExamples().Should().OnlyContain(e => e.Exception.InnerException is AfterAllException);
58        }
59
60        [Test]
61        public void examples_should_fail_for_formatter()
62        {
63            formatter.WrittenExamples.Should().OnlyContain(e => e.Failed);
64        }
65
66        [Test]
67        public void examples_body_should_still_run()
68        {
69            string[] expecteds = new[]
70            {
71                "should fail",
72                "should also fail",
73            };
74
75            MethodAfterAllThrowsSpecClass.ExamplesRun.ShouldBeEquivalentTo(expecteds);
76        }
77    }
78}
79

Source: when_method_level_after_all_contains_exception.cs

using System;
using System.Linq;
using NSpec.Domain;
using NUnit.Framework;
using FluentAssertions;
using System.Collections.Generic;

namespace NSpec.Tests.WhenRunningSpecs.Exceptions
{
    [TestFixture]
    [Category("RunningSpecs")]
    public class when_method_level_after_all_contains_exception : when_running_specs
    {
        class MethodAfterAllThrowsSpecClass : nspec
        {
            void after_all()
            {
                throw new AfterAllException();
            }

            void should_fail_this_example()
            {
                it["should fail"] = () =>
                {
                    ExamplesRun.Add("should fail");
                    Assert.That(true, Is.True);
                };
            }

            void should_also_fail_this_example()
            {
                it["should also fail"] = () =>
                {
                    ExamplesRun.Add("should also fail");
                    Assert.That(true, Is.True);
                };
            }

            public static List<string> ExamplesRun = new List<string>();
        }

        [SetUp]
        public void setup()
        {
            Run(typeof(MethodAfterAllThrowsSpecClass));
        }

        [Test]
        public void examples_should_fail_with_framework_exception()
        {
            classContext.AllExamples().Should().OnlyContain(e => e.Exception is ExampleFailureException);
        }

        [Test]
        public void examples_with_only_after_all_failure_should_fail_because_of_that()
        {
           classContext.AllExamples().Should().OnlyContain(e => e.Exception.InnerException is AfterAllException);
        }

        [Test]
        public void examples_should_fail_for_formatter()
        {
            formatter.WrittenExamples.Should().OnlyContain(e => e.Failed);
        }

        [Test]
        public void examples_body_should_still_run()
        {
            string[] expecteds = new[]
            {
                "should fail",
                "should also fail",
            };

            MethodAfterAllThrowsSpecClass.ExamplesRun.ShouldBeEquivalentTo(expecteds);
        }
    }
}