public async Task OperationsOnDisconnectedServer()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
pair.Connect();
Assert.Throws <InvalidOperationException>(() => server.IsMessageComplete);
Assert.Throws <InvalidOperationException>(() => server.WaitForConnection());
await Assert.ThrowsAsync <InvalidOperationException>(() => server.WaitForConnectionAsync()); // fails because allowed connections is set to 1
server.Disconnect();
Assert.Throws <InvalidOperationException>(() => server.Disconnect()); // double disconnect
byte[] buffer = new byte[] { 0, 0, 0, 0 };
if (pair.writeToServer)
{
Assert.Throws <InvalidOperationException>(() => server.Write(buffer, 0, buffer.Length));
Assert.Throws <InvalidOperationException>(() => server.WriteByte(5));
Assert.Throws <InvalidOperationException>(() => { server.WriteAsync(buffer, 0, buffer.Length); });
}
else
{
Assert.Throws <InvalidOperationException>(() => server.Read(buffer, 0, buffer.Length));
Assert.Throws <InvalidOperationException>(() => server.ReadByte());
Assert.Throws <InvalidOperationException>(() => { server.ReadAsync(buffer, 0, buffer.Length); });
}
Assert.Throws <InvalidOperationException>(() => server.Flush());
Assert.Throws <InvalidOperationException>(() => server.IsMessageComplete);
}
}
protected override NamedPipePair CreateNamedPipePair(PipeOptions serverOptions, PipeOptions clientOptions)
{
NamedPipePair ret = new NamedPipePair();
string pipeName = GetUniquePipeName();
ret.serverStream = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, serverOptions);
ret.clientStream = new NamedPipeClientStream(".", pipeName, PipeDirection.Out, clientOptions);
ret.writeToServer = false;
return(ret);
}
public async Task DisposedClientPipe_Throws_ObjectDisposedException()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeClientStream pipe = pair.clientStream;
pipe.Dispose();
byte[] buffer = new byte[] { 0, 0, 0, 0 };
Assert.Throws <ObjectDisposedException>(() => pipe.Connect());
await Assert.ThrowsAsync <ObjectDisposedException>(() => pipe.ConnectAsync());
}
}
public async Task Windows_OperationsOnNamedServerWithDisposedClient()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
pair.Connect();
pair.clientStream.Dispose();
Assert.Throws <IOException>(() => server.WaitForConnection());
await Assert.ThrowsAsync <IOException>(() => server.WaitForConnectionAsync());
}
}
public async Task CancelTokenOn_ServerWaitForConnectionAsyncWithOuterCancellation_Throws_IOException()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
var cts = new CancellationTokenSource();
NamedPipeServerStream server = pair.serverStream;
Task waitForConnectionTask = server.WaitForConnectionAsync(cts.Token);
Assert.True(Interop.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAsync <IOException>(() => waitForConnectionTask);
}
}
public async Task CancelTokenOff_ServerWaitForConnectionAsyncWithOuterCancellation_Throws_OperationCanceledException()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
Task waitForConnectionTask = server.WaitForConnectionAsync(CancellationToken.None);
Assert.True(Interop.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => waitForConnectionTask);
Assert.True(waitForConnectionTask.IsCanceled);
}
}
public async Task DisposedServerPipe_Throws_ObjectDisposedException()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream pipe = pair.serverStream;
pipe.Dispose();
byte[] buffer = new byte[] { 0, 0, 0, 0 };
Assert.Throws <ObjectDisposedException>(() => pipe.Disconnect());
Assert.Throws <ObjectDisposedException>(() => pipe.WaitForConnection());
await Assert.ThrowsAsync <ObjectDisposedException>(() => pipe.WaitForConnectionAsync());
}
}
public async Task Unix_OperationsOnNamedServerWithDisposedClient()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
pair.Connect();
pair.clientStream.Dispose();
// On Unix, the server still thinks that it is connected after client Disposal.
Assert.Throws <InvalidOperationException>(() => server.WaitForConnection());
await Assert.ThrowsAsync <InvalidOperationException>(() => server.WaitForConnectionAsync());
}
}
public void OperationsOnUnconnectedServer()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
// doesn't throw exceptions
PipeTransmissionMode transmitMode = server.TransmissionMode;
Assert.Throws <ArgumentOutOfRangeException>(() => server.ReadMode = (PipeTransmissionMode)999);
byte[] buffer = new byte[] { 0, 0, 0, 0 };
if (pair.writeToServer)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
Assert.Equal(0, server.OutBufferSize);
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => server.OutBufferSize);
}
Assert.Throws <InvalidOperationException>(() => server.Write(buffer, 0, buffer.Length));
Assert.Throws <InvalidOperationException>(() => server.WriteByte(5));
Assert.Throws <InvalidOperationException>(() => { server.WriteAsync(buffer, 0, buffer.Length); });
}
else
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
Assert.Equal(0, server.InBufferSize);
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => server.InBufferSize);
}
PipeTransmissionMode readMode = server.ReadMode;
Assert.Throws <InvalidOperationException>(() => server.Read(buffer, 0, buffer.Length));
Assert.Throws <InvalidOperationException>(() => server.ReadByte());
Assert.Throws <InvalidOperationException>(() => { server.ReadAsync(buffer, 0, buffer.Length); });
}
Assert.Throws <InvalidOperationException>(() => server.Disconnect()); // disconnect when not connected
Assert.Throws <InvalidOperationException>(() => server.IsMessageComplete);
}
}
public void WaitForConnectionOnAlreadyConnectedServer_Throws_InvalidOperationException()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
NamedPipeClientStream client = pair.clientStream;
byte[] buffer = new byte[] { 0, 0, 0, 0 };
pair.Connect();
Assert.True(client.IsConnected);
Assert.True(server.IsConnected);
Assert.Throws <InvalidOperationException>(() => server.WaitForConnection());
}
}
public async Task CancelTokenOn_ServerWaitForConnectionAsync_Throws_OperationCanceledException()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
var ctx = new CancellationTokenSource();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // [ActiveIssue(812, PlatformID.AnyUnix)] - cancellation token after the operation has been initiated
{
Task serverWaitTimeout = server.WaitForConnectionAsync(ctx.Token);
ctx.Cancel();
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => serverWaitTimeout);
}
ctx.Cancel();
Assert.True(server.WaitForConnectionAsync(ctx.Token).IsCanceled);
}
}
public async Task CancelTokenOn_ServerWaitForConnectionAsync_Throws_OperationCanceledException()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
var ctx = new CancellationTokenSource();
if (OperatingSystem.IsWindows()) // cancellation token after the operation has been initiated
{
Task serverWaitTimeout = server.WaitForConnectionAsync(ctx.Token);
ctx.Cancel();
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => serverWaitTimeout);
}
ctx.Cancel();
Assert.True(server.WaitForConnectionAsync(ctx.Token).IsCanceled);
}
}
public async Task ReadAsync_DisconnectDuringRead_Returns0()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
pair.Connect();
Task <int> readTask;
if (pair.clientStream.CanRead)
{
readTask = pair.clientStream.ReadAsync(new byte[1], 0, 1);
pair.serverStream.Dispose();
}
else
{
readTask = pair.serverStream.ReadAsync(new byte[1], 0, 1);
pair.clientStream.Dispose();
}
Assert.Equal(0, await readTask);
}
}
public virtual async Task OperationsOnDisconnectedClient()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
NamedPipeClientStream client = pair.clientStream;
pair.Connect();
Assert.Throws <InvalidOperationException>(() => client.IsMessageComplete);
Assert.Throws <InvalidOperationException>(() => client.Connect());
await Assert.ThrowsAsync <InvalidOperationException>(() => client.ConnectAsync());
server.Disconnect();
byte[] buffer = new byte[] { 0, 0, 0, 0 };
if (!pair.writeToServer)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // writes on Unix may still succeed after other end disconnects, due to socket being used
{
// Pipe is broken
Assert.Throws <IOException>(() => client.Write(buffer, 0, buffer.Length));
Assert.Throws <IOException>(() => client.WriteByte(5));
Assert.Throws <IOException>(() => { client.WriteAsync(buffer, 0, buffer.Length); });
Assert.Throws <IOException>(() => client.Flush());
Assert.Throws <IOException>(() => client.NumberOfServerInstances);
}
}
else
{
// Nothing for the client to read, but no exception throwing
Assert.Equal(0, client.Read(buffer, 0, buffer.Length));
Assert.Equal(-1, client.ReadByte());
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // NumberOfServerInstances not supported on Unix
{
Assert.Throws <PlatformNotSupportedException>(() => client.NumberOfServerInstances);
}
}
Assert.Throws <InvalidOperationException>(() => client.IsMessageComplete);
}
}
public async Task WriteAsync_DisconnectDuringWrite_Throws()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
pair.Connect();
Task writeTask;
if (pair.clientStream.CanWrite)
{
writeTask = pair.clientStream.WriteAsync(new byte[1], 0, 1);
pair.serverStream.Dispose();
}
else
{
writeTask = pair.serverStream.WriteAsync(new byte[1], 0, 1);
pair.clientStream.Dispose();
}
await Assert.ThrowsAsync <IOException>(() => writeTask);
}
}
public async Task ClonedServer_ActsAsOriginalServer()
{
byte[] msg1 = new byte[] { 5, 7, 9, 10 };
byte[] received1 = new byte[] { 0, 0, 0, 0 };
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream serverBase = pair.serverStream;
NamedPipeClientStream client = pair.clientStream;
pair.Connect();
if (pair.writeToServer)
{
Task <int> clientTask = client.ReadAsync(received1, 0, received1.Length);
using (NamedPipeServerStream server = new NamedPipeServerStream(PipeDirection.Out, false, true, serverBase.SafePipeHandle))
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Assert.Equal(1, client.NumberOfServerInstances);
}
server.Write(msg1, 0, msg1.Length);
int receivedLength = await clientTask;
Assert.Equal(msg1.Length, receivedLength);
Assert.Equal(msg1, received1);
}
}
else
{
Task clientTask = client.WriteAsync(msg1, 0, msg1.Length);
using (NamedPipeServerStream server = new NamedPipeServerStream(PipeDirection.In, false, true, serverBase.SafePipeHandle))
{
int receivedLength = server.Read(received1, 0, msg1.Length);
Assert.Equal(msg1.Length, receivedLength);
Assert.Equal(msg1, received1);
await clientTask;
}
}
}
}
public async Task ClonedClient_ActsAsOriginalClient()
{
byte[] msg1 = new byte[] { 5, 7, 9, 10 };
byte[] received1 = new byte[] { 0, 0, 0, 0 };
using (NamedPipePair pair = CreateNamedPipePair())
{
pair.Connect();
NamedPipeServerStream server = pair.serverStream;
if (pair.writeToServer)
{
using (NamedPipeClientStream client = new NamedPipeClientStream(PipeDirection.In, false, true, pair.clientStream.SafePipeHandle))
{
if (OperatingSystem.IsWindows())
{
Assert.Equal(1, client.NumberOfServerInstances);
}
Task <int> clientTask = client.ReadAsync(received1, 0, received1.Length);
server.Write(msg1, 0, msg1.Length);
int receivedLength = await clientTask;
Assert.Equal(msg1.Length, receivedLength);
Assert.Equal(msg1, received1);
}
}
else
{
using (NamedPipeClientStream client = new NamedPipeClientStream(PipeDirection.Out, false, true, pair.clientStream.SafePipeHandle))
{
Task clientTask = client.WriteAsync(msg1, 0, msg1.Length);
int receivedLength = server.Read(received1, 0, msg1.Length);
Assert.Equal(msg1.Length, receivedLength);
Assert.Equal(msg1, received1);
await clientTask;
}
}
}
}
public async Task ManyConcurrentOperations(bool cancelable)
{
using (NamedPipePair pair = CreateNamedPipePair(PipeOptions.Asynchronous, PipeOptions.Asynchronous))
{
await Task.WhenAll(pair.serverStream.WaitForConnectionAsync(), pair.clientStream.ConnectAsync());
const int NumOps = 100;
const int DataPerOp = 512;
byte[] sendingData = new byte[NumOps * DataPerOp];
byte[] readingData = new byte[sendingData.Length];
new Random().NextBytes(sendingData);
var cancellationToken = cancelable ? new CancellationTokenSource().Token : CancellationToken.None;
Stream reader = pair.writeToServer ? (Stream)pair.clientStream : pair.serverStream;
Stream writer = pair.writeToServer ? (Stream)pair.serverStream : pair.clientStream;
var reads = new Task <int> [NumOps];
var writes = new Task[NumOps];
for (int i = 0; i < reads.Length; i++)
{
reads[i] = reader.ReadAsync(readingData, i * DataPerOp, DataPerOp, cancellationToken);
}
for (int i = 0; i < reads.Length; i++)
{
writes[i] = writer.WriteAsync(sendingData, i * DataPerOp, DataPerOp, cancellationToken);
}
const int WaitTimeout = 30000;
Assert.True(Task.WaitAll(writes, WaitTimeout));
Assert.True(Task.WaitAll(reads, WaitTimeout));
// The data of each write may not be written atomically, and as such some of the data may be
// interleaved rather than entirely in the order written.
Assert.Equal(sendingData.OrderBy(b => b), readingData.OrderBy(b => b));
}
}
public async Task Server_ReadWriteCancelledToken_Throws_OperationCanceledException()
{
using (NamedPipePair pair = CreateNamedPipePair())
{
NamedPipeServerStream server = pair.serverStream;
NamedPipeClientStream client = pair.clientStream;
byte[] buffer = new byte[] { 0, 0, 0, 0 };
pair.Connect();
if (server.CanRead && client.CanWrite)
{
var ctx1 = new CancellationTokenSource();
Task <int> serverReadToken = server.ReadAsync(buffer, 0, buffer.Length, ctx1.Token);
ctx1.Cancel();
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => serverReadToken);
ctx1.Cancel();
Assert.True(server.ReadAsync(buffer, 0, buffer.Length, ctx1.Token).IsCanceled);
}
if (server.CanWrite)
{
var ctx1 = new CancellationTokenSource();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // On Unix WriteAsync's aren't cancelable once initiated
{
Task serverWriteToken = server.WriteAsync(buffer, 0, buffer.Length, ctx1.Token);
ctx1.Cancel();
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => serverWriteToken);
}
ctx1.Cancel();
Assert.True(server.WriteAsync(buffer, 0, buffer.Length, ctx1.Token).IsCanceled);
}
}
}
public async Task OneWayReadWrites(PipeOptions serverOptions, PipeOptions clientOptions, bool asyncServerOps, bool asyncClientOps)
{
using (NamedPipePair pair = CreateNamedPipePair(serverOptions, clientOptions))
{
NamedPipeClientStream client = pair.clientStream;
NamedPipeServerStream server = pair.serverStream;
byte[] received = new byte[] { 0 };
Task clientTask = Task.Run(async() =>
{
if (asyncClientOps)
{
await client.ConnectAsync();
if (pair.writeToServer)
{
received = await ReadBytesAsync(client, sendBytes.Length);
}
else
{
await WriteBytesAsync(client, sendBytes);
}
}
else
{
client.Connect();
if (pair.writeToServer)
{
received = ReadBytes(client, sendBytes.Length);
}
else
{
WriteBytes(client, sendBytes);
}
}
});
if (asyncServerOps)
{
await server.WaitForConnectionAsync();
if (pair.writeToServer)
{
await WriteBytesAsync(server, sendBytes);
}
else
{
received = await ReadBytesAsync(server, sendBytes.Length);
}
}
else
{
server.WaitForConnection();
if (pair.writeToServer)
{
WriteBytes(server, sendBytes);
}
else
{
received = ReadBytes(server, sendBytes.Length);
}
}
await clientTask;
Assert.Equal(sendBytes, received);
server.Disconnect();
Assert.False(server.IsConnected);
}
}
protected override NamedPipePair CreateNamedPipePair(PipeOptions serverOptions, PipeOptions clientOptions)
{
NamedPipePair ret = new NamedPipePair();
string pipeName = GetUniquePipeName();
ret.serverStream = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, serverOptions);
ret.clientStream = new NamedPipeClientStream(".", pipeName, PipeDirection.Out, clientOptions);
ret.writeToServer = false;
return ret;
}
