Improve AsyncAutoResetEvent behavior.

source/PlanningAI.Tests/AsyncAutoResetEventTests.cs

@@ -0,0 +1,53 @@
+using System.Threading;
+using System.Threading.Tasks;
+using PlanningAi.Utils;
+using Xunit;
+
+namespace PlanningAI.Tests
+{
+    public class AsyncAutoResetEventTests
+    {
+        [Fact]
+        public void ShouldReleaseOneWaitingTask()
+        {
+            var evt = new AsyncAutoResetEvent();
+
+            var task1 = evt.WaitAsync();
+            var task2 = evt.WaitAsync();
+
+            evt.Set();
+
+            Assert.True(task1.IsCompletedSuccessfully);
+            Assert.False(task2.IsCompleted);
+        }
+
+        [Fact]
+        public void ShouldReleaseFirstNonCanceledTask()
+        {
+            var source = new CancellationTokenSource();
+            var evt = new AsyncAutoResetEvent();
+
+            var task1 = evt.WaitAsync(source.Token);
+            var task2 = evt.WaitAsync(default);
+
+            source.Cancel();
+            evt.Set();
+
+            Assert.True(task1.IsCanceled);
+            Assert.True(task2.IsCompletedSuccessfully);
+        }
+
+        [Fact]
+        public async Task AwaitingCanceledTaskShouldThrow()
+        {
+            var evt = new AsyncAutoResetEvent();
+
+            var source = new CancellationTokenSource();
+            var exTask = Assert.ThrowsAsync<TaskCanceledException>(async () => await evt.WaitAsync(source.Token));
+
+            source.Cancel();
+
+            await exTask;
+        }
+    }
+}

source/PlanningAI.Tests/PlannerTests.cs

@@ -10,7 +10,7 @@ namespace PlanningAI.Tests
 {
     public class PlannerTests
     {
-        private const int BenchmarkIterations = 1000;
+        private const int BenchmarkIterations = 1;
 
         [Fact]
         public void FailedPlanningShouldReturnNullPlan()
@@ -58,10 +58,10 @@ public void PlanningShouldFindWayToReachTargetValue()
             var planner = PlannerFactory.CreatePlanner(new PlannerSettings {PlannerType = PlannerType.Regressive});
 
             // WarmUp
-            for (var i = 0; i < 10; i++)
-            {
-                var _ = planner.GetPlan(start, goal, actions);
-            }
+//            for (var i = 0; i < 10; i++)
+//            {
+//                var _ = planner.GetPlan(start, goal, actions);
+//            }
 
             PlanningResult result = null;
             var sw = Stopwatch.StartNew();

source/PlanningAi/PlanningAi.csproj

@@ -21,7 +21,7 @@
   </PropertyGroup>
 
   <PropertyGroup Condition="$(Configuration) == 'Release'">
-    <Version>0.10.0</Version>
+    <Version>0.10.1</Version>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Configuration>Release</Configuration>
   </PropertyGroup>

source/PlanningAi/Utils/AsyncAutoResetEvent.cs

@@ -9,12 +9,20 @@ public sealed class AsyncAutoResetEvent
         private readonly object _syncRoot = new object();
         private readonly Queue<TaskCompletionSource<bool>> _taskQueue = new Queue<TaskCompletionSource<bool>>();
 
-        public async Task WaitAsync(CancellationToken token)
+        public async Task WaitAsync(CancellationToken token = default)
         {
             if (token.IsCancellationRequested) return;
 
             var source = new TaskCompletionSource<bool>();
-            token.Register(() => source.SetCanceled());
+            if (token.CanBeCanceled)
+            {
+                token.Register(() =>
+                {
+                    if (source.Task.IsCompleted) return;
+                    source.SetCanceled();
+                });
+            }
+
             lock (_syncRoot)
             {
                 _taskQueue.Enqueue(source);
@@ -28,8 +36,7 @@ public void Set()
             TaskCompletionSource<bool> source;
             while ((source = GetNextQueueEntry()) != null)
             {
-                var task = source.Task;
-                if (task.IsCanceled || task.IsCompleted) continue;
+                if (source.Task.IsCompleted) continue;
 
                 source.SetResult(true);
                 return;