public void ToTaskSignaledHandleWithZeroTimeout()
{
var handle = new ManualResetEvent(initialState: true);
Task <bool> actual = TplExtensions.ToTask(handle, timeout: 0);
Assert.Same(TplExtensions.TrueTask, actual);
}
public async Task ToTaskOnDisposedHandle()
{
var handle = new ManualResetEvent(false);
handle.Dispose();
await Assert.ThrowsAsync <ObjectDisposedException>(() => TplExtensions.ToTask(handle));
}
public void ToTaskReturnsCompletedTaskPreSignaled()
{
var handle = new ManualResetEvent(initialState: true);
Task <bool> actual = TplExtensions.ToTask(handle);
Assert.Same(TplExtensions.TrueTask, actual);
}
public void WithTimeout_NullTask(bool generic)
{
// Verify that a faulted task is returned instead of throwing.
Task timeoutTask = generic
? TplExtensions.WithTimeout <int>(null, TimeSpan.FromSeconds(1))
: TplExtensions.WithTimeout(null, TimeSpan.FromSeconds(1));
Assert.Throws <ArgumentNullException>(() => timeoutTask.GetAwaiter().GetResult());
}
public void ToTaskOnHandleSignaledAfterCancellation()
{
var handle = new ManualResetEvent(initialState: false);
var cts = new CancellationTokenSource();
Task <bool> actual = TplExtensions.ToTask(handle, cancellationToken: cts.Token);
cts.Cancel();
Assert.True(actual.IsCanceled);
handle.Set();
}
public async Task ToTaskOnHandleSignaledAfterNonZeroTimeout()
{
using (var handle = new ManualResetEvent(initialState: false))
{
Task <bool> actual = TplExtensions.ToTask(handle, timeout: 1);
bool result = await actual.WithTimeout(TimeSpan.FromMilliseconds(AsyncDelay));
Assert.False(result);
}
}
public async Task ToTaskOnHandleSignaledLater()
{
var handle = new ManualResetEvent(initialState: false);
Task <bool> actual = TplExtensions.ToTask(handle);
Assert.False(actual.IsCompleted);
handle.Set();
bool result = await actual;
Assert.True(result);
}
public async Task ToTaskOnHandleSignaledAfterNonZeroTimeout()
{
var handle = new ManualResetEvent(initialState: false);
Task <bool> actual = TplExtensions.ToTask(handle, timeout: 1);
await Task.Delay(2);
handle.Set();
bool result = await actual;
Assert.False(result);
}
public void WithTimeout_MinusOneMeansInfiniteTimeout(bool generic)
{
this.ExecuteOnDispatcher(async delegate
{
var tcs = new TaskCompletionSource <object>();
var timeoutTask = generic
? TplExtensions.WithTimeout <object>(tcs.Task, TimeSpan.FromMilliseconds(-1))
: TplExtensions.WithTimeout((Task)tcs.Task, TimeSpan.FromMilliseconds(-1));
Assert.False(timeoutTask.IsCompleted);
await Task.Delay(AsyncDelay / 2);
Assert.False(timeoutTask.IsCompleted);
tcs.SetResult(null);
timeoutTask.GetAwaiter().GetResult();
});
}
public void FollowCancelableTaskToCompletionEndsInFault()
{
var currentTCS = new TaskCompletionSource <int>();
Task <int> latestTask = currentTCS.Task;
var followingTask = TplExtensions.FollowCancelableTaskToCompletion(() => latestTask, CancellationToken.None);
for (int i = 0; i < 3; i++)
{
var oldTCS = currentTCS;
currentTCS = new TaskCompletionSource <int>();
latestTask = currentTCS.Task;
oldTCS.SetCanceled();
}
currentTCS.SetException(new InvalidOperationException());
Assert.IsType(typeof(InvalidOperationException), followingTask.Exception.InnerException);
}
public void FollowCancelableTaskToCompletionEndsInCompletion()
{
var currentTCS = new TaskCompletionSource <int>();
Task <int> latestTask = currentTCS.Task;
var followingTask = TplExtensions.FollowCancelableTaskToCompletion(() => latestTask, CancellationToken.None);
for (int i = 0; i < 3; i++)
{
var oldTCS = currentTCS;
currentTCS = new TaskCompletionSource <int>();
latestTask = currentTCS.Task;
oldTCS.SetCanceled();
}
currentTCS.SetResult(3);
Assert.Equal(3, followingTask.Result);
}
public void FollowCancelableTaskToCompletionEndsInUltimateCancellation()
{
var currentTCS = new TaskCompletionSource <int>();
Task <int> latestTask = currentTCS.Task;
var cts = new CancellationTokenSource();
var followingTask = TplExtensions.FollowCancelableTaskToCompletion(() => latestTask, cts.Token);
for (int i = 0; i < 3; i++)
{
var oldTCS = currentTCS;
currentTCS = new TaskCompletionSource <int>();
latestTask = currentTCS.Task;
oldTCS.SetCanceled();
}
cts.Cancel();
Assert.True(followingTask.IsCanceled);
}
public void FollowCancelableTaskToCompletionEndsInCompletionWithSpecifiedTaskSource()
{
var specifiedTaskSource = new TaskCompletionSource <int>();
var currentTCS = new TaskCompletionSource <int>();
Task <int> latestTask = currentTCS.Task;
Task <int>?followingTask = TplExtensions.FollowCancelableTaskToCompletion(() => latestTask, CancellationToken.None, specifiedTaskSource);
Assert.Same(specifiedTaskSource.Task, followingTask);
for (int i = 0; i < 3; i++)
{
TaskCompletionSource <int>?oldTCS = currentTCS;
currentTCS = new TaskCompletionSource <int>();
latestTask = currentTCS.Task;
oldTCS.SetCanceled();
}
currentTCS.SetResult(3);
Assert.Equal(3, followingTask.Result);
}
public void ApplyResultToNullTaskNonGeneric()
{
Assert.Throws <ArgumentNullException>(() => TplExtensions.ApplyResultTo((Task)null, new TaskCompletionSource <object>()));
}
public void ApplyResultToNullTaskSource()
{
var tcs = new TaskCompletionSource <object>();
Assert.Throws <ArgumentNullException>(() => TplExtensions.ApplyResultTo(tcs.Task, null));
}
public void ApplyResultToNullTaskSourceNonGeneric()
{
var tcs = new TaskCompletionSource <object>();
Assert.Throws <ArgumentNullException>(() => TplExtensions.ApplyResultTo((Task)tcs.Task, (TaskCompletionSource <object?>)null !));
}
