Add more tests for System.Console

stephentoub · stephentoub · commit 6179876e78ea · 2015-06-18T14:38:45.000-04:00
This improves code coverage as much as we can reasonably, given the difficulty in automating certain console-related functionality in inner loop testing, e.g. allowing ctrl-c to take down the testing process.
diff --git a/src/System.Console/tests/CancelKeyPress.cs b/src/System.Console/tests/CancelKeyPress.cs
@@ -2,23 +2,66 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.Runtime.InteropServices;
+using System.Threading;
 using Xunit;
 
 public class CancelKeyPress
 {
+    private const int WaitFailTestTimeoutSeconds = 30;
+
     [Fact]
     public static void CanAddAndRemoveHandler()
     {
-        ConsoleCancelEventHandler handler = new ConsoleCancelEventHandler(Console_CancelKeyPress);
-
+        ConsoleCancelEventHandler handler = (sender, e) =>
+        {
+            // We don't actually want to do anything here.  This will only get called on the off chance
+            // that someone CTRL+C's the test run while the handler is hooked up.  This is just used to 
+            // validate that we can add and remove a handler, we don't care about exercising it.
+        };
         Console.CancelKeyPress += handler;
         Console.CancelKeyPress -= handler;
     }
 
-    static void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
+    [Fact]
+    [PlatformSpecific(PlatformID.AnyUnix)]
+    public static void InvokingCancelKeyPressHandler()
     {
-        // We don't actually want to do anything here.  This will only get called on the off chance
-        // that someone CTRL+C's the test run while the handler is hooked up.  This is just used to 
-        // validate that we can add and remove a handler, we don't care about exercising it.
+        // On Windows we could use GenerateConsoleCtrlEvent to send a ctrl-C to the process,
+        // however that'll apply to all processes associated with the same group, which will
+        // include processes like the code coverage tool when doing code coverage runs, causing
+        // those other processes to exit.  As such, we test this only on Unix, where we can
+        // send a SIGINT signal to this specific process only.
+
+        using (var mres = new ManualResetEventSlim())
+        {
+            ConsoleCancelEventHandler handler = (sender, e) => {
+                e.Cancel = true;
+                mres.Set();
+            };
+
+            Console.CancelKeyPress += handler;
+            try
+            {
+                Assert.Equal(0, kill(getpid(), SIGINT));
+                Assert.True(mres.Wait(WaitFailTestTimeoutSeconds));
+            }
+            finally
+            {
+                Console.CancelKeyPress -= handler;
+            }
+        }
     }
+
+    #region Unix Imports
+    // P/Invokes included here rather than being pulled from Interop\Unix
+    // to avoid platform-dependent includes in csproj
+    [DllImport("libc", SetLastError = true)]
+    private static extern int kill(int pid, int sig);
+
+    [DllImport("libc")]
+    private static extern int getpid();
+
+    private const int SIGINT = 2;
+    #endregion
 }
