Add more pipe tests

Author: Maxwe11

src/System.IO.Pipes/tests/Interop.cs

@@ -0,0 +1,94 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using Microsoft.Win32.SafeHandles;
+
+namespace System.IO.Pipes.Tests
+{
+    /// <summary>
+    /// The class contains interop declarations and helpers methods for them.
+    /// </summary>
+    internal static class Interop
+    {
+        #region Windows
+
+        [DllImport("api-ms-win-core-io-l1-1-0.dll", SetLastError = true)]
+        private static extern unsafe bool CancelIoEx(SafeHandle handle, NativeOverlapped* lpOverlapped);
+
+        internal static unsafe bool CancelIoEx(SafeHandle handle)
+        {
+            return CancelIoEx(handle, null);
+        }
+
+        [DllImport("api-ms-win-core-namedpipe-l1-2-1.dll", CharSet = CharSet.Unicode, SetLastError = true, BestFitMapping = false, EntryPoint = "GetNamedPipeHandleStateW")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool GetNamedPipeHandleState(
+            SafePipeHandle hNamedPipe,
+            IntPtr lpState,
+            out int lpCurInstances,
+            IntPtr lpMaxCollectionCount,
+            IntPtr lpCollectDataTimeout,
+            StringBuilder lpUserName,
+            int nMaxUserNameSize);
+
+        internal static bool TryGetImpersonationUserName(SafePipeHandle handle, out string userName)
+        {
+            const int CREDUI_MAX_USERNAME_LENGTH = 513;
+            int serverInstances;
+            var builder = new StringBuilder(CREDUI_MAX_USERNAME_LENGTH + 1);
+
+            if (GetNamedPipeHandleState(handle, IntPtr.Zero, out serverInstances, IntPtr.Zero, IntPtr.Zero, builder, builder.Capacity))
+            {
+                userName = builder.ToString();
+                return true;
+            }
+
+            userName = "";
+            return false;
+        }
+
+        internal static bool TryGetNumberOfServerInstances(SafePipeHandle handle, out int numberOfServerInstances)
+        {
+            int serverInstances;
+
+            if (GetNamedPipeHandleState(handle, IntPtr.Zero, out serverInstances, IntPtr.Zero, IntPtr.Zero, null, 0))
+            {
+                numberOfServerInstances = serverInstances;
+                return true;
+            }
+
+            numberOfServerInstances = 0;
+            return false;
+        }
+
+        #endregion
+
+        #region Unix
+
+        [DllImport("libc", SetLastError = true)]
+        private static extern unsafe int gethostname(byte* name, int len);
+
+        internal static unsafe bool TryGetHostName(out string hostName)
+        {
+            const int HOST_NAME_MAX = 255; // man gethostname
+            const int ArrLength = HOST_NAME_MAX + 1;
+
+            byte* name = stackalloc byte[ArrLength];
+            int result = gethostname(name, ArrLength);
+
+            if (result == 0)
+            {
+                hostName = Marshal.PtrToStringAnsi((IntPtr)name);
+                return true;
+            }
+
+            hostName = "";
+            return false;
+        }
+
+        #endregion
+    }
+}

src/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateClient.cs

@@ -50,6 +50,33 @@ public static void EmptyStringServerName_Throws_ArgumentException(PipeDirection
             Assert.Throws<ArgumentException>(() => new NamedPipeClientStream("", "client1", direction, PipeOptions.None, TokenImpersonationLevel.None));
         }
 
+        [Theory]
+        [InlineData(PipeDirection.In)]
+        [InlineData(PipeDirection.InOut)]
+        [InlineData(PipeDirection.Out)]
+        [PlatformSpecific(PlatformID.Windows)]
+        public static void ReservedPipeName_Throws_ArgumentOutOfRangeException(PipeDirection direction)
+        {
+            const string serverName = ".";
+            const string reservedName = "anonymous";
+            Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(reservedName));
+            Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(serverName, reservedName));
+            Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(serverName, reservedName, direction));
+            Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(serverName, reservedName, direction, PipeOptions.None));
+            Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(serverName, reservedName, direction, PipeOptions.None, TokenImpersonationLevel.Impersonation));
+        }
+
+        [Fact]
+        [PlatformSpecific(PlatformID.AnyUnix)]
+        public static void NotSupportedPipePath_Throws_PlatformNotSupportedException()
+        {
+            string hostName;
+            Assert.True(Interop.TryGetHostName(out hostName));
+
+            Assert.Throws<PlatformNotSupportedException>(() => new NamedPipeClientStream("foobar" + hostName, "foobar"));
+            Assert.Throws<PlatformNotSupportedException>(() => new NamedPipeClientStream(hostName, "foobar" + Path.GetInvalidFileNameChars()[0]));
+        }
+
         [Theory]
         [InlineData((PipeDirection)123)]
         public static void InvalidPipeDirection_Throws_ArgumentOutOfRangeException(PipeDirection direction)

