NCBC-4131: Address flaky unit test on Task.WhenAnySuccessful

Motivation
----------
The unit test on Task.WhenAnySuccessful is flaky because it is affected
by race conditions.

Modifications
-------------
Rewrite the test to not use truly async logic and Task.Delay, instead
controlling TaskCompletionSource objects directly. Also, don't require
that the first successful task be returned, merely one of the successful
tasks.

Results
-------
The unit test is more consistent, especially on resource constrained
systems like build agents.

Change-Id: I62a6df807f31db4deac4b128afe390eef437b771
Reviewed-on: https://review.couchbase.org/c/couchbase-net-client/+/239337
Tested-by: Build Bot <build@couchbase.com>
Reviewed-by: Jeffry Morris <jeffrymorris@gmail.com>

Author: brantburnett

tests/Couchbase.UnitTests/Utils/TaskHelpersTests.cs

@@ -10,23 +10,56 @@ namespace Couchbase.UnitTests.Utils;
 
 public class TaskHelpersTests
 {
-    [Theory(Skip = "Skipping because this is a flaky test and we shouldn't care which task is returned.")]
-    [InlineData("TaskFive", new[] {true, true, true, true, false})]
-    [InlineData("TaskFour", new[] {true, true, true, false, true})]
-    [InlineData("TaskTwo", new[] {true, false, true, false, true})]
-    public static async Task WhenAnySuccessful_Should_Return_First_Successful_Task(string expectedId, bool[] throws)
+    public enum TaskResult
     {
-        var taskOne = WaitOrThrow("TaskOne", 1, throws[0]);
-        var taskTwo = WaitOrThrow("TaskTwo", 2, throws[1]);
-        var taskThree = WaitOrThrow("TaskThree", 3, throws[2]);
-        var taskFour = WaitOrThrow("TaskFour", 4, throws[3]);
-        var taskFive = WaitOrThrow("TaskFive", 5, throws[4]);
+        Success,
+        Failure,
+        NeverCompletes
+    }
+
+    [Theory]
+    [InlineData(new[] { TaskResult.Failure, TaskResult.Failure, TaskResult.Failure, TaskResult.Failure, TaskResult.Success })]
+    [InlineData(new[] { TaskResult.Failure, TaskResult.Failure, TaskResult.Failure, TaskResult.Success, TaskResult.Failure })]
+    [InlineData(new[] { TaskResult.Failure, TaskResult.Success, TaskResult.Failure, TaskResult.Success, TaskResult.Failure })]
+    [InlineData(new[] { TaskResult.NeverCompletes, TaskResult.NeverCompletes, TaskResult.NeverCompletes, TaskResult.NeverCompletes, TaskResult.Success })]
+    [InlineData(new[] { TaskResult.NeverCompletes, TaskResult.NeverCompletes, TaskResult.NeverCompletes, TaskResult.Success, TaskResult.NeverCompletes })]
+    [InlineData(new[] { TaskResult.NeverCompletes, TaskResult.Success, TaskResult.NeverCompletes, TaskResult.Success, TaskResult.NeverCompletes })]
+    public static async Task WhenAnySuccessful_Should_Return_A_Successful_Task(TaskResult[] taskResults)
+    {
+        // true = success, false = failure, null = never completes
+
+        TaskCompletionSource<string>[] taskCompletionSources = taskResults
+            .Select(p => new TaskCompletionSource<string>())
+            .ToArray();
+
+        // Just in case, don't let this test run forever
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+
+        var completeTask = TaskHelpers.WhenAnySuccessful(taskCompletionSources.Select(p => p.Task), cts.Token);
+
+        for (var i=0; i< taskResults.Length; i++)
+        {
+            var taskResult = taskResults[i];
+            if (taskResult == TaskResult.Success)
+            {
+                taskCompletionSources[i].SetResult($"{i}");
+            }
+            else if (taskResult == TaskResult.Failure)
+            {
+                taskCompletionSources[i].SetException(new Exception("intentional failure " + i));
+            }
+        }
 
-        var taskList = new[] { taskOne, taskTwo, taskThree , taskFour, taskFive};
+        var firstSuccessful = await completeTask
+#if NET6_0_OR_GREATER
+            .WaitAsync(cts.Token); // Extra safeguard against a stuck test
+#else
+            ;
+#endif
 
-        var firstSuccessful = await TaskHelpers.WhenAnySuccessful(taskList, CancellationToken.None);
+        var index = int.Parse(firstSuccessful);
 
-        Assert.Equal(expectedId, firstSuccessful);
+        Assert.Equal(TaskResult.Success, taskResults[index]);
     }
 
     [Fact]
@@ -93,14 +126,4 @@ public void WhenAnySuccessful_AllFailed_ShouldThrowAggregate()
         _ = Assert.ThrowsAsync<AggregateException>(() => whenAnySuccessful);
 #pragma warning restore xUnit2021
     }
-
-    private static async Task<string> WaitOrThrow(string id, int seconds, bool throws)
-    {
-        await Task.Delay(TimeSpan.FromSeconds(seconds));
-        if (throws)
-        {
-            throw new Exception($"Task {id} threw.");
-        }
-        return id;
-    }
 }