Reworked the tests for System.IO.Pipes

I made a number of changes to our current Pipes tests and added several hundred new tests for edge cases that were previously ignored, particularly with Named Pipes defined with an InOut PipeDirection

- Refactored the great Throws tests currently in place to allow testing pipes with all in/out direction combinations for both Named pipes as well as Anonymous pipes
- Replaced all relevant hardcoded pipe names with unique values
- Reorganized the tests to use more inheritance and share more code for easy extensibility
- All test classes are now in the same namespace: System.IO.Pipes.Tests
- Expanded tests for InOut NamedPipes and made all existing In/Out tests also test all valid InOut combinations.
- Split the Named and Anonymous tests into two separate folders: NamedPipeTest and AnonymousPipeTest
- Increased code coverage across all test classes

Author: Ian Hays

src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.cs

@@ -108,6 +108,9 @@ private NamedPipeServerStream(String pipeName, PipeDirection direction, int maxN
             {
                 throw new ArgumentOutOfRangeException("maxNumberOfServerInstances", SR.ArgumentOutOfRange_MaxNumServerInstances);
             }
+            // inheritability will always be None since this private constructor is only called from other constructors from which
+            // inheritability is always set to None. Desktop has a public constructor to allow setting it to something else, but Core
+            // doesnt.
             if (inheritability < HandleInheritability.None || inheritability > HandleInheritability.Inheritable)
             {
                 throw new ArgumentOutOfRangeException("inheritability", SR.ArgumentOutOfRange_HandleInheritabilityNoneOrInheritable);

src/System.IO.Pipes/tests/AnonymousPipeTests/AnonymousPipeTest.CreateClient.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Pipes.Tests
+{
+    /// <summary>
+    /// Tests for the constructors of AnonymousPipeClientStream
+    /// </summary>
+    public class AnonymousPipeTest_CreateClient : AnonymousPipeTestBase
+    {
+        [Fact]
+        public static void NullParameters_Throws_ArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>("pipeHandleAsString", () => new AnonymousPipeClientStream((string)null));
+            Assert.Throws<ArgumentNullException>("pipeHandleAsString", () => new AnonymousPipeClientStream(PipeDirection.Out, (string)null));
+            Assert.Throws<ArgumentNullException>("safePipeHandle", () => new AnonymousPipeClientStream(PipeDirection.In, (SafePipeHandle)null));
+        }
+
+        [Fact]
+        public static void CreateClientStreamFromStringHandle_Valid()
+        {
+            using (var server = new AnonymousPipeServerStream(PipeDirection.Out))
+            using (var client = new AnonymousPipeClientStream(server.GetClientHandleAsString()))
+            { }
+        }
+
+        [Theory]
+        [InlineData("abc")]
+        [InlineData("-1")]
+        public static void InvalidStringParameters_Throws_ArgumentException(string handle)
+        {
+            // Parameters must be nonnegative numeric characters
+            Assert.Throws<ArgumentException>("pipeHandleAsString", () => new AnonymousPipeClientStream(handle));
+            Assert.Throws<ArgumentException>("pipeHandleAsString", () => new AnonymousPipeClientStream(PipeDirection.Out, handle));
+        }
+
+        [Fact]
+        public static void InvalidPipeHandle_Throws_ArgumentException()
+        {
+            SafePipeHandle pipeHandle = new SafePipeHandle(new IntPtr(-1), true);
+            Assert.Throws<ArgumentException>("safePipeHandle", () => new AnonymousPipeClientStream(PipeDirection.In, pipeHandle));
+        }
+
+        [Fact]
+        public static void InOutPipeDirection_Throws_NotSupportedException()
+        {
+            // Anonymous pipes can't be made with PipeDirection.InOut
+            Assert.Throws<NotSupportedException>(() => new AnonymousPipeClientStream(PipeDirection.InOut, "123"));
+
+            SafePipeHandle pipeHandle = new SafePipeHandle(new IntPtr(-1), true);
+            Assert.Throws<NotSupportedException>(() => new AnonymousPipeClientStream(PipeDirection.InOut, pipeHandle));
+        }
+    }
+}

src/System.IO.Pipes/tests/AnonymousPipeTests/AnonymousPipeTest.CreateServer.cs

@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.IO.Pipes.Tests
+{
+    /// <summary>
+    /// Tests for the constructors of AnonymousPipeServerStream
+    /// </summary>
+    public class AnonymousPipeTest_CreateServer : AnonymousPipeTestBase
+    {
+        [Fact]
+        public static void InOutPipeDirection_Throws_NotSupportedException()
+        {
+            Assert.Throws<NotSupportedException>(() => new AnonymousPipeServerStream(PipeDirection.InOut));
+            Assert.Throws<NotSupportedException>(() => new AnonymousPipeServerStream(PipeDirection.InOut, HandleInheritability.None));
+            Assert.Throws<NotSupportedException>(() => new AnonymousPipeServerStream(PipeDirection.InOut, HandleInheritability.None, 500));
+
+            using (AnonymousPipeServerStream dummyserver = new AnonymousPipeServerStream(PipeDirection.Out))
+            {
+                Assert.Throws<NotSupportedException>(() => new AnonymousPipeServerStream(PipeDirection.InOut, dummyserver.SafePipeHandle, null));
+            }
+
+            using (AnonymousPipeServerStream dummyserver = new AnonymousPipeServerStream(PipeDirection.In))
+            {
+                Assert.Throws<NotSupportedException>(() => new AnonymousPipeServerStream(PipeDirection.InOut, dummyserver.SafePipeHandle, null));
+            }
+        }
+
+        [Theory]
+        [InlineData(PipeDirection.In, 999)]
+        [InlineData(PipeDirection.Out, 999)]
+        public static void ServerBadInheritabilityThrows(PipeDirection direction, HandleInheritability inheritability)
+        {
+            Assert.Throws<ArgumentOutOfRangeException>("inheritability", () => new AnonymousPipeServerStream(direction, inheritability));
+            Assert.Throws<ArgumentOutOfRangeException>("inheritability", () => new AnonymousPipeServerStream(direction, inheritability, 500));
+        }
+
+        [Theory]
+        [InlineData(PipeDirection.In, -500)]
+        [InlineData(PipeDirection.Out, -500)]
+        [InlineData(PipeDirection.InOut, -500)] //bufferSize will cause an exception before InOut will
+        public static void InvalidBufferSize_Throws_ArgumentOutOfRangeException(PipeDirection direction, int bufferSize)
+        {
+            Assert.Throws<ArgumentOutOfRangeException>("bufferSize", () => new AnonymousPipeServerStream(direction, HandleInheritability.None, bufferSize));
+        }
+
+        [Fact]
+        public static void InvalidPipeDirection_Throws_ArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>("direction", () => new AnonymousPipeServerStream((PipeDirection)123, HandleInheritability.None, 500));
+            Assert.Throws<ArgumentOutOfRangeException>("direction", () => new AnonymousPipeServerStream((PipeDirection)123, (HandleInheritability)999, -500));
+            Assert.Throws<ArgumentOutOfRangeException>("direction", () => new AnonymousPipeServerStream((PipeDirection)123, HandleInheritability.None, - 500));
+        }
+
+        [Fact]
+        public static void InvalidPipeHandle_Throws()
+        {
+            using (AnonymousPipeServerStream dummyserver = new AnonymousPipeServerStream(PipeDirection.Out))
+            {
+                Assert.Throws<ArgumentNullException>("serverSafePipeHandle", () => new AnonymousPipeServerStream(PipeDirection.Out, null, dummyserver.ClientSafePipeHandle));
+
+                Assert.Throws<ArgumentNullException>("clientSafePipeHandle", () => new AnonymousPipeServerStream(PipeDirection.Out, dummyserver.SafePipeHandle, null));
+
+                SafePipeHandle pipeHandle = new SafePipeHandle(new IntPtr(-1), true);
+                Assert.Throws<ArgumentException>("serverSafePipeHandle", () => new AnonymousPipeServerStream(PipeDirection.Out, pipeHandle, dummyserver.ClientSafePipeHandle));
+
+                Assert.Throws<ArgumentException>("clientSafePipeHandle", () => new AnonymousPipeServerStream(PipeDirection.Out, dummyserver.SafePipeHandle, pipeHandle));
+            }
+        }
+
+        [Fact]
+        public static void ValidConstructors()
+        {
+            new AnonymousPipeServerStream().Dispose();
+            new AnonymousPipeServerStream(PipeDirection.Out).Dispose();
+            new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None).Dispose();
+            new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None, 0).Dispose();
+        }
+    }
+}

