private static async Task Pipes_ReadWriteValues <T>(bool firstWaitToRead, int numItems, Func <int, T> getValue)
{
using (AnonymousPipeServerStream serverPipe = new AnonymousPipeServerStream(PipeDirection.Out))
using (AnonymousPipeClientStream clientPipe = new AnonymousPipeClientStream(PipeDirection.In, serverPipe.ClientSafePipeHandle))
{
IWritableChannel <T> writer = Channel.WriteToStream <T>(serverPipe);
IReadableChannel <T> reader = Channel.ReadFromStream <T>(clientPipe);
for (int i = 0; i < numItems; i++)
{
T itemToWrite = getValue(i);
Task <T> readItem = firstWaitToRead ?
reader.WaitToReadAsync().ContinueWith(_ => reader.ReadAsync().AsTask()).Unwrap() :
reader.ReadAsync().AsTask();
Task writeItem = writer.WriteAsync(itemToWrite);
await Task.WhenAll(readItem, writeItem);
Assert.Equal(itemToWrite, readItem.Result);
}
writer.Complete();
Assert.False(await reader.WaitToReadAsync());
await reader.Completion;
}
}
public async Task SuccessTask_AfterWaitAsync_Success()
{
var tcs = new TaskCompletionSource <int>(TaskCreationOptions.RunContinuationsAsynchronously);
IReadableChannel <int> c = Channel.CreateFromTask(tcs.Task);
Task <bool> read = c.WaitToReadAsync();
Assert.False(read.IsCompleted);
tcs.SetResult(42);
Assert.True(await read);
AssertSynchronousTrue(c.WaitToReadAsync());
}
public async Task SuccessTask_BeforeReadAsync_Success()
{
IReadableChannel <int> c = Channel.CreateFromTask(Task.FromResult(42));
AssertSynchronousTrue(c.WaitToReadAsync());
Task <int> read = c.ReadAsync().AsTask();
Assert.Equal(TaskStatus.RanToCompletion, read.Status);
Assert.Equal(42, read.Result);
AssertSynchronousFalse(c.WaitToReadAsync());
await Assert.ThrowsAnyAsync <InvalidOperationException>(() => c.ReadAsync().AsTask());
}
private static void Pipes_WaitForReadThenTryReadValues()
{
using (AnonymousPipeServerStream serverPipe = new AnonymousPipeServerStream(PipeDirection.Out))
using (AnonymousPipeClientStream clientPipe = new AnonymousPipeClientStream(PipeDirection.In, serverPipe.ClientSafePipeHandle))
{
IWritableChannel <int> writer = Channel.WriteToStream <int>(serverPipe);
IReadableChannel <int> reader = Channel.ReadFromStream <int>(clientPipe);
Task.WaitAll(
Task.Run(async() =>
{
for (int i = 0; i < 100; i++)
{
await writer.WriteAsync(i);
}
writer.Complete();
Assert.False(writer.TryWrite(100));
}),
Task.Run(async() =>
{
int result;
int i = 0;
while (await reader.WaitToReadAsync())
{
if (reader.TryRead(out result))
{
Assert.Equal(i++, result);
}
}
Assert.False(reader.TryRead(out result));
}));
}
}
public async Task Range_AllDataReadable_Success(int mode)
{
const int Start = 42, Count = 99;
IReadableChannel <int> c = Channel.CreateFromEnumerable <int>(Enumerable.Range(Start, Count));
Assert.False(c.Completion.IsCompleted);
int result;
for (int i = Start; i < Start + Count; i++)
{
switch (mode)
{
case 0: // TryRead
Assert.True(c.TryRead(out result));
Assert.Equal(i, result);
break;
case 1: // WaitToReadAsync then TryRead
Assert.True(await c.WaitToReadAsync());
Assert.True(c.TryRead(out result));
Assert.Equal(i, result);
break;
case 2: // ReadAsync
Assert.Equal(i, await c.ReadAsync());
break;
case 3: // WaitToReadAsync then ReadAsync
Assert.True(await c.WaitToReadAsync());
Assert.Equal(i, await c.ReadAsync());
break;
case 4: // Multiple WaitToReadAsync then ReadAsync
Assert.True(await c.WaitToReadAsync());
Assert.True(await c.WaitToReadAsync());
Assert.True(await c.WaitToReadAsync());
Assert.True(await c.WaitToReadAsync());
Assert.Equal(i, await c.ReadAsync());
break;
}
}
Assert.False(await c.WaitToReadAsync());
Assert.False(await c.WaitToReadAsync());
Assert.False(c.TryRead(out result));
Assert.False(c.TryRead(out result));
await Assert.ThrowsAnyAsync <InvalidOperationException>(() => c.ReadAsync().AsTask());
await Assert.ThrowsAnyAsync <InvalidOperationException>(() => c.ReadAsync().AsTask());
await c.Completion;
}
public void ReadFromStream_Precancellation()
{
IReadableChannel <int> r = Channel.ReadFromStream <int>(new MemoryStream());
var cts = new CancellationTokenSource();
cts.Cancel();
AssertSynchronouslyCanceled(r.WaitToReadAsync(cts.Token), cts.Token);
AssertSynchronouslyCanceled(r.ReadAsync(cts.Token).AsTask(), cts.Token);
}
public void SuccessTask_BeforeTryRead_Success()
{
IReadableChannel <int> c = Channel.CreateFromTask(Task.FromResult(42));
AssertSynchronousTrue(c.WaitToReadAsync());
Assert.False(c.Completion.IsCompleted);
int result;
Assert.True(c.TryRead(out result));
Assert.Equal(42, result);
Assert.True(c.Completion.IsCompleted);
AssertSynchronousFalse(c.WaitToReadAsync());
Assert.False(c.TryRead(out result));
Assert.Equal(0, result);
}
public void Precancellation_Reading_ReturnsCanceledImmediately()
{
IReadableChannel <int> c = Channel.CreateFromEnumerable(Enumerable.Empty <int>());
var cts = new CancellationTokenSource();
cts.Cancel();
AssertSynchronouslyCanceled(c.ReadAsync(cts.Token).AsTask(), cts.Token);
AssertSynchronouslyCanceled(c.WaitToReadAsync(cts.Token), cts.Token);
}
public void Precancellation()
{
IReadableChannel <int> c = Channel.CreateFromTask(Task.FromResult(42));
var cts = new CancellationTokenSource();
cts.Cancel();
AssertSynchronouslyCanceled(c.WaitToReadAsync(cts.Token), cts.Token);
AssertSynchronouslyCanceled(c.ReadAsync(cts.Token).AsTask(), cts.Token);
}
public async Task FaultedTask_AfterWaitAsync()
{
var tcs = new TaskCompletionSource <int>();
Task <int> t = tcs.Task;
IReadableChannel <int> c = Channel.CreateFromTask(t);
Task <bool> read = c.WaitToReadAsync();
tcs.SetException(new FormatException());
Assert.Equal(t.Exception.InnerException, await Assert.ThrowsAsync <FormatException>(() => c.Completion));
Assert.False(await read);
}
public async Task Completion_NotEmpty_Idempotent()
{
IReadableChannel <int> c = Channel.CreateFromEnumerable(Enumerable.Range(0, 10));
Assert.Same(c.Completion, c.Completion);
while (await c.WaitToReadAsync())
{
int result;
Assert.True(c.TryRead(out result));
}
await c.Completion;
}
public async Task CanceledTask_AfterWaitAsync()
{
var tcs = new TaskCompletionSource <int>();
Task <int> t = tcs.Task;
IReadableChannel <int> c = Channel.CreateFromTask(t);
Task <bool> read = c.WaitToReadAsync();
tcs.SetCanceled();
await Assert.ThrowsAnyAsync <InvalidOperationException>(() => c.Completion);
Assert.False(await read);
}
public async Task CanceledTask_BeforeCreation()
{
Task <int> t = Task.FromCanceled <int>(new CancellationToken(true));
IReadableChannel <int> c = Channel.CreateFromTask(t);
Assert.Equal(TaskStatus.Canceled, c.Completion.Status);
AssertSynchronousFalse(c.WaitToReadAsync());
await Assert.ThrowsAnyAsync <InvalidOperationException>(() => c.ReadAsync().AsTask());
int result;
Assert.False(c.TryRead(out result));
Assert.Equal(0, result);
}
public async Task FaultedTask_BeforeCreation()
{
Task <int> t = Task.FromException <int>(new FormatException());
IReadableChannel <int> c = Channel.CreateFromTask(t);
Assert.Equal(TaskStatus.Faulted, c.Completion.Status);
Assert.Same(t.Exception.InnerException, c.Completion.Exception.InnerException);
AssertSynchronousFalse(c.WaitToReadAsync());
await Assert.ThrowsAsync <FormatException>(() => c.ReadAsync().AsTask());
int result;
Assert.False(c.TryRead(out result));
Assert.Equal(0, result);
}
public async Task FaultedTask_AfterCreation()
{
var tcs = new TaskCompletionSource <int>();
Task <int> t = tcs.Task;
IReadableChannel <int> c = Channel.CreateFromTask(t);
tcs.SetException(new FormatException());
Assert.Equal(t.Exception.InnerException, await Assert.ThrowsAsync <FormatException>(() => c.Completion));
AssertSynchronousFalse(c.WaitToReadAsync());
await Assert.ThrowsAsync <FormatException>(() => c.ReadAsync().AsTask());
int result;
Assert.False(c.TryRead(out result));
Assert.Equal(0, result);
}
public async Task CanceledTask_AfterCreation()
{
var tcs = new TaskCompletionSource <int>();
Task <int> t = tcs.Task;
IReadableChannel <int> c = Channel.CreateFromTask(t);
tcs.SetCanceled();
await Assert.ThrowsAnyAsync <InvalidOperationException>(() => c.Completion);
AssertSynchronousFalse(c.WaitToReadAsync());
await Assert.ThrowsAnyAsync <InvalidOperationException>(() => c.ReadAsync().AsTask());
int result;
Assert.False(c.TryRead(out result));
Assert.Equal(0, result);
}
public override Task <bool> WaitAsync(CancellationToken cancellationToken)
{
return(_channel.WaitToReadAsync(cancellationToken));
}
