Support for async/await specifications

src/Examples/Example.Random/AsyncSpecifications.cs

@@ -0,0 +1,45 @@
+using System.Threading.Tasks;
+using Machine.Specifications;
+
+namespace Example.Random
+{
+ public class AsyncSpecifications
+ {
+ public static bool establish_invoked;
+
+ public static bool because_invoked;
+
+ public static bool async_it_invoked;
+
+ public static bool sync_it_invoked;
+
+ public static bool cleanup_invoked;
+
+ Establish context = async () =>
+ {
+ establish_invoked = true;
+ await Task.Delay(10);
+ };
+
+ Because of = async () =>
+ {
+ because_invoked = true;
+ await Task.Delay(10);
+ };
+
+ It should_invoke_sync = () =>
+ sync_it_invoked = true;
+
+ It should_invoke_async = async () =>
+ {
+ async_it_invoked = true;
+ await Task.Delay(10);
+ };
+
+ Cleanup after = async () =>
+ {
+ cleanup_invoked = true;
+ await Task.Delay(10);
+ };
+ }
+}

src/Examples/Example.Random/AsyncSpecificationsWithExceptions.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Threading.Tasks;
+using Machine.Specifications;
+
+namespace Example.Random
+{
+ public class AsyncSpecificationsWithExceptions
+ {
+ Because of = async () =>
+ {
+ await Task.Delay(10);
+
+ throw new InvalidOperationException("something went wrong");
+ };
+
+ It should_invoke_sync = () =>
+ {
+ throw new InvalidOperationException("something went wrong");
+ };
+
+ It should_invoke_async = async () =>
+ {
+ await Task.Delay(10);
+
+ throw new InvalidOperationException("something went wrong");
+ };
+ }
+}

src/Machine.Specifications.Specs/Runner/AsyncDelegateRunnerSpecs.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Linq;
+using Example.Random;
+using FluentAssertions;
+using Machine.Specifications.Factories;
+using Machine.Specifications.Runner;
+using Machine.Specifications.Runner.Impl;
+
+namespace Machine.Specifications.Specs.Runner
+{
+ [Subject("Async Delegate Runner")]
+ public class when_running_async_specifications : RunnerSpecs
+ {
+ Establish context = () =>
+ {
+ AsyncSpecifications.establish_invoked = false;
+ AsyncSpecifications.because_invoked = false;
+ AsyncSpecifications.async_it_invoked = false;
+ AsyncSpecifications.sync_it_invoked = false;
+ AsyncSpecifications.cleanup_invoked = false;
+ };
+
+ Because of = () =>
+ Run<AsyncSpecifications>();
+
+ It should_call_establish = () =>
+ AsyncSpecifications.establish_invoked.Should().BeTrue();
+
+ It should_call_because = () =>
+ AsyncSpecifications.because_invoked.Should().BeTrue();
+
+ It should_call_async_spec = () =>
+ AsyncSpecifications.async_it_invoked.Should().BeTrue();
+
+ It should_call_sync_spec = () =>
+ AsyncSpecifications.sync_it_invoked.Should().BeTrue();
+
+ It should_call_cleanup = () =>
+ AsyncSpecifications.cleanup_invoked.Should().BeTrue();
+ }
+
+ [Subject("Async Delegate Runner")]
+ public class when_running_async_specifications_with_exceptions : RunnerSpecs
+ {
+ static ContextFactory factory;
+
+ static Result[] results;
+
+ Establish context = () =>
+ factory = new ContextFactory();
+
+ Because of = () =>
+ {
+ var context = factory.CreateContextFrom(Activator.CreateInstance<AsyncSpecificationsWithExceptions>());
+
+ results = ContextRunnerFactory
+ .GetContextRunnerFor(context)
+ .Run(context,
+ new RunListenerBase(),
+ RunOptions.Default,
+ Array.Empty<ICleanupAfterEveryContextInAssembly>(),
+ Array.Empty<ISupplementSpecificationResults>())
+ .ToArray();
+ };
+
+ It should_run_two_specs = () =>
+ results.Length.Should().Be(2);
+
+ It should_have_failures = () =>
+ results.Should().Match(x => x.All(y => !y.Passed));
+ }
+}

src/Machine.Specifications/Machine.Specifications.csproj

@@ -46,6 +46,7 @@
  <PackageReference Include="System.Reflection" Version="4.1.0" />
  <PackageReference Include="System.Reflection.Extensions" Version="4.0.1" />
  <PackageReference Include="System.Reflection.TypeExtensions" Version="4.1.0" />
+ <PackageReference Include="System.Threading.ThreadPool" Version="4.3.0" />
  </ItemGroup>
 
  <PropertyGroup Condition=" '$(TargetFramework)' == 'net35' ">

src/Machine.Specifications/Model/Specification.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Text;
+using Machine.Specifications.Utility;
 using Machine.Specifications.Utility.Internal;
 
 namespace Machine.Specifications.Model
@@ -80,7 +81,7 @@ public bool IsExecutable
 
  protected virtual void InvokeSpecificationField()
  {
- _it.DynamicInvoke();
+ _it.InvokeAsync();
  }
  }
