Added unit tests to cover passing nullable types to System.Diagnostics.Tracing

src/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestUtilities.cs

@@ -10,6 +10,7 @@
 using System.Diagnostics;
 using Xunit;
 using System;
+using System.Collections.Generic;
 
 namespace BasicEventSourceTests
 {
@@ -47,5 +48,35 @@ public static void CheckNoEventSourcesRunning(string message = "")
             Debug.WriteLine(message);
             Assert.Equal("", eventSourceNames);
         }
+
+        /// <summary>
+        /// Unwraps a nullable returned from either ETW or EventListener
+        /// </summary>
+        /// <typeparam name="T">The type to unwrap</typeparam>
+        /// <param name="wrappedValue">Value returned from event payload</param>
+        /// <returns></returns>
+        public static T? UnwrapNullable<T>(object wrappedValue) where T : struct
+        {
+            // ETW will return a collection of key/value pairs
+            if (wrappedValue is IDictionary<string, object> dict)
+            {
+                Assert.True(dict.ContainsKey("HasValue"));
+                Assert.True(dict.ContainsKey("Value"));
+
+                if ((bool)dict["HasValue"])
+                {
+                    return (T)dict["Value"];
+                }
+            }
+            // EventListener will return the boxed value of the nullable, which will either be a value or null object reference
+            else if (wrappedValue != null)
+            {
+                Assert.IsType(typeof(T), wrappedValue);
+                return (T?)wrappedValue;
+            }
+
+            // wrappedValue is null or wrappedValue is IDictionary, but HasValue is false
+            return null;
+        }
     }
 }

src/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestsWrite.cs

@@ -25,6 +25,7 @@ internal enum ColorUInt64 : ulong { Red, Blue, Green };
 
     public partial class TestsWrite
     {
+
         [EventData]
         private struct PartB_UserInfo
         {
@@ -127,6 +128,66 @@ private void Test_Write_T(Listener listener)
                         Array.Equals(eventArray, byteArray);
                     }));
                 /*************************************************************************/
+                int? nullableInt = 12;
+                tests.Add(new SubTest("Write/Basic/int?/12",
+                    delegate ()
+                    {
+                        logger.Write("Int12", new { nInteger = nullableInt });
+                    },
+                    delegate (Event evt)
+                    {
+                        Assert.Equal(logger.Name, evt.ProviderName);
+                        Assert.Equal("Int12", evt.EventName);
+
+                        var payload = evt.PayloadValue(0, "nInteger");
+                        Assert.Equal(nullableInt, TestUtilities.UnwrapNullable<int>(payload));
+                    }));
+                /*************************************************************************/
+                int? nullableInt2 = null;
+                tests.Add(new SubTest("Write/Basic/int?/null",
+                    delegate ()
+                    {
+                        logger.Write("IntNull", new { nInteger = nullableInt2 });
+                    },
+                    delegate (Event evt)
+                    {
+                        Assert.Equal(logger.Name, evt.ProviderName);
+                        Assert.Equal("IntNull", evt.EventName);
+
+                        var payload = evt.PayloadValue(0, "nInteger");
+                        Assert.Equal(nullableInt2, TestUtilities.UnwrapNullable<int>(payload));
+                    }));
+                ///*************************************************************************/
+                DateTime? nullableDate = DateTime.Now;
+                tests.Add(new SubTest("Write/Basic/DateTime?/Now",
+                    delegate ()
+                    {
+                        logger.Write("DateTimeNow", new { nowTime = nullableDate });
+                    },
+                    delegate (Event evt)
+                    {
+                        Assert.Equal(logger.Name, evt.ProviderName);
+                        Assert.Equal("DateTimeNow", evt.EventName);
+
+                        var payload = evt.PayloadValue(0, "nowTime");
+                        Assert.Equal(nullableDate, TestUtilities.UnwrapNullable<DateTime>(payload));
+                    }));
+                /*************************************************************************/
+                DateTime? nullableDate2 = null;
+                tests.Add(new SubTest("Write/Basic/DateTime?/Null",
+                    delegate ()
+                    {
+                        logger.Write("DateTimeNull", new { nowTime = nullableDate2 });
+                    },
+                    delegate (Event evt)
+                    {
+                        Assert.Equal(logger.Name, evt.ProviderName);
+                        Assert.Equal("DateTimeNull", evt.EventName);
+
+                        var payload = evt.PayloadValue(0, "nowTime");
+                        Assert.Equal(nullableDate2, TestUtilities.UnwrapNullable<DateTime>(payload));
+                    }));
+                /*************************************************************************/
                 tests.Add(new SubTest("Write/Basic/PartBOnly",
                     delegate ()
                     {

src/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestsWriteEvent.cs

@@ -414,6 +414,71 @@ private void Test_WriteEvent_ComplexData_SelfDescribing(Listener listener)
                         Assert.Equal(5, evt.PayloadValue(1, "anInt"));
                     }));
 
