Merge pull request #2067 from stephentoub/console_tests

Add more tests for System.Console

Author: stephentoub

src/System.Console/src/System/IO/SyncTextReader.cs

@@ -1,35 +1,23 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System;
-using System.IO;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Globalization;
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics;
 using System.Diagnostics.Contracts;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
 
 namespace System.IO
 {
     internal sealed class SyncTextReader : TextReader
     {
-        internal TextReader _in;
+        private readonly TextReader _in;
         private readonly object _methodLock = new object();
 
-        public static TextReader GetSynchronizedTextReader(TextReader reader)
+        public static SyncTextReader GetSynchronizedTextReader(TextReader reader)
         {
-            if (reader == null)
-                throw new ArgumentNullException("reader");
-            Contract.Ensures(Contract.Result<TextReader>() != null);
-            Contract.EndContractBlock();
-
-            if (reader is SyncTextReader)
-                return reader;
-
-            return new SyncTextReader(reader);
+            Debug.Assert(reader != null);
+            return reader as SyncTextReader ?? 
+                new SyncTextReader(reader);
         }
 
         internal SyncTextReader(TextReader t)

src/System.Console/src/System/IO/SyncTextWriter.cs

@@ -1,9 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System.Diagnostics.CodeAnalysis;
-using System.Diagnostics.Contracts;
-using System.Runtime.InteropServices;
+using System.Diagnostics;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -14,15 +12,10 @@ internal sealed class SyncTextWriter : TextWriter, IDisposable
         private readonly object _methodLock = new object();
         internal readonly TextWriter _out;
 
-        internal static TextWriter GetSynchronizedTextWriter(TextWriter writer)
+        internal static SyncTextWriter GetSynchronizedTextWriter(TextWriter writer)
         {
-            if (writer == null)
-                throw new ArgumentNullException("writer");
-            Contract.Ensures(Contract.Result<TextWriter>() != null);
-            Contract.EndContractBlock();
-
-            return writer is SyncTextWriter ?
-                writer :
+            Debug.Assert(writer != null);
+            return writer as SyncTextWriter ?? 
                 new SyncTextWriter(writer);
         }
 

src/System.Console/src/System/Text/ConsoleEncoding.cs

@@ -22,6 +22,21 @@ public override byte[] GetPreamble()
             return Array.Empty<byte>();
         }
 
+        public override int CodePage
+        {
+            get { return _encoding.CodePage; }
+        }
+
+        public override bool IsSingleByte
+        {
+            get { return _encoding.IsSingleByte; }
+        }
+
+        public override string EncodingName
+        {
+            get { return _encoding.EncodingName; }
+        }
+
         public override string WebName
         {
             get { return _encoding.WebName; }
@@ -32,6 +47,11 @@ public override int GetByteCount(char[] chars)
             return _encoding.GetByteCount(chars);
         }
 
+        public override unsafe int GetByteCount(char* chars, int count)
+        {
+            return _encoding.GetByteCount(chars, count);
+        }
+
         public override int GetByteCount(char[] chars, int index, int count)
         {
             return _encoding.GetByteCount(chars, index, count);
@@ -42,6 +62,11 @@ public override int GetByteCount(string s)
             return _encoding.GetByteCount(s);
         }
 
+        public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
+        {
+            return _encoding.GetBytes(chars, charCount, bytes, byteCount);
+        }
+
         public override byte[] GetBytes(char[] chars)
         {
             return _encoding.GetBytes(chars);
@@ -67,6 +92,11 @@ public override int GetBytes(string s, int charIndex, int charCount, byte[] byte
             return _encoding.GetBytes(s, charIndex, charCount, bytes, byteIndex);
         }
 
+        public override unsafe int GetCharCount(byte* bytes, int count)
+        {
+            return _encoding.GetCharCount(bytes, count);
+        }
+
         public override int GetCharCount(byte[] bytes)
         {
             return _encoding.GetCharCount(bytes);
@@ -77,6 +107,11 @@ public override int GetCharCount(byte[] bytes, int index, int count)
             return _encoding.GetCharCount(bytes, index, count);
         }
 
+        public override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
+        {
+            return _encoding.GetChars(bytes, byteCount, chars, charCount);
+        }
+
         public override char[] GetChars(byte[] bytes)
         {
             return _encoding.GetChars(bytes);
@@ -112,9 +147,14 @@ public override int GetMaxCharCount(int byteCount)
             return _encoding.GetMaxCharCount(byteCount);
         }
 
+        public override string GetString(byte[] bytes)
+        {
+            return _encoding.GetString(bytes);
+        }
+
         public override string GetString(byte[] bytes, int index, int count)
         {
             return _encoding.GetString(bytes, index, count);
         }
     }
-}
+}

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
 }

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()

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);
         }
     }
 }