diff --git a/src/System.Console/tests/Color.cs b/src/System.Console/tests/Color.cs
@@ -9,6 +9,32 @@
 
 public class Color
 {
+    [Fact]
+    public static void InvalidColors()
+    {
+        Assert.Throws<ArgumentException>(() => Console.BackgroundColor = (ConsoleColor)42);
+        Assert.Throws<ArgumentException>(() => Console.ForegroundColor = (ConsoleColor)42);
+    }
+
+    [Fact]
+    public static void RoundtrippingColor()
+    {
+        if (Interop.IsWindows)
+        {
+            Console.BackgroundColor = Console.BackgroundColor;
+            Console.ForegroundColor = Console.ForegroundColor;
+            // Changing color on Windows doesn't have effect in some testing environments
+            // when there is no associated console, such as when run under a profiler like 
+            // our code coverage tools, so we don't assert that the change took place and 
+            // simple ensure that getting/setting doesn't throw.
+        }
+        else
+        {
+            Assert.Throws<PlatformNotSupportedException>(() => Console.BackgroundColor);
+            Assert.Throws<PlatformNotSupportedException>(() => Console.ForegroundColor);
+        }
+    }
+
     [Fact]
     [PlatformSpecific(PlatformID.AnyUnix)]
     public static void RedirectedOutputDoesNotUseAnsiSequences()
diff --git a/src/System.Console/tests/Helpers.cs b/src/System.Console/tests/Helpers.cs
@@ -11,7 +11,9 @@ public static void SetAndReadHelper(Action<TextWriter> setHelper, Func<TextWrite
     {
         const string TestString = "Test";
 
-        TextWriter oldErrorToRestore = getHelper();
+        TextWriter oldWriterToRestore = getHelper();
+        Assert.NotNull(oldWriterToRestore);
+
         try
         {
             using (MemoryStream memStream = new MemoryStream())
@@ -40,7 +42,7 @@ public static void SetAndReadHelper(Action<TextWriter> setHelper, Func<TextWrite
         }
         finally
         {
-            setHelper(oldErrorToRestore);
+            setHelper(oldWriterToRestore);
         }
     }
 }
diff --git a/src/System.Console/tests/ReadAndWrite.cs b/src/System.Console/tests/ReadAndWrite.cs
@@ -2,9 +2,9 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using System.Threading.Tasks;
 using Xunit;
 
 public class ReadAndWrite
@@ -97,6 +97,11 @@ private static void WriteCore()
 
     private static void WriteLineCore()
     {
+        Assert.Equal(Environment.NewLine, Console.Out.NewLine);
+        Console.Out.NewLine = "abcd";
+        Assert.Equal("abcd", Console.Out.NewLine);
+        Console.Out.NewLine = Environment.NewLine;
+
         // We just want to ensure none of these throw exceptions, we don't actually validate 
         // what was written.
 
@@ -126,6 +131,133 @@ private static void WriteLineCore()
         Console.WriteLine("Hello World");
     }
 
+    [Fact]
+    public static async Task OutWriteAndWriteLineOverloads()
+    {
+        TextWriter savedStandardOutput = Console.Out;
+        try
+        {
+            using (var sw = new StreamWriter(new MemoryStream()))
+            {
+                Console.SetOut(sw);
+                TextWriter writer = Console.Out;
+                Assert.NotNull(writer);
+                Assert.NotEqual(writer, sw); // the writer we provide gets wrapped
+
+                // We just want to ensure none of these throw exceptions, we don't actually validate 
+                // what was written.
+
+                writer.Write("{0}", 32);
+                writer.Write("{0} {1}", 32, "Hello");
+                writer.Write("{0} {1} {2}", 32, "Hello", (uint)50);
+                writer.Write("{0} {1} {2} {3}", 32, "Hello", (uint)50, (ulong)5);
+                writer.Write("{0} {1} {2} {3} {4}", 32, "Hello", (uint)50, (ulong)5, 'a');
+                writer.Write(true);
+                writer.Write('a');
+                writer.Write(new char[] { 'a', 'b', 'c', 'd', });
+                writer.Write(new char[] { 'a', 'b', 'c', 'd', }, 1, 2);
+                writer.Write(1.23d);
+                writer.Write(123.456M);
+                writer.Write(1.234f);
+                writer.Write(39);
+                writer.Write(50u);
+                writer.Write(50L);
+                writer.Write(50UL);
+                writer.Write(new object());
+                writer.Write("Hello World");
+
+                writer.Flush();
+
+                await writer.WriteAsync('c');
+                await writer.WriteAsync(new char[] { 'a', 'b', 'c', 'd' });
+                await writer.WriteAsync(new char[] { 'a', 'b', 'c', 'd' }, 1, 2);
+                await writer.WriteAsync("Hello World");
+
+                await writer.WriteLineAsync('c');
+                await writer.WriteLineAsync(new char[] { 'a', 'b', 'c', 'd' });
+                await writer.WriteLineAsync(new char[] { 'a', 'b', 'c', 'd' }, 1, 2);
+                await writer.WriteLineAsync("Hello World");
+
+                await writer.FlushAsync();
+            }
+        }
+        finally
+        {
+            Console.SetOut(savedStandardOutput);
+        }
+    }
+
+    [Fact]
+    public static unsafe void ValidateConsoleEncoding()
+    {
+        Assert.Same(Console.Out, Console.Out);
+
+        Encoding encoding = Console.Out.Encoding;
+        Assert.NotNull(encoding);
+        Assert.Same(encoding, Console.Out.Encoding);
+
+        // The primary purpose of ConsoleEncoding is to return an empty preamble.
+        Assert.Equal(Array.Empty<byte>(), encoding.GetPreamble());
+
+        // There's not much validation we can do, but we can at least invoke members
+        // to ensure they don't throw exceptions as they delegate to the underlying
+        // encoding wrapped by ConsoleEncoding.
+
+        Assert.False(string.IsNullOrWhiteSpace(encoding.EncodingName));
+        Assert.False(string.IsNullOrWhiteSpace(encoding.WebName));
+        Assert.True(encoding.CodePage >= 0);
+        bool ignored = encoding.IsSingleByte;
+
+        // And we can validate that the encoding is self-consistent by roundtripping
+        // data between chars and bytes.
+
+        string str = "This is the input string.";
+        char[] strAsChars = str.ToCharArray();
+        byte[] strAsBytes = encoding.GetBytes(str);
+        Assert.Equal(strAsBytes.Length, encoding.GetByteCount(str));
+        Assert.True(encoding.GetMaxByteCount(str.Length) >= strAsBytes.Length);
+
+        Assert.Equal(str, encoding.GetString(strAsBytes));
+        Assert.Equal(str, encoding.GetString(strAsBytes, 0, strAsBytes.Length));
+        Assert.Equal(str, new string(encoding.GetChars(strAsBytes)));
+        Assert.Equal(str, new string(encoding.GetChars(strAsBytes, 0, strAsBytes.Length)));
+        fixed (byte* bytesPtr = strAsBytes)
+        {
+            char[] outputArr = new char[encoding.GetMaxCharCount(strAsBytes.Length)];
+
+            int len = encoding.GetChars(strAsBytes, 0, strAsBytes.Length, outputArr, 0);
+            Assert.Equal(str, new string(outputArr, 0, len));
+            Assert.Equal(len, encoding.GetCharCount(strAsBytes));
+            Assert.Equal(len, encoding.GetCharCount(strAsBytes, 0, strAsBytes.Length));
+
+            fixed (char* charsPtr = outputArr)
+            {
+                len = encoding.GetChars(bytesPtr, strAsBytes.Length, charsPtr, outputArr.Length);
+                Assert.Equal(str, new string(charsPtr, 0, len));
+                Assert.Equal(len, encoding.GetCharCount(bytesPtr, strAsBytes.Length));
+            }
+
+            Assert.Equal(str, encoding.GetString(bytesPtr, strAsBytes.Length));
+        }
+
+        Assert.Equal(strAsBytes, encoding.GetBytes(strAsChars));
+        Assert.Equal(strAsBytes, encoding.GetBytes(strAsChars, 0, strAsChars.Length));
+        Assert.Equal(strAsBytes.Length, encoding.GetByteCount(strAsChars));
+        Assert.Equal(strAsBytes.Length, encoding.GetByteCount(strAsChars, 0, strAsChars.Length));
+        fixed (char* charsPtr = strAsChars)
+        {
+            Assert.Equal(strAsBytes.Length, encoding.GetByteCount(charsPtr, strAsChars.Length));
+
+            byte[] outputArr = new byte[encoding.GetMaxByteCount(strAsChars.Length)];
+            Assert.Equal(strAsBytes.Length, encoding.GetBytes(strAsChars, 0, strAsChars.Length, outputArr, 0));
+            fixed (byte* bytesPtr = outputArr)
+            {
+                Assert.Equal(strAsBytes.Length, encoding.GetBytes(charsPtr, strAsChars.Length, bytesPtr, outputArr.Length));
+            }
+            Assert.Equal(strAsBytes.Length, encoding.GetBytes(str, 0, str.Length, outputArr, 0));
+        }
+    }
+
     static readonly string[] s_testLines = new string[] {
         "3232 Hello32 Hello 5032 Hello 50 532 Hello 50 5 aTrueaabcdbc1.23123.4561.23439505050System.ObjectHello World",
         "32",
diff --git a/src/System.Console/tests/SyncTextReader.cs b/src/System.Console/tests/SyncTextReader.cs
@@ -66,8 +66,13 @@ private static void Test(string content, Action action)
         }
         finally
         {
+            TextWriter oldWriter = Console.Out;
             Console.SetOut(savedStandardOutput);
+            oldWriter.Dispose();
+
+            TextReader oldReader = Console.In;
             Console.SetIn(savedStandardInput);
+            oldReader.Dispose();
         }
     }
 
@@ -163,6 +168,12 @@ public void ReadBlockAsync()
             Assert.Equal(5, result);
             Assert.Equal(expected, buffer);
             Assert.Equal(-1, Console.Read()); // We should be at EOF now. 
+
+            // Invalid args
+            Assert.Throws<ArgumentNullException>(() => { Console.In.ReadBlockAsync(null, 0, 0); });
+            Assert.Throws<ArgumentOutOfRangeException>(() => { Console.In.ReadBlockAsync(new char[1], -1, 0); });
+            Assert.Throws<ArgumentOutOfRangeException>(() => { Console.In.ReadBlockAsync(new char[1], 0, -1); });
+            Assert.Throws<ArgumentException>(() => { Console.In.ReadBlockAsync(new char[1], 1, 1); });
         });
     }
 
