public void OverflowAndRetention_Set()
{
string source = "Source_" + nameof(OverflowAndRetention_Set);
string log = "Overflow_Set";
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
// The second argument is only used when the overflow policy is set to OverWrite Older
eventLog.ModifyOverflowPolicy(OverflowAction.DoNotOverwrite, 1);
Assert.Equal(OverflowAction.DoNotOverwrite, eventLog.OverflowAction);
// -1 means overflow action is donot OverWrite
Assert.Equal(-1, eventLog.MinimumRetentionDays);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
private void RaisingEvent(string log, string methodName, bool waitOnEvent = true)
{
signal = new AutoResetEvent(false);
eventCounter = 0;
string source = "Source_" + methodName;
try
{
EventLog.CreateEventSource(source, log);
var query = new EventLogQuery(log, PathType.LogName);
using (EventLog eventLog = new EventLog())
using (EventLogWatcher eventLogWatcher = new EventLogWatcher(query))
{
eventLog.Source = source;
eventLogWatcher.EventRecordWritten += (s, e) =>
{
eventCounter += 1;
Assert.True(e.EventException != null || e.EventRecord != null);
signal.Set();
};
Helpers.Retry(() => eventLogWatcher.Enabled = waitOnEvent);
Helpers.Retry(() => eventLog.WriteEntry(message, EventLogEntryType.Information));
if (waitOnEvent)
{
Assert.True(signal.WaitOne(6000));
}
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.RetrySilently(() => EventLog.Delete(log));
}
}
public void TraceEventTest(TraceEventType eventType, EventLogEntryType expectedType, int id, int expectedId)
{
string log = "TraceEvent";
string source = "Source" + nameof(TraceEventTest);
try
{
EventLog.CreateEventSource(source, log);
using (var listener = new EventLogTraceListener(source))
{
string message = "One simple message to trace";
listener.TraceEvent(null, source, eventType, id, message);
EventLogEntry eventLogEntry = ValidateLastEntryMessage(listener, message, source);
if (eventLogEntry != null)
{
Assert.Equal(expectedType, eventLogEntry.EntryType);
Assert.Equal(expectedId, eventLogEntry.InstanceId);
}
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void CanReadAndWriteMessages()
{
string messageDllPath = Path.Combine(Path.GetDirectoryName(typeof(EventLog).Assembly.Location), "System.Diagnostics.EventLog.Messages.dll");
EventSourceCreationData log = new EventSourceCreationData($"TestEventMessageSource {Guid.NewGuid()}", "Application")
{
MessageResourceFile = messageDllPath
};
try
{
if (EventLog.SourceExists(log.Source))
{
EventLog.DeleteEventSource(log.Source);
}
EventLog.CreateEventSource(log);
string message = $"Hello {Guid.NewGuid()}";
Helpers.Retry(() => EventLog.WriteEntry(log.Source, message));
using (EventLogReader reader = new EventLogReader(new EventLogQuery("Application", PathType.LogName, $"*[System/Provider/@Name=\"{log.Source}\"]")))
{
EventRecord evt = reader.ReadEvent();
string logMessage = evt.FormatDescription();
Assert.Equal(message, logMessage);
}
}
finally
{
EventLog.DeleteEventSource(log.Source);
}
}
public void CheckingEntryEqualityAndIndex()
{
string log = "IndexTest";
string source = "Source_" + nameof(CheckingEntryEqualityAndIndex);
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
Helpers.Retry(() => eventLog.WriteEntry(message));
Helpers.WaitForEventLog(eventLog, 1); //There is latency between writing and getting the entry
EventLogEntry entry = Helpers.Retry(() => eventLog.Entries[eventLog.Entries.Count - 1]);
Assert.True(entry.Equals(entry));
Helpers.Retry(() => eventLog.WriteEntry(message));
Helpers.WaitForEventLog(eventLog, 2);
EventLogEntry secondEntry = Helpers.Retry(() => eventLog.Entries[eventLog.Entries.Count - 1]);
Assert.Equal(entry.Index + 1, secondEntry.Index);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void LogNameWithSame8FirstChars_NetCore()
{
string firstSource = "FirstSource_" + nameof(LogNameWithSame8FirstChars_NetCore);
string firstLog = "LogNameWithSame8FirstChars";
string secondSource = "SecondSource_" + nameof(LogNameWithSame8FirstChars_NetCore);
string secondLog = "LogNameWithSame8FirstCharsDuplicate";
// No Exception should be thrown.
try
{
EventLog.CreateEventSource(firstSource, firstLog);
Assert.True(EventLog.SourceExists(firstSource));
EventLog.CreateEventSource(secondSource, secondLog);
Assert.True(EventLog.SourceExists(secondSource));
}
finally
{
EventLog.DeleteEventSource(firstSource);
if (EventLog.Exists(firstLog))
{
Helpers.Retry(() => EventLog.Delete(firstLog));
}
EventLog.DeleteEventSource(secondSource);
if (EventLog.Exists(secondLog))
{
Helpers.Retry(() => EventLog.Delete(secondLog));
}
}
}
public void ClearLog_LogExists_Success()
{
using (var session = new EventLogSession())
{
string log = "Log_" + nameof(ClearLog_LogExists_Success);
string source = "Source_" + nameof(ClearLog_LogExists_Success);
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
Helpers.Retry(() => eventLog.WriteEntry("Writing to event log."));
Assert.NotEqual(0, Helpers.Retry((() => eventLog.Entries.Count)));
session.ClearLog(logName: log);
Assert.Equal(0, Helpers.Retry((() => eventLog.Entries.Count)));
}
}
finally
{
EventLog.DeleteEventSource(source);
}
session.CancelCurrentOperations();
}
}
public void CopyingEventLogEntryCollection()
{
string log = "CopyCollection";
string source = "Source_" + nameof(CopyingEventLogEntryCollection);
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
Helpers.Retry(() => eventLog.WriteEntry(message));
Helpers.Retry(() => eventLog.WriteEntry("Further Testing"));
EventLogEntryCollection entryCollection = eventLog.Entries;
EventLogEntry[] entryCollectionCopied = new EventLogEntry[entryCollection.Count];
Helpers.Retry(() => entryCollection.CopyTo(entryCollectionCopied, 0));
int i = 0;
foreach (EventLogEntry entry in entryCollection)
{
Assert.Equal(entry.Message, Helpers.Retry(() => entryCollectionCopied[i].Message));
i += 1;
}
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void WriteEvent(bool SourceFlag)
{
string source = "Source_" + nameof(WriteEvent);
string log = "Event";
try
{
EventLog.CreateEventSource(source, log);
EventLogEntry eventLogEntry;
if (SourceFlag)
{
eventLogEntry = WriteLogEntryEventSource(source);
}
else
{
eventLogEntry = WriteLogEntryEvent(source);
}
if (eventLogEntry != null)
{
Assert.All(insertStrings, message => eventLogEntry.Message.Contains(message));
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void WriteEventWithData(bool SourceFlag)
{
string log = "EventData";
string source = "Source_" + nameof(WriteEventWithData);
try
{
EventLog.CreateEventSource(source, log);
EventLogEntry eventLogEntry;
if (SourceFlag)
{
eventLogEntry = WriteLogEntryEventSource(source, data: true);
}
else
{
eventLogEntry = WriteLogEntryEvent(source, data: true);
}
if (eventLogEntry != null)
{
Assert.Equal(rawData, eventLogEntry.Data);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void WriteEntryWithTypeAndId(bool sourceFlag)
{
string source = "Source" + nameof(WriteEntryWithTypeAndId);
string log = "InstanceEntry";
try
{
EventLog.CreateEventSource(source, log);
EventLogEntry eventLogEntry;
if (sourceFlag)
{
eventLogEntry = WriteLogEntry(source, type: true, instance: true);
}
else
{
eventLogEntry = WriteLogEntryWithSource(source, type: true, instance: true);
}
if (eventLogEntry != null)
{
Assert.Contains(message, eventLogEntry.Message);
Assert.Equal((int)eventInstance.InstanceId, eventLogEntry.InstanceId);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void WriteEntryWithTypeIdCategoryAndData(bool sourceFlag)
{
string source = "Source" + nameof(WriteEntryWithTypeIdCategoryAndData);
string log = "EntryData";
try
{
EventLog.CreateEventSource(source, log);
EventLogEntry eventLogEntry;
if (sourceFlag)
{
eventLogEntry = WriteLogEntry(source, type: true, instance: true, category: true, data: true);
}
else
{
eventLogEntry = WriteLogEntryWithSource(source, type: true, instance: true, category: true, data: true);
}
if (eventLogEntry != null)
{
Assert.Contains(message, eventLogEntry.Message);
Assert.Equal(rawData, eventLogEntry.Data);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void WriteEntryWithType(bool sourceFlag)
{
string source = "Source" + nameof(WriteEntryWithType);
string log = "TypeEntry";
try
{
EventLog.CreateEventSource(source, log);
EventLogEntry eventLogEntry;
if (sourceFlag)
{
eventLogEntry = WriteLogEntry(source, type: true);
}
else
{
eventLogEntry = WriteLogEntryWithSource(source, type: true);
}
if (eventLogEntry != null)
{
Assert.Contains(message, eventLogEntry.Message);
Assert.Equal(EventLogEntryType.Warning, eventLogEntry.EntryType);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void WriteEntry(bool sourceFlag)
{
string log = "Entry";
string source = "Source" + nameof(WriteEntry);
try
{
EventLog.CreateEventSource(source, log);
EventLogEntry eventLogEntry;
if (sourceFlag)
{
eventLogEntry = WriteLogEntry(source);
}
else
{
eventLogEntry = WriteLogEntryWithSource(source);
}
if (eventLogEntry != null)
{
Assert.Contains(message, eventLogEntry.Message);
Assert.Equal(source, eventLogEntry.Source);
Assert.StartsWith(Environment.MachineName.ToLowerInvariant(), eventLogEntry.MachineName.ToLowerInvariant());
Assert.Equal(eventLogEntry.TimeWritten, eventLogEntry.TimeGenerated);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void WriteTest()
{
string log = "Write";
string source = "Source" + nameof(WriteTest);
try
{
EventLog.CreateEventSource(source, log);
using (var listener = new EventLogTraceListener(source))
{
string message = "A little message for the log";
Helpers.Retry(() => listener.Write(message));
ValidateLastEntryMessage(listener, message, source);
message = "One more message for my friend";
Helpers.Retry(() => listener.WriteLine(message));
ValidateLastEntryMessage(listener, message, source);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void RegisterDisplayLogName()
{
string log = "DisplayName";
string source = "Source_" + nameof(RegisterDisplayLogName);
string messageFile = GetTestFilePath();
long DisplayNameMsgId = 42; // It could be any number
EventSourceCreationData sourceData = new EventSourceCreationData(source, log);
try
{
EventLog.CreateEventSource(sourceData);
log = EventLog.LogNameFromSourceName(source, ".");
using (EventLog eventLog = new EventLog(log, ".", source))
{
if (messageFile.Length > 0)
{
eventLog.RegisterDisplayName(messageFile, DisplayNameMsgId);
}
Assert.Equal(log, eventLog.LogDisplayName);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void CheckingEntryInEquality()
{
string log = "InEqualityTest";
string source = "Source_" + nameof(CheckingEntryInEquality);
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
Helpers.Retry(() => eventLog.WriteEntry(message));
Helpers.Retry(() => eventLog.WriteEntry(message));
Helpers.WaitForEventLog(eventLog, 2);
EventLogEntry entry = Helpers.Retry(() => eventLog.Entries[eventLog.Entries.Count - 1]);
EventLogEntry secondEntry = Helpers.Retry(() => eventLog.Entries[eventLog.Entries.Count - 2]);
Assert.False(entry.Equals(secondEntry));
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void Overflow_OverWriteOlderAndRetention_Set()
{
string source = "Source_" + nameof(OverflowAndRetention_Set);
string log = "Overflow_Set";
int retentionDays = 30; // A number between 0 and 365 should work
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
// The second argument is only used when the overflow policy is set to OverWrite Older
eventLog.ModifyOverflowPolicy(OverflowAction.OverwriteOlder, retentionDays);
Assert.Equal(OverflowAction.OverwriteOlder, eventLog.OverflowAction);
Assert.Equal(retentionDays, eventLog.MinimumRetentionDays);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void ApplicationEventLog_Count()
{
using (EventLog eventLog = new EventLog("Application"))
{
Assert.InRange(Helpers.Retry((() => eventLog.Entries.Count)), 1, int.MaxValue);
}
}
public void WriteEventMessageValues_OutOfRange()
{
string source = "Source_" + nameof(WriteEventMessageValues_OutOfRange);
string[] message = new string[1];
message[0] = new string('c', 32767);
Helpers.Retry(() => Assert.Throws <ArgumentException>(() => EventLog.WriteEvent(source, eventInstance, message)));
}
public void GetEventLogEntriesTest()
{
foreach (var eventLog in EventLog.GetEventLogs())
{
// Accessing eventlog properties should not throw.
Assert.True(Helpers.Retry(() => eventLog.Entries.Count) >= 0);
}
}
public void TraceEventFormatAndParams(string format, object[] parameters)
{
string log = "TraceEvent";
string source = "Source" + nameof(TraceEventFormatAndParams);
try
{
EventLog.CreateEventSource(source, log);
using (var listener = new EventLogTraceListener(source))
{
listener.TraceEvent(null, source, TraceEventType.Information, 1000, format, parameters);
if (parameters == null || parameters.Length == 0)
{
string[] messages;
if (string.IsNullOrEmpty(format))
{
messages = Array.Empty <string>();
}
else
{
messages = new string[] { format }
};
EventLogEntry eventLogEntry = listener.EventLog.Entries.LastOrDefault();
if (eventLogEntry != null)
{
Assert.All(messages, message => eventLogEntry.Message.Contains(message));
}
}
else if (string.IsNullOrEmpty(format))
{
string[] messages = new string[parameters.Length];
for (int i = 0; i < messages.Length; i++)
{
messages[i] = parameters[i].ToString();
}
EventLogEntry eventLogEntry = listener.EventLog.Entries.LastOrDefault();
if (eventLogEntry != null)
{
Assert.All(messages, message => eventLogEntry.Message.Contains(message));
}
}
else
{
string expectedMessage = string.Format(CultureInfo.InvariantCulture, format, parameters);
ValidateLastEntryMessage(listener, expectedMessage, source);
}
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void WriteWithoutExistingSource()
{
string source = "Source_" + nameof(WriteWithoutExistingSource);
try
{
Helpers.Retry(() => EventLog.WriteEvent(source, eventInstance, rawData, null));
Assert.Equal("Application", EventLog.LogNameFromSourceName(source, "."));
}
finally
{
EventLog.DeleteEventSource(source);
}
}
public void TraceWithFilters()
{
string log = "TraceWithFilters";
string source = "Source" + nameof(TraceEventFormatAndParams);
try
{
EventLog.CreateEventSource(source, log);
using (var listener = new EventLogTraceListener(source))
{
listener.Filter = new EventTypeFilter(SourceLevels.Critical);
listener.TraceData(null, source, TraceEventType.Information, 12, "string shouldn't be present");
EventLogEntry eventLogEntry = listener.EventLog.Entries.LastOrDefault();
if (eventLogEntry != null)
{
Assert.DoesNotContain("string shouldn't be present", eventLogEntry.Message);
}
listener.TraceData(null, source, TraceEventType.Information, 12, "string shouldn't be present", "neither should this");
eventLogEntry = listener.EventLog.Entries.LastOrDefault();
if (eventLogEntry != null)
{
Assert.DoesNotContain("string shouldn't be present", eventLogEntry.Message);
Assert.DoesNotContain("neither should this", eventLogEntry.Message);
}
listener.TraceEvent(null, source, TraceEventType.Information, 12, "trace an event casually", "one more", null);
eventLogEntry = listener.EventLog.Entries.LastOrDefault();
if (eventLogEntry != null)
{
Assert.DoesNotContain("trace an event casually", eventLogEntry.Message);
Assert.DoesNotContain("one more", eventLogEntry.Message);
}
listener.TraceEvent(null, source, TraceEventType.Information, 12, "i shouldn't be here");
eventLogEntry = listener.EventLog.Entries.LastOrDefault();
if (eventLogEntry != null)
{
Assert.DoesNotContain("i shouldn't be here", eventLogEntry.Message);
}
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
private EventLogEntry WriteLogEntryEventSource(string source, bool data = false)
{
if (data)
{
Helpers.Retry(() => EventLog.WriteEvent(source, eventInstance, rawData, insertStrings));
}
else
{
Helpers.Retry(() => EventLog.WriteEvent(source, eventInstance, insertStrings));
}
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
return(eventLog.Entries.LastOrDefault());
}
}
public void SourceAlreadyExistsWhenCreatingSource()
{
string source = "Source_" + nameof(SourceAlreadyExistsWhenCreatingSource);
string log = "ExistingSource";
try
{
EventLog.CreateEventSource(source, log);
Assert.True(EventLog.SourceExists(source));
Assert.Throws <ArgumentException>(() => EventLog.CreateEventSource(source, log));
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
}
}
public void DeleteLog()
{
string log = "DeleteTest";
string source = "Source_" + nameof(DeleteLog);
try
{
EventLog.CreateEventSource(source, log);
Assert.True(EventLog.Exists(log));
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log));
Assert.False(EventLog.Exists(log));
}
}
public void CheckSourceExistenceAndDeletion()
{
string source = "Source_" + nameof(EventLogSourceCreationTests);
string log = "SourceExistenceLog";
try
{
EventLog.CreateEventSource(source, log);
Assert.True(EventLog.SourceExists(source));
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.Retry(() => EventLog.Delete(log)); // unlike other tests, throw if delete fails
}
Assert.False(EventLog.SourceExists(source));
}
private EventLogEntry WriteLogEntryEvent(string source, bool data = false)
{
using (EventLog eventLog = new EventLog())
{
string[] insertStringsSingleton = { "ExtraText" };
eventLog.Source = source;
if (data)
{
Helpers.Retry(() => eventLog.WriteEvent(eventInstance, rawData, insertStringsSingleton));
}
else
{
Helpers.Retry(() => eventLog.WriteEvent(eventInstance, insertStringsSingleton));
}
return(eventLog.Entries.LastOrDefault());
}
}
public void LogNameWithSame8FirstChars_NetFramework()
{
string firstSource = "FirstSource_" + nameof(LogNameWithSame8FirstChars_NetFramework);
string firstLog = "LogNameWithSame8FirstChars";
string secondSource = "SecondSource_" + nameof(LogNameWithSame8FirstChars_NetFramework);
string secondLog = "LogNameWithSame8FirstCharsDuplicate";
try
{
EventLog.CreateEventSource(firstSource, firstLog);
Assert.True(EventLog.SourceExists(firstSource));
Assert.Throws <ArgumentException>(() => EventLog.CreateEventSource(secondSource, secondLog));
}
finally
{
EventLog.DeleteEventSource(firstSource);
Helpers.Retry(() => EventLog.Delete(firstLog));
}
}
