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

1using NUnit.Framework;
2using System.Threading.Tasks;
3
4namespace NSpec.Tests.WhenRunningSpecs
5{
6    [TestFixture]
7    [Category("RunningSpecs")]
8    [Category("Async")]
9    public class describe_async_before : when_describing_async_hooks
10    {
11        class SpecClass : BaseSpecClass
12        {
13            void given_async_before_is_set()
14            {
15                beforeAsync = SetStateAsync;
16
17                it["Should have final value"] = ShouldHaveFinalState;
18            }
19
20            void given_async_before_fails()
21            {
22                beforeAsync = FailAsync;
23
24                it["Should fail"] = () => Assert.That(true, Is.True);
25            }
26
27            void given_both_sync_and_async_before_are_set()
28            {
29                before = SetAnotherState;
30
31                beforeAsync = SetStateAsync;
32
33                it["Should not know what to expect"] = () => Assert.That(true, Is.True);
34            }
35
36            void given_before_is_set_to_async_lambda()
37            {
38                before = async () => { await Task.Delay(0); };
39
40                it["Should fail because before is set to async lambda"] = () => Assert.That(true, Is.True);
41
42                // No chance of error when (async) return value is explicitly typed. The following do not even compile:
43                /*
44                Func<Task> asyncTaggedDelegate = async () => { await Task.Delay(0); };
45                Func<Task> asyncUntaggedDelegate = () => { return Task.Delay(0); };
46
47                // set to async method
48                before = SetStateAsync;
49
50                // set to async tagged delegate
51                before = asyncTaggedDelegate;
52
53                // set to async untagged delegate
54                before = asyncUntaggedDelegate;
55                */
56            }
57        }
58
59        [SetUp]
60        public void setup()
61        {
62            Run(typeof(SpecClass));
63        }
64
65        [Test]
66        public void async_before_waits_for_task_to_complete()
67        {
68            ExampleRunsWithExpectedState("Should have final value");
69        }
70
71        [Test]
72        public void async_before_with_exception_fails()
73        {
74            ExampleRunsWithException("Should fail");
75        }
76
77        [Test]
78        public void context_with_both_sync_and_async_before_always_fails()
79        {
80            ExampleRunsWithInnerAsyncMismatchException("Should not know what to expect");
81        }
82
83        [Test]
84        public void sync_before_set_to_async_lambda_fails()
85        {
86            ExampleRunsWithInnerAsyncMismatchException("Should fail because before is set to async lambda");
87        }
88    }
89}
90

Source: describe_async_before.cs

using NUnit.Framework;
using System.Threading.Tasks;

namespace NSpec.Tests.WhenRunningSpecs
{
    [TestFixture]
    [Category("RunningSpecs")]
    [Category("Async")]
    public class describe_async_before : when_describing_async_hooks
    {
        class SpecClass : BaseSpecClass
        {
            void given_async_before_is_set()
            {
                beforeAsync = SetStateAsync;

                it["Should have final value"] = ShouldHaveFinalState;
            }

            void given_async_before_fails()
            {
                beforeAsync = FailAsync;

                it["Should fail"] = () => Assert.That(true, Is.True);
            }

            void given_both_sync_and_async_before_are_set()
            {
                before = SetAnotherState;

                beforeAsync = SetStateAsync;

                it["Should not know what to expect"] = () => Assert.That(true, Is.True);
            }

            void given_before_is_set_to_async_lambda()
            {
                before = async () => { await Task.Delay(0); };

                it["Should fail because before is set to async lambda"] = () => Assert.That(true, Is.True);

                // No chance of error when (async) return value is explicitly typed. The following do not even compile:
                /*
                Func<Task> asyncTaggedDelegate = async () => { await Task.Delay(0); };
                Func<Task> asyncUntaggedDelegate = () => { return Task.Delay(0); };

                // set to async method
                before = SetStateAsync;

                // set to async tagged delegate
                before = asyncTaggedDelegate;

                // set to async untagged delegate
                before = asyncUntaggedDelegate;
                */
            }
        }

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

        [Test]
        public void async_before_waits_for_task_to_complete()
        {
            ExampleRunsWithExpectedState("Should have final value");
        }

        [Test]
        public void async_before_with_exception_fails()
        {
            ExampleRunsWithException("Should fail");
        }

        [Test]
        public void context_with_both_sync_and_async_before_always_fails()
        {
            ExampleRunsWithInnerAsyncMismatchException("Should not know what to expect");
        }

        [Test]
        public void sync_before_set_to_async_lambda_fails()
        {
            ExampleRunsWithInnerAsyncMismatchException("Should fail because before is set to async lambda");
        }
    }
}