@@ -181,6 +192,12 @@ public void ReadAsync()
             Assert.Equal(5, result);
             Assert.Equal(expected, buffer);
             Assert.Equal(-1, Console.Read()); // We should be at EOF now.
+
+            // Invalid args
+            Assert.Throws<ArgumentNullException>(() => { Console.In.ReadAsync(null, 0, 0); });
+            Assert.Throws<ArgumentOutOfRangeException>(() => { Console.In.ReadAsync(new char[1], -1, 0); });
+            Assert.Throws<ArgumentOutOfRangeException>(() => { Console.In.ReadAsync(new char[1], 0, -1); });
+            Assert.Throws<ArgumentException>(() => { Console.In.ReadAsync(new char[1], 1, 1); });
         });
     }
 
diff --git a/src/System.Console/tests/System.Console.Tests.csproj b/src/System.Console/tests/System.Console.Tests.csproj
@@ -8,12 +8,11 @@
     <OutputType>Library</OutputType>
     <AssemblyName>System.Console.Tests</AssemblyName>
     <RootNamespace>System.Console.Tests</RootNamespace>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU'" />
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU'" />
   <ItemGroup>
     <Compile Include="CancelKeyPress.cs" />
     <Compile Include="Helpers.cs" />
@@ -27,6 +26,7 @@
     <Compile Include="Timeout.cs" />
     <Compile Include="ThreadSafety.cs" />
     <Compile Include="XunitAssemblyAttributes.cs" />
+    <Compile Include="$(CommonPath)\Interop\Interop.PlatformDetection.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\src\System.Console.csproj">

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,9 @@ public static void SetAndReadHelper(Action<TextWriter> setHelper, Func<TextWrite`
`11`	`11`	`{`
`12`	`12`	`const string TestString = "Test";`
`13`	`13`
`14`		`- TextWriter oldErrorToRestore = getHelper();`
	`14`	`+ TextWriter oldWriterToRestore = getHelper();`
	`15`	`+ Assert.NotNull(oldWriterToRestore);`
	`16`	`+`
`15`	`17`	`try`
`16`	`18`	`{`
`17`	`19`	`using (MemoryStream memStream = new MemoryStream())`
`@@ -40,7 +42,7 @@ public static void SetAndReadHelper(Action<TextWriter> setHelper, Func<TextWrite`
`40`	`42`	`}`
`41`	`43`	`finally`
`42`	`44`	`{`
`43`		`- setHelper(oldErrorToRestore);`
	`45`	`+ setHelper(oldWriterToRestore);`
`44`	`46`	`}`
`45`	`47`	`}`
`46`	`48`	`}`