public async Task ReadsShouldUnblockWrites()
{
var p = new BufferedPipe(70);
var input = new byte[70];
var input2 = new byte[50];
var output = new byte[60];
for (var i = 0; i < 70; i++)
{
input[i] = (byte)i;
}
// Fill the complete buffer
await p.WriteAsync(new ArraySegment <byte>(input));
var writeMoreTask = p.WriteAsync(new ArraySegment <byte>(input2));
// Read in the background to unblock
var readTask = Task.Run(async() =>
{
await Task.Delay(10);
return(await p.ReadAsync(new ArraySegment <byte>(output)).AsTask());
});
// The next line would deadlock without the reader in the background
await writeMoreTask;
var res = await readTask;
Assert.Equal(false, res.EndOfStream);
Assert.Equal(60, res.BytesRead);
for (var i = 0; i < 60; i++)
{
Assert.Equal(i, output[i]);
}
}
public async Task CloseShouldUnblockReads()
{
var p = new BufferedPipe(128);
var input = new byte[70];
var output = new byte[50];
for (var i = 0; i < 70; i++)
{
input[i] = (byte)i;
}
// Start read first
var task = p.ReadAsync(new ArraySegment <byte>(output)).AsTask();
// Schedule close
var writeTask = Task.Run(async() =>
{
await Task.Delay(10);
await p.CloseAsync();
});
// And wait for read to unblock
var res = await task;
Assert.Equal(true, res.EndOfStream);
Assert.Equal(0, res.BytesRead);
// The writeTask should also finish
await writeTask;
}
public async Task WritingOnOneEndShallYieldInDataOnTheOtherEnd()
{
var p = new BufferedPipe(128);
var input = new byte[70];
var output = new byte[50];
for (var i = 0; i < 70; i++)
{
input[i] = (byte)i;
}
await p.WriteAsync(new ArraySegment <byte>(input));
var res = await p.ReadAsync(new ArraySegment <byte>(output));
Assert.Equal(false, res.EndOfStream);
Assert.Equal(50, res.BytesRead);
for (var i = 0; i < 50; i++)
{
Assert.Equal(i, output[i]);
}
await p.CloseAsync();
res = await p.ReadAsync(new ArraySegment <byte>(output));
Assert.Equal(false, res.EndOfStream);
Assert.Equal(20, res.BytesRead);
for (var i = 0; i < 20; i++)
{
Assert.Equal(50 + i, output[i]);
}
await p.CloseAsync();
res = await p.ReadAsync(new ArraySegment <byte>(output));
Assert.Equal(true, res.EndOfStream);
Assert.Equal(0, res.BytesRead);
}
public async Task ReadsShouldBlockIfNoDataIsAvailable()
{
var p = new BufferedPipe(128);
var input = new byte[30];
var output = new byte[50];
// Fill some data first - first try should succeed
await p.WriteAsync(new ArraySegment <byte>(input));
var res = await p.ReadAsync(new ArraySegment <byte>(output));
Assert.Equal(false, res.EndOfStream);
Assert.Equal(30, res.BytesRead);
// Try to read more data from the pipe which wil never get available
var readTask = Task.Run(async() => await p.ReadAsync(new ArraySegment <byte>(output)));
// Start a timer in parallel
var timerTask = Task.Delay(20);
var finishedTask = await Task.WhenAny(readTask, timerTask);
Assert.Equal(timerTask, finishedTask);
Assert.Equal(false, readTask.IsCompleted);
}
public async Task CloseShouldAllowRemainingDataToBeReadBeforeSignalClose()
{
var p = new BufferedPipe(128);
var input = new byte[20];
var output = new byte[10];
for (var i = 0; i < 20; i++)
{
input[i] = (byte)i;
}
await p.WriteAsync(new ArraySegment <byte>(input));
await p.CloseAsync();
var res = await p.ReadAsync(new ArraySegment <byte>(output));
Assert.Equal(false, res.EndOfStream);
Assert.Equal(10, res.BytesRead);
for (var i = 0; i < 10; i++)
{
Assert.Equal(i, output[i]);
}
res = await p.ReadAsync(new ArraySegment <byte>(output));
Assert.Equal(false, res.EndOfStream);
Assert.Equal(10, res.BytesRead);
for (var i = 0; i < 10; i++)
{
Assert.Equal(i + 10, output[i]);
}
res = await p.ReadAsync(new ArraySegment <byte>(output));
Assert.Equal(true, res.EndOfStream);
Assert.Equal(0, res.BytesRead);
}
public async Task ServerShouldCloseTheConnectionIfNoPrefaceIsSent(
int nrDummyPrefaceData)
{
var inPipe = new BufferedPipe(1024);
var outPipe = new BufferedPipe(1024);
var http2Con = BuildConnection(true, inPipe, outPipe);
// Write some dummy data
// All this data is not long enough to be a preface, so the
// preface reception should time out
if (nrDummyPrefaceData != 0)
{
var b = new byte[nrDummyPrefaceData];
for (var i = 0; i < b.Length; i++)
{
b[i] = 10;
}
await inPipe.WriteAsync(new ArraySegment <byte>(b));
}
// Settings will be sent by connection before the preface is
// checked - so they must be discarded
await outPipe.ReadAndDiscardSettings();
// Wait for the stream to end within 400ms.
// This is longer than the timeout in the connection waiting for the
// preface
var buf = new byte[1];
var readTask = outPipe.ReadAsync(new ArraySegment <byte>(buf)).AsTask();
var timeoutTask = Task.Delay(400);
var finishedTask = await Task.WhenAny(
new Task[] { readTask, timeoutTask });
if (ReferenceEquals(finishedTask, readTask))
{
var res = readTask.Result;
Assert.Equal(true, res.EndOfStream);
Assert.Equal(0, res.BytesRead);
// Received end of stream
return;
}
Assert.True(false,
"Expected connection to close outgoing stream. " +
"Got timeout");
}
