Port Akka.Tests.Actor.Scheduler tests to async/await - 2

src/core/Akka.Tests/Actor/Scheduler/SchedulerShutdownSpec.cs

@@ -13,6 +13,7 @@
 using Akka.Dispatch;
 using Akka.Event;
 using Akka.TestKit;
+using Akka.Tests.Util;
 using Akka.Util.Internal;
 using FluentAssertions;
 using Xunit;
@@ -82,26 +83,25 @@ public ShutdownScheduler(Config scheduler, ILoggingAdapter log) : base(scheduler
         public static readonly Config Config = ConfigurationFactory.ParseString("akka.scheduler.implementation = \""+ typeof(ShutdownScheduler).AssemblyQualifiedName + "\"");
 
         [Fact]
-        public void ActorSystem_must_terminate_scheduler_on_shutdown()
+        public async Task ActorSystem_must_terminate_scheduler_on_shutdown()
         {
             ActorSystem sys = null;
             try
             {
                 sys = ActorSystem.Create("SchedulerShutdownSys1", Config);
                 var scheduler = (ShutdownScheduler)sys.Scheduler;
                 var currentCounter = scheduler.Shutdown.Current;
-                sys.Terminate().Wait(sys.Settings.SchedulerShutdownTimeout).Should().BeTrue();
-                var nextCounter = scheduler.Shutdown.Current;
-                nextCounter.Should().Be(currentCounter + 1);
+                (await sys.Terminate().AwaitWithTimeout(sys.Settings.SchedulerShutdownTimeout)).Should().BeTrue();
+                (scheduler.Shutdown.Current).Should().Be(currentCounter + 1);
             }
             finally
             {
-                sys?.Terminate().Wait(TimeSpan.FromSeconds(5));
+                await sys?.Terminate().AwaitWithTimeout(TimeSpan.FromSeconds(5));
             }
         }
 
         [Fact]
-        public void ActorSystem_must_terminate_scheduler_with_queued_work_on_shutdown()
+        public async Task ActorSystem_must_terminate_scheduler_with_queued_work_on_shutdown()
         {
             ActorSystem sys = null;
             try
@@ -110,28 +110,27 @@ public void ActorSystem_must_terminate_scheduler_with_queued_work_on_shutdown()
                 sys = ActorSystem.Create("SchedulerShutdownSys1", Config);
                 var scheduler = (ShutdownScheduler)sys.Scheduler;
                 sys.Scheduler.Advanced.ScheduleRepeatedly(TimeSpan.FromMilliseconds(0), TimeSpan.FromMilliseconds(10), () => i++);
-                Task.Delay(100).Wait(); // give the scheduler a chance to start and run
+                await Task.Delay(100); // give the scheduler a chance to start and run
                 var currentCounter = scheduler.Shutdown.Current;
-                sys.Terminate().Wait(sys.Settings.SchedulerShutdownTimeout).Should().BeTrue();
-                var nextCounter = scheduler.Shutdown.Current;
-                nextCounter.Should().Be(currentCounter + 1);
+                (await sys.Terminate().AwaitWithTimeout(sys.Settings.SchedulerShutdownTimeout)).Should().BeTrue();
+                (scheduler.Shutdown.Current).Should().Be(currentCounter + 1);
                 var stoppedValue = i;
                 stoppedValue.Should().BeGreaterThan(0, "should have incremented at least once");
-                Task.Delay(100).Wait();
+                await Task.Delay(100);
                 i.Should().Be(stoppedValue, "Scheduler shutdown; should not still be incrementing values.");
             }
             finally
             {
-                sys?.Terminate().Wait(TimeSpan.FromSeconds(5));
+                sys?.Terminate().AwaitWithTimeout(TimeSpan.FromSeconds(5));
             }
         }
 
         [Fact]
-        public void ActorSystem_default_scheduler_mustbe_able_to_terminate_on_shutdown()
+        public async Task ActorSystem_default_scheduler_mustbe_able_to_terminate_on_shutdown()
         {
             ActorSystem sys = ActorSystem.Create("SchedulerShutdownSys2");
             Assert.True(sys.Scheduler is IDisposable);
-            sys.Terminate().Wait(TimeSpan.FromSeconds(5));
+            await sys.Terminate().AwaitWithTimeout(TimeSpan.FromSeconds(5));
         }
 
 
@@ -154,15 +153,17 @@ public MyScheduledActor()
         }
 
         [Fact]
-        public void ActorSystem_default_scheduler_must_never_accept_more_work_after_shutdown()
+        public async Task ActorSystem_default_scheduler_must_never_accept_more_work_after_shutdown()
         {
             ActorSystem sys = ActorSystem.Create("SchedulerShutdownSys3");
             var receiver = sys.ActorOf(Props.Create(() => new MyScheduledActor()));
             sys.Scheduler.ScheduleTellOnce(0, receiver, "set", ActorRefs.NoSender);
-            Thread.Sleep(50); // let the scheduler run
-            Assert.True(receiver.Ask<bool>("get", TimeSpan.FromMilliseconds(100)).Result);
+            await Task.Delay(50); // let the scheduler run
+            var received = await receiver.Ask<bool>("get", TimeSpan.FromMilliseconds(100));
+            Assert.True(received);
 
-            if(!sys.Terminate().Wait(TimeSpan.FromSeconds(5)))
+            var terminated = await sys.Terminate().AwaitWithTimeout(TimeSpan.FromSeconds(5));
+            if (!terminated)
                 Assert.True(false, $"Expected ActorSystem to terminate within 5s. Took longer.");
 
             Assert.Throws<SchedulerException>(() =>

src/core/Akka.Tests/Util/TaskHelpers.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Akka.Tests.Util
+{
+    public static class TaskHelpers
+    {
+        public static async Task<bool> AwaitWithTimeout(this Task parentTask, TimeSpan timeout)
+        {
+            var delayed = Task.Delay(timeout);
+            await Task.WhenAny(delayed, parentTask);
+            return parentTask.IsCompleted;
+        }
+    }
+}