src/System.IO.Pipes/tests/AnonymousPipeTests/AnonymousPipeTest.Read.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Xunit;
+
+namespace System.IO.Pipes.Tests
+{
+    public class AnonymousPipeTest_Read_ServerIn_ClientOut : PipeTest_Read
+    {
+        protected override ServerClientPair CreateServerClientPair()
+        {
+            ServerClientPair ret = new ServerClientPair();
+            ret.readablePipe = new AnonymousPipeServerStream(PipeDirection.In);
+            ret.writeablePipe = new AnonymousPipeClientStream(PipeDirection.Out, ((AnonymousPipeServerStream)ret.readablePipe).ClientSafePipeHandle);
+            return ret;
+        }
+    }
+
+    public class AnonymousPipeTest_Read_ServerOut_ClientIn : PipeTest_Read
+    {
+        protected override ServerClientPair CreateServerClientPair()
+        {
+            ServerClientPair ret = new ServerClientPair();
+            ret.writeablePipe = new AnonymousPipeServerStream(PipeDirection.Out);
+            ret.readablePipe = new AnonymousPipeClientStream(PipeDirection.In, ((AnonymousPipeServerStream)ret.writeablePipe).ClientSafePipeHandle);
+            return ret;
+        }
+    }
+}

src/System.IO.Pipes/tests/AnonymousPipeTests/AnonymousPipeTest.Specific.cs

