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.RetryOnWin7(() => 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.RetryOnWin7(() => EventLog.Delete(log));
}
}
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.RetryOnWin7(() => EventLog.Delete(log));
}
}
public void WriteEventMessageValues_OutOfRange()
{
string source = "Source_" + nameof(WriteEventMessageValues_OutOfRange);
string[] message = new string[1];
message[0] = new string('c', 32767);
Assert.Throws <ArgumentException>(() => Helpers.RetryOnWin7(() => EventLog.WriteEvent(source, eventInstance, message)));
}
public void GetEventLogEntriesTest()
{
foreach (var eventLog in EventLog.GetEventLogs())
{
// Accessing eventlog properties should not throw.
Assert.True(Helpers.RetryOnWin7(() => 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.RetryOnWin7(() => EventLog.Delete(log));
}
}
public void WriteWithoutExistingSource()
{
string source = "Source_" + nameof(WriteWithoutExistingSource);
try
{
Helpers.RetryOnWin7(() => EventLog.WriteEvent(source, eventInstance, rawData, null));
Assert.Equal("Application", EventLog.LogNameFromSourceName(source, "."));
}
finally
{
EventLog.DeleteEventSource(source);
}
}
public void GetMessageUsingEventMessageDLL()
{
if (CultureInfo.CurrentCulture.ToString() != "en-US")
{
return;
}
using (EventLog eventlog = new EventLog("Security"))
{
eventlog.Source = "Security";
EventLogEntry eventLogEntry;
eventLogEntry = Helpers.RetryOnWin7(() => eventlog.Entries[0]);
Assert.Contains("", eventLogEntry.Message);
}
}
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.RetryOnWin7(() => EventLog.Delete(log));
}
}
private EventLogEntry WriteLogEntryEventSource(string source, bool data = false)
{
if (data)
{
Helpers.RetryOnWin7(() => EventLog.WriteEvent(source, eventInstance, rawData, insertStrings));
}
else
{
Helpers.RetryOnWin7(() => EventLog.WriteEvent(source, eventInstance, insertStrings));
}
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
return(eventLog.Entries.LastOrDefault());
}
}
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.RetryOnWin7(() => EventLog.Delete(log));
Assert.False(EventLog.Exists(log));
}
}
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.RetryOnWin7(() => EventLog.Delete(log));
}
}
private EventLogEntry WriteLogEntryEvent(string source, bool data = false)
{
using (EventLog eventLog = new EventLog())
{
string[] insertStringsSingleton = { "ExtraText" };
eventLog.Source = source;
if (data)
{
Helpers.RetryOnWin7(() => eventLog.WriteEvent(eventInstance, rawData, insertStringsSingleton));
}
else
{
Helpers.RetryOnWin7(() => eventLog.WriteEvent(eventInstance, insertStringsSingleton));
}
return(eventLog.Entries.LastOrDefault());
}
}
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.RetryOnWin7(() => EventLog.Delete(log));
}
Assert.False(EventLog.SourceExists(source));
}
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.RetryOnWin7(() => EventLog.Delete(firstLog));
}
}
public void LogDisplayNameDefault()
{
string source = "Source_" + nameof(LogDisplayNameDefault);
string log = "MyLogDisplay";
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventlog = new EventLog())
{
eventlog.Source = source;
Assert.Equal(log, eventlog.LogDisplayName);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.RetryOnWin7(() => EventLog.Delete(log));
}
}
public void GetMaxKilobytes_Set()
{
string source = "Source_" + nameof(GetMaxKilobytes_Set);
string log = "maxKilobytesLog";
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
eventLog.MaximumKilobytes = 0x400;
Assert.Equal(0x400, eventLog.MaximumKilobytes);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.RetryOnWin7(() => EventLog.Delete(log));
}
}
public void TraceDataParamsData(object[] parameters)
{
string log = "TraceDataParamsData";
string source = "Source" + nameof(TraceDataParamsData);
try
{
EventLog.CreateEventSource(source, log);
using (var listener = new EventLogTraceListener(source))
{
listener.TraceData(null, source, TraceEventType.Information, 1, parameters);
string expectedMessage = GetExpectedMessage(parameters);
ValidateLastEntryMessage(listener, expectedMessage, source);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.RetryOnWin7(() => 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);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
eventLog.EntryWritten += new EntryWrittenEventHandler((object sourceObject, EntryWrittenEventArgs e) =>
{
eventCounter += 1;
signal.Set();
});
Helpers.RetryOnWin7(() => eventLog.EnableRaisingEvents = waitOnEvent);
Helpers.RetryOnWin7(() => eventLog.WriteEntry(message, EventLogEntryType.Information));
if (waitOnEvent)
{
if (!signal.WaitOne(6000))
{
eventLog.WriteEntry(message, EventLogEntryType.Information);
Assert.True(signal.WaitOne(6000));
}
// The system responds to WriteEntry only if the last write event occurred at least six seconds previously.
// This implies that the system will only receive one EntryWritten event notification within a six-second interval, even if more than one event log change occurs.
// For more information https://msdn.microsoft.com/en-us/library/system.diagnostics.eventlog.entrywritten(v=vs.110).aspx
}
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.RetryOnWin7(() => EventLog.Delete(log));
}
}
public void CheckingEntryEqualityWithNull()
{
string log = "NullTest";
string source = "Source_" + nameof(CheckingEntryEqualityWithNull);
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
Helpers.RetryOnWin7(() => eventLog.WriteEntry(message));
Helpers.WaitForEventLog(eventLog, 1);
EventLogEntry entry = Helpers.RetryOnWin7(() => eventLog.Entries[eventLog.Entries.Count - 1]);
Assert.False(entry.Equals(null));
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.RetryOnWin7(() => 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);
Helpers.RetryOnWin7(() => EventLog.Delete(firstLog));
EventLog.DeleteEventSource(secondSource);
Helpers.RetryOnWin7(() => EventLog.Delete(secondLog));
}
}
private EventLogEntry WriteLogEntryWithSource(string source, bool type = false, bool instance = false, bool category = false, bool data = false)
{
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
if (instance)
{
Helpers.RetryOnWin7(() => EventLog.WriteEvent(source, eventInstance));
if (data)
{
Helpers.RetryOnWin7(() => EventLog.WriteEntry(source, message, EventLogEntryType.Warning, (int)eventInstance.InstanceId, (short)eventInstance.CategoryId, rawData));
return(eventLog.Entries.LastOrDefault());
}
else if (category)
{
Helpers.RetryOnWin7(() => EventLog.WriteEntry(source, message, EventLogEntryType.Warning, (int)eventInstance.InstanceId, (short)eventInstance.CategoryId));
return(eventLog.Entries.LastOrDefault());
}
else
{
Helpers.RetryOnWin7(() => EventLog.WriteEntry(source, message, EventLogEntryType.Warning, (int)eventInstance.InstanceId));
return(eventLog.Entries.LastOrDefault());
}
}
else if (type)
{
Helpers.RetryOnWin7(() => EventLog.WriteEntry(source, message, EventLogEntryType.Warning));
}
else
{
Helpers.RetryOnWin7(() => EventLog.WriteEntry(source, message));
}
return(eventLog.Entries.LastOrDefault());
}
}
public void WriteEntryWithTypeIdAndCategory(bool sourceFlag)
{
string source = "Source" + nameof(WriteEntryWithTypeIdAndCategory);
string log = "CategoryEntry";
try
{
EventLog.CreateEventSource(source, log);
EventLogEntry eventLogEntry;
if (sourceFlag)
{
eventLogEntry = WriteLogEntry(source, type: true, instance: true, category: true);
}
else
{
eventLogEntry = WriteLogEntryWithSource(source, type: true, instance: true, category: true);
}
// There is some prefix string already attached to the message passed
// The description for Event ID '0' in Source 'SourceWriteEntryWithTypeIDAndCategory' cannot be found. The local computer may not have the necessary registry information or message DLL files to display the message, or you may not have permission
// to access them. The following information is part of the event:'EventLogWriteEntryTestsMessage'
// The last part is the associated message
// The initial message is due in insufficient permission to access resource library EventLogMsgs.dll
if (eventLogEntry != null)
{
Assert.Contains(message, eventLogEntry.Message);
Assert.Equal((short)eventInstance.CategoryId, eventLogEntry.CategoryNumber);
Assert.Equal("(" + eventLogEntry.CategoryNumber + ")", eventLogEntry.Category);
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.RetryOnWin7(() => EventLog.Delete(log));
}
}
public void ClearLog()
{
string log = "ClearTest";
string source = "Source_" + nameof(ClearLog);
try
{
EventLog.CreateEventSource(source, log);
using (EventLog eventLog = new EventLog())
{
eventLog.Source = source;
Helpers.RetryOnWin7(() => eventLog.Clear());
Assert.Equal(0, Helpers.RetryOnWin7((() => eventLog.Entries.Count)));
Helpers.RetryOnWin7(() => eventLog.WriteEntry("Writing to event log."));
Helpers.WaitForEventLog(eventLog, 1);
Assert.Equal(1, Helpers.RetryOnWin7((() => eventLog.Entries.Count)));
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.RetryOnWin7(() => EventLog.Delete(log));
}
}
internal static EventLogEntry LastOrDefault(this EventLogEntryCollection elec)
{
return(Helpers.RetryOnWin7(() => elec.Count > 0 ? elec[elec.Count - 1] : null));
}
public void WriteEventInstanceNull()
{
string source = "Source_" + nameof(WriteEventInstanceNull);
Assert.Throws <ArgumentNullException>(() => Helpers.RetryOnWin7(() => EventLog.WriteEvent(source, null, insertStrings)));
}
