public async void ReceiveAsync_With_Null_Stream()
{
var pipe = new NamedPipeTransport(null);
var result = await pipe.ReceiveAsync(new byte[0], 0, 0);
Assert.Equal(0, result);
}
public WebSocketTransportCollection RegisterNamedPipes(Action <NamedPipeTransport> configure = null)
{
var transport = new NamedPipeTransport();
configure?.Invoke(transport);
this.Add(transport);
return(this);
}
public void ClosedStream_Not_IsConnected()
{
var pipeName = Guid.NewGuid().ToString();
var readStream = new NamedPipeServerStream(pipeName, PipeDirection.In, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.WriteThrough | PipeOptions.Asynchronous);
var reader = new NamedPipeTransport(readStream);
Assert.False(reader.IsConnected);
readStream.Dispose();
}
public void CanWriteAndRead()
{
var tasks = new List <Task>();
var data = new byte[100];
for (var b = 0; b < data.Length; b++)
{
data[b] = (byte)b;
}
var pipeName = Guid.NewGuid().ToString();
var readStream = new NamedPipeServerStream(pipeName, PipeDirection.In, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.WriteThrough | PipeOptions.Asynchronous);
var writeStream = new NamedPipeClientStream(".", pipeName, PipeDirection.Out, PipeOptions.WriteThrough | PipeOptions.Asynchronous);
try
{
var reader = new NamedPipeTransport(readStream);
var writer = new NamedPipeTransport(writeStream);
tasks.Add(Task.Run(
async() =>
{
_output.WriteLine("Before WaitForConnectAsync");
await readStream.WaitForConnectionAsync().ConfigureAwait(false);
_output.WriteLine("After WaitForConnectAsync");
var readBuffer = new byte[data.Length];
var length = await reader.ReceiveAsync(readBuffer, 0, readBuffer.Length).ConfigureAwait(false);
_output.WriteLine("After Read");
Assert.Equal(length, data.Length);
for (var b = 0; b < data.Length; b++)
{
Assert.Equal(readBuffer[b], data[b]);
}
}));
tasks.Add(Task.Run(
async() =>
{
_output.WriteLine("Before ConnectAsync");
await writeStream.ConnectAsync(500).ConfigureAwait(false);
_output.WriteLine("After ConnectAsync");
await writer.SendAsync(data, 0, data.Length).ConfigureAwait(false);
_output.WriteLine("After Write");
}));
Task.WaitAll(tasks.ToArray());
}
finally
{
readStream.Disconnect();
readStream.Dispose();
writeStream.Dispose();
}
}
public void Write_ReturnsZeroLength_WhenClosedDuringWrite()
{
var tasks = new List <Task>();
var data = new byte[100];
for (var b = 0; b < data.Length; b++)
{
data[b] = (byte)b;
}
var pipeName = Guid.NewGuid().ToString();
var readStream = new NamedPipeServerStream(pipeName, PipeDirection.In, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.WriteThrough | PipeOptions.Asynchronous);
var writeStream = new NamedPipeClientStream(".", pipeName, PipeDirection.Out, PipeOptions.WriteThrough | PipeOptions.Asynchronous);
var waiter = new TaskCompletionSource <string>();
try
{
var reader = new NamedPipeTransport(readStream);
var writer = new NamedPipeTransport(writeStream);
tasks.Add(Task.Run(
async() =>
{
_output.WriteLine("Before WaitForConnectAsync");
await readStream.WaitForConnectionAsync().ConfigureAwait(false);
_output.WriteLine("After WaitForConnectAsync");
reader.Close();
Task.WaitAll(Task.Run(() => waiter.SetResult("go")));
}));
tasks.Add(Task.Run(
async() =>
{
_output.WriteLine("Before ConnectAsync");
await writeStream.ConnectAsync(500).ConfigureAwait(false);
_output.WriteLine("After ConnectAsync");
var r = await waiter.Task.ConfigureAwait(false);
var length = await writer.SendAsync(data, 0, data.Length).ConfigureAwait(false);
Assert.Equal(0, length);
}));
Task.WaitAll(tasks.ToArray());
}
finally
{
readStream.Dispose();
writeStream.Dispose();
}
}
public void Send()
{
var task = StartServerSingleRead(_buffToSend.Length);
using (var transport = new NamedPipeTransport(_pipeName))
{
Assert.True(transport.Send(_buffToSend, _buffToSend.Length));
}
CollectionAssert.AreEqual(task.Result, _buffToSend);
}
public void Reconnection()
{
using (var transport = new NamedPipeTransport(_pipeName))
{
for (int i = 0; i < 3; i++)
{
var task = StartServerSingleRead(_buffToSend.Length);
Assert.True(transport.Send(_buffToSend, _buffToSend.Length));
CollectionAssert.AreEqual(task.Result, _buffToSend);
}
}
}
public void Read_ReturnsZeroLength_WhenClosedDuringRead()
{
var tasks = new List <Task>();
var pipeName = Guid.NewGuid().ToString();
var readStream = new NamedPipeServerStream(pipeName, PipeDirection.In, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.WriteThrough | PipeOptions.Asynchronous);
var writeStream = new NamedPipeClientStream(".", pipeName, PipeDirection.Out, PipeOptions.WriteThrough | PipeOptions.Asynchronous);
try
{
var reader = new NamedPipeTransport(readStream);
var writer = new NamedPipeTransport(writeStream);
TaskCompletionSource <string> waiter = new TaskCompletionSource <string>();
tasks.Add(Task.Run(
async() =>
{
TestContext.WriteLine("Before WaitForConnectAsync");
await readStream.WaitForConnectionAsync().ConfigureAwait(false);
TestContext.WriteLine("After WaitForConnectAsync");
Task.WaitAll(Task.Run(() => waiter.SetResult("go")));
var readBuffer = new byte[100];
var length = await reader.ReceiveAsync(readBuffer, 0, readBuffer.Length).ConfigureAwait(false);
Assert.AreEqual(0, length);
}));
tasks.Add(Task.Run(
async() =>
{
TestContext.WriteLine("Before ConnectAsync");
await writeStream.ConnectAsync(500).ConfigureAwait(false);
TestContext.WriteLine("After ConnectAsync");
var r = await waiter.Task.ConfigureAwait(false);
writer.Close();
TestContext.WriteLine("After Close");
}));
Task.WaitAll(tasks.ToArray());
}
finally
{
readStream.Disconnect();
readStream.Dispose();
writeStream.Dispose();
}
}
public void NoTimeout()
{
var task = StartServerMultipleReads(4, _serverBufferSize, TimeSpan.FromSeconds(1));
using (var transport = new NamedPipeTransport(_pipeName, TimeSpan.FromSeconds(2)))
{
var buff = new byte[_serverBufferSize];
for (int i = 0; i < 4; ++i)
{
Assert.True(transport.Send(buff, buff.Length));
}
}
task.Wait();
}
public void Timeout()
{
var task = StartServerMultipleReads(4, _serverBufferSize, TimeSpan.FromSeconds(1));
using (var transport = new NamedPipeTransport(_pipeName, TimeSpan.FromMilliseconds(100)))
{
var buff = new byte[_serverBufferSize];
bool bufferSent = true;
for (int i = 0; i < 4; ++i)
{
bufferSent = bufferSent && transport.Send(buff, buff.Length);
}
Assert.False(bufferSent);
}
task.Wait();
}
public void Close_DisconnectsStream()
{
var pipeName = Guid.NewGuid().ToString();
var readStream = new NamedPipeServerStream(pipeName, PipeDirection.In, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.WriteThrough | PipeOptions.Asynchronous);
var writeStream = new NamedPipeClientStream(".", pipeName, PipeDirection.Out, PipeOptions.WriteThrough | PipeOptions.Asynchronous);
var reader = new NamedPipeTransport(readStream);
var writer = new NamedPipeTransport(writeStream);
try
{
var tasks = new List <Task>();
tasks.Add(Task.Run(
async() =>
{
_output.WriteLine("Before WaitForConnectAsync");
await readStream.WaitForConnectionAsync().ConfigureAwait(false);
_output.WriteLine("After WaitForConnectAsync");
}));
tasks.Add(Task.Run(
async() =>
{
_output.WriteLine("Before ConnectAsync");
await writeStream.ConnectAsync(500).ConfigureAwait(false);
_output.WriteLine("After ConnectAsync");
}));
Task.WaitAll(tasks.ToArray());
Assert.True(reader.IsConnected);
reader.Close();
Assert.False(reader.IsConnected);
}
finally
{
readStream.Dispose();
writeStream.Dispose();
}
}