@@ -0,0 +1,181 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Xunit;
+
+namespace System.IO.Pipes.Tests
+{
+    /// <summary>
+    /// The Specific AnonymousPipe tests cover edge cases or otherwise narrow cases that
+    /// show up within particular server/client directional combinations.
+    /// </summary>
+    public class AnonymousPipeTest_Specific : AnonymousPipeTestBase
+    {
+        [Fact]
+        public static void DisposeLocalCopyOfClientHandle_BeforeServerRead()
+        {
+            using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
+            {
+                using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.Out, server.ClientSafePipeHandle))
+                {
+                    byte[] sent = new byte[] { 123 };
+                    byte[] received = new byte[] { 0 };
+                    client.Write(sent, 0, 1);
+
+                    server.DisposeLocalCopyOfClientHandle();
+
+                    Assert.Equal(1, server.Read(received, 0, 1));
+                    Assert.Equal(sent[0], received[0]);
+                }
+            }
+        }
+
+        [Fact]
+        public static void ClonedServer_ActsAsOriginalServer()
+        {
+            using (AnonymousPipeServerStream serverBase = new AnonymousPipeServerStream(PipeDirection.Out))
+            {
+                using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, serverBase.SafePipeHandle, serverBase.ClientSafePipeHandle))
+                {
+                    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<IOException>(() => server.WriteByte(5));
+                }
+            }
+        }
+
+        [Fact]
+        public static void ClonedClient_ActsAsOriginalClient()
+        {
+            using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
+            {
+                using (AnonymousPipeClientStream clientBase = new AnonymousPipeClientStream(PipeDirection.In, server.GetClientHandleAsString()))
+                {
+                    using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, clientBase.SafePipeHandle))
+                    {
+                        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]);
+                    }
+                }
+            }
+        }
+
+        [Fact]
+        [PlatformSpecific(PlatformID.Linux)]
+        public static void Linux_BufferSizeRoundtrips()
+        {
+            // On Linux, setting the buffer size of the server will also set the buffer size of the
+            // client, regardless of the direction of the flow
+
+            int desiredBufferSize;
+            using (var server = new AnonymousPipeServerStream(PipeDirection.Out))
+            {
+                desiredBufferSize = server.OutBufferSize * 2;
+                Assert.True(desiredBufferSize > 0);
+            }
+
+            using (var server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None, desiredBufferSize))
+            using (var client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle))
+            {
+                Assert.Equal(desiredBufferSize, server.OutBufferSize);
+                Assert.Equal(desiredBufferSize, client.InBufferSize);
+            }
+
+            using (var server = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.None, desiredBufferSize))
+            using (var client = new AnonymousPipeClientStream(PipeDirection.Out, server.ClientSafePipeHandle))
+            {
+                Assert.Equal(desiredBufferSize, server.InBufferSize);
+                Assert.Equal(desiredBufferSize, client.OutBufferSize);
+            }
+        }
+
+        [Fact]
+        [PlatformSpecific(~PlatformID.Linux)]
+        public static void BufferSizeRoundtripping()
+        {
+            // On systems other than Linux, setting the buffer size of the server will only set
+            // set the buffer size of the client if the flow of the pipe is towards the client i.e.
+            // the client is defined with PipeDirection.In
+
+            int desiredBufferSize = 10;
+            using (var server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None, desiredBufferSize))
+            using (var client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle))
+            {
+                Assert.Equal(desiredBufferSize, server.OutBufferSize);
+                Assert.Equal(desiredBufferSize, client.InBufferSize);
+            }
+
+            using (var server = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.None, desiredBufferSize))
+            using (var client = new AnonymousPipeClientStream(PipeDirection.Out, server.ClientSafePipeHandle))
+            {
+                Assert.Equal(desiredBufferSize, server.InBufferSize);
+                Assert.Equal(0, client.OutBufferSize);
+            }
+        }
+
+        [Fact]
+        public void PipeTransmissionMode_Returns_Byte()
+        {
+            using (ServerClientPair pair = CreateServerClientPair())
+            {
+                Assert.Equal(PipeTransmissionMode.Byte, pair.writeablePipe.TransmissionMode);
+                Assert.Equal(PipeTransmissionMode.Byte, pair.readablePipe.TransmissionMode);
+            }
+        }
+
+        [Theory]
+        [InlineData(PipeDirection.Out, PipeDirection.In)]
+        [InlineData(PipeDirection.In, PipeDirection.Out)]
+        public void ReadModeToByte_Accepted(PipeDirection serverDirection, PipeDirection clientDirection)
+        {
+            using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(serverDirection))
+            using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(clientDirection, server.GetClientHandleAsString()))
+            {
+                server.ReadMode = PipeTransmissionMode.Byte;
+                client.ReadMode = PipeTransmissionMode.Byte;
+                Assert.Equal(PipeTransmissionMode.Byte, server.ReadMode);
+                Assert.Equal(PipeTransmissionMode.Byte, client.ReadMode);
+            }
+        }
+
+        [Fact]
+        public void MessageReadMode_Throws_NotSupportedException()
+        {
+            using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
+            using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.GetClientHandleAsString()))
+            {
+                Assert.Throws<NotSupportedException>(() => server.ReadMode = PipeTransmissionMode.Message);
+                Assert.Throws<NotSupportedException>(() => client.ReadMode = PipeTransmissionMode.Message);
+            }
+        }
+
+        [Fact]
+        public void InvalidReadMode_Throws_ArgumentOutOfRangeException()
+        {
+            using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
+            using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.GetClientHandleAsString()))
+            {
+                Assert.Throws<ArgumentOutOfRangeException>(() => server.ReadMode = (PipeTransmissionMode)999);
+                Assert.Throws<ArgumentOutOfRangeException>(() => client.ReadMode = (PipeTransmissionMode)999);
+            }
+        }
+    }
+}

src/System.IO.Pipes/tests/AnonymousPipeTests/AnonymousPipeTest.Write.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Xunit;
+
+namespace System.IO.Pipes.Tests
+{
+    public class AnonymousPipeTest_Write_ServerIn_ClientOut : PipeTest_Write
+    {
+        protected override ServerClientPair CreateServerClientPair()
+        {
+            ServerClientPair ret = new ServerClientPair();
+            ret.readablePipe = new AnonymousPipeServerStream(PipeDirection.In);
+            ret.writeablePipe = new AnonymousPipeClientStream(PipeDirection.Out, ((AnonymousPipeServerStream)ret.readablePipe).ClientSafePipeHandle);
+            return ret;
+        }
+    }
+
+    public class AnonymousPipeTest_Write_ServerOut_ClientIn : PipeTest_Write
+    {
+        protected override ServerClientPair CreateServerClientPair()
+        {
+            ServerClientPair ret = new ServerClientPair();
+            ret.writeablePipe = new AnonymousPipeServerStream(PipeDirection.Out);
+            ret.readablePipe = new AnonymousPipeClientStream(PipeDirection.In, ((AnonymousPipeServerStream)ret.writeablePipe).ClientSafePipeHandle);
+            return ret;
+        }
+    }
+}