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.RetrySilently(() => 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.RetrySilently(() => 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.RetrySilently(() => 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.RetrySilently(() => 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.RetrySilently(() => 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.RetrySilently(() => EventLog.Delete(log));
}
}
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.RetrySilently(() => 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.RetrySilently(() => EventLog.Delete(log));
}
}
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.RetrySilently(() => 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.RetrySilently(() => 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.RetrySilently(() => 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.RetrySilently(() => 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.RetrySilently(() => EventLog.Delete(log));
}
}
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.RetrySilently(() => EventLog.Delete(log));
}
}
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.RetrySilently(() => EventLog.Delete(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.RetrySilently(() => EventLog.Delete(log));
}
}
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.RetrySilently(() => 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.RetrySilently(() => 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.RetrySilently(() => 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.Retry(() => eventLog.Clear());
Assert.Equal(0, Helpers.Retry((() => eventLog.Entries.Count)));
Helpers.Retry(() => eventLog.WriteEntry("Writing to event log."));
Helpers.WaitForEventLog(eventLog, 1);
Assert.Equal(1, Helpers.Retry((() => eventLog.Entries.Count)));
}
}
finally
{
EventLog.DeleteEventSource(source);
Helpers.RetrySilently(() => EventLog.Delete(log));
}
}
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.RetrySilently(() => EventLog.Delete(log));
}
}