+
+                int? nullableInt = 12;
+                tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/Int12",
+                    delegate ()
+                    {
+                        logger.EventNullableIntInt(nullableInt, 5);
+                    },
+                    delegate (Event evt)
+                    {
+                        Assert.Equal(logger.Name, evt.ProviderName);
+                        Assert.Equal("EventNullableIntInt", evt.EventName);
+
+                        var payload = evt.PayloadValue(0, "nullableInt");
+                        Assert.Equal(nullableInt, TestUtilities.UnwrapNullable<int>(payload));
+                        Assert.Equal(5, evt.PayloadValue(1, "anInt"));
+                    }));
+
+                int? nullableInt2 = null;
+                tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/IntNull",
+                    delegate ()
+                    {
+                        logger.EventNullableIntInt(nullableInt2, 5);
+                    },
+                    delegate (Event evt)
+                    {
+                        Assert.Equal(logger.Name, evt.ProviderName);
+                        Assert.Equal("EventNullableIntInt", evt.EventName);
+
+                        var payload = evt.PayloadValue(0, "nullableInt");
+                        Assert.Equal(nullableInt2, TestUtilities.UnwrapNullable<int>(payload));
+                        Assert.Equal(5, evt.PayloadValue(1, "anInt"));
+                    }));
+
+                DateTime? nullableDate = DateTime.Now;
+                tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/DateTimeNow",
+                    delegate ()
+                    {
+                        logger.EventNullableDateTimeInt(nullableDate, 5);
+                    },
+                    delegate (Event evt)
+                    {
+                        Assert.Equal(logger.Name, evt.ProviderName);
+                        Assert.Equal("EventNullableDateTimeInt", evt.EventName);
+
+                        var payload = evt.PayloadValue(0, "nullableDate");
+                        Assert.Equal(nullableDate, TestUtilities.UnwrapNullable<DateTime>(payload));
+                        Assert.Equal(5, evt.PayloadValue(1, "anInt"));
+                    }));
+
+                DateTime? nullableDate2 = null;
+                tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/DateTimeNull",
+                    delegate ()
+                    {
+                        logger.EventNullableDateTimeInt(nullableDate2, 5);
+                    },
+                    delegate (Event evt)
+                    {
+                        Assert.Equal(logger.Name, evt.ProviderName);
+                        Assert.Equal("EventNullableDateTimeInt", evt.EventName);
+
+                        var payload = evt.PayloadValue(0, "nullableDate");
+                        Assert.Equal(nullableDate2, TestUtilities.UnwrapNullable<DateTime>(nullableDate2));
+                        Assert.Equal(5, evt.PayloadValue(1, "anInt"));
+                    }));
+
                 // If you only wish to run one or several of the tests you can filter them here by 
                 // Uncommenting the following line.  
                 // tests = tests.FindAll(test => Regex.IsMatch(test.Name, "ventWithByteArray"));
@@ -621,6 +686,8 @@ public sealed class EventSourceTestSelfDescribingOnly : EventSource
         public EventSourceTestSelfDescribingOnly() : base(EventSourceSettings.EtwSelfDescribingEventFormat) { }
         public void EventByteArrayInt(byte[] array, int anInt) { WriteEvent(1, array, anInt); }
         public void EventUserDataInt(UserData aClass, int anInt) { WriteEvent(2, aClass, anInt); }
+        public void EventNullableIntInt(int? nullableInt, int anInt) { WriteEvent(3, nullableInt, anInt); }
+        public void EventNullableDateTimeInt(DateTime? nullableDate, int anInt) { WriteEvent(4, nullableDate, anInt); }
     }
 
     public sealed class EventSourceTestByteArray : EventSource

src/System.Diagnostics.Tracing/tests/CustomEventSources/EventSourceTest.cs

@@ -19,7 +19,10 @@ namespace SdtEventSources
     /// <summary>
     /// A sample Event source. The Guid and Name attributes are "idempotent", i.e. they 
     /// don't change the default computed by EventSource; they're specified here just to 
-    /// increase the code coverage.
+    /// increase the code coverage. 
+    /// 
+    /// Also, this EventSource uses manifest-based ETW and is not self-describing. That means
+    /// it does not support complex data types, including nullables, as event arguments.
     /// </summary>
     [EventSource(Guid = "69e2aa3e-083b-5014-cad4-3e511a0b94cf", Name = "EventSourceTest")]
     public sealed class EventSourceTest : EventSource