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

1using System.Collections.Generic;
2using System.Linq;
3using NSpec.Domain;
4using NUnit.Framework;
5
6namespace NSpec.Tests.WhenRunningSpecs
7{
8    [TestFixture]
9    [Category("RunningSpecs")]
10    public class describe_implicit_befores : when_running_specs
11    {
12        class SpecClass : nspec
13        {
14            void method_level_context()
15            {
16                List<int> ints = new List<int>();
17                ints.Add(5);
18
19                it["should have two entries"] = () =>
20                {
21                    ints.Add(16);
22                    Assert.That(ints.Count, Is.EqualTo(1));
23                };
24
25                specify = () => Assert.That(ints.Count, Is.EqualTo(1));
26            }
27        }
28
29        [Test, Ignore("It cannot be tested")]
30        public void should_give_each_specify_a_new_instance_of_spec()
31        {
32            Run(typeof(SpecClass));
33            Assert.Inconclusive("I dont think this is possible....");
34            TheMethodContextExamples().First().ShouldHavePassed();
35            TheMethodContextExamples().Last().ShouldHavePassed();
36        }
37
38        private IEnumerable<ExampleBase> TheMethodContextExamples()
39        {
40            return classContext.Contexts.First().AllExamples();
41        }
42    }
43}
44

Source: describe_implicit_befores.cs

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

namespace NSpec.Tests.WhenRunningSpecs
{
    [TestFixture]
    [Category("RunningSpecs")]
    public class describe_implicit_befores : when_running_specs
    {
        class SpecClass : nspec
        {
            void method_level_context()
            {
                List<int> ints = new List<int>();
                ints.Add(5);

                it["should have two entries"] = () =>
                {
                    ints.Add(16);
                    Assert.That(ints.Count, Is.EqualTo(1));
                };

                specify = () => Assert.That(ints.Count, Is.EqualTo(1));
            }
        }

        [Test, Ignore("It cannot be tested")]
        public void should_give_each_specify_a_new_instance_of_spec()
        {
            Run(typeof(SpecClass));
            Assert.Inconclusive("I dont think this is possible....");
            TheMethodContextExamples().First().ShouldHavePassed();
            TheMethodContextExamples().Last().ShouldHavePassed();
        }

        private IEnumerable<ExampleBase> TheMethodContextExamples()
        {
            return classContext.Contexts.First().AllExamples();
        }
    }
}