-}
+}

src/Machine.Specifications/Runner/Impl/AsyncManualResetEvent.cs

@@ -0,0 +1,34 @@
+#if !NET35
+using System.Threading.Tasks;
+
+namespace Machine.Specifications.Runner.Impl
+{
+ internal class AsyncManualResetEvent
+ {
+ private volatile TaskCompletionSource<bool> source = new TaskCompletionSource<bool>();
+
+ public AsyncManualResetEvent()
+ {
+ source.TrySetResult(true);
+ }
+
+ public void Reset()
+ {
+ if (source.Task.IsCompleted)
+ {
+ source = new TaskCompletionSource<bool>();
+ }
+ }
+
+ public void Set()
+ {
+ source.TrySetResult(true);
+ }
+
+ public void Wait()
+ {
+ source.Task.Wait();
+ }
+ }
+}
+#endif

src/Machine.Specifications/Runner/Impl/AsyncSynchronizationContext.cs

@@ -0,0 +1,104 @@
+#if !NET35
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Machine.Specifications.Runner.Impl
+{
+ internal class AsyncSynchronizationContext : SynchronizationContext
+ {
+ private readonly SynchronizationContext inner;
+
+ private readonly AsyncManualResetEvent events = new AsyncManualResetEvent();
+
+ private int callCount;
+
+ private Exception exception;
+
+ public AsyncSynchronizationContext(SynchronizationContext inner)
+ {
+ this.inner = inner;
+ }
+
+ private void Execute(SendOrPostCallback callback, object state)
+ {
+ try
+ {
+ callback(state);
+ }
+ catch (Exception ex)
+ {
+ exception = ex;
+ }
+ finally
+ {
+ OperationCompleted();
+ }
+ }
+
+ public override void OperationCompleted()
+ {
+ var count = Interlocked.Decrement(ref callCount);
+
+ if (count == 0)
+ {
+ events.Set();
+ }
+ }
+
+ public override void OperationStarted()
+ {
+ Interlocked.Increment(ref callCount);
+
+ events.Reset();
+ }
+
+ public override void Post(SendOrPostCallback d, object state)
+ {
+ OperationStarted();
+
+ try
+ {
+ if (inner == null)
+ {
+ ThreadPool.QueueUserWorkItem(_ => Execute(d, state));
+ }
+ else
+ {
+ inner.Post(_ => Execute(d, state), null);
+ }
+ }
+ catch
+ {
+ // ignored
+ }
+ }
+
+ public override void Send(SendOrPostCallback d, object state)
+ {
+ try
+ {
+ if (inner == null)
+ {
+ d(state);
+ }
+ else
+ {
+ inner.Send(d, state);
+ }
+ }
+ catch (Exception ex)
+ {
+ exception = ex;
+ }
+ }
+
+ public Exception WaitAsync()
+ {
+ events.Wait();
+
+ return exception;
+ }
+ }
+}
+#endif

src/Machine.Specifications/Runner/Impl/DelegateRunner.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Threading;
+
+namespace Machine.Specifications.Runner.Impl
+{
+ internal class DelegateRunner
+ {
+ private readonly Delegate target;
+
+ private readonly object[] args;
+
+ public DelegateRunner(Delegate target, params object[] args)
+ {
+ this.target = target;
+ this.args = args;
+ }
+
+ public void Execute()
+ {
+#if NET35
+ target.DynamicInvoke(args);
+#else
+ var currentContext = SynchronizationContext.Current;
+
+ var context = new AsyncSynchronizationContext(currentContext);
+
+ SynchronizationContext.SetSynchronizationContext(context);
+
+ try
+ {
+ target.DynamicInvoke(args);
+
+ var exception = context.WaitAsync();
+
+ if (exception != null)
+ {
+ throw exception;
+ }
+ }
+ finally
+ {
+ SynchronizationContext.SetSynchronizationContext(currentContext);
+ }
+#endif
+ }
+ }
+}

src/Machine.Specifications/Utility/RandomExtensionMethods.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-
+using Machine.Specifications.Runner.Impl;
 using Machine.Specifications.Sdk;
 
 namespace Machine.Specifications.Utility
@@ -19,7 +19,13 @@ public static void Each<T>(this IEnumerable<T> enumerable, Action<T> action)
 
  internal static void InvokeAll(this IEnumerable<Delegate> contextActions, params object[] args)
  {
- contextActions.AllNonNull().Select<Delegate, Action>(x => () => x.DynamicInvoke(args)).InvokeAll();
+ contextActions.AllNonNull().Select<Delegate, Action>(x => () => x.InvokeAsync(args)).InvokeAll();
+ }
+
+ internal static void InvokeAsync(this Delegate target, params object[] args)
+ {
+ var runner = new DelegateRunner(target, args);
+ runner.Execute();
  }
 
  static IEnumerable<T> AllNonNull<T>(this IEnumerable<T> elements) where T : class
@@ -77,4 +83,4 @@ internal static AttributeFullName GetCustomDelegateAttributeFullName(this Type t
  return null;
  }
  }
-}
+}