public async Task <string> CallMethod(string callMethodInfo)
{
_ewh.Set();
var buffer = callMethodInfo.GetBytes(); //Encoding.UTF8.GetBytes(callMethodInfo);
#if NETCOREAPP
await _pipeWrite.WriteAsync(BitConverter.GetBytes(buffer.Length).AsMemory(0, sizeof(int)), _cancellationToken);
await _pipeWrite.WriteAsync(buffer.AsMemory(0, buffer.Length), _cancellationToken);
#else
await _pipeWrite.WriteAsync(BitConverter.GetBytes(buffer.Length), 0, sizeof(int), _cancellationToken);
await _pipeWrite.WriteAsync(buffer, 0, buffer.Length, _cancellationToken);
#endif
buffer = await GetByteArrayFromStreamAsync(_pipeRead, sizeof(int));
int streamSize = BitConverter.ToInt32(buffer, 0);
if (streamSize == 0)
{
return(null);
}
buffer = await GetByteArrayFromStreamAsync(_pipeRead, streamSize);
return(buffer.GetString()); //Encoding.UTF8.GetString(buffer);
}
async public Task TestAsyncOutputStream_CancelOutputRead()
{
// This test might have some false negatives due to possible race condition in System.Diagnostics.AsyncStreamReader.ReadBufferAsync
// There is not way to know if parent process has processed async output from child process
using (AnonymousPipeServerStream pipeWrite = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable))
using (AnonymousPipeServerStream pipeRead = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable))
{
using (Process p = CreateProcess(TestAsyncOutputStream_CancelOutputRead_RemotelyInvokable, $"{pipeWrite.GetClientHandleAsString()} {pipeRead.GetClientHandleAsString()}"))
{
var dataReceived = new List <int>();
var dataArrivedEvent = new AutoResetEvent(false);
p.StartInfo.RedirectStandardOutput = true;
p.OutputDataReceived += (s, e) =>
{
if (e.Data != null)
{
dataReceived.Add(int.Parse(e.Data));
}
dataArrivedEvent.Set();
};
// Start child process
p.Start();
pipeWrite.DisposeLocalCopyOfClientHandle();
pipeRead.DisposeLocalCopyOfClientHandle();
// Wait child process start
Assert.True(await WaitPipeSignal(pipeRead, WaitInMS), "Child process not started");
//Start listening and produce output 1
p.BeginOutputReadLine();
await pipeWrite.WriteAsync(new byte[1], 0, 1);
// Wait child signal produce number 1
Assert.True(await WaitPipeSignal(pipeRead, WaitInMS), "Missing child signal for value 1");
Assert.True(dataArrivedEvent.WaitOne(WaitInMS), "Value 1 not received");
// Stop listening and signal to produce value 2
p.CancelOutputRead();
await pipeWrite.WriteAsync(new byte[1], 0, 1);
// Wait child signal produce number 2
Assert.True(await WaitPipeSignal(pipeRead, WaitInMS), "Missing child signal for value 2");
// Wait child process close to be sure that output buffer has been flushed
Assert.True(p.WaitForExit(WaitInMS), "Child process didn't close");
p.WaitForExit(); // wait for event handlers to complete
Assert.Equal(1, dataReceived.Count);
Assert.Equal(1, dataReceived[0]);
}
}
}
public async static void ServerWriteAsyncNegativeOffsetThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => server.WriteAsync(new byte[5], -1, 1));
// array is checked first
await Assert.ThrowsAsync <ArgumentNullException>(() => server.WriteAsync(null, -1, 1));
}
}
public async Task AnonymousPipeViaFileStream_AllDataCopied(int writeSize, int numWrites)
{
long totalLength = writeSize * numWrites;
var expectedData = new byte[totalLength];
new Random(42).NextBytes(expectedData);
var results = new MemoryStream();
using (var server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Task serverTask = Task.Run(async() =>
{
for (int i = 0; i < numWrites; i++)
{
await server.WriteAsync(expectedData, i * writeSize, writeSize);
}
});
using (var client = new FileStream(new SafeFileHandle(server.ClientSafePipeHandle.DangerousGetHandle(), false), FileAccess.Read, bufferSize: 3))
{
Task copyTask = client.CopyToAsync(results, writeSize);
await await Task.WhenAny(serverTask, copyTask);
server.Dispose();
await copyTask;
}
}
byte[] actualData = results.ToArray();
Assert.Equal(expectedData.Length, actualData.Length);
Assert.Equal <byte>(expectedData, actualData);
}
public async static void ServerWriteAsyncBufferNullThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
await Assert.ThrowsAsync <ArgumentNullException>(() => server.WriteAsync(null, 0, 1));
}
}
public async static void ServerReadOnlyAsyncThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
await Assert.ThrowsAsync <NotSupportedException>(() => server.WriteAsync(new byte[5], 0, 5));
}
}
public static void ServerWriteBufferNullThrows()
{
// force different constructor path
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None))
{
Assert.Throws<ArgumentNullException>(() => server.Write(null, 0, 1));
Assert.Throws<ArgumentNullException>(() => NotReachable(server.WriteAsync(null, 0, 1)));
}
}
public static void ServerWriteBufferNullThrows()
{
// force different constructor path
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None))
{
Assert.Throws <ArgumentNullException>(() => server.Write(null, 0, 1));
Assert.Throws <ArgumentNullException>(() => NotReachable(server.WriteAsync(null, 0, 1)));
}
}
public static void ServerWriteNegativeCountThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Assert.Throws <ArgumentOutOfRangeException>(() => server.Write(new byte[5], 0, -1));
// offset is checked before count
Assert.Throws <ArgumentOutOfRangeException>(() => server.Write(new byte[1], -1, -1));
// array is checked first
Assert.Throws <ArgumentNullException>(() => server.Write(null, -1, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => NotReachable(server.WriteAsync(new byte[5], 0, -1)));
// offset is checked before count
Assert.Throws <ArgumentOutOfRangeException>(() => NotReachable(server.WriteAsync(new byte[1], -1, -1)));
// array is checked first
Assert.Throws <ArgumentNullException>(() => NotReachable(server.WriteAsync(null, -1, -1)));
}
}
public static void ServerReadOnlyThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Assert.Throws <NotSupportedException>(() => server.Write(new byte[5], 0, 5));
Assert.Throws <NotSupportedException>(() => server.WriteByte(123));
Assert.Throws <NotSupportedException>(() => server.Flush());
Assert.Throws <NotSupportedException>(() => server.OutBufferSize);
Assert.Throws <NotSupportedException>(() => server.WaitForPipeDrain());
Assert.Throws <NotSupportedException>(() => NotReachable(server.WriteAsync(new byte[5], 0, 5)));
}
}
public static async Task ServerSendsByteClientReceivesAsync()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Assert.True(server.IsConnected);
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(server.GetClientHandleAsString()))
{
Assert.True(server.IsConnected);
Assert.True(client.IsConnected);
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
await server.WriteAsync(sent, 0, 1);
Assert.Equal(1, await client.ReadAsync(received, 0, 1));
Assert.Equal(sent[0], received[0]);
}
}
}
public static void ServerPInvokeChecks()
{
// calling every API related to server and client to detect any bad PInvokes
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Task clientTask = Task.Run(() => StartClient(PipeDirection.In, server.ClientSafePipeHandle));
Assert.False(server.CanRead);
Assert.False(server.CanSeek);
Assert.False(server.CanTimeout);
Assert.True(server.CanWrite);
Assert.False(string.IsNullOrWhiteSpace(server.GetClientHandleAsString()));
Assert.False(server.IsAsync);
Assert.True(server.IsConnected);
Assert.Equal(0, server.OutBufferSize);
Assert.Equal(PipeTransmissionMode.Byte, server.ReadMode);
Assert.NotNull(server.SafePipeHandle);
Assert.Equal(PipeTransmissionMode.Byte, server.TransmissionMode);
server.Write(new byte[] { 123 }, 0, 1);
server.WriteAsync(new byte[] { 124 }, 0, 1).Wait();
server.Flush();
server.WaitForPipeDrain();
clientTask.Wait();
server.DisposeLocalCopyOfClientHandle();
}
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Task clientTask = Task.Run(() => StartClient(PipeDirection.Out, server.ClientSafePipeHandle));
Assert.Equal(4096, server.InBufferSize);
byte[] readData = new byte[] { 0, 1 };
Assert.Equal(1, server.Read(readData, 0, 1));
Assert.Equal(1, server.ReadAsync(readData, 1, 1).Result);
Assert.Equal(123, readData[0]);
Assert.Equal(124, readData[1]);
clientTask.Wait();
}
}
public async Task AnonymousPipeReadViaFileStream(bool asyncReads)
{
using (var server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Task serverTask = server.WriteAsync(new byte[] { 0, 1, 2, 3, 4, 5 }, 0, 6);
using (var client = new FileStream(new SafeFileHandle(server.ClientSafePipeHandle.DangerousGetHandle(), false), FileAccess.Read, bufferSize: 3))
{
var arr = new byte[1];
for (int i = 0; i < 6; i++)
{
Assert.Equal(1, asyncReads ?
await client.ReadAsync(arr, 0, 1) :
client.Read(arr, 0, 1));
Assert.Equal(i, arr[0]);
}
}
await serverTask;
}
}
public static void ServerWriteArrayOutOfBoundsThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
// offset out of bounds
Assert.Throws <ArgumentException>(null, () => server.Write(new byte[1], 1, 1));
// offset out of bounds for 0 count read
Assert.Throws <ArgumentException>(null, () => server.Write(new byte[1], 2, 0));
// offset out of bounds even for 0 length buffer
Assert.Throws <ArgumentException>(null, () => server.Write(new byte[0], 1, 0));
// combination offset and count out of bounds
Assert.Throws <ArgumentException>(null, () => server.Write(new byte[2], 1, 2));
// edges
Assert.Throws <ArgumentException>(null, () => server.Write(new byte[0], int.MaxValue, 0));
Assert.Throws <ArgumentException>(null, () => server.Write(new byte[0], int.MaxValue, int.MaxValue));
Assert.Throws <ArgumentException>(() => server.Write(new byte[5], 3, 4));
// offset out of bounds
Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[1], 1, 1)));
// offset out of bounds for 0 count read
Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[1], 2, 0)));
// offset out of bounds even for 0 length buffer
Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], 1, 0)));
// combination offset and count out of bounds
Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[2], 1, 2)));
// edges
Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], int.MaxValue, 0)));
Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], int.MaxValue, int.MaxValue)));
Assert.Throws <ArgumentException>(() => NotReachable(server.WriteAsync(new byte[5], 3, 4)));
}
}
public static void ServerPInvokeChecks()
{
// calling every API related to server and client to detect any bad PInvokes
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Task clientTask = StartClientAsync(PipeDirection.In, server.ClientSafePipeHandle);
Console.WriteLine("server.CanRead = {0}", server.CanRead);
Console.WriteLine("server.CanSeek = {0}", server.CanSeek);
Console.WriteLine("server.CanTimeout = {0}", server.CanTimeout);
Console.WriteLine("server.CanWrite = {0}", server.CanWrite);
Console.WriteLine("server.GetClientHandleAsString() = {0}", server.GetClientHandleAsString());
Console.WriteLine("server.IsAsync = {0}", server.IsAsync);
Console.WriteLine("server.IsConnected = {0}", server.IsConnected);
Console.WriteLine("server.OutBufferSize = {0}", server.OutBufferSize);
Console.WriteLine("server.ReadMode = {0}", server.ReadMode);
Console.WriteLine("server.SafePipeHandle = {0}", server.SafePipeHandle);
Console.WriteLine("server.TransmissionMode = {0}", server.TransmissionMode);
server.Write(new byte[] { 123 }, 0, 1);
server.WriteAsync(new byte[] { 124 }, 0, 1).Wait();
server.Flush();
Console.WriteLine("Waiting for Pipe Drain.");
server.WaitForPipeDrain();
clientTask.Wait();
server.DisposeLocalCopyOfClientHandle();
}
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Task clientTask = StartClientAsync(PipeDirection.Out, server.ClientSafePipeHandle);
Console.WriteLine("server.InBufferSize = {0}", server.InBufferSize);
byte[] readData = new byte[] { 0, 1 };
server.Read(readData, 0, 1);
server.ReadAsync(readData, 1, 1).Wait();
Assert.Equal(123, readData[0]);
Assert.Equal(124, readData[1]);
}
}
public static void ServerSendsByteClientReceivesAsync()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Assert.True(server.IsConnected);
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(server.GetClientHandleAsString()))
{
Assert.True(server.IsConnected);
Assert.True(client.IsConnected);
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
Task writeTask = server.WriteAsync(sent, 0, 1);
writeTask.Wait();
Task <int> readTask = client.ReadAsync(received, 0, 1);
readTask.Wait();
Assert.Equal(1, readTask.Result);
Assert.Equal(sent[0], received[0]);
}
}
}
public async Task WriteAsync(byte[] bytes)
{
await pipe.WriteAsync(bytes, 0, bytes.Length);
}
public static void ServerWriteArrayOutOfBoundsThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
// offset out of bounds
Assert.Throws<ArgumentException>(null, () => server.Write(new byte[1], 1, 1));
// offset out of bounds for 0 count read
Assert.Throws<ArgumentException>(null, () => server.Write(new byte[1], 2, 0));
// offset out of bounds even for 0 length buffer
Assert.Throws<ArgumentException>(null, () => server.Write(new byte[0], 1, 0));
// combination offset and count out of bounds
Assert.Throws<ArgumentException>(null, () => server.Write(new byte[2], 1, 2));
// edges
Assert.Throws<ArgumentException>(null, () => server.Write(new byte[0], int.MaxValue, 0));
Assert.Throws<ArgumentException>(null, () => server.Write(new byte[0], int.MaxValue, int.MaxValue));
Assert.Throws<ArgumentException>(() => server.Write(new byte[5], 3, 4));
// offset out of bounds
Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[1], 1, 1)));
// offset out of bounds for 0 count read
Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[1], 2, 0)));
// offset out of bounds even for 0 length buffer
Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], 1, 0)));
// combination offset and count out of bounds
Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[2], 1, 2)));
// edges
Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], int.MaxValue, 0)));
Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], int.MaxValue, int.MaxValue)));
Assert.Throws<ArgumentException>(() => NotReachable(server.WriteAsync(new byte[5], 3, 4)));
}
}
public static void ServerReadOnlyThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Assert.Throws<NotSupportedException>(() => server.Write(new byte[5], 0, 5));
Assert.Throws<NotSupportedException>(() => server.WriteByte(123));
Assert.Throws<NotSupportedException>(() => server.Flush());
Assert.Throws<NotSupportedException>(() => server.OutBufferSize);
Assert.Throws<NotSupportedException>(() => server.WaitForPipeDrain());
Assert.Throws<NotSupportedException>(() => NotReachable(server.WriteAsync(new byte[5], 0, 5)));
}
}
public static void ServerWriteNegativeCountThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Assert.Throws<ArgumentOutOfRangeException>(() => server.Write(new byte[5], 0, -1));
// offset is checked before count
Assert.Throws<ArgumentOutOfRangeException>(() => server.Write(new byte[1], -1, -1));
// array is checked first
Assert.Throws<ArgumentNullException>(() => server.Write(null, -1, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => NotReachable(server.WriteAsync(new byte[5], 0, -1)));
// offset is checked before count
Assert.Throws<ArgumentOutOfRangeException>(() => NotReachable(server.WriteAsync(new byte[1], -1, -1)));
// array is checked first
Assert.Throws<ArgumentNullException>(() => NotReachable(server.WriteAsync(null, -1, -1)));
}
}
async public Task TestAsyncOutputStream_BeginCancelBeginOutputRead()
{
using (AnonymousPipeServerStream pipeWrite = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable))
using (AnonymousPipeServerStream pipeRead = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable))
{
using (Process p = CreateProcess(TestAsyncOutputStream_BeginCancelBeinOutputRead_RemotelyInvokable, $"{pipeWrite.GetClientHandleAsString()} {pipeRead.GetClientHandleAsString()}"))
{
var dataReceived = new BlockingCollection <int>();
p.StartInfo.RedirectStandardOutput = true;
p.OutputDataReceived += (s, e) =>
{
if (e.Data != null)
{
dataReceived.Add(int.Parse(e.Data));
}
};
// Start child process
p.Start();
pipeWrite.DisposeLocalCopyOfClientHandle();
pipeRead.DisposeLocalCopyOfClientHandle();
// Wait child process start
Assert.True(await WaitPipeSignal(pipeRead, WaitInMS), "Child process not started");
//Start listening and signal client to produce 1,2,3
p.BeginOutputReadLine();
await pipeWrite.WriteAsync(new byte[1], 0, 1);
// Wait child signal produce number 1,2,3
Assert.True(await WaitPipeSignal(pipeRead, WaitInMS), "Missing child signal for value 1,2,3");
using (CancellationTokenSource cts = new CancellationTokenSource(WaitInMS))
{
try
{
List <int> expectedValue123 = new List <int>()
{
1, 2, 3
};
foreach (int value in dataReceived.GetConsumingEnumerable(cts.Token))
{
expectedValue123.Remove(value);
if (expectedValue123.Count == 0)
{
break;
}
}
}
catch (OperationCanceledException)
{
Assert.False(cts.IsCancellationRequested, "Values 1,2,3 not arrived");
}
}
// Cancel and signal child
p.CancelOutputRead();
await pipeWrite.WriteAsync(new byte[1], 0, 1);
// Re-start listening and signal child
p.BeginOutputReadLine();
await pipeWrite.WriteAsync(new byte[1], 0, 1);
// Wait child process close
Assert.True(p.WaitForExit(WaitInMS), "Child process didn't close");
p.WaitForExit(); // wait for event handlers to complete
// Wait for value 7,8,9
using (CancellationTokenSource cts = new CancellationTokenSource(WaitInMS))
{
try
{
List <int> expectedValue789 = new List <int>()
{
7, 8, 9
};
foreach (int value in dataReceived.GetConsumingEnumerable(cts.Token))
{
expectedValue789.Remove(value);
if (expectedValue789.Count == 0)
{
break;
}
}
}
catch (OperationCanceledException)
{
Assert.False(cts.IsCancellationRequested, "Values 7,8,9 not arrived");
}
}
}
}
}
public static async Task ServerPInvokeChecks()
{
// calling every API related to server and client to detect any bad PInvokes
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None, 4096))
{
Task clientTask = Task.Run(() => StartClient(PipeDirection.In, server.ClientSafePipeHandle));
Assert.False(server.CanRead);
Assert.False(server.CanSeek);
Assert.False(server.CanTimeout);
Assert.True(server.CanWrite);
Assert.False(string.IsNullOrWhiteSpace(server.GetClientHandleAsString()));
Assert.False(server.IsAsync);
Assert.True(server.IsConnected);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ||
RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
Assert.True(server.OutBufferSize > 0);
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => server.OutBufferSize);
}
Assert.Equal(PipeTransmissionMode.Byte, server.ReadMode);
Assert.NotNull(server.SafePipeHandle);
Assert.Equal(PipeTransmissionMode.Byte, server.TransmissionMode);
server.Write(new byte[] { 123 }, 0, 1);
await server.WriteAsync(new byte[] { 124 }, 0, 1);
server.Flush();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
server.WaitForPipeDrain();
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => server.WaitForPipeDrain());
}
await clientTask;
server.DisposeLocalCopyOfClientHandle();
}
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Task clientTask = Task.Run(() => StartClient(PipeDirection.Out, server.ClientSafePipeHandle));
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Assert.Equal(4096, server.InBufferSize);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
Assert.True(server.InBufferSize > 0);
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => server.InBufferSize);
}
byte[] readData = new byte[] { 0, 1 };
Assert.Equal(1, server.Read(readData, 0, 1));
Assert.Equal(1, server.ReadAsync(readData, 1, 1).Result);
Assert.Equal(123, readData[0]);
Assert.Equal(124, readData[1]);
await clientTask;
}
}