NUnitExtensions: Add a NUnitLogger

Add an NUnitLogger, based on the example given in [1], and documentation from Microsoft in [2]. When logging, it might be tempting to use `.AddConsole()`, but NUnit can't log the console reliably, and results in missing output, or output in the wrong test case. Using NUnit.TestContext.Write() resolves this problem and allows your test cases to log to NUnit.

[1] nunit/nunit#3919 (comment)
[2] https://docs.microsoft.com/en-us/dotnet/core/extensions/custom-logging-provider

The code itself doesn't have a direct dependency to NUnit.Framework, but pulls it in via reflection. This allows the user to have the library automaticall adapt to NUnit 2.x or NUnit 3.x (they're similar, but not compatible and otherwise both can't be used at the same time).

Issue: DOTNET-382

Author: jcurl

CodeQuality/NUnitExtensions/Deploy.cs

@@ -88,24 +88,6 @@ public static class Deploy
         private const int CopyWaitInterval = 250;
         private const int CopyWaitAttempts = 4;
 
-        private readonly static object s_TestContextLock = new object();
-        private static TestContextAccessor s_TestContextAccessor;
-
-        private static TestContextAccessor TestContext
-        {
-            get
-            {
-                if (s_TestContextAccessor == null) {
-                    lock (s_TestContextLock) {
-                        if (s_TestContextAccessor == null) {
-                            s_TestContextAccessor = TestContextAccessor.GetTestContext();
-                        }
-                    }
-                }
-                return s_TestContextAccessor;
-            }
-        }
-
         /// <summary>
         /// Gets the NUnit test directory.
         /// </summary>
@@ -124,7 +106,7 @@ private static TestContextAccessor TestContext
         /// </exception>
         public static string TestDirectory
         {
-            get { return TestContext.TestDirectory ?? string.Empty; }
+            get { return TestContextAccessor.Instance.TestDirectory ?? string.Empty; }
         }
 
         /// <summary>
@@ -145,7 +127,7 @@ public static string TestDirectory
         /// </exception>
         public static string WorkDirectory
         {
-            get { return TestContext.WorkDirectory ?? string.Empty; }
+            get { return TestContextAccessor.Instance.WorkDirectory ?? string.Empty; }
         }
 
         private static string WorkDirectoryAbsolute
@@ -164,7 +146,7 @@ private static string WorkDirectoryAbsolute
         /// <value>The name of the test.</value>
         public static string TestName
         {
-            get { return TestContext.TestName ?? string.Empty; }
+            get { return TestContextAccessor.Instance.TestName ?? string.Empty; }
         }
 
         /// <summary>
@@ -173,7 +155,7 @@ public static string TestName
         /// <value>The full name of the test.</value>
         public static string TestFullName
         {
-            get { return TestContext.TestFullName ?? string.Empty; }
+            get { return TestContextAccessor.Instance.TestFullName ?? string.Empty; }
         }
 
         /// <summary>

CodeQuality/NUnitExtensions/TestContextAccessor+WriteConsole.cs

@@ -0,0 +1,76 @@
+namespace RJCP.CodeQuality.NUnitExtensions
+{
+    using System;
+
+    internal partial class TestContextAccessor
+    {
+        private static class WriteConsole
+        {
+            public static void Write(ulong value) { Console.Write(value); }
+
+            public static void Write(uint value) { Console.Write(value); }
+
+            public static void Write(string value) { Console.Write(value); }
+
+            public static void Write(float value) { Console.Write(value); }
+
+            public static void Write(object value) { Console.Write(value); }
+
+            public static void Write(decimal value) { Console.Write(value); }
+
+            public static void Write(long value) { Console.Write(value); }
+
+            public static void Write(int value) { Console.Write(value); }
+
+            public static void Write(double value) { Console.Write(value); }
+
+            public static void Write(char[] value) { Console.Write(value); }
+
+            public static void Write(char value) { Console.Write(value); }
+
+            public static void Write(bool value) { Console.Write(value); }
+
+            public static void Write(string format, object arg1) { Console.Write(format, arg1); }
+
+            public static void Write(string format, object arg1, object arg2) { Console.Write(format, arg1, arg2); }
+
+            public static void Write(string format, object arg1, object arg2, object arg3) { Console.Write(format, arg1, arg2, arg3); }
+
+            public static void Write(string format, params object[] args) { Console.Write(format, args); }
+
+            public static void WriteLine() { Console.WriteLine(); }
+
+            public static void WriteLine(ulong value) { Console.WriteLine(value); }
+
+            public static void WriteLine(uint value) { Console.WriteLine(value); }
+
+            public static void WriteLine(string value) { Console.WriteLine(value); }
+
+            public static void WriteLine(float value) { Console.WriteLine(value); }
+
+            public static void WriteLine(object value) { Console.WriteLine(value); }
+
+            public static void WriteLine(decimal value) { Console.WriteLine(value); }
+
+            public static void WriteLine(long value) { Console.WriteLine(value); }
+
+            public static void WriteLine(int value) { Console.WriteLine(value); }
+
+            public static void WriteLine(double value) { Console.WriteLine(value); }
+
+            public static void WriteLine(char[] value) { Console.WriteLine(value); }
+
+            public static void WriteLine(char value) { Console.WriteLine(value); }
+
+            public static void WriteLine(bool value) { Console.WriteLine(value); }
+
+            public static void WriteLine(string format, object arg1) { Console.WriteLine(format, arg1); }
+
+            public static void WriteLine(string format, object arg1, object arg2) { Console.WriteLine(format, arg1, arg2); }
+
+            public static void WriteLine(string format, object arg1, object arg2, object arg3) { Console.WriteLine(format, arg1, arg2, arg3); }
+
+            public static void WriteLine(string format, params object[] args) { Console.WriteLine(format, args); }
+        }
+    }
+}

