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)); }