public void ForNonSeekable(string input, params string[] lines)
{
using (var s = new AnonymousPipeServerStream())
using (var c = new AnonymousPipeClientStream(s.GetClientHandleAsString()))
{
var bytes = Encoding.ASCII.GetBytes(input);
s.Write(bytes, 0, bytes.Length);
s.Close();
var skipLF = false;
foreach (var line in lines)
{
Assert.Equal(line, c.ReadProtocolLineWithEnd(skipLF));
skipLF = (line.Last() == '\r');
}
}
using (var s = new AnonymousPipeServerStream())
using (var c = new AnonymousPipeClientStream(s.GetClientHandleAsString()))
{
var bytes = Encoding.ASCII.GetBytes(input);
s.Write(bytes, 0, bytes.Length);
s.Close();
var skipLF = false;
foreach (var line in lines)
{
Assert.Equal(line.TrimEnd(LineEnds), c.ReadProtocolLine(skipLF));
skipLF = (line.Last() == '\r');
}
}
}
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.ThrowsAsync<ArgumentNullException>(() => server.WriteAsync(null, 0, 1));
}
}
public static void ServerSendsByteClientReceives()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Assert.True(server.IsConnected);
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle))
{
Assert.True(server.IsConnected);
Assert.True(client.IsConnected);
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
server.Write(sent, 0, 1);
int bytesReceived = client.Read(received, 0, 1);
Assert.Equal(1, bytesReceived);
Assert.Equal(sent[0], received[0]);
}
}
}
public static void ServerSendsByteClientReceives()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Assert.True(server.IsConnected);
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.GetClientHandleAsString()))
{
Assert.True(server.IsConnected);
Assert.True(client.IsConnected);
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
server.Write(sent, 0, 1);
Assert.Equal(1, client.Read(received, 0, 1));
Assert.Equal(sent[0], received[0]);
}
Assert.Throws<System.IO.IOException>(() => server.WriteByte(5));
}
}
static void Relaunch()
{
var tempdir = Path.Combine( Path.GetTempPath(), Path.GetRandomFileName() );
Directory.CreateDirectory( tempdir );
var xcopy_args = String.Format( "/E \"{0}\" \"{1}\\\"", Path.GetDirectoryName(OriginalPath).Replace("file:\\",""), tempdir );
var pcopy = Process.Start( "xcopy", xcopy_args );
if (!pcopy.WaitForExit(10000)) throw new InvalidOperationException("Relaunch copy hanged!");
Win32.MoveFileEx( tempdir, null, Win32.MoveFileFlags.MOVEFILE_DELAY_UNTIL_REBOOT) ;
var newexe = Path.Combine( tempdir, Path.GetFileName(OriginalPath) );
if ( Connection != null && Connection.Socket.Connected ) {
var pipe = new AnonymousPipeServerStream( PipeDirection.Out, HandleInheritability.Inheritable );
var pipename = pipe.GetClientHandleAsString();
var pcloneinfo = new ProcessStartInfo( newexe, string.Format( "--original={0} --pipe={1}", OriginalPath, pipename ) );
pcloneinfo.UseShellExecute = false;
var pclone = Process.Start(pcloneinfo);
var sockinfo = Connection.Socket.DuplicateAndClose(pclone.Id).ProtocolInformation;
pipe.Write( sockinfo, 0, sockinfo.Length );
pipe.WaitForPipeDrain();
pipe.Close();
} else {
var pclone = Process.Start( newexe, string.Format( "--original={0}", OriginalPath ) );
}
}
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);
if (Interop.IsWindows)
{
Assert.Equal(0, server.OutBufferSize);
}
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);
server.WriteAsync(new byte[] { 124 }, 0, 1).Wait();
server.Flush();
if (Interop.IsWindows)
{
server.WaitForPipeDrain();
}
else
{
Assert.Throws<PlatformNotSupportedException>(() => server.WaitForPipeDrain());
}
clientTask.Wait();
server.DisposeLocalCopyOfClientHandle();
}
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
Task clientTask = Task.Run(() => StartClient(PipeDirection.Out, server.ClientSafePipeHandle));
if (Interop.IsWindows)
{
Assert.Equal(4096, server.InBufferSize);
}
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]);
clientTask.Wait();
}
}
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 ServerWriteNegativeOffsetThrows()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Assert.Throws<ArgumentOutOfRangeException>(() => server.Write(new byte[5], -1, 1));
// array is checked first
Assert.Throws<ArgumentNullException>(() => server.Write(null, -1, 1));
Assert.ThrowsAsync<ArgumentNullException>(() => 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.ThrowsAsync<NotSupportedException>(() => server.WriteAsync(new byte[5], 0, 5));
}
}
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.ThrowsAsync<ArgumentException>(null, () => server.WriteAsync(new byte[1], 1, 1));
// offset out of bounds for 0 count read
Assert.ThrowsAsync<ArgumentException>(null, () => server.WriteAsync(new byte[1], 2, 0));
// offset out of bounds even for 0 length buffer
Assert.ThrowsAsync<ArgumentException>(null, () => server.WriteAsync(new byte[0], 1, 0));
// combination offset and count out of bounds
Assert.ThrowsAsync<ArgumentException>(null, () => server.WriteAsync(new byte[2], 1, 2));
// edges
Assert.ThrowsAsync<ArgumentException>(null, () => server.WriteAsync(new byte[0], int.MaxValue, 0));
Assert.ThrowsAsync<ArgumentException>(null, () => server.WriteAsync(new byte[0], int.MaxValue, int.MaxValue));
Assert.ThrowsAsync<ArgumentException>(() => server.WriteAsync(new byte[5], 3, 4));
}
}