CodeQuality/NUnitExtensions/TestContextAccessor.cs

@@ -5,9 +5,27 @@
     using System.IO;
     using System.Reflection;
 
-    internal class TestContextAccessor
+    internal partial class TestContextAccessor
     {
-        public static TestContextAccessor GetTestContext()
+        private static readonly object s_Lock = new object();
+        private static TestContextAccessor s_TestContext;
+
+        public static TestContextAccessor Instance
+        {
+            get
+            {
+                if (s_TestContext == null) {
+                    lock (s_Lock) {
+                        if (s_TestContext == null) {
+                            s_TestContext = Create();
+                        }
+                    }
+                }
+                return s_TestContext;
+            }
+        }
+
+        private static TestContextAccessor Create()
         {
             Assembly nUnitAssembly;
 
@@ -102,6 +120,8 @@ private TestContextAccessor(Assembly nUnitAssembly)
                     }
                 }
             }
+
+            InitWriteAccessor(currentContext);
         }
 
         private static PrivateObject GetCurrentContext(Assembly nUnitAssembly)
@@ -131,5 +151,197 @@ private TestAccessor Test
         public string TestName { get { return Test.Name; } }
 
         public string TestFullName { get { return Test.FullName; } }
+
+        #region Write via Reflection
+        private Action<ulong> m_WriteUlong;
+        private Action<uint> m_WriteUint;
+        private Action<string> m_WriteString;
+        private Action<float> m_WriteFloat;
+        private Action<object> m_WriteObject;
+        private Action<decimal> m_WriteDecimal;
+        private Action<long> m_WriteLong;
+        private Action<int> m_WriteInt;
+        private Action<double> m_WriteDouble;
+        private Action<char[]> m_WriteCharArray;
+        private Action<char> m_WriteChar;
+        private Action<bool> m_WriteBool;
+        private Action<string, object> m_WriteFormat1;
+        private Action<string, object, object> m_WriteFormat2;
+        private Action<string, object, object, object> m_WriteFormat3;
+        private Action<string, object[]> m_WriteFormatS;
+
+        private Action m_WriteLine;
+        private Action<ulong> m_WriteLineUlong;
+        private Action<uint> m_WriteLineUint;
+        private Action<string> m_WriteLineString;
+        private Action<float> m_WriteLineFloat;
+        private Action<object> m_WriteLineObject;
+        private Action<decimal> m_WriteLineDecimal;
+        private Action<long> m_WriteLineLong;
+        private Action<int> m_WriteLineInt;
+        private Action<double> m_WriteLineDouble;
+        private Action<char[]> m_WriteLineCharArray;
+        private Action<char> m_WriteLineChar;
+        private Action<bool> m_WriteLineBool;
+        private Action<string, object> m_WriteLineFormat1;
+        private Action<string, object, object> m_WriteLineFormat2;
+        private Action<string, object, object, object> m_WriteLineFormat3;
+        private Action<string, object[]> m_WriteLineFormatS;
+
+        private void InitWriteAccessor(PrivateObject currentContext)
+        {
+            m_WriteUlong = GetDelegate<ulong>(currentContext.RealType, nameof(Write));
+            m_WriteUint = GetDelegate<uint>(currentContext.RealType, nameof(Write));
+            m_WriteString = GetDelegate<string>(currentContext.RealType, nameof(Write));
+            m_WriteFloat = GetDelegate<float>(currentContext.RealType, nameof(Write));
+            m_WriteObject = GetDelegate<object>(currentContext.RealType, nameof(Write));
+            m_WriteDecimal = GetDelegate<decimal>(currentContext.RealType, nameof(Write));
+            m_WriteLong = GetDelegate<long>(currentContext.RealType, nameof(Write));
+            m_WriteInt = GetDelegate<int>(currentContext.RealType, nameof(Write));
+            m_WriteDouble = GetDelegate<double>(currentContext.RealType, nameof(Write));
+            m_WriteCharArray = GetDelegate<char[]>(currentContext.RealType, nameof(Write));
+            m_WriteChar = GetDelegate<char>(currentContext.RealType, nameof(Write));
+            m_WriteBool = GetDelegate<bool>(currentContext.RealType, nameof(Write));
+
+            MethodInfo methodInfoArgs1 = currentContext.RealType.GetMethod(nameof(Write), new Type[] { typeof(string), typeof(object) });
+            if (methodInfoArgs1 == null)
+                methodInfoArgs1 = typeof(WriteConsole).GetMethod(nameof(Write), new Type[] { typeof(string), typeof(object) });
+            m_WriteFormat1 = (Action<string, object>)Delegate.CreateDelegate(typeof(Action<string, object>), methodInfoArgs1);
+
+            MethodInfo methodInfoArgs2 = currentContext.RealType.GetMethod(nameof(Write), new Type[] { typeof(string), typeof(object), typeof(object) });
+            if (methodInfoArgs2 == null)
+                methodInfoArgs2 = typeof(WriteConsole).GetMethod(nameof(Write), new Type[] { typeof(string), typeof(object), typeof(object) });
+            m_WriteFormat2 = (Action<string, object, object>)Delegate.CreateDelegate(typeof(Action<string, object, object>), methodInfoArgs2);
+
+            MethodInfo methodInfoArgs3 = currentContext.RealType.GetMethod(nameof(Write), new Type[] { typeof(string), typeof(object), typeof(object), typeof(object) });
+            if (methodInfoArgs3 == null)
+                methodInfoArgs3 = typeof(WriteConsole).GetMethod(nameof(Write), new Type[] { typeof(string), typeof(object), typeof(object), typeof(object) });
+            m_WriteFormat3 = (Action<string, object, object, object>)Delegate.CreateDelegate(typeof(Action<string, object, object, object>), methodInfoArgs3);
+
+            MethodInfo methodInfoArgsS = currentContext.RealType.GetMethod(nameof(Write), new Type[] { typeof(string), typeof(object[]) });
+            if (methodInfoArgsS == null)
+                methodInfoArgsS = typeof(WriteConsole).GetMethod(nameof(Write), new Type[] { typeof(string), typeof(object[]) });
+            m_WriteFormatS = (Action<string, object[]>)Delegate.CreateDelegate(typeof(Action<string, object[]>), methodInfoArgs1);
+
+            m_WriteLineUlong = GetDelegate<ulong>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineUint = GetDelegate<uint>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineString = GetDelegate<string>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineFloat = GetDelegate<float>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineObject = GetDelegate<object>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineDecimal = GetDelegate<decimal>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineLong = GetDelegate<long>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineInt = GetDelegate<int>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineDouble = GetDelegate<double>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineCharArray = GetDelegate<char[]>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineChar = GetDelegate<char>(currentContext.RealType, nameof(WriteLine));
+            m_WriteLineBool = GetDelegate<bool>(currentContext.RealType, nameof(WriteLine));
+
+            MethodInfo methodInfoLineArgs1 = currentContext.RealType.GetMethod(nameof(WriteLine), new Type[] { typeof(string), typeof(object) });
+            if (methodInfoLineArgs1 == null)
+                methodInfoLineArgs1 = typeof(WriteConsole).GetMethod(nameof(WriteLine), new Type[] { typeof(string), typeof(object) });
+            m_WriteLineFormat1 = (Action<string, object>)Delegate.CreateDelegate(typeof(Action<string, object>), methodInfoLineArgs1);
+
+            MethodInfo methodInfoLineArgs2 = currentContext.RealType.GetMethod(nameof(WriteLine), new Type[] { typeof(string), typeof(object), typeof(object) });
+            if (methodInfoLineArgs2 == null)
+                methodInfoLineArgs2 = typeof(WriteConsole).GetMethod(nameof(WriteLine), new Type[] { typeof(string), typeof(object), typeof(object) });
+            m_WriteLineFormat2 = (Action<string, object, object>)Delegate.CreateDelegate(typeof(Action<string, object, object>), methodInfoLineArgs2);
+
+            MethodInfo methodInfoLineArgs3 = currentContext.RealType.GetMethod(nameof(WriteLine), new Type[] { typeof(string), typeof(object), typeof(object), typeof(object) });
+            if (methodInfoLineArgs3 == null)
+                methodInfoLineArgs3 = typeof(WriteConsole).GetMethod(nameof(WriteLine), new Type[] { typeof(string), typeof(object), typeof(object), typeof(object) });
+            m_WriteLineFormat3 = (Action<string, object, object, object>)Delegate.CreateDelegate(typeof(Action<string, object, object, object>), methodInfoLineArgs3);
+
+            MethodInfo methodInfoLineArgsS = currentContext.RealType.GetMethod(nameof(WriteLine), new Type[] { typeof(string), typeof(object[]) });
+            if (methodInfoLineArgsS == null)
+                methodInfoLineArgsS = typeof(WriteConsole).GetMethod(nameof(WriteLine), new Type[] { typeof(string), typeof(object[]) });
+            m_WriteLineFormatS = (Action<string, object[]>)Delegate.CreateDelegate(typeof(Action<string, object[]>), methodInfoLineArgs1);
+
+#if NETFRAMEWORK
+            MethodInfo methodInfoLine = currentContext.RealType.GetMethod(nameof(WriteLine), new Type[] { });
+            if (methodInfoLine == null)
+                methodInfoLine = typeof(WriteConsole).GetMethod(nameof(WriteLine), new Type[] { });
+#else
+            MethodInfo methodInfoLine = currentContext.RealType.GetMethod(nameof(WriteLine), Array.Empty<Type>());
+            if (methodInfoLine == null)
+                methodInfoLine = typeof(WriteConsole).GetMethod(nameof(WriteLine), Array.Empty<Type>());
+#endif
+            m_WriteLine = (Action)Delegate.CreateDelegate(typeof(Action), methodInfoLine);
+        }
+
+        private static Action<T> GetDelegate<T>(Type type, string methodName)
+        {
+            MethodInfo methodInfo = type.GetMethod(methodName, new Type[] { typeof(T) });
+            if (methodInfo == null)
+                methodInfo = typeof(WriteConsole).GetMethod(methodName, new Type[] { typeof(T) });
+
+            return (Action<T>)Delegate.CreateDelegate(typeof(Action<T>), methodInfo);
+        }
+
+        public void Write(ulong value) { m_WriteUlong(value); }
+
+        public void Write(uint value) { m_WriteUint(value); }
+
+        public void Write(string value) { m_WriteString(value); }
+
+        public void Write(float value) { m_WriteFloat(value); }
+
+        public void Write(object value) { m_WriteObject(value); }
+
+        public void Write(decimal value) { m_WriteDecimal(value); }
+
+        public void Write(long value) { m_WriteLong(value); }
+
+        public void Write(int value) { m_WriteInt(value); }
+
+        public void Write(double value) { m_WriteDouble(value); }
+
+        public void Write(char[] value) { m_WriteCharArray(value); }
+
+        public void Write(char value) { m_WriteChar(value); }
+
+        public void Write(bool value) { m_WriteBool(value); }
+
+        public void Write(string format, object arg1) { m_WriteFormat1(format, arg1); }
+
+        public void Write(string format, object arg1, object arg2) { m_WriteFormat2(format, arg1, arg2); }
+
+        public void Write(string format, object arg1, object arg2, object arg3) { m_WriteFormat3(format, arg1, arg2, arg3); }
+
+        public void Write(string format, params object[] args) { m_WriteFormatS(format, args); }
+
+        public void WriteLine() { m_WriteLine(); }
+
+        public void WriteLine(ulong value) { m_WriteLineUlong(value); }
+
+        public void WriteLine(uint value) { m_WriteLineUint(value); }
+
+        public void WriteLine(string value) { m_WriteLineString(value); }
+
+        public void WriteLine(float value) { m_WriteLineFloat(value); }
+
+        public void WriteLine(object value) { m_WriteLineObject(value); }
+
+        public void WriteLine(decimal value) { m_WriteLineDecimal(value); }
+
+        public void WriteLine(long value) { m_WriteLineLong(value); }
+
+        public void WriteLine(int value) { m_WriteLineInt(value); }
+
+        public void WriteLine(double value) { m_WriteLineDouble(value); }
+
+        public void WriteLine(char[] value) { m_WriteLineCharArray(value); }
+
+        public void WriteLine(char value) { m_WriteLineChar(value); }
+
+        public void WriteLine(bool value) { m_WriteLineBool(value); }
+
+        public void WriteLine(string format, object arg1) { m_WriteLineFormat1(format, arg1); }
+
+        public void WriteLine(string format, object arg1, object arg2) { m_WriteLineFormat2(format, arg1, arg2); }
+
+        public void WriteLine(string format, object arg1, object arg2, object arg3) { m_WriteLineFormat3(format, arg1, arg2, arg3); }
+
+        public void WriteLine(string format, params object[] args) { m_WriteLineFormatS(format, args); }
+        #endregion
     }
 }