How to use finds_and_runs_three_class_level_examples method of NSpec.Tests.WhenRunningSpecs.SpecClass class

1using System;
2using NUnit.Framework;
3using NSpec.Tests.WhenRunningSpecs.Exceptions;
4using FluentAssertions;
5
6namespace NSpec.Tests.WhenRunningSpecs
7{
8    [TestFixture]
9    [Category("RunningSpecs")]
10    public class describe_example : when_running_specs
11    {
12        class SpecClass : nspec
13        {
14            void it_changes_status_after_run()
15            {
16            }
17
18            void it_passes()
19            {
20            }
21
22            void it_fails()
23            {
24                throw new KnownException();
25            }
26        }
27
28        [Test]
29        public void execution_status_changes_after_run()
30        {
31            Run(typeof(SpecClass));
32
33            var ex = TheExample("it changes status after run");
34
35            //ex.HasRun.Should().BeFalse(); //broken after making init and run happen all at once
36
37            ex.HasRun.Should().BeTrue();
38        }
39
40        [Test]
41        public void duration_is_set_after_run()
42        {
43            Run(typeof(SpecClass));
44
45            var ex = TheExample("it changes status after run");
46
47            ex.Duration.Should().BeGreaterThan(TimeSpan.Zero);
48        }
49
50        [Test]
51        public void passing_status_is_passed_when_it_succeeds()
52        {
53            Run(typeof(SpecClass));
54
55            TheExample("it passes").ShouldHavePassed();
56        }
57
58        [Test]
59        public void passing_status_is_not_passed_when_it_fails()
60        {
61            Run(typeof(SpecClass));
62
63            TheExample("it fails").ShouldHaveFailed();
64        }
65
66        class SpecClassWithAnonymousLambdas : nspec
67        {
68            void describe_specs_with_anonymous_lambdas()
69            {
70                context["Some context with anonymous lambdas"] = () =>
71                {
72                    it["has an anonymous lambda"] = () =>
73                    {
74                    };
75                };
76            }
77        }
78
79        [Test]
80        public void finds_and_runs_three_class_level_examples()
81        {
82            Run(typeof(SpecClass));
83
84            TheExampleCount().Should().Be(3);
85        }
86
87        [Test]
88        public void finds_and_runs_only_one_example_ignoring_anonymous_lambdas()
89        {
90            Run(typeof(SpecClassWithAnonymousLambdas));
91
92            TheExampleCount().Should().Be(1);
93        }
94    }
95}

Source: describe_example.cs

using System;
using NUnit.Framework;
using NSpec.Tests.WhenRunningSpecs.Exceptions;
using FluentAssertions;

namespace NSpec.Tests.WhenRunningSpecs
{
    [TestFixture]
    [Category("RunningSpecs")]
    public class describe_example : when_running_specs
    {
        class SpecClass : nspec
        {
            void it_changes_status_after_run()
            {
            }

            void it_passes()
            {
            }

            void it_fails()
            {
                throw new KnownException();
            }
        }

        [Test]
        public void execution_status_changes_after_run()
        {
            Run(typeof(SpecClass));

            var ex = TheExample("it changes status after run");

            //ex.HasRun.Should().BeFalse(); //broken after making init and run happen all at once

            ex.HasRun.Should().BeTrue();
        }

        [Test]
        public void duration_is_set_after_run()
        {
            Run(typeof(SpecClass));

            var ex = TheExample("it changes status after run");

            ex.Duration.Should().BeGreaterThan(TimeSpan.Zero);
        }

        [Test]
        public void passing_status_is_passed_when_it_succeeds()
        {
            Run(typeof(SpecClass));

            TheExample("it passes").ShouldHavePassed();
        }

        [Test]
        public void passing_status_is_not_passed_when_it_fails()
        {
            Run(typeof(SpecClass));

            TheExample("it fails").ShouldHaveFailed();
        }

        class SpecClassWithAnonymousLambdas : nspec
        {
            void describe_specs_with_anonymous_lambdas()
            {
                context["Some context with anonymous lambdas"] = () =>
                {
                    it["has an anonymous lambda"] = () =>
                    {
                    };
                };
            }
        }

        [Test]
        public void finds_and_runs_three_class_level_examples()
        {
            Run(typeof(SpecClass));

            TheExampleCount().Should().Be(3);
        }

        [Test]
        public void finds_and_runs_only_one_example_ignoring_anonymous_lambdas()
        {
            Run(typeof(SpecClassWithAnonymousLambdas));

            TheExampleCount().Should().Be(1);
        }
    }
}