How to use should_skip_innocent_bystander_after_all method of NSpec.Tests.WhenRunningSpecs.Target class

1using NUnit.Framework;
2using FluentAssertions;
3
4namespace NSpec.Tests.WhenRunningSpecs
5{
6    [TestFixture]
7    public class describe_skipped_before_alls_when_excluded_by_tag : when_running_specs
8    {
9        class InnocentBystander : nspec
10        {
11            public static string sequence = "";
12
13            void before_all()
14            {
15                sequence = "should not run innocent bystander before_all";
16            }
17
18            void context_bystander()
19            {
20                it["should not run because of tags"] = () => Assert.That("not tagged", Is.EqualTo("not tagged"));
21            }
22        }
23
24        class Target : nspec
25        {
26            void it_specifies_something()
27            {
28                specify = () => Assert.That(true, Is.True);
29            }
30        }
31
32        [SetUp]
33        public void Setup()
34        {
35            tags = "Target";
36            Run(typeof(Target), typeof(InnocentBystander));
37        }
38
39        [Test]
40        public void should_skip_innocent_bystander_before_all()
41        {
42            InnocentBystander.sequence.Should().Be("");
43        }
44    }
45
46    [TestFixture]
47    public class describe_skipped_after_alls_when_excluded_by_tag : when_running_specs
48    {
49        class InnocentBystander : nspec
50        {
51            public static string sequence = "";
52
53            void context_bystander()
54            {
55                it["should not run because of tags"] = () => "not tagged".Should().Be("not tagged");
56            }
57
58            void after_all()
59            {
60                sequence = "should not run innocent bystander after_all";
61            }
62        }
63
64        class Target : nspec
65        {
66            void it_specifies_something()
67            {
68                specify = () => Assert.That(true, Is.True);
69            }
70        }
71
72        [SetUp]
73        public void Setup()
74        {
75            tags = "Target";
76            Run(typeof(Target), typeof(InnocentBystander));
77        }
78
79        [Test]
80        public void should_skip_innocent_bystander_after_all()
81        {
82            InnocentBystander.sequence.Should().Be("");
83        }
84    }
85}
86

Source: describe_skipped_before_after_alls_when_excluded_by_tag.cs

using NUnit.Framework;
using FluentAssertions;

namespace NSpec.Tests.WhenRunningSpecs
{
    [TestFixture]
    public class describe_skipped_before_alls_when_excluded_by_tag : when_running_specs
    {
        class InnocentBystander : nspec
        {
            public static string sequence = "";

            void before_all()
            {
                sequence = "should not run innocent bystander before_all";
            }

            void context_bystander()
            {
                it["should not run because of tags"] = () => Assert.That("not tagged", Is.EqualTo("not tagged"));
            }
        }

        class Target : nspec
        {
            void it_specifies_something()
            {
                specify = () => Assert.That(true, Is.True);
            }
        }

        [SetUp]
        public void Setup()
        {
            tags = "Target";
            Run(typeof(Target), typeof(InnocentBystander));
        }

        [Test]
        public void should_skip_innocent_bystander_before_all()
        {
            InnocentBystander.sequence.Should().Be("");
        }
    }

    [TestFixture]
    public class describe_skipped_after_alls_when_excluded_by_tag : when_running_specs
    {
        class InnocentBystander : nspec
        {
            public static string sequence = "";

            void context_bystander()
            {
                it["should not run because of tags"] = () => "not tagged".Should().Be("not tagged");
            }

            void after_all()
            {
                sequence = "should not run innocent bystander after_all";
            }
        }

        class Target : nspec
        {
            void it_specifies_something()
            {
                specify = () => Assert.That(true, Is.True);
            }
        }

        [SetUp]
        public void Setup()
        {
            tags = "Target";
            Run(typeof(Target), typeof(InnocentBystander));
        }

        [Test]
        public void should_skip_innocent_bystander_after_all()
        {
            InnocentBystander.sequence.Should().Be("");
        }
    }
}