src/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Simple.cs

@@ -235,45 +235,33 @@ public async Task CancelTokenOn_ServerWaitForConnectionAsync_Throws_OperationCan
             }
         }
 
-        [DllImport("api-ms-win-core-io-l1-1-0.dll", SetLastError = true)]
-        private static unsafe extern bool CancelIoEx(SafeHandle handle, NativeOverlapped* lpOverlapped);
-
         [Fact]
         [PlatformSpecific(PlatformID.Windows)]
-        // [ActiveIssue(2640)]
         public async Task CancelTokenOff_ServerWaitForConnectionAsyncWithOuterCancellation_Throws_OperationCanceledException()
         {
             using (NamedPipePair pair = CreateNamedPipePair())
             {
                 NamedPipeServerStream server = pair.serverStream;
                 Task waitForConnectionTask = server.WaitForConnectionAsync(CancellationToken.None);
-                unsafe
-                {
-                    Assert.True(CancelIoEx(server.SafePipeHandle, null), "Outer cancellation failed");
-                }
 
+                Assert.True(Interop.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
                 await Assert.ThrowsAnyAsync<OperationCanceledException>(() => waitForConnectionTask);
                 Assert.True(waitForConnectionTask.IsCanceled);
             }
         }
 
         [Fact]
         [PlatformSpecific(PlatformID.Windows)]
-        // [ActiveIssue(2640)]
         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);
-                unsafe
-                {
-                    Assert.True(CancelIoEx(server.SafePipeHandle, null), "Outer cancellation failed");
-                }
 
+                Assert.True(Interop.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
                 await Assert.ThrowsAsync<IOException>(() => waitForConnectionTask);
-                Assert.False(waitForConnectionTask.IsCanceled);
             }
         }
 
@@ -310,6 +298,7 @@ public async Task OperationsOnDisconnectedServer()
 
                 Assert.Throws<InvalidOperationException>(() => server.Flush());
                 Assert.Throws<InvalidOperationException>(() => server.IsMessageComplete);
+                Assert.Throws<InvalidOperationException>(() => server.GetImpersonationUserName());
             }
         }
 
@@ -337,12 +326,18 @@ public virtual async Task OperationsOnDisconnectedClient()
                     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))
+                    {
+                        Assert.Throws<PlatformNotSupportedException>(() => client.NumberOfServerInstances);
+                    }
                 }
 
                 Assert.Throws<InvalidOperationException>(() => client.IsMessageComplete);
@@ -361,6 +356,7 @@ public async Task Windows_OperationsOnNamedServerWithDisposedClient()
 
                 Assert.Throws<IOException>(() => server.WaitForConnection());
                 await Assert.ThrowsAsync<IOException>(() => server.WaitForConnectionAsync());
+                Assert.Throws<IOException>(() => server.GetImpersonationUserName());
             }
         }
 
@@ -377,6 +373,7 @@ public async Task Unix_OperationsOnNamedServerWithDisposedClient()
                 // 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.Throws<PlatformNotSupportedException>(() => server.GetImpersonationUserName());
             }
         }
 
@@ -463,6 +460,7 @@ public async Task DisposedServerPipe_Throws_ObjectDisposedException()
                 byte[] buffer = new byte[] { 0, 0, 0, 0 };
 
                 Assert.Throws<ObjectDisposedException>(() => pipe.Disconnect());
+                Assert.Throws<ObjectDisposedException>(() => pipe.GetImpersonationUserName());
                 Assert.Throws<ObjectDisposedException>(() => pipe.WaitForConnection());
                 await Assert.ThrowsAsync<ObjectDisposedException>(() => pipe.WaitForConnectionAsync());
             }
@@ -473,12 +471,14 @@ public async Task DisposedClientPipe_Throws_ObjectDisposedException()
         {
             using (NamedPipePair pair = CreateNamedPipePair())
             {
+                pair.Connect();
                 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());
+                Assert.Throws<ObjectDisposedException>(() => pipe.NumberOfServerInstances);
             }
         }
 
@@ -512,6 +512,66 @@ public async Task Server_ReadWriteCancelledToken_Throws_OperationCanceledExcepti
             }
         }
 
