Enable nullable for EventLogCollector (#3674)

src/DataCollectors/Microsoft.TestPlatform.Extensions.EventLogCollector/CollectorNameValueConfigurationManager.cs

@@ -6,8 +6,6 @@
 
 using Microsoft.VisualStudio.TestPlatform.ObjectModel;
 
-#nullable disable
-
 namespace Microsoft.TestPlatform.Extensions.EventLogCollector;
 
 /// <summary>
@@ -32,7 +30,7 @@ internal class CollectorNameValueConfigurationManager
     /// <param name="configurationElement">
     /// XML element containing the configuration
     /// </param>
-    public CollectorNameValueConfigurationManager(XmlElement configurationElement)
+    public CollectorNameValueConfigurationManager(XmlElement? configurationElement)
     {
         if (configurationElement == null)
         {
@@ -79,14 +77,14 @@ public CollectorNameValueConfigurationManager(XmlElement configurationElement)
         }
     }
 
-    internal IDictionary<string, string> NameValuePairs { get; } = new Dictionary<string, string>();
+    internal IDictionary<string, string?> NameValuePairs { get; } = new Dictionary<string, string?>();
 
     /// <summary>
     /// Gets the value of the setting specified by name, or null if it was not found
     /// </summary>
     /// <param name="name">The setting name</param>
     /// <returns>The setting value, or null if the setting was not found</returns>
-    public string this[string name]
+    public string? this[string name]
     {
         get
         {

src/DataCollectors/Microsoft.TestPlatform.Extensions.EventLogCollector/EventLogCollectorException.cs

@@ -3,8 +3,6 @@
 
 using System;
 
-#nullable disable
-
 namespace Microsoft.TestPlatform.Extensions.EventLogCollector;
 
 /// <summary>
@@ -17,7 +15,7 @@ internal class EventLogCollectorException : Exception
     /// </summary>
     /// <param name="localizedMessage">the localized exception message</param>
     /// <param name="innerException">the inner exception</param>
-    public EventLogCollectorException(string localizedMessage, Exception innerException)
+    public EventLogCollectorException(string? localizedMessage, Exception? innerException)
         : base(localizedMessage, innerException)
     {
     }

src/DataCollectors/Microsoft.TestPlatform.Extensions.EventLogCollector/EventLogConstants.cs

@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-#nullable disable
-
 namespace Microsoft.TestPlatform.Extensions.EventLogCollector;
 
 /// <summary>

src/DataCollectors/Microsoft.TestPlatform.Extensions.EventLogCollector/EventLogContainer.cs

@@ -11,23 +11,21 @@
 
 using Resource = Microsoft.TestPlatform.Extensions.EventLogCollector.Resources.Resources;
 
-#nullable disable
-
 namespace Microsoft.TestPlatform.Extensions.EventLogCollector;
 
 /// <summary>
 /// The event log container.
 /// </summary>
 internal class EventLogContainer : IEventLogContainer
 {
-    private readonly ISet<string> _eventSources;
+    private readonly ISet<string>? _eventSources;
 
     private readonly ISet<EventLogEntryType> _entryTypes;
     private readonly int _maxLogEntries;
 
     private readonly DataCollectionLogger _dataCollectionLogger;
 
-    private readonly DataCollectionContext _dataCollectionContext;
+    private readonly DataCollectionContext? _dataCollectionContext;
 
     /// <summary>
     /// Keeps track of if we are disposed.
@@ -55,7 +53,7 @@ internal class EventLogContainer : IEventLogContainer
     /// <param name="dataCollectionContext">
     /// Data Collection Context
     /// </param>
-    public EventLogContainer(string eventLogName, ISet<string> eventSources, ISet<EventLogEntryType> entryTypes, int maxLogEntries, DataCollectionLogger dataCollectionLogger, DataCollectionContext dataCollectionContext)
+    public EventLogContainer(string eventLogName, ISet<string>? eventSources, ISet<EventLogEntryType> entryTypes, int maxLogEntries, DataCollectionLogger dataCollectionLogger, DataCollectionContext? dataCollectionContext)
     {
         EventLog = new EventLog(eventLogName);
         EventLog.EnableRaisingEvents = true;
@@ -119,7 +117,7 @@ public void Dispose()
     /// </summary>
     /// <param name="source">Source</param>
     /// <param name="e">The System.Diagnostics.EntryWrittenEventArgs object describing the entry that was written.</param>
-    public void OnEventLogEntryWritten(object source, EntryWrittenEventArgs e)
+    public void OnEventLogEntryWritten(object? source, EntryWrittenEventArgs? e)
     {
         while (!LimitReached)
         {

src/DataCollectors/Microsoft.TestPlatform.Extensions.EventLogCollector/EventLogDataCollector.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -16,8 +17,6 @@
 
 using Resource = Microsoft.TestPlatform.Extensions.EventLogCollector.Resources.Resources;
 
-#nullable disable
-
 namespace Microsoft.TestPlatform.Extensions.EventLogCollector;
 
 /// <summary>
@@ -65,22 +64,22 @@ public class EventLogDataCollector : DataCollector
     /// <summary>
     /// Object containing the execution events the data collector registers for
     /// </summary>
-    private DataCollectionEvents _events;
+    private DataCollectionEvents? _events;
 
     /// <summary>
     /// The sink used by the data collector to send its data
     /// </summary>
-    private DataCollectionSink _dataSink;
+    private DataCollectionSink? _dataSink;
 
     /// <summary>
     /// The data collector context.
     /// </summary>
-    private DataCollectionContext _dataCollectorContext;
+    private DataCollectionContext? _dataCollectorContext;
 
     /// <summary>
     /// Used by the data collector to send warnings, errors, or other messages
     /// </summary>
-    private DataCollectionLogger _logger;
+    private DataCollectionLogger? _logger;
 
     /// <summary>
     /// The file helper.
@@ -120,18 +119,17 @@ internal EventLogDataCollector(IFileHelper fileHelper)
 
     internal int MaxEntries { get; private set; }
 
-    internal ISet<string> EventSources { get; private set; }
+    internal ISet<string>? EventSources { get; private set; }
 
-    internal ISet<EventLogEntryType> EntryTypes { get; private set; }
+    internal ISet<EventLogEntryType>? EntryTypes { get; private set; }
 
-    internal ISet<string> EventLogNames { get; private set; }
+    internal ISet<string>? EventLogNames { get; private set; }
 
     /// <summary>
     /// Gets the context data.
     /// </summary>
     internal Dictionary<DataCollectionContext, EventLogSessionContext> ContextMap { get; }
 
-
     #region DataCollector Members
 
     /// <summary>
@@ -149,12 +147,13 @@ internal EventLogDataCollector(IFileHelper fileHelper)
     /// Used by the data collector to send warnings, errors, or other messages
     /// </param>
     /// <param name="dataCollectionEnvironmentContext">Provides contextual information about the agent environment</param>
+    [MemberNotNull(nameof(_events), nameof(_dataSink), nameof(_logger))]
     public override void Initialize(
-        XmlElement configurationElement,
+        XmlElement? configurationElement,
         DataCollectionEvents events!!,
         DataCollectionSink dataSink!!,
         DataCollectionLogger logger!!,
-        DataCollectionEnvironmentContext dataCollectionEnvironmentContext)
+        DataCollectionEnvironmentContext dataCollectionEnvironmentContext!!)
     {
         _events = events;
         _dataSink = dataSink;
@@ -224,7 +223,7 @@ internal string WriteEventLogs(List<EventLogEntry> eventLogEntries, int maxLogEn
         {
             for (int i = 1; !unusedFilenameFound; i++)
             {
-                eventLogPath = eventLogBasePath + "-" + i.ToString(CultureInfo.InvariantCulture) + ".xml";
+                eventLogPath = $"{eventLogBasePath}-{i.ToString(CultureInfo.InvariantCulture)}.xml";
 
                 if (!_fileHelper.Exists(eventLogPath))
                 {
@@ -267,6 +266,7 @@ internal string WriteEventLogs(List<EventLogEntry> eventLogEntries, int maxLogEn
         // Write the event log file
         FileTransferInformation fileTransferInformation =
             new(dataCollectionContext, eventLogPath, true, _fileHelper);
+        TPDebug.Assert(_dataSink != null, "Initialize should have been called.");
         _dataSink.SendFileAsync(fileTransferInformation);
 
         EqtTrace.Verbose(
@@ -287,10 +287,13 @@ protected override void Dispose(bool disposing)
         base.Dispose(disposing);
 
         // Unregister events
-        _events.SessionStart -= _sessionStartEventHandler;
-        _events.SessionEnd -= _sessionEndEventHandler;
-        _events.TestCaseStart -= _testCaseStartEventHandler;
-        _events.TestCaseEnd -= _testCaseEndEventHandler;
+        if (_events != null)
+        {
+            _events.SessionStart -= _sessionStartEventHandler;
+            _events.SessionEnd -= _sessionEndEventHandler;
+            _events.TestCaseStart -= _testCaseStartEventHandler;
+            _events.TestCaseEnd -= _testCaseEndEventHandler;
+        }
 
         // Unregister EventLogEntry Written.
         foreach (var eventLogContainer in _eventLogContainerMap.Values)
@@ -351,8 +354,8 @@ private void OnTestCaseStart(object sender, TestCaseStartEventArgs e!!)
 
     private void OnTestCaseEnd(object sender, TestCaseEndEventArgs e!!)
     {
-        Debug.Assert(e.Context != null, "Context is null");
-        Debug.Assert(e.Context.HasTestCase, "Context is not for a test case");
+        TPDebug.Assert(e.Context != null, "Context is null");
+        TPDebug.Assert(e.Context.HasTestCase, "Context is not for a test case");
 
         EqtTrace.Verbose(
             "EventLogDataCollector: TestCaseEnd received for test '{0}' with Test Outcome: {1}.",
@@ -409,6 +412,7 @@ private void WriteCollectedEventLogEntries(
             }
             catch (Exception e)
             {
+                TPDebug.Assert(_logger != null, "Initialize should have been called.");
                 _logger.LogWarning(
                     dataCollectionContext,
                     string.Format(
@@ -430,15 +434,16 @@ private void WriteCollectedEventLogEntries(
         }
     }
 
+    [MemberNotNull(nameof(EventLogNames))]
     private void ConfigureEventLogNames(CollectorNameValueConfigurationManager collectorNameValueConfigurationManager)
     {
         EventLogNames = new HashSet<string>();
-        string eventLogs = collectorNameValueConfigurationManager[EventLogConstants.SettingEventLogs];
+        string? eventLogs = collectorNameValueConfigurationManager[EventLogConstants.SettingEventLogs];
         if (eventLogs != null)
         {
             EventLogNames = ParseCommaSeparatedList(eventLogs);
             EqtTrace.Verbose(
-                "EventLogDataCollector configuration: " + EventLogConstants.SettingEventLogs + "=" + eventLogs);
+                $"EventLogDataCollector configuration: {EventLogConstants.SettingEventLogs}={eventLogs}");
         }
         else
         {
@@ -447,6 +452,8 @@ private void ConfigureEventLogNames(CollectorNameValueConfigurationManager colle
             EventLogNames.Add("Application");
         }
 
+        TPDebug.Assert(_logger != null && EntryTypes != null, "Initialize should have been called.");
+
         foreach (string eventLogName in EventLogNames)
         {
             try
@@ -470,27 +477,27 @@ private void ConfigureEventLogNames(CollectorNameValueConfigurationManager colle
             {
                 _logger.LogError(
                     _dataCollectorContext,
-                    new EventLogCollectorException(string.Format(CultureInfo.InvariantCulture, Resource.ReadError, eventLogName, Environment.MachineName), ex));
+                    new EventLogCollectorException(string.Format(CultureInfo.CurrentCulture, Resource.ReadError, eventLogName, Environment.MachineName), ex));
             }
         }
     }
 
     private void ConfigureEventSources(CollectorNameValueConfigurationManager collectorNameValueConfigurationManager)
     {
-        string eventSourcesStr = collectorNameValueConfigurationManager[EventLogConstants.SettingEventSources];
+        string? eventSourcesStr = collectorNameValueConfigurationManager[EventLogConstants.SettingEventSources];
         if (!string.IsNullOrEmpty(eventSourcesStr))
         {
-            EventSources = ParseCommaSeparatedList(eventSourcesStr);
+            EventSources = ParseCommaSeparatedList(eventSourcesStr!);
             EqtTrace.Verbose(
-                "EventLogDataCollector configuration: " + EventLogConstants.SettingEventSources + "="
-                + EventSources);
+                $"EventLogDataCollector configuration: {EventLogConstants.SettingEventSources}={EventSources}");
         }
     }
 
+    [MemberNotNull(nameof(EntryTypes))]
     private void ConfigureEntryTypes(CollectorNameValueConfigurationManager collectorNameValueConfigurationManager)
     {
         EntryTypes = new HashSet<EventLogEntryType>();
-        string entryTypesStr = collectorNameValueConfigurationManager[EventLogConstants.SettingEntryTypes];
+        string? entryTypesStr = collectorNameValueConfigurationManager[EventLogConstants.SettingEntryTypes];
         if (entryTypesStr != null)
         {
             foreach (string entryTypestring in ParseCommaSeparatedList(entryTypesStr))
@@ -500,8 +507,7 @@ private void ConfigureEntryTypes(CollectorNameValueConfigurationManager collecto
             }
 
             EqtTrace.Verbose(
-                "EventLogDataCollector configuration: " + EventLogConstants.SettingEntryTypes + "="
-                + EntryTypes);
+                $"EventLogDataCollector configuration: {EventLogConstants.SettingEntryTypes}={EntryTypes}");
         }
         else
         {
@@ -513,7 +519,7 @@ private void ConfigureEntryTypes(CollectorNameValueConfigurationManager collecto
 
     private void ConfigureMaxEntries(CollectorNameValueConfigurationManager collectorNameValueConfigurationManager)
     {
-        string maxEntriesstring = collectorNameValueConfigurationManager[EventLogConstants.SettingMaxEntries];
+        string? maxEntriesstring = collectorNameValueConfigurationManager[EventLogConstants.SettingMaxEntries];
         if (maxEntriesstring != null)
         {
             try
@@ -532,8 +538,7 @@ private void ConfigureMaxEntries(CollectorNameValueConfigurationManager collecto
             }
 
             EqtTrace.Verbose(
-                "EventLogDataCollector configuration: " + EventLogConstants.SettingMaxEntries + "="
-                + MaxEntries);
+                $"EventLogDataCollector configuration: {EventLogConstants.SettingMaxEntries}={MaxEntries}");
         }
         else
         {
@@ -553,7 +558,7 @@ private EventLogSessionContext GetEventLogSessionContext(DataCollectionContext d
         if (!eventLogContainerFound)
         {
             string msg = string.Format(
-                CultureInfo.InvariantCulture,
+                CultureInfo.CurrentCulture,
                 Resource.ContextNotFoundException,
                 dataCollectionContext.ToString());
             throw new EventLogCollectorException(msg, null);

src/DataCollectors/Microsoft.TestPlatform.Extensions.EventLogCollector/EventLogSessionContext.cs

@@ -2,8 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
-
-#nullable disable
+using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.TestPlatform.Extensions.EventLogCollector;
 
@@ -34,11 +33,12 @@ public EventLogSessionContext(IDictionary<string, IEventLogContainer> eventLogCo
     /// <summary>
     /// Gets the end index for EventLogs Entries
     /// </summary>
-    internal Dictionary<string, int> EventLogContainerEndIndexMap { get; private set; }
+    internal Dictionary<string, int>? EventLogContainerEndIndexMap { get; private set; }
 
     /// <summary>
     /// Creates the end index map for EventLogs Entries
     /// </summary>
+    [MemberNotNull(nameof(EventLogContainerEndIndexMap))]
     public void CreateEventLogContainerEndIndexMap()
     {
         EventLogContainerEndIndexMap = new Dictionary<string, int>(_eventLogContainerMap.Count);
@@ -54,6 +54,7 @@ public void CreateEventLogContainerEndIndexMap()
     /// <summary>
     /// Creates the start index map for EventLogs Entries
     /// </summary>
+    [MemberNotNull(nameof(EventLogContainerStartIndexMap))]
     public void CreateEventLogContainerStartIndexMap()
     {
         EventLogContainerStartIndexMap = new Dictionary<string, int>(_eventLogContainerMap.Count);

src/DataCollectors/Microsoft.TestPlatform.Extensions.EventLogCollector/EventLogXmlWriter.cs

@@ -11,8 +11,6 @@
 
 using Microsoft.VisualStudio.TestPlatform.Utilities.Helpers.Interfaces;
 
-#nullable disable
-
 namespace Microsoft.TestPlatform.Extensions.EventLogCollector;
 
 /// <summary>

src/DataCollectors/Microsoft.TestPlatform.Extensions.EventLogCollector/IEventLogContainer.cs

@@ -5,8 +5,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 
-#nullable disable
-
 namespace Microsoft.TestPlatform.Extensions.EventLogCollector;
 
 /// <summary>
@@ -33,5 +31,5 @@ internal interface IEventLogContainer : IDisposable
     /// <param name="e">
     /// Contains data related to EventLog entry.
     /// </param>
-    void OnEventLogEntryWritten(object source, EntryWrittenEventArgs e);
+    void OnEventLogEntryWritten(object? source, EntryWrittenEventArgs? e);
 }