public async Task ClientCanSendReadOnlyStreamToServer(bool orderedArguments)
{
var ms = new MemoryStream(MemoryBuffer);
var readOnlyStream = new OneWayWrapperStream(ms, canRead: true);
int bytesReceived;
if (orderedArguments)
{
bytesReceived = await this.clientRpc.InvokeWithCancellationAsync <int>(
nameof(Server.AcceptReadableStream),
new object[] { ExpectedFileName, readOnlyStream },
this.TimeoutToken);
}
else
{
bytesReceived = await this.clientRpc.InvokeWithParameterObjectAsync <int>(
nameof(Server.AcceptReadableStream),
new { fileName = ExpectedFileName, content = readOnlyStream },
this.TimeoutToken);
}
Assert.Equal(MemoryBuffer.Length, bytesReceived);
// Assert that the client-side stream is closed, since the server closed their side.
await this.AssertStreamClosesAsync(ms);
}
public async Task ClientCanSendWriteOnlyStreamToServer(bool orderedArguments)
{
(Stream, Stream)duplexStream = FullDuplexStream.CreatePair();
var writeOnlyStream = new OneWayWrapperStream(duplexStream.Item2, canWrite: true);
int bytesToReceive = MemoryBuffer.Length - 1;
if (orderedArguments)
{
await this.clientRpc.InvokeWithCancellationAsync(
nameof(Server.AcceptWritableStream),
new object[] { writeOnlyStream, bytesToReceive },
this.TimeoutToken);
}
else
{
await this.clientRpc.InvokeWithParameterObjectAsync(
nameof(Server.AcceptWritableStream),
new { lengthToWrite = bytesToReceive, content = writeOnlyStream },
this.TimeoutToken);
}
// Read all that the server wanted us to know, and verify it.
byte[] buffer = new byte[bytesToReceive + 1];
int receivedBytes = 0;
while (receivedBytes < bytesToReceive)
{
int count = await duplexStream.Item1.ReadAsync(buffer, receivedBytes, buffer.Length - receivedBytes);
receivedBytes += count;
}
Assert.Equal(MemoryBuffer.Take(bytesToReceive), buffer.Take(bytesToReceive));
// Assert that the client-side stream is closed, since the server closed their side.
await this.AssertStreamClosesAsync(duplexStream.Item2);
}