+        [Fact]
+        [PlatformSpecific(PlatformID.Windows)]
+        public async Task CancelTokenOff_Server_ReadWriteCancelledToken_Throws_OperationCanceledException()
+        {
+            using (NamedPipePair pair = CreateNamedPipePair())
+            {
+                NamedPipeServerStream server = pair.serverStream;
+                byte[] buffer = new byte[] { 0, 0, 0, 0 };
+
+                pair.Connect();
+
+                if (server.CanRead)
+                {
+                    Task serverReadToken = server.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None);
+
+                    Assert.True(Interop.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
+                    await Assert.ThrowsAnyAsync<OperationCanceledException>(() => serverReadToken);
+                    Assert.True(serverReadToken.IsCanceled);
+                }
+                if (server.CanWrite)
+                {
+                    Task serverWriteToken = server.WriteAsync(buffer, 0, buffer.Length, CancellationToken.None);
+
+                    Assert.True(Interop.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
+                    await Assert.ThrowsAnyAsync<OperationCanceledException>(() => serverWriteToken);
+                    Assert.True(serverWriteToken.IsCanceled);
+                }
+            }
+        }
+
+        [Fact]
+        [PlatformSpecific(PlatformID.Windows)]
+        public async Task CancelTokenOn_Server_ReadWriteCancelledToken_Throws_IOException()
+        {
+            using (NamedPipePair pair = CreateNamedPipePair())
+            {
+                NamedPipeServerStream server = pair.serverStream;
+                byte[] buffer = new byte[] { 0, 0, 0, 0 };
+
+                pair.Connect();
+
+                if (server.CanRead)
+                {
+                    var cts = new CancellationTokenSource();
+                    Task serverReadToken = server.ReadAsync(buffer, 0, buffer.Length, cts.Token);
+
+                    Assert.True(Interop.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
+                    await Assert.ThrowsAsync<IOException>(() => serverReadToken);
+                }
+                if (server.CanWrite)
+                {
+                    var cts = new CancellationTokenSource();
+                    Task serverWriteToken = server.WriteAsync(buffer, 0, buffer.Length, cts.Token);
+
+                    Assert.True(Interop.CancelIoEx(server.SafePipeHandle), "Outer cancellation failed");
+                    await Assert.ThrowsAsync<IOException>(() => serverWriteToken);
+                }
+            }
+        }
+
         [Fact]
         [ActiveIssue(812, PlatformID.AnyUnix)] // the cancellation token is ignored after the operation is initiated, due to base Stream's implementation        
         public async Task Client_ReadWriteCancelledToken_Throws_OperationCanceledException()
@@ -540,6 +600,64 @@ public async Task Client_ReadWriteCancelledToken_Throws_OperationCanceledExcepti
                 }
             }
         }
+
+        [Fact]
+        [PlatformSpecific(PlatformID.Windows)]
+        public async Task CancelTokenOff_Client_ReadWriteCancelledToken_Throws_OperationCanceledException()
+        {
+            using (NamedPipePair pair = CreateNamedPipePair())
+            {
+                NamedPipeClientStream client = pair.clientStream;
+                byte[] buffer = new byte[] { 0, 0, 0, 0 };
+
+                pair.Connect();
+                if (client.CanRead)
+                {
+                    Task clientReadToken = client.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None);
+
+                    Assert.True(Interop.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(Interop.CancelIoEx(client.SafePipeHandle), "Outer cancellation failed");
+                    await Assert.ThrowsAnyAsync<OperationCanceledException>(() => clientWriteToken);
+                    Assert.True(clientWriteToken.IsCanceled);
+                }
+            }
+        }
+
+        [Fact]
+        [PlatformSpecific(PlatformID.Windows)]
+        public async Task CancelTokenOn_Client_ReadWriteCancelledToken_Throws_IOException()
+        {
+            using (NamedPipePair pair = CreateNamedPipePair())
+            {
+                NamedPipeClientStream client = pair.clientStream;
+                byte[] buffer = new byte[] { 0, 0, 0, 0 };
+
+                pair.Connect();
+                if (client.CanRead)
+                {
+                    var cts = new CancellationTokenSource();
+                    Task clientReadToken = client.ReadAsync(buffer, 0, buffer.Length, cts.Token);
+
+                    Assert.True(Interop.CancelIoEx(client.SafePipeHandle), "Outer cancellation failed");
+                    await Assert.ThrowsAsync<IOException>(() => clientReadToken);
+                }
+                if (client.CanWrite)
+                {
+                    var cts = new CancellationTokenSource();
+                    Task clientWriteToken = client.WriteAsync(buffer, 0, buffer.Length, cts.Token);
+
+                    Assert.True(Interop.CancelIoEx(client.SafePipeHandle), "Outer cancellation failed");
+                    await Assert.ThrowsAsync<IOException>(() => clientWriteToken);
+                }
+            }
+        }
     }
 
     public class NamedPipeTest_Simple_ServerInOutRead_ClientInOutWrite : NamedPipeTest_Simple
@@ -581,6 +699,7 @@ public override async Task OperationsOnDisconnectedClient()
                     await client.WriteAsync(buffer, 0, buffer.Length);
                     client.Flush();
                     Assert.Throws<InvalidOperationException>(() => client.IsMessageComplete);
+                    Assert.Throws<PlatformNotSupportedException>(() => client.NumberOfServerInstances);
                 }
             }
         }