public void OperationsOnUnconnectedServer()
{
(NamedPipeServerStream server, NamedPipeClientStream client) = CreateServerAndClientStreams();
using StreamPair streams = (server, client);
// doesn't throw exceptions
PipeTransmissionMode transmitMode = server.TransmissionMode;
Assert.Throws <ArgumentOutOfRangeException>(() => server.ReadMode = (PipeTransmissionMode)999);
var buffer = new byte[4];
foreach ((Stream writeable, Stream readable) in GetReadWritePairs(streams))
{
if (ReferenceEquals(writeable, server))
{
Assert.Equal(0, 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
{
Assert.Equal(0, 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);
}
protected override Task <StreamPair> CreateWrappedConnectedStreamsAsync(StreamPair wrapped, bool leaveOpen = false)
{
var b1 = new BufferedStream(wrapped.Stream1, 1024);
var b2 = new BufferedStream(wrapped.Stream2, 1024);
return(Task.FromResult <StreamPair>((b1, b2)));
}
public async Task OperationsOnDisconnectedServer()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
(NamedPipeServerStream server, NamedPipeClientStream client) = GetClientAndServer(streams);
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[4];
foreach ((Stream writeable, Stream readable) in GetReadWritePairs(streams))
{
if (ReferenceEquals(writeable, server))
{
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);
Assert.Throws <InvalidOperationException>(() => server.GetImpersonationUserName());
}
public async Task Client_ReadWriteCancelledToken_Throws_OperationCanceledException()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
(NamedPipeServerStream server, NamedPipeClientStream client) = GetClientAndServer(streams);
var buffer = new byte[4];
if (client.CanRead)
{
var ctx1 = new CancellationTokenSource();
Task serverReadToken = client.ReadAsync(buffer, 0, buffer.Length, ctx1.Token);
ctx1.Cancel();
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => serverReadToken);
Assert.True(client.ReadAsync(buffer, 0, buffer.Length, ctx1.Token).IsCanceled);
}
if (client.CanWrite)
{
var ctx1 = new CancellationTokenSource();
if (OperatingSystem.IsWindows()) // On Unix WriteAsync's aren't cancelable once initiated
{
Task serverWriteToken = client.WriteAsync(buffer, 0, buffer.Length, ctx1.Token);
ctx1.Cancel();
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => serverWriteToken);
}
ctx1.Cancel();
Assert.True(client.WriteAsync(buffer, 0, buffer.Length, ctx1.Token).IsCanceled);
}
}
[PlatformSpecific(TestPlatforms.Windows)] // P/Invoking to Win32 functions
public async Task CancelTokenOff_Client_ReadWriteCancelledToken_Throws_OperationCanceledException()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
(NamedPipeServerStream server, NamedPipeClientStream client) = GetClientAndServer(streams);
var buffer = new byte[4];
if (client.CanRead)
{
Task clientReadToken = client.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None);
Assert.True(InteropTest.CancelIoEx(client.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => clientReadToken);
Assert.True(clientReadToken.IsCanceled);
}
if (client.CanWrite)
{
Task clientWriteToken = client.WriteAsync(buffer, 0, buffer.Length, CancellationToken.None);
Assert.True(InteropTest.CancelIoEx(client.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => clientWriteToken);
Assert.True(clientWriteToken.IsCanceled);
}
}
[PlatformSpecific(TestPlatforms.Windows)] // P/Invoking to Win32 functions
public async Task CancelTokenOn_Client_ReadWriteCancelledToken_Throws_OperationCanceledException()
{
if ((Options & PipeOptions.Asynchronous) == 0)
{
// Test depends on PipeOptions.Asynchronous, as CancelIoEx is for overlapped I/O
return;
}
using StreamPair streams = await CreateConnectedStreamsAsync();
(NamedPipeServerStream server, NamedPipeClientStream client) = GetClientAndServer(streams);
var buffer = new byte[4];
if (client.CanRead)
{
var cts = new CancellationTokenSource();
Task clientReadToken = client.ReadAsync(buffer, 0, buffer.Length, cts.Token);
Assert.True(InteropTest.CancelIoEx(client.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => clientReadToken);
}
if (client.CanWrite)
{
var cts = new CancellationTokenSource();
Task clientWriteToken = client.WriteAsync(buffer, 0, buffer.Length, cts.Token);
Assert.True(InteropTest.CancelIoEx(client.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => clientWriteToken);
}
}
public void OperationsOnUnconnectedClient()
{
(NamedPipeServerStream server, NamedPipeClientStream client) = CreateServerAndClientStreams();
using StreamPair streams = (server, client);
var buffer = new byte[4];
if (client.CanRead)
{
Assert.Throws <InvalidOperationException>(() => client.Read(buffer, 0, buffer.Length));
Assert.Throws <InvalidOperationException>(() => client.ReadByte());
Assert.Throws <InvalidOperationException>(() => { client.ReadAsync(buffer, 0, buffer.Length); });
Assert.Throws <InvalidOperationException>(() => client.ReadMode);
Assert.Throws <InvalidOperationException>(() => client.ReadMode = PipeTransmissionMode.Byte);
}
if (client.CanWrite)
{
Assert.Throws <InvalidOperationException>(() => client.Write(buffer, 0, buffer.Length));
Assert.Throws <InvalidOperationException>(() => client.WriteByte(5));
Assert.Throws <InvalidOperationException>(() => { client.WriteAsync(buffer, 0, buffer.Length); });
}
Assert.Throws <InvalidOperationException>(() => client.NumberOfServerInstances);
Assert.Throws <InvalidOperationException>(() => client.TransmissionMode);
Assert.Throws <InvalidOperationException>(() => client.InBufferSize);
Assert.Throws <InvalidOperationException>(() => client.OutBufferSize);
Assert.Throws <InvalidOperationException>(() => client.SafePipeHandle);
}
[PlatformSpecific(TestPlatforms.Windows)] // P/Invoking to Win32 functions
public async Task CancelTokenOn_Server_ReadWriteCancelledToken_Throws_OperationCanceledException()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
(NamedPipeServerStream server, NamedPipeClientStream client) = GetClientAndServer(streams);
var buffer = new byte[4];
if (server.CanRead)
{
var cts = new CancellationTokenSource();
Task serverReadToken = server.ReadAsync(buffer, 0, buffer.Length, cts.Token);
Assert.True(InteropTest.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => serverReadToken);
}
if (server.CanWrite)
{
var cts = new CancellationTokenSource();
Task serverWriteToken = server.WriteAsync(buffer, 0, buffer.Length, cts.Token);
Assert.True(InteropTest.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => serverWriteToken);
}
}
public async Task ConnectOnAlreadyConnectedClient_Throws_InvalidOperationException()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
NamedPipeClientStream client = streams.Stream1 as NamedPipeClientStream ?? (NamedPipeClientStream)streams.Stream2;
Assert.Throws <InvalidOperationException>(() => client.Connect());
}
public async Task WaitForConnectionOnAlreadyConnectedServer_Throws_InvalidOperationException()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
NamedPipeServerStream server = streams.Stream1 as NamedPipeServerStream ?? (NamedPipeServerStream)streams.Stream2;
Assert.Throws <InvalidOperationException>(() => server.WaitForConnection());
}
protected override async Task <StreamPair> CreateConnectedStreamsAsync()
{
StreamPair pair = await base.CreateConnectedStreamsAsync();
Assert.True(pair.Stream2.CanWrite);
Assert.True(pair.Stream2.CanRead);
return(pair);
}
protected override Task <StreamPair> CreateWrappedConnectedStreamsAsync(StreamPair wrapped, bool leaveOpen = false)
{
ICryptoTransform transform = new IdentityTransform(1, 1, true);
(Stream writeable, Stream readable) = GetReadWritePair(wrapped);
var encryptedWriteable = new CryptoStream(writeable, transform, CryptoStreamMode.Write, leaveOpen);
var decryptedReadable = new CryptoStream(readable, transform, CryptoStreamMode.Read, leaveOpen);
return(Task.FromResult <StreamPair>((encryptedWriteable, decryptedReadable)));
}
public async Task ReadAsync_DisconnectDuringRead_Returns0()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
(Stream writeable, Stream readable) = GetReadWritePair(streams);
Task <int> readTask = readable.ReadAsync(new byte[1], 0, 1);
writeable.Dispose();
Assert.Equal(0, await readTask);
}
public async Task WriteAsync_DisconnectDuringWrite_Throws()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
(Stream writeable, Stream readable) = GetReadWritePair(streams);
Task writeTask = writeable.WriteAsync(new byte[1], 0, 1);
readable.Dispose();
await Assert.ThrowsAsync <IOException>(() => writeTask);
}
[PlatformSpecific(TestPlatforms.Windows)] // P/Invoking to Win32 functions
public async Task CancelTokenOn_ServerWaitForConnectionAsyncWithOuterCancellation_Throws_IOException()
{
(NamedPipeServerStream server, NamedPipeClientStream client) = CreateServerAndClientStreams();
using StreamPair streams = (server, client);
var cts = new CancellationTokenSource();
Task waitForConnectionTask = server.WaitForConnectionAsync(cts.Token);
Assert.True(InteropTest.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAsync <IOException>(() => waitForConnectionTask);
}
public async Task DisposedClientPipe_Throws_ObjectDisposedException()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
(NamedPipeServerStream server, NamedPipeClientStream client) = GetClientAndServer(streams);
client.Dispose();
Assert.Throws <ObjectDisposedException>(() => client.Connect());
await Assert.ThrowsAsync <ObjectDisposedException>(() => client.ConnectAsync());
Assert.Throws <ObjectDisposedException>(() => client.NumberOfServerInstances);
}
[PlatformSpecific(TestPlatforms.Windows)] // P/Invoking to Win32 functions
public async Task CancelTokenOff_ServerWaitForConnectionAsyncWithOuterCancellation_Throws_OperationCanceledException()
{
(NamedPipeServerStream server, NamedPipeClientStream client) = CreateServerAndClientStreams();
using StreamPair streams = (server, client);
Task waitForConnectionTask = server.WaitForConnectionAsync(CancellationToken.None);
Assert.True(InteropTest.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => waitForConnectionTask);
Assert.True(waitForConnectionTask.IsCanceled);
}
public void NewEvent <T>(int count)
{
Assert.AreNotEqual(0, count);
if (_handleKeys.ContainsKey(typeof(T)))
{
return;
}
var key = _handleKeys[typeof(T)] = ++_eventCount;
_eventCollection[key] = new StreamPair(count);
ResetHandles(key);
}
public async Task CancelTokenOn_ServerWaitForConnectionAsync_Throws_OperationCanceledException(int cancellationDelay)
{
(NamedPipeServerStream server, NamedPipeClientStream client) = CreateServerAndClientStreams();
using StreamPair streams = (server, client);
var ctx = new CancellationTokenSource();
Task serverWaitTimeout = server.WaitForConnectionAsync(ctx.Token);
ctx.CancelAfter(cancellationDelay);
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => serverWaitTimeout);
Assert.True(server.WaitForConnectionAsync(ctx.Token).IsCanceled);
}
public NativeStream.Writer GetWriter <T>(ref JobHandle dependencies, int count) where T : struct
{
var key = _handleKeys[typeof(T)];
dependencies = JobHandle.CombineDependencies(_consumerHandles[key], _producerHandles[key], dependencies);
if (_eventCollection[key].ForEachCount >= count)
{
dependencies = new ClearStreamJob(_eventCollection[key].Stream).Schedule(dependencies);
return(_eventCollection[key].Stream.AsWriter());
}
dependencies.Complete();
_toDispose.Add(_eventCollection[key].Stream);
_eventCollection[key] = new StreamPair(2 * count);
return(_eventCollection[key].Stream.AsWriter());
}
public async Task PipeStream_WaitForPipeDrain()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
foreach ((Stream writeable, Stream readable) in GetReadWritePairs(streams))
{
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
Task t = Task.Run(() => writeable.Write(sent, 0, sent.Length));
Assert.Equal(sent.Length, readable.Read(received, 0, sent.Length));
Assert.Equal(sent, received);
((PipeStream)writeable).WaitForPipeDrain();
await t;
}
}
public async Task CancelTokenOn_ServerWaitForConnectionAsync_Throws_OperationCanceledException()
{
(NamedPipeServerStream server, NamedPipeClientStream client) = CreateServerAndClientStreams();
using StreamPair streams = (server, client);
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);
}
[PlatformSpecific(TestPlatforms.Windows)] // P/Invoking to Win32 functions
public async Task CancelTokenOn_ServerWaitForConnectionAsyncWithOuterCancellation_Throws_IOException()
{
if ((Options & PipeOptions.Asynchronous) == 0)
{
// Test depends on PipeOptions.Asynchronous, as CancelIoEx is for overlapped I/O
return;
}
(NamedPipeServerStream server, NamedPipeClientStream client) = CreateServerAndClientStreams();
using StreamPair streams = (server, client);
var cts = new CancellationTokenSource();
Task waitForConnectionTask = server.WaitForConnectionAsync(cts.Token);
Assert.True(InteropTest.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
await Assert.ThrowsAsync <IOException>(() => waitForConnectionTask);
}
public virtual async Task OperationsOnDisconnectedClient()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
(NamedPipeServerStream server, NamedPipeClientStream client) = GetClientAndServer(streams);
Assert.Throws <InvalidOperationException>(() => client.IsMessageComplete);
Assert.Throws <InvalidOperationException>(() => client.Connect());
await Assert.ThrowsAsync <InvalidOperationException>(() => client.ConnectAsync());
server.Disconnect();
var buffer = new byte[4];
foreach ((Stream writeable, Stream readable) in GetReadWritePairs(streams))
{
if (ReferenceEquals(writeable, client))
{
if (OperatingSystem.IsWindows()) // 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 (!OperatingSystem.IsWindows()) // NumberOfServerInstances not supported on Unix
{
Assert.Throws <PlatformNotSupportedException>(() => client.NumberOfServerInstances);
}
}
}
Assert.Throws <InvalidOperationException>(() => client.IsMessageComplete);
}
public async Task ClonedServer_ActsAsOriginalServer()
{
byte[] msg1 = new byte[] { 5, 7, 9, 10 };
byte[] received1 = new byte[] { 0, 0, 0, 0 };
using StreamPair streams = await CreateConnectedStreamsAsync();
(Stream writeable, Stream readable) = GetReadWritePair(streams);
if (writeable is NamedPipeServerStream serverBase)
{
Task <int> clientTask = readable.ReadAsync(received1, 0, received1.Length);
using (NamedPipeServerStream server = new NamedPipeServerStream(PipeDirection.Out, false, true, serverBase.SafePipeHandle))
{
server.Write(msg1, 0, msg1.Length);
int receivedLength = await clientTask;
Assert.Equal(msg1.Length, receivedLength);
Assert.Equal(msg1, received1);
if (OperatingSystem.IsWindows())
{
Assert.Equal(1, ((NamedPipeClientStream)readable).NumberOfServerInstances);
}
}
}
else
{
Task clientTask = writeable.WriteAsync(msg1, 0, msg1.Length);
using (NamedPipeServerStream server = new NamedPipeServerStream(PipeDirection.In, false, true, ((NamedPipeServerStream)readable).SafePipeHandle))
{
int receivedLength = server.Read(received1, 0, msg1.Length);
Assert.Equal(msg1.Length, receivedLength);
Assert.Equal(msg1, received1);
await clientTask;
}
}
}
public async Task Windows_OperationsOnNamedServerWithDisposedClient()
{
using StreamPair streams = await CreateConnectedStreamsAsync();
(NamedPipeServerStream server, NamedPipeClientStream client) = GetClientAndServer(streams);
client.Dispose();
if (OperatingSystem.IsWindows())
{
Assert.Throws <IOException>(() => server.WaitForConnection());
await Assert.ThrowsAsync <IOException>(() => server.WaitForConnectionAsync());
Assert.Throws <IOException>(() => server.GetImpersonationUserName());
}
else
{
// On Unix, the server still thinks that it is connected after client Disposal.
Assert.Throws <InvalidOperationException>(() => server.WaitForConnection());
await Assert.ThrowsAsync <InvalidOperationException>(() => server.WaitForConnectionAsync());
Assert.NotNull(server.GetImpersonationUserName());
}
}
protected override Task <StreamPair> CreateWrappedConnectedStreamsAsync(StreamPair wrapped, bool leaveOpen) => Task.FromResult <StreamPair>((CreateStream(wrapped.Stream1, CompressionMode.Compress, leaveOpen), CreateStream(wrapped.Stream2, CompressionMode.Decompress, leaveOpen)));
protected override async Task <StreamPair> CreateWrappedConnectedStreamsAsync(StreamPair wrapped, bool leaveOpen = false)
{
X509Certificate2?cert = Test.Common.Configuration.Certificates.GetServerCertificate();
var ssl1 = new SslStream(wrapped.Stream1, leaveOpen, delegate { return(true); });
var ssl2 = new SslStream(wrapped.Stream2, leaveOpen, delegate { return(true); });
await new[]
{
ssl1.AuthenticateAsClientAsync(cert.GetNameInfo(X509NameType.SimpleName, false), null, GetSslProtocols(), false),
ssl2.AuthenticateAsServerAsync(cert, false, GetSslProtocols(), false)
}.WhenAllOrAnyFailed().ConfigureAwait(false);
if (GetSslProtocols() == SslProtocols.Tls13)
{
// TLS 1.3 can generate some extra messages and we may get reset if test sends unidirectional traffic
// and extra packet stays in socket buffer.
// This ping-ping should flush leftovers from the handshake.
// We use sync method to preserve socket in default blocking state
// (as we don't go back once Async is used at least once)
ssl1.Write(new byte[1]);
ssl2.Write(new byte[1]);
Assert.Equal(1, ssl2.Read(new byte[1]));
Assert.Equal(1, ssl1.Read(new byte[1]));
}
return(new StreamPair(ssl1, ssl2));
}
public override async Task ArgumentValidation_ThrowsExpectedException()
{
// Only validate the second stream (the first is the server stream that's part of the test).
using StreamPair streams = await CreateConnectedStreamsAsync();
await ValidateMisuseExceptionsAsync(streams.Stream2);
}
protected override async Task <StreamPair> CreateWrappedConnectedStreamsAsync(StreamPair wrapped, bool leaveOpen = false)
{
X509Certificate2?cert = Test.Common.Configuration.Certificates.GetServerCertificate();
var ssl1 = new SslStream(wrapped.Stream1, leaveOpen, delegate { return(true); });
var ssl2 = new SslStream(wrapped.Stream2, leaveOpen, delegate { return(true); });
await new[]
{
ssl1.AuthenticateAsClientAsync(cert.GetNameInfo(X509NameType.SimpleName, false)),
ssl2.AuthenticateAsServerAsync(cert, false, false)
}.WhenAllOrAnyFailed().ConfigureAwait(false);
return(new StreamPair(ssl1, ssl2));
}
