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)); } }