3 // NUnit Test Cases for System.Diagnostics.EventLog
6 // Gert Driesen <driesen@users.sourceforge.net>
8 // Copyright (C) 2006 Novell, Inc (http://www.novell.com)
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
32 // - CreateEventSource2
33 // - CreateEventSource3 (2.0 only)
34 // - Exists : local file
35 // - SourceExists : local file
36 // - GetEventLogs (2 overloads)
37 // - case-insensitive tests
38 // - use temp directory for event storage on 2.0 profile
39 // - WriteEvent tests with large instanceID (and check EventID)
45 using System.Collections;
46 using System.ComponentModel;
47 using System.Diagnostics;
48 using System.Globalization;
50 using System.Threading;
52 using Microsoft.Win32;
54 using NUnit.Framework;
56 namespace MonoTests.System.Diagnostics
59 public class EventLogTest
61 private string _originalEventLogImpl;
62 private string _eventLogStore;
64 private const string EVENTLOG_TYPE_VAR = "MONO_EVENTLOG_TYPE";
66 // IMPORTANT: also update constants in EventLogTest
67 private const string LOCAL_FILE_IMPL = "local";
68 private const string WIN32_IMPL = "win32";
69 private const string NULL_IMPL = "null";
74 if (Win32EventLogEnabled)
77 // determine temp directory for eventlog store
78 _eventLogStore = Path.Combine (Path.GetTempPath (),
79 Guid.NewGuid ().ToString ());
81 // save original eventlog implementation type (if set)
82 _originalEventLogImpl = Environment.GetEnvironmentVariable (
85 // use local file implementation
86 Environment.SetEnvironmentVariable (EVENTLOG_TYPE_VAR, "local:"
91 public void TearDown ()
93 if (Win32EventLogEnabled)
96 // restore original eventlog implementation type
97 Environment.SetEnvironmentVariable (EVENTLOG_TYPE_VAR,
98 _originalEventLogImpl);
100 // delete temp directory for eventlog store
101 if (Directory.Exists (_eventLogStore))
102 Directory.Delete (_eventLogStore, true);
108 if (EventLogImplType == NULL_IMPL)
109 // test cannot pass with NULL implementation
110 Assert.Ignore ("No EventLogImplType.");
112 if (EventLog.SourceExists ("monotempsource", "."))
113 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
115 if (EventLog.SourceExists ("monoothersource", "."))
116 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
118 if (EventLog.Exists ("monologtemp", "."))
119 Assert.Ignore ("Event log 'monologtemp' should not exist.");
121 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
122 EventLog.CreateEventSource ("monoothersource", "monologtemp", ".");
124 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
125 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A1");
127 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
128 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A3");
129 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
130 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A5");
131 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A6");
132 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A7");
134 EventLog.WriteEntry ("monotempsource", "Clear1");
136 Assert.AreEqual (1, eventLog.Entries.Count, "#B1");
138 Assert.AreEqual (0, eventLog.Entries.Count, "#B2");
139 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B3");
140 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
141 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B5");
142 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B6");
143 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B7");
145 EventLog.WriteEntry ("monotempsource", "Clear2");
147 EventLog.WriteEntry ("monotempsource", "Clear3");
148 EventLog.WriteEntry ("monoothersource", "Clear4");
150 Assert.AreEqual (2, eventLog.Entries.Count, "#C1");
151 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#C2");
152 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#C3");
153 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#C4");
154 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#C5");
155 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#C6");
157 EventLogEntry entry = eventLog.Entries [0];
158 Assert.IsNotNull (entry, "#D1");
159 Assert.IsNotNull (entry.Category, "#D2");
160 Assert.AreEqual ("(0)", entry.Category, "#D3");
161 Assert.AreEqual (0, entry.CategoryNumber, "#D4");
162 Assert.IsNotNull (entry.Data, "#D5");
163 Assert.AreEqual (0, entry.Data.Length, "#D6");
164 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#D7");
165 Assert.AreEqual (0, entry.EventID, "#D8");
166 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
167 Assert.IsNotNull (entry.MachineName, "#D10");
168 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#D11");
169 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
170 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
171 Assert.AreEqual ("Clear3", entry.ReplacementStrings [0], "#D14");
172 Assert.IsNotNull (entry.Source, "#D15");
173 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
174 Assert.IsNull (entry.UserName, "#D17");
176 entry = eventLog.Entries [1];
177 Assert.IsNotNull (entry, "#E1");
178 Assert.IsNotNull (entry.Category, "#E2");
179 Assert.AreEqual ("(0)", entry.Category, "#E3");
180 Assert.AreEqual (0, entry.CategoryNumber, "#E4");
181 Assert.IsNotNull (entry.Data, "#E5");
182 Assert.AreEqual (0, entry.Data.Length, "#E6");
183 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#E7");
184 Assert.AreEqual (0, entry.EventID, "#E8");
185 Assert.AreEqual (entry.EventID, entry.InstanceId, "#E9");
186 Assert.IsNotNull (entry.MachineName, "#E10");
187 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#E11");
188 Assert.IsNotNull (entry.ReplacementStrings, "#E12");
189 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#E13");
190 Assert.AreEqual ("Clear4", entry.ReplacementStrings [0], "#E14");
191 Assert.IsNotNull (entry.Source, "#E15");
192 Assert.AreEqual ("monoothersource", entry.Source, "#E16");
193 Assert.IsNull (entry.UserName, "#E17");
196 Assert.AreEqual (0, eventLog.Entries.Count, "#F1");
197 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#F2");
198 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#F3");
199 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#F4");
200 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#F5");
201 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#F6");
204 if (EventLog.Exists ("monologtemp"))
205 EventLog.Delete ("monologtemp");
210 public void Clear_Log_DoesNotExist ()
212 if (EventLogImplType == NULL_IMPL)
213 // test cannot pass with NULL implementation
214 Assert.Ignore ("No EventLogImplType.");
216 if (EventLog.Exists ("monologtemp", "."))
217 Assert.Ignore ("Event log 'monologtemp' should not exist.");
219 using (EventLog eventLog = new EventLog ("monologtemp", ".")) {
223 } catch (InvalidOperationException ex) {
224 // The event log 'monologtemp' on computer '.' does not exist
225 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
226 Assert.IsNotNull (ex.Message, "#3");
227 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#4");
228 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
229 Assert.IsNull (ex.InnerException, "#6");
231 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#7");
236 public void Clear_Log_Empty ()
238 if (EventLogImplType == NULL_IMPL)
239 // test cannot pass with NULL implementation
240 Assert.Ignore ("No EventLogImplType.");
242 if (EventLog.SourceExists ("monotempsource", "."))
243 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
245 if (EventLog.SourceExists ("monoothersource", "."))
246 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
248 if (EventLog.Exists ("monologtemp", "."))
249 Assert.Ignore ("Event log 'monologtemp' should not exist.");
251 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
253 using (EventLog eventLog = new EventLog (string.Empty, ".")) {
254 EventLog.WriteEntry ("monotempsource", "Clear_Log_Empty");
256 // both source & log are not set
260 } catch (ArgumentException ex) {
261 // Log property value has not been specified.
262 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
263 Assert.IsNotNull (ex.Message, "#A3");
264 Assert.IsNull (ex.InnerException, "#A4");
265 Assert.IsNull (ex.ParamName, "#A5");
267 Assert.AreEqual (string.Empty, eventLog.Log, "#A6");
269 // set non-existing source
270 eventLog.Source = "monoothersource";
275 } catch (ArgumentException ex) {
276 // Log property value has not been specified.
277 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
278 Assert.IsNotNull (ex.Message, "#B3");
279 Assert.IsNull (ex.InnerException, "#B4");
280 Assert.IsNull (ex.ParamName, "#B5");
282 Assert.AreEqual (string.Empty, eventLog.Log, "#B6");
284 // set existing source
285 eventLog.Source = "monotempsource";
287 Assert.IsTrue (eventLog.Entries.Count > 0, "#C1");
289 Assert.AreEqual ("monologtemp", eventLog.Log, "#C2");
290 Assert.AreEqual (0, eventLog.Entries.Count, "#C3");
293 if (EventLog.Exists ("monologtemp"))
294 EventLog.Delete ("monologtemp");
299 public void Clear_Source_DoesNotExist ()
301 if (EventLogImplType == NULL_IMPL)
302 // test cannot pass with NULL implementation
303 Assert.Ignore ("No EventLogImplType.");
305 if (EventLog.SourceExists ("monotempsource", "."))
306 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
308 if (EventLog.SourceExists ("monoothersource", "."))
309 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
311 if (EventLog.Exists ("monologtemp", "."))
312 Assert.Ignore ("Event log 'monologtemp' should not exist.");
314 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
316 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monoothersource")) {
317 EventLog.WriteEntry ("monotempsource", "Clear_Source_DoesNotExist");
319 Assert.IsTrue (eventLog.Entries.Count > 0, "#1");
321 Assert.AreEqual (0, eventLog.Entries.Count, "#2");
322 Assert.IsFalse (EventLog.SourceExists ("monoothersource", "."), "#3");
323 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#4");
324 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#5");
325 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#6");
326 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#7");
329 if (EventLog.Exists ("monologtemp"))
330 EventLog.Delete ("monologtemp");
335 public void Clear_Source_Empty ()
337 if (EventLogImplType == NULL_IMPL)
338 // test cannot pass with NULL implementation
339 Assert.Ignore ("No EventLogImplType.");
341 if (EventLog.SourceExists ("monotempsource", "."))
342 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
344 if (EventLog.Exists ("monologtemp", "."))
345 Assert.Ignore ("Event log 'monologtemp' should not exist.");
347 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
349 using (EventLog eventLog = new EventLog ("monologtemp", ".", string.Empty)) {
350 EventLog.WriteEntry ("monotempsource", "Clear_Source_Empty");
352 Assert.IsTrue (eventLog.Entries.Count > 0, "#1");
354 Assert.AreEqual (0, eventLog.Entries.Count, "#2");
355 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#3");
356 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#4");
357 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#5");
360 if (EventLog.Exists ("monologtemp"))
361 EventLog.Delete ("monologtemp");
366 public void Clear_Source_Null ()
368 if (EventLogImplType == NULL_IMPL)
369 // test cannot pass with NULL implementation
370 Assert.Ignore ("No EventLogImplType.");
372 if (EventLog.SourceExists ("monotempsource", "."))
373 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
375 if (EventLog.Exists ("monologtemp", "."))
376 Assert.Ignore ("Event log 'monologtemp' should not exist.");
378 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
380 using (EventLog eventLog = new EventLog ("monologtemp", ".", null)) {
381 EventLog.WriteEntry ("monotempsource", "Clear_Source_Null");
383 Assert.IsTrue (eventLog.Entries.Count > 0, "#1");
385 Assert.AreEqual (0, eventLog.Entries.Count, "#2");
386 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#3");
387 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#4");
388 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#5");
391 if (EventLog.Exists ("monologtemp"))
392 EventLog.Delete ("monologtemp");
397 public void Constructor1 ()
399 if (EventLogImplType == NULL_IMPL)
400 // test cannot pass with NULL implementation
401 Assert.Ignore ("No EventLogImplType.");
403 EventLog eventLog = new EventLog ();
404 Assert.IsFalse (eventLog.EnableRaisingEvents, "#1");
405 Assert.IsNotNull (eventLog.Entries, "#2");
407 eventLog.Entries.GetEnumerator ().MoveNext ();
409 } catch (ArgumentException ex) {
410 // Log property is not set (zero-length string)
411 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#3b");
412 Assert.IsNotNull (ex.Message, "#3c");
413 Assert.IsNull (ex.InnerException, "#3d");
414 Assert.IsNull (ex.ParamName, "#3e");
416 Assert.IsNotNull (eventLog.Log, "#4");
417 Assert.AreEqual (string.Empty, eventLog.Log, "#5");
419 string displayName = eventLog.LogDisplayName;
420 Assert.Fail ("#6a: " + displayName);
421 } catch (InvalidOperationException ex) {
422 // Event log names must consist of printable characters and
423 // cannot contain \, *, ?, or spaces
424 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#6b");
425 Assert.IsNotNull (ex.Message, "#6c");
426 Assert.IsNull (ex.InnerException, "#6d");
428 Assert.IsNotNull (eventLog.MachineName, "#7");
429 Assert.AreEqual (".", eventLog.MachineName, "#8");
430 Assert.IsNotNull (eventLog.Source, "#9");
431 Assert.AreEqual (string.Empty, eventLog.Source, "#10");
436 public void Constructor2 ()
438 if (EventLogImplType == NULL_IMPL)
439 // test cannot pass with NULL implementation
440 Assert.Ignore ("No EventLogImplType.");
442 if (EventLog.SourceExists ("monotempsource", "."))
443 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
445 if (EventLog.Exists ("monologtemp", "."))
446 Assert.Ignore ("Event log 'monologtemp' should not exist.");
448 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
450 using (EventLog eventLog = new EventLog ("monologtemp")) {
451 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
452 Assert.IsNotNull (eventLog.Entries, "#B2");
453 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#B3");
454 Assert.IsNotNull (eventLog.Log, "#B4");
455 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
456 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#B6");
457 Assert.IsNotNull (eventLog.MachineName, "#B7");
458 Assert.AreEqual (".", eventLog.MachineName, "#B8");
459 Assert.IsNotNull (eventLog.Source, "#B9");
460 Assert.AreEqual (string.Empty, eventLog.Source, "#B10");
463 EventLog.Delete ("monologtemp");
468 public void Constructor2_Log_DoesNotExist ()
470 if (EventLogImplType == NULL_IMPL)
471 // test cannot pass with NULL implementation
472 Assert.Ignore ("No EventLogImplType.");
474 if (EventLog.Exists ("monologtemp", "."))
475 Assert.Ignore ("Event log 'monologtemp' should not exist.");
477 EventLog eventLog = new EventLog ("monologtemp");
478 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
479 Assert.IsNotNull (eventLog.Entries, "#B2");
481 eventLog.Entries.GetEnumerator ().MoveNext ();
482 Assert.Fail ("#B3a");
483 } catch (InvalidOperationException ex) {
484 // The event log 'monologtemp' on computer '.' does not exist
485 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B3b");
486 Assert.IsNotNull (ex.Message, "#B3c");
487 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B3d");
488 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B3e");
489 Assert.IsNull (ex.InnerException, "#B3f");
491 Assert.IsNotNull (eventLog.Log, "#B4");
492 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
494 string displayName = eventLog.LogDisplayName;
495 Assert.Fail ("#B6a: " + displayName);
496 } catch (InvalidOperationException ex) {
497 // Cannot find Log monologtemp on computer .
498 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B6b");
499 Assert.IsNotNull (ex.Message, "#B6c");
500 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#B6d");
501 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#B6e");
502 Assert.IsNull (ex.InnerException, "#B6f");
504 Assert.IsNotNull (eventLog.MachineName, "#B7");
505 Assert.AreEqual (".", eventLog.MachineName, "#B8");
506 Assert.IsNotNull (eventLog.Source, "#B9");
507 Assert.AreEqual (string.Empty, eventLog.Source, "#B10");
512 public void Constructor2_Log_Empty ()
514 if (EventLogImplType == NULL_IMPL)
515 // test cannot pass with NULL implementation
516 Assert.Ignore ("No EventLogImplType.");
518 EventLog eventLog = new EventLog (string.Empty);
519 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
520 Assert.IsNotNull (eventLog.Entries, "#A2");
522 eventLog.Entries.GetEnumerator ().MoveNext ();
523 Assert.Fail ("#A3a");
524 } catch (ArgumentException ex) {
525 // Log property is not set (zero-length string)
526 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A3b");
527 Assert.IsNotNull (ex.Message, "#A3c");
528 Assert.IsNull (ex.InnerException, "#A3d");
529 Assert.IsNull (ex.ParamName, "#A3e");
531 Assert.IsNotNull (eventLog.Log, "#A4");
532 Assert.AreEqual (string.Empty, eventLog.Log, "#A5");
534 string displayName = eventLog.LogDisplayName;
535 Assert.Fail ("#A6a: " + displayName);
536 } catch (InvalidOperationException ex) {
537 // Event log names must consist of printable characters and
538 // cannot contain \, *, ?, or spaces
539 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A6b");
540 Assert.IsNotNull (ex.Message, "#A6c");
541 Assert.IsNull (ex.InnerException, "#A6d");
543 Assert.IsNotNull (eventLog.MachineName, "#A7");
544 Assert.AreEqual (".", eventLog.MachineName, "#A8");
545 Assert.IsNotNull (eventLog.Source, "#A9");
546 Assert.AreEqual (string.Empty, eventLog.Source, "#A10");
551 [ExpectedException (typeof (ArgumentNullException))]
552 public void Constructor2_Log_Null ()
558 public void Constructor3 ()
560 if (EventLogImplType == NULL_IMPL)
561 // test cannot pass with NULL implementation
562 Assert.Ignore ("No EventLogImplType.");
564 if (EventLog.SourceExists ("monotempsource", "."))
565 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
567 if (EventLog.Exists ("monologtemp", "."))
568 Assert.Ignore ("Event log 'monologtemp' should not exist.");
570 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
572 using (EventLog eventLog = new EventLog ("monologtemp", ".")) {
573 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
574 Assert.IsNotNull (eventLog.Entries, "#B2");
575 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#B3");
576 Assert.IsNotNull (eventLog.Log, "#B4");
577 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
578 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#B6");
579 Assert.IsNotNull (eventLog.MachineName, "#B7");
580 Assert.AreEqual (".", eventLog.MachineName, "#B8");
581 Assert.IsNotNull (eventLog.Source, "#B9");
582 Assert.AreEqual (string.Empty, eventLog.Source, "#B10");
585 EventLog.Delete ("monologtemp");
590 public void Constructor3_Log_DoesNotExist ()
592 if (EventLogImplType == NULL_IMPL)
593 // test cannot pass with NULL implementation
594 Assert.Ignore ("No EventLogImplType.");
596 if (EventLog.Exists ("monologtemp", "."))
597 Assert.Ignore ("Event log 'monologtemp' should not exist.");
599 EventLog eventLog = new EventLog ("monologtemp", ".");
600 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
601 Assert.IsNotNull (eventLog.Entries, "#B2");
603 eventLog.Entries.GetEnumerator ().MoveNext ();
604 Assert.Fail ("#B3a");
605 } catch (InvalidOperationException ex) {
606 // The event log 'monologtemp' on computer '.' does not exist
607 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B3b");
608 Assert.IsNotNull (ex.Message, "#B3c");
609 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B3d");
610 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B3e");
611 Assert.IsNull (ex.InnerException, "#B3f");
613 Assert.IsNotNull (eventLog.Log, "#B4");
614 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
616 string displayName = eventLog.LogDisplayName;
617 Assert.Fail ("#B6a: " + displayName);
618 } catch (InvalidOperationException ex) {
619 // Cannot find Log monologtemp on computer .
620 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B6b");
621 Assert.IsNotNull (ex.Message, "#B6c");
622 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#B6d");
623 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#B6e");
624 Assert.IsNull (ex.InnerException, "#B6f");
626 Assert.IsNotNull (eventLog.MachineName, "#B7");
627 Assert.AreEqual (".", eventLog.MachineName, "#B8");
628 Assert.IsNotNull (eventLog.Source, "#B9");
629 Assert.AreEqual (string.Empty, eventLog.Source, "#B10");
634 public void Constructor3_Log_Empty ()
636 if (EventLogImplType == NULL_IMPL)
637 // test cannot pass with NULL implementation
638 Assert.Ignore ("No EventLogImplType.");
640 EventLog eventLog = new EventLog (string.Empty, ".");
641 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
642 Assert.IsNotNull (eventLog.Entries, "#A2");
644 eventLog.Entries.GetEnumerator ().MoveNext ();
645 Assert.Fail ("#A3a");
646 } catch (ArgumentException ex) {
647 // Log property is not set (zero-length string)
648 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A3b");
649 Assert.IsNotNull (ex.Message, "#A3c");
650 Assert.IsNull (ex.InnerException, "#A3d");
651 Assert.IsNull (ex.ParamName, "#A3e");
653 Assert.IsNotNull (eventLog.Log, "#A4");
654 Assert.AreEqual (string.Empty, eventLog.Log, "#A5");
656 string displayName = eventLog.LogDisplayName;
657 Assert.Fail ("#A6a: " + displayName);
658 } catch (InvalidOperationException ex) {
659 // Event log names must consist of printable characters and
660 // cannot contain \, *, ?, or spaces
661 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A6b");
662 Assert.IsNotNull (ex.Message, "#A6c");
663 Assert.IsNull (ex.InnerException, "#A6d");
665 Assert.IsNotNull (eventLog.MachineName, "#A7");
666 Assert.AreEqual (".", eventLog.MachineName, "#A8");
667 Assert.IsNotNull (eventLog.Source, "#A9");
668 Assert.AreEqual (string.Empty, eventLog.Source, "#A10");
673 [ExpectedException (typeof (ArgumentNullException))]
674 public void Constructor3_Log_Null ()
676 new EventLog (null, ".");
680 public void Constructor3_MachineName_Empty ()
683 new EventLog ("monologtemp", string.Empty);
685 } catch (ArgumentException ex) {
686 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
687 Assert.IsNotNull (ex.Message, "#A3");
688 // Invalid value '' for parameter 'machineName'
689 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
690 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
691 Assert.IsNull (ex.InnerException, "#A6");
692 Assert.IsNull (ex.ParamName, "#A7");
696 new EventLog ("monologtemp", " \t\n");
698 } catch (ArgumentException ex) {
699 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
700 Assert.IsNotNull (ex.Message, "#B3");
701 // Invalid value ' \t\n' for parameter 'machineName'
702 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
703 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#B5");
704 Assert.IsNull (ex.InnerException, "#B6");
705 Assert.IsNull (ex.ParamName, "#B7");
710 public void Constructor3_MachineName_Null ()
713 new EventLog ("monologtemp", null);
715 } catch (ArgumentException ex) {
716 // Invalid value '' for parameter 'machineName'
717 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
718 Assert.IsNotNull (ex.Message, "#A3");
719 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
720 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
721 Assert.IsNull (ex.InnerException, "#A6");
722 Assert.IsNull (ex.ParamName, "#A7");
727 public void Constructor4 ()
729 if (EventLogImplType == NULL_IMPL)
730 // test cannot pass with NULL implementation
731 Assert.Ignore ("No EventLogImplType.");
733 if (EventLog.SourceExists ("monotempsource", "."))
734 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
736 if (EventLog.Exists ("monologtemp", "."))
737 Assert.Ignore ("Event log 'monologtemp' should not exist.");
739 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
741 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
742 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
743 Assert.IsNotNull (eventLog.Entries, "#A2");
744 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A3");
745 Assert.IsNotNull (eventLog.Log, "#A4");
746 Assert.AreEqual ("monologtemp", eventLog.Log, "#A5");
747 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#A6");
748 Assert.IsNotNull (eventLog.MachineName, "#A7");
749 Assert.AreEqual (".", eventLog.MachineName, "#A8");
750 Assert.IsNotNull (eventLog.Source, "#A9");
751 Assert.AreEqual ("monotempsource", eventLog.Source, "#A10");
754 using (EventLog eventLog = new EventLog ("monologtemp", ".", "whatever")) {
755 Assert.AreEqual ("monologtemp", eventLog.Log, "#B1");
756 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#B2");
759 EventLog.Delete ("monologtemp");
764 public void Constructor4_Log_DoesNotExist ()
766 if (EventLogImplType == NULL_IMPL)
767 // test cannot pass with NULL implementation
768 Assert.Ignore ("No EventLogImplType.");
770 if (EventLog.Exists ("monologtemp", "."))
771 Assert.Ignore ("Event log 'monologtemp' should not exist.");
773 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
774 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
775 Assert.IsNotNull (eventLog.Entries, "#B2");
777 eventLog.Entries.GetEnumerator ().MoveNext ();
778 Assert.Fail ("#B3a");
779 } catch (InvalidOperationException ex) {
780 // The event log 'monologtemp' on computer '.' does not exist
781 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B3b");
782 Assert.IsNotNull (ex.Message, "#B3c");
783 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B3d");
784 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B3e");
785 Assert.IsNull (ex.InnerException, "#B3f");
787 Assert.IsNotNull (eventLog.Log, "#B4");
788 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
790 string displayName = eventLog.LogDisplayName;
791 Assert.Fail ("#B6a: " + displayName);
792 } catch (InvalidOperationException ex) {
793 // Cannot find Log monologtemp on computer .
794 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B6b");
795 Assert.IsNotNull (ex.Message, "#B6c");
796 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#B6d");
797 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#B6e");
798 Assert.IsNull (ex.InnerException, "#B6f");
800 Assert.IsNotNull (eventLog.MachineName, "#B7");
801 Assert.AreEqual (".", eventLog.MachineName, "#B8");
802 Assert.IsNotNull (eventLog.Source, "#B9");
803 Assert.AreEqual ("monotempsource", eventLog.Source, "#B10");
808 public void Constructor4_Log_Empty ()
810 if (EventLogImplType == NULL_IMPL)
811 // test cannot pass with NULL implementation
812 Assert.Ignore ("No EventLogImplType.");
814 if (EventLog.SourceExists ("monotempsource", "."))
815 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
817 bool applicationLogExists = EventLog.Exists ("Application");
819 EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource");
820 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
821 Assert.IsNotNull (eventLog.Entries, "#A2");
823 eventLog.Entries.GetEnumerator ().MoveNext ();
824 Assert.Fail ("#A3a");
825 } catch (ArgumentException ex) {
826 // Log property is not set (zero-length string)
827 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A3b");
828 Assert.IsNotNull (ex.Message, "#A3c");
829 Assert.IsNull (ex.InnerException, "#A3d");
830 Assert.IsNull (ex.ParamName, "#A3e");
832 Assert.IsNotNull (eventLog.Log, "#A4");
833 Assert.AreEqual (string.Empty, eventLog.Log, "#A5");
835 string displayName = eventLog.LogDisplayName;
836 Assert.Fail ("#A6a: " + displayName);
837 } catch (InvalidOperationException ex) {
838 // Event log names must consist of printable characters and
839 // cannot contain \, *, ?, or spaces
840 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A6b");
841 Assert.IsNotNull (ex.Message, "#A6c");
842 Assert.IsNull (ex.InnerException, "#A6d");
844 Assert.IsNotNull (eventLog.MachineName, "#A7");
845 Assert.AreEqual (".", eventLog.MachineName, "#A8");
846 Assert.IsNotNull (eventLog.Source, "#A9");
847 Assert.AreEqual ("monotempsource", eventLog.Source, "#A10");
850 if (!applicationLogExists) {
851 if (EventLog.Exists ("Application"))
852 EventLog.Delete ("Application");
854 if (EventLog.SourceExists ("monotempsource", "."))
855 EventLog.DeleteEventSource ("monotempsource", ".");
861 [ExpectedException (typeof (ArgumentNullException))]
862 public void Constructor4_Log_Null ()
864 new EventLog (null, ".", "monotempsource");
868 public void Constructor4_MachineName_Empty ()
871 new EventLog ("monologtemp", string.Empty, "monotempsource");
873 } catch (ArgumentException ex) {
874 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
875 Assert.IsNotNull (ex.Message, "#A3");
876 // Invalid value '' for parameter 'machineName'
877 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
878 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
879 Assert.IsNull (ex.InnerException, "#A6");
880 Assert.IsNull (ex.ParamName, "#A7");
884 new EventLog ("monologtemp", " \t\n", "monotempsource");
886 } catch (ArgumentException ex) {
887 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
888 Assert.IsNotNull (ex.Message, "#B3");
889 // Invalid value ' \t\n' for parameter 'machineName'
890 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
891 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#B5");
892 Assert.IsNull (ex.InnerException, "#B6");
893 Assert.IsNull (ex.ParamName, "#B7");
898 public void Constructor4_MachineName_Null ()
901 new EventLog ("monologtemp", null, "monotempsource");
903 } catch (ArgumentException ex) {
904 // Invalid value '' for parameter 'machineName'
905 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
906 Assert.IsNotNull (ex.Message, "#A3");
907 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
908 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
909 Assert.IsNull (ex.InnerException, "#A6");
910 Assert.IsNull (ex.ParamName, "#A7");
915 public void Constructor4_Source_DoesNotExist ()
917 if (EventLogImplType == NULL_IMPL)
918 // test cannot pass with NULL implementation
919 Assert.Ignore ("No EventLogImplType.");
921 if (EventLog.SourceExists ("monoothersource", "."))
922 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
924 if (EventLog.SourceExists ("monotempsource", "."))
925 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
927 if (EventLog.Exists ("monologtemp", "."))
928 Assert.Ignore ("Event log 'monologtemp' should not exist.");
930 EventLog.CreateEventSource ("monoothersource", "monologtemp", ".");
932 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
933 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
934 Assert.IsNotNull (eventLog.Entries, "#A2");
935 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A3");
936 Assert.IsNotNull (eventLog.Log, "#A4");
937 Assert.AreEqual ("monologtemp", eventLog.Log, "#A5");
938 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#A6");
939 Assert.IsNotNull (eventLog.MachineName, "#A7");
940 Assert.AreEqual (".", eventLog.MachineName, "#A8");
941 Assert.IsNotNull (eventLog.Source, "#A9");
942 Assert.AreEqual ("monotempsource", eventLog.Source, "#A10");
943 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A11");
944 Assert.IsTrue (EventLog.SourceExists ("monoothersource"), "#A12");
945 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A13");
946 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A14");
947 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A15");
950 if (EventLog.Exists ("monologtemp"))
951 EventLog.Delete ("monologtemp");
956 public void Constructor4_Source_Empty ()
958 if (EventLogImplType == NULL_IMPL)
959 // test cannot pass with NULL implementation
960 Assert.Ignore ("No EventLogImplType.");
962 if (EventLog.SourceExists ("monotempsource", "."))
963 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
965 if (EventLog.Exists ("monologtemp", "."))
966 Assert.Ignore ("Event log 'monologtemp' should not exist.");
968 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
970 using (EventLog eventLog = new EventLog ("monologtemp", ".", string.Empty)) {
971 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
972 Assert.IsNotNull (eventLog.Entries, "#A2");
973 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A3");
974 Assert.IsNotNull (eventLog.Log, "#A4");
975 Assert.AreEqual ("monologtemp", eventLog.Log, "#A5");
976 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#A6");
977 Assert.IsNotNull (eventLog.MachineName, "#A7");
978 Assert.AreEqual (".", eventLog.MachineName, "#A8");
979 Assert.IsNotNull (eventLog.Source, "#A9");
980 Assert.AreEqual (string.Empty, eventLog.Source, "#A10");
981 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A11");
982 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A12");
983 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A13");
986 if (EventLog.Exists ("monologtemp"))
987 EventLog.Delete ("monologtemp");
992 public void Constructor4_Source_Null ()
994 if (EventLogImplType == NULL_IMPL)
995 // test cannot pass with NULL implementation
996 Assert.Ignore ("No EventLogImplType.");
998 if (EventLog.SourceExists ("monotempsource", "."))
999 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1001 if (EventLog.Exists ("monologtemp", "."))
1002 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1004 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1006 using (EventLog eventLog = new EventLog ("monologtemp", ".", null)) {
1007 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
1008 Assert.IsNotNull (eventLog.Entries, "#A2");
1009 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A3");
1010 Assert.IsNotNull (eventLog.Log, "#A4");
1011 Assert.AreEqual ("monologtemp", eventLog.Log, "#A5");
1012 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#A6");
1013 Assert.IsNotNull (eventLog.MachineName, "#A7");
1014 Assert.AreEqual (".", eventLog.MachineName, "#A8");
1015 Assert.IsNull (eventLog.Source, "#A9");
1016 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A10");
1017 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A11");
1018 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A12");
1021 if (EventLog.Exists ("monologtemp"))
1022 EventLog.Delete ("monologtemp");
1027 public void CreateEventSource1 ()
1029 if (EventLogImplType == NULL_IMPL)
1030 // test cannot pass with NULL implementation
1031 Assert.Ignore ("No EventLogImplType.");
1033 if (EventLog.SourceExists ("monotempsource", "."))
1034 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1036 if (EventLog.SourceExists ("monologtemp", "."))
1037 Assert.Ignore ("Event log source 'monologtemp' should not exist.");
1039 if (EventLog.Exists ("monologtemp", "."))
1040 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1042 if (EventLog.Exists ("monologother", "."))
1043 Assert.Ignore ("Event log 'monologother' should not exist.");
1046 EventLog.CreateEventSource ("monotempsource", "monologtemp");
1047 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A1");
1048 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A2");
1049 Assert.IsTrue (EventLog.SourceExists ("monologtemp", "."), "#A3");
1050 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A4");
1052 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
1053 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
1054 Assert.IsNotNull (eventLog.Entries, "#B2");
1055 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#B3");
1056 Assert.IsNotNull (eventLog.Log, "#B4");
1057 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
1058 Assert.IsNotNull (eventLog.LogDisplayName, "#B6");
1059 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#B7");
1060 Assert.IsNotNull (eventLog.MachineName, "#B8");
1061 Assert.AreEqual (".", eventLog.MachineName, "#B9");
1062 Assert.IsNotNull (eventLog.Source, "#B10");
1063 Assert.AreEqual ("monotempsource", eventLog.Source, "#B11");
1067 EventLog.CreateEventSource ("monologtemp", "monologother");
1068 Assert.Fail ("#C1");
1069 } catch (ArgumentException ex) {
1070 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1071 Assert.IsNotNull (ex.Message, "#C3");
1072 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#C4");
1073 Assert.IsTrue (ex.Message.IndexOf ("monologother") == -1, "#C5");
1074 Assert.IsNull (ex.InnerException, "#C6");
1075 Assert.IsNull (ex.ParamName, "#C7");
1079 EventLog.CreateEventSource ("monotempsource", "monologother");
1080 Assert.Fail ("#D1");
1081 } catch (ArgumentException ex) {
1082 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
1083 Assert.IsNotNull (ex.Message, "#D3");
1084 Assert.IsTrue (ex.Message.IndexOf ("monotempsource") != -1, "#D4");
1085 Assert.IsTrue (ex.Message.IndexOf ("monologother") == -1, "#D5");
1086 Assert.IsNull (ex.InnerException, "#D6");
1087 Assert.IsNull (ex.ParamName, "#D7");
1091 EventLog.CreateEventSource ("MonoTempSource", "monologother");
1092 Assert.Fail ("#E1");
1093 } catch (ArgumentException ex) {
1094 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
1095 Assert.IsNotNull (ex.Message, "#E3");
1096 Assert.IsTrue (ex.Message.IndexOf ("MonoTempSource") != -1, "#E4");
1097 Assert.IsTrue (ex.Message.IndexOf ("monologother") == -1, "#E5");
1098 Assert.IsNull (ex.InnerException, "#E6");
1099 Assert.IsNull (ex.ParamName, "#E7");
1102 if (EventLog.Exists ("monologtemp", "."))
1103 EventLog.Delete ("monologtemp", ".");
1105 if (EventLog.Exists ("monologother", "."))
1106 EventLog.Delete ("monologother", ".");
1111 [ExpectedException (typeof (ArgumentException))] // Must specify value for source
1112 public void CreateEventSource1_Source_Empty ()
1114 EventLog.CreateEventSource (string.Empty, "monologtemp");
1118 [ExpectedException (typeof (ArgumentException))] // Must specify value for source
1119 public void CreateEventSource1_Source_Null ()
1121 EventLog.CreateEventSource (null, "monologtemp");
1125 public void CreateEventSource1_Log_Empty ()
1127 if (EventLogImplType == NULL_IMPL)
1128 // test cannot pass with NULL implementation
1129 Assert.Ignore ("No EventLogImplType.");
1131 if (EventLog.SourceExists ("monotempsource", "."))
1132 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1134 bool logExists = EventLog.Exists ("Application", ".");
1136 EventLog.CreateEventSource ("monotempsource", string.Empty);
1137 string logName = EventLog.LogNameFromSourceName ("monotempsource", ".");
1138 Assert.IsNotNull (logName, "#1");
1139 Assert.AreEqual ("Application", logName, "#2");
1142 if (EventLog.Exists ("Application", ".")) {
1143 EventLog.Delete ("Application", ".");
1146 if (EventLog.SourceExists ("monotempsource", "."))
1147 EventLog.DeleteEventSource ("monotempsource", ".");
1153 public void CreateEventSource1_Log_ExistsAsSource ()
1155 if (EventLogImplType == NULL_IMPL)
1156 // test cannot pass with NULL implementation
1157 Assert.Ignore ("No EventLogImplType.");
1159 if (EventLog.SourceExists ("monotempsource", "."))
1160 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1162 if (EventLog.SourceExists ("monologtemp", "."))
1163 Assert.Ignore ("Event log source 'monologtemp' should not exist.");
1165 if (EventLog.Exists ("monologtemp", "."))
1166 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1168 if (EventLog.Exists ("monologother", "."))
1169 Assert.Ignore ("Event log 'monologother' should not exist.");
1172 EventLog.CreateEventSource ("monologtemp", "monologother", ".");
1173 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A1");
1174 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#A2");
1175 Assert.IsTrue (EventLog.SourceExists ("monologtemp", "."), "#A3");
1176 Assert.IsTrue (EventLog.SourceExists ("monologother", "."), "#A4");
1179 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1180 Assert.Fail ("#B1");
1181 } catch (ArgumentException ex) {
1182 // Log monologtemp has already been registered as a source
1183 // on the local computer
1184 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1185 Assert.IsNotNull (ex.Message, "#B3");
1186 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#B4");
1187 Assert.IsNull (ex.InnerException, "#B5");
1188 Assert.IsNull (ex.ParamName, "#B6");
1191 if (EventLog.Exists ("monologtemp", "."))
1192 EventLog.Delete ("monologtemp", ".");
1194 if (EventLog.Exists ("monologother", "."))
1195 EventLog.Delete ("monologother", ".");
1200 public void CreateEventSource1_Log_InvalidCustomerLog ()
1202 if (EventLogImplType != NULL_IMPL)
1203 // test cannot pass with NULL implementation
1204 Assert.Ignore ("No EventLogImplType.");
1206 if (EventLog.SourceExists ("monotempsource", "."))
1207 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1209 if (EventLog.Exists ("AppEvent", "."))
1210 Assert.Ignore ("Event log 'AppEvent' should not exist.");
1213 EventLog.CreateEventSource ("monotempsource", "AppEvent");
1214 Assert.Fail ("#A1");
1215 } catch (ArgumentException ex) {
1216 // The log name: 'AppEvent' is invalid for customer log creation
1217 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1218 Assert.IsNotNull (ex.Message, "#A3");
1219 Assert.IsTrue (ex.Message.IndexOf ("'AppEvent'") != -1, "#A4");
1220 Assert.IsNull (ex.InnerException, "#A5");
1221 Assert.IsNull (ex.ParamName, "#A6");
1225 EventLog.CreateEventSource ("monotempsource", "appevent");
1226 Assert.Fail ("#B1");
1227 } catch (ArgumentException ex) {
1228 // The log name: 'appevent' is invalid for customer log creation
1229 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1230 Assert.IsNotNull (ex.Message, "#B3");
1231 Assert.IsTrue (ex.Message.IndexOf ("'appevent'") != -1, "#B4");
1232 Assert.IsNull (ex.InnerException, "#B5");
1233 Assert.IsNull (ex.ParamName, "#B6");
1236 if (EventLog.Exists ("SysEvent", "."))
1237 Assert.Ignore ("Event log 'SysEvent' should not exist.");
1240 EventLog.CreateEventSource ("monotempsource", "SysEvent");
1241 Assert.Fail ("#C1");
1242 } catch (ArgumentException ex) {
1243 // The log name: 'SysEvent' is invalid for customer log creation
1244 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1245 Assert.IsNotNull (ex.Message, "#C3");
1246 Assert.IsTrue (ex.Message.IndexOf ("'SysEvent'") != -1, "#C4");
1247 Assert.IsNull (ex.InnerException, "#C5");
1248 Assert.IsNull (ex.ParamName, "#C6");
1252 EventLog.CreateEventSource ("monotempsource", "sysevent");
1253 Assert.Fail ("#D1");
1254 } catch (ArgumentException ex) {
1255 // The log name: 'sysEvent' is invalid for customer log creation
1256 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
1257 Assert.IsNotNull (ex.Message, "#D3");
1258 Assert.IsTrue (ex.Message.IndexOf ("'sysevent'") != -1, "#D4");
1259 Assert.IsNull (ex.InnerException, "#D5");
1260 Assert.IsNull (ex.ParamName, "#D6");
1263 if (EventLog.Exists ("SecEvent", "."))
1264 Assert.Ignore ("Event log 'SecEvent' should not exist.");
1267 EventLog.CreateEventSource ("monotempsource", "SecEvent");
1268 Assert.Fail ("#E1");
1269 } catch (ArgumentException ex) {
1270 // The log name: 'SecEvent' is invalid for customer log creation
1271 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
1272 Assert.IsNotNull (ex.Message, "#E3");
1273 Assert.IsTrue (ex.Message.IndexOf ("'SecEvent'") != -1, "#E4");
1274 Assert.IsNull (ex.InnerException, "#E5");
1275 Assert.IsNull (ex.ParamName, "#E6");
1279 EventLog.CreateEventSource ("monotempsource", "secevent");
1280 Assert.Fail ("#F1");
1281 } catch (ArgumentException ex) {
1282 // The log name: 'secevent' is invalid for customer log creation
1283 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
1284 Assert.IsNotNull (ex.Message, "#F3");
1285 Assert.IsTrue (ex.Message.IndexOf ("'secevent'") != -1, "#F4");
1286 Assert.IsNull (ex.InnerException, "#F5");
1287 Assert.IsNull (ex.ParamName, "#F6");
1290 if (EventLog.Exists ("AppEventA", "."))
1291 Assert.Ignore ("Event log 'AppEventA' should not exist.");
1294 EventLog.CreateEventSource ("monotempsource", "AppEventA");
1295 Assert.Fail ("#G1");
1296 } catch (ArgumentException ex) {
1297 // The log name: 'AppEventA' is invalid for customer log creation
1298 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#G2");
1299 Assert.IsNotNull (ex.Message, "#G3");
1300 Assert.IsTrue (ex.Message.IndexOf ("'AppEventA'") != -1, "#G4");
1301 Assert.IsNull (ex.InnerException, "#G5");
1302 Assert.IsNull (ex.ParamName, "#G6");
1305 if (EventLog.Exists ("SysEventA", "."))
1306 Assert.Ignore ("Event log 'SysEventA' should not exist.");
1309 EventLog.CreateEventSource ("monotempsource", "SysEventA");
1310 Assert.Fail ("#H1");
1311 } catch (ArgumentException ex) {
1312 // The log name: 'SysEventA' is invalid for customer log creation
1313 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#H2");
1314 Assert.IsNotNull (ex.Message, "#H3");
1315 Assert.IsTrue (ex.Message.IndexOf ("'SysEventA'") != -1, "#H4");
1316 Assert.IsNull (ex.InnerException, "#H5");
1317 Assert.IsNull (ex.ParamName, "#H6");
1320 if (EventLog.Exists ("SecEventA", "."))
1321 Assert.Ignore ("Event log 'SecEventA' should not exist.");
1324 EventLog.CreateEventSource ("monotempsource", "SecEventA");
1325 Assert.Fail ("#I1");
1326 } catch (ArgumentException ex) {
1327 // The log name: 'SecEventA' is invalid for customer log creation
1328 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
1329 Assert.IsNotNull (ex.Message, "#I3");
1330 Assert.IsTrue (ex.Message.IndexOf ("'SecEventA'") != -1, "#I4");
1331 Assert.IsNull (ex.InnerException, "#I5");
1332 Assert.IsNull (ex.ParamName, "#I6");
1337 public void CreateEventSource1_Log_NotUnique ()
1339 if (EventLogImplType != NULL_IMPL)
1340 // test cannot pass with NULL implementation
1341 Assert.Ignore ("No EventLogImplType.");
1343 if (EventLog.SourceExists ("monotempsource", "."))
1344 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1346 if (EventLog.SourceExists ("monotestsource", "."))
1347 Assert.Ignore ("Event log source 'monotestsource' should not exist.");
1349 if (EventLog.SourceExists ("monoothersource", "."))
1350 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1352 if (EventLog.Exists ("monologtemp", "."))
1353 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1355 if (EventLog.Exists ("monologtest", "."))
1356 Assert.Ignore ("Event log 'monologtest' should not exist.");
1358 if (EventLog.Exists ("monologother", "."))
1359 Assert.Ignore ("Event log 'monologother' should not exist.");
1361 // the 8th character of the log name differs
1363 EventLog.CreateEventSource ("monoothersource", "monologother");
1364 EventLog.CreateEventSource ("monotempsource", "monologtemp");
1366 if (EventLog.Exists ("monologother"))
1367 EventLog.Delete ("monologother");
1368 if (EventLog.Exists ("monologtemp"))
1369 EventLog.Delete ("monologtemp");
1372 // the first 8 characters match
1374 EventLog.CreateEventSource ("monotestsource", "monologtest");
1375 EventLog.CreateEventSource ("monotempsource", "monologtemp");
1376 Assert.Fail ("#A1");
1377 } catch (ArgumentException ex) {
1378 // Only the first eight characters of a custom log name are
1379 // significant, and there is already another log on the system
1380 // using the first eight characters of the name given.
1381 // Name given: 'monologtemp', name of existing log: 'monologtest'
1382 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1383 Assert.IsNotNull (ex.Message, "#B3");
1384 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B4");
1385 Assert.IsTrue (ex.Message.IndexOf ("'monologtest'") != -1, "#B5");
1386 Assert.IsNull (ex.InnerException, "#B6");
1387 Assert.IsNull (ex.ParamName, "#B7");
1389 if (EventLog.Exists ("monologtest"))
1390 EventLog.Delete ("monologtest");
1391 if (EventLog.Exists ("monologtemp"))
1392 EventLog.Delete ("monologtemp");
1397 public void CreateEventSource1_Log_Null ()
1399 if (EventLogImplType == NULL_IMPL)
1400 // test cannot pass with NULL implementation
1401 Assert.Ignore ("No EventLogImplType.");
1403 if (EventLog.SourceExists ("monotempsource", "."))
1404 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1406 bool logExists = EventLog.Exists ("Application", ".");
1408 EventLog.CreateEventSource ("monotempsource", null);
1409 string logName = EventLog.LogNameFromSourceName ("monotempsource", ".");
1410 Assert.IsNotNull (logName, "#1");
1411 Assert.AreEqual ("Application", logName, "#2");
1414 if (EventLog.Exists ("Application"))
1415 EventLog.Delete ("Application");
1417 if (EventLog.SourceExists ("monotempsource", "."))
1418 EventLog.DeleteEventSource ("monotempsource", ".");
1424 public void Delete1 ()
1426 if (EventLogImplType == NULL_IMPL)
1427 // test cannot pass with NULL implementation
1428 Assert.Ignore ("No EventLogImplType.");
1430 if (EventLog.SourceExists ("monotempsource", "."))
1431 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1433 if (EventLog.SourceExists ("monoothersource", "."))
1434 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
1436 if (EventLog.Exists ("monologtemp", "."))
1437 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1439 if (EventLog.Exists ("monologother", "."))
1440 Assert.Ignore ("Event log 'monologother' should not exist.");
1443 EventLog.CreateEventSource ("monoothersource", "monologother", ".");
1444 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1446 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A1");
1447 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A2");
1448 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A3");
1449 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
1450 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A5");
1451 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A6");
1452 EventLog.Delete ("monologtemp");
1453 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#A7");
1454 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A8");
1455 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#A9");
1456 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A10");
1457 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A11");
1458 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A12");
1460 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1462 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B1");
1463 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#B2");
1464 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B3");
1465 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
1466 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B5");
1467 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B6");
1468 EventLog.Delete ("MonoLogTemp");
1469 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#B7");
1470 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#B8");
1471 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#B9");
1472 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B10");
1473 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B11");
1474 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B12");
1476 if (EventLog.Exists ("monologother"))
1477 EventLog.Delete ("monologother");
1482 public void Delete1_Log_DoesNotExist ()
1484 if (EventLogImplType == NULL_IMPL)
1485 // test cannot pass with NULL implementation
1486 Assert.Ignore ("No EventLogImplType.");
1488 if (EventLog.SourceExists ("monotempsource", "."))
1489 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1491 if (EventLog.Exists ("monologtemp", "."))
1492 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1495 EventLog.Delete ("monologtemp");
1497 } catch (InvalidOperationException ex) {
1498 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1499 Assert.IsNotNull (ex.Message, "#3");
1500 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#4");
1501 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#5");
1502 Assert.IsNull (ex.InnerException, "#6");
1507 [ExpectedException (typeof (ArgumentException))] // Log to delete was not specified
1508 public void Delete1_Log_Empty ()
1510 EventLog.Delete (string.Empty);
1514 [ExpectedException (typeof (ArgumentException))] // Log to delete was not specified
1515 public void Delete1_Log_Null ()
1517 EventLog.Delete (null);
1521 public void Delete2 ()
1523 if (EventLogImplType == NULL_IMPL)
1524 // test cannot pass with NULL implementation
1525 Assert.Ignore ("No EventLogImplType.");
1527 if (EventLog.SourceExists ("monotempsource", "."))
1528 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1530 if (EventLog.SourceExists ("monoothersource", "."))
1531 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
1533 if (EventLog.Exists ("monologtemp", "."))
1534 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1536 if (EventLog.Exists ("monologother", "."))
1537 Assert.Ignore ("Event log 'monologother' should not exist.");
1540 EventLog.CreateEventSource ("monoothersource", "monologother", ".");
1541 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1543 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A1");
1544 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A2");
1545 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A3");
1546 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
1547 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A5");
1548 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A6");
1549 EventLog.Delete ("monologtemp", ".");
1550 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#A7");
1551 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A8");
1552 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#A9");
1553 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A10");
1554 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A11");
1555 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A12");
1557 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1559 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B1");
1560 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#B2");
1561 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B3");
1562 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
1563 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B5");
1564 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B6");
1565 EventLog.Delete ("MonoLogTemp", ".");
1566 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#B7");
1567 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#B8");
1568 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#B9");
1569 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B10");
1570 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B11");
1571 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B12");
1573 if (EventLog.Exists ("monologother"))
1574 EventLog.Delete ("monologother");
1579 public void Delete2_Log_DoesNotExist ()
1581 if (EventLogImplType == NULL_IMPL)
1582 // test cannot pass with NULL implementation
1583 Assert.Ignore ("No EventLogImplType.");
1585 if (EventLog.SourceExists ("monotempsource", "."))
1586 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1588 if (EventLog.Exists ("monologtemp", "."))
1589 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1592 EventLog.Delete ("monologtemp", ".");
1594 } catch (InvalidOperationException ex) {
1595 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1596 Assert.IsNotNull (ex.Message, "#3");
1597 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#4");
1598 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#5");
1599 Assert.IsNull (ex.InnerException, "#6");
1604 [ExpectedException (typeof (ArgumentException))] // Log to delete was not specified
1605 public void Delete2_Log_Empty ()
1607 EventLog.Delete (string.Empty, ".");
1611 [ExpectedException (typeof (ArgumentException))] // Log to delete was not specified
1612 public void Delete2_Log_Null ()
1614 EventLog.Delete (null, ".");
1618 public void Delete2_MachineName_Empty ()
1621 EventLog.Delete ("monologtemp", string.Empty);
1622 Assert.Fail ("#A1");
1623 } catch (ArgumentException ex) {
1624 // // Invalid format for argument machineName
1625 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1626 Assert.IsNotNull (ex.Message, "#A3");
1627 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#A4");
1628 Assert.IsNull (ex.InnerException, "#A5");
1629 Assert.IsNull (ex.ParamName, "#A6");
1633 EventLog.Delete ("monologtemp", " \t\n");
1634 Assert.Fail ("#B1");
1635 } catch (ArgumentException ex) {
1636 // // Invalid format for argument machineName
1637 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1638 Assert.IsNotNull (ex.Message, "#B3");
1639 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#B4");
1640 Assert.IsNull (ex.InnerException, "#B5");
1641 Assert.IsNull (ex.ParamName, "#B6");
1646 public void Delete2_MachineName_Null ()
1649 EventLog.Delete ("monologtemp", null);
1651 } catch (ArgumentException ex) {
1652 // // Invalid format for argument machineName
1653 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1654 Assert.IsNotNull (ex.Message, "#3");
1655 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#4");
1656 Assert.IsNull (ex.InnerException, "#5");
1657 Assert.IsNull (ex.ParamName, "#6");
1662 public void DeleteEventSource1 ()
1664 if (EventLogImplType == NULL_IMPL)
1665 // test cannot pass with NULL implementation
1666 Assert.Ignore ("No EventLogImplType.");
1668 if (EventLog.SourceExists ("monotempsource", "."))
1669 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1671 if (EventLog.SourceExists ("monoothersource", "."))
1672 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
1674 bool monologtempExists = EventLog.Exists ("monologtemp", ".");
1676 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1677 EventLog.CreateEventSource ("monoothersource", "monologtemp", ".");
1679 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A1");
1680 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A2");
1681 EventLog.DeleteEventSource ("monotempsource");
1682 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#A3");
1683 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
1684 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A5");
1685 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A6");
1686 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A7");
1688 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1690 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B1");
1691 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A2");
1692 EventLog.DeleteEventSource ("MonoTempSource");
1693 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#B3");
1694 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
1695 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B5");
1696 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B6");
1697 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B7");
1699 if (!monologtempExists) {
1700 EventLog.Delete ("monologtemp");
1706 public void DeleteEventSource1_Source_DoesNotExist ()
1708 if (EventLogImplType == NULL_IMPL)
1709 // test cannot pass with NULL implementation
1710 Assert.Ignore ("No EventLogImplType.");
1712 if (EventLog.SourceExists ("monotempsource", "."))
1713 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1716 EventLog.DeleteEventSource ("monotempsource");
1718 } catch (ArgumentException ex) {
1719 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1720 Assert.IsNotNull (ex.Message, "#3");
1721 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#4");
1722 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
1723 Assert.IsNull (ex.InnerException, "#6");
1724 Assert.IsNull (ex.ParamName, "#7");
1729 [ExpectedException (typeof (ArgumentException))] // The source '' is not registered on machine '.', ...
1730 public void DeleteEventSource1_Source_Empty ()
1732 if (EventLogImplType == NULL_IMPL)
1733 // allow test to pass with NULL implementation
1734 throw new ArgumentException ();
1736 EventLog.DeleteEventSource (string.Empty);
1740 [ExpectedException (typeof (ArgumentException))] // The source '' is not registered on machine '.', ...
1741 public void DeleteEventSource1_Source_Null ()
1743 if (EventLogImplType == NULL_IMPL)
1744 // allow test to pass with NULL implementation
1745 throw new ArgumentException ();
1747 EventLog.DeleteEventSource (null);
1751 public void DeleteEventSource2 ()
1753 if (EventLogImplType == NULL_IMPL)
1754 // test cannot pass with NULL implementation
1755 Assert.Ignore ("No EventLogImplType.");
1757 if (EventLog.SourceExists ("monotempsource", "."))
1758 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1760 if (EventLog.SourceExists ("monoothersource", "."))
1761 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
1763 bool monologtempExists = EventLog.Exists ("monologtemp", ".");
1765 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1766 EventLog.CreateEventSource ("monoothersource", "monologtemp", ".");
1768 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A1");
1769 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A2");
1770 EventLog.DeleteEventSource ("monotempsource");
1771 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#A3");
1772 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
1773 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A5");
1774 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A6");
1775 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A7");
1777 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1779 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B1");
1780 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A2");
1781 EventLog.DeleteEventSource ("MonoTempSource");
1782 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#B3");
1783 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
1784 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B5");
1785 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B6");
1786 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B7");
1788 if (!monologtempExists) {
1789 EventLog.Delete ("monologtemp");
1795 public void DeleteEventSource2_MachineName_Empty ()
1798 EventLog.DeleteEventSource ("monotempsource", string.Empty);
1799 Assert.Fail ("#A1");
1800 } catch (ArgumentException ex) {
1801 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1802 Assert.IsNotNull (ex.Message, "#A3");
1803 // Invalid value '' for parameter 'machineName'
1804 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
1805 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
1806 Assert.IsNull (ex.InnerException, "#A6");
1807 Assert.IsNull (ex.ParamName, "#A7");
1811 EventLog.DeleteEventSource ("monotempsource", " \t\n");
1812 Assert.Fail ("#B1");
1813 } catch (ArgumentException ex) {
1814 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1815 Assert.IsNotNull (ex.Message, "#B3");
1816 // Invalid value ' \t\n' for parameter 'machineName'
1817 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
1818 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#B5");
1819 Assert.IsNull (ex.InnerException, "#B6");
1820 Assert.IsNull (ex.ParamName, "#B7");
1825 public void DeleteEventSource2_MachineName_Null ()
1828 EventLog.DeleteEventSource ("monotempsource", null);
1829 Assert.Fail ("#A1");
1830 } catch (ArgumentException ex) {
1831 // Invalid value '' for parameter 'machineName'
1832 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1833 Assert.IsNotNull (ex.Message, "#A3");
1834 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
1835 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
1836 Assert.IsNull (ex.InnerException, "#A6");
1837 Assert.IsNull (ex.ParamName, "#A7");
1842 public void DeleteEventSource2_Source_DoesNotExist ()
1844 if (EventLogImplType == NULL_IMPL)
1845 // test cannot pass with NULL implementation
1846 Assert.Ignore ("No EventLogImplType.");
1848 if (EventLog.SourceExists ("monotempsource", "."))
1849 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1852 EventLog.DeleteEventSource ("monotempsource", ".");
1854 } catch (ArgumentException ex) {
1855 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1856 Assert.IsNotNull (ex.Message, "#3");
1857 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#4");
1858 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
1859 Assert.IsNull (ex.InnerException, "#6");
1860 Assert.IsNull (ex.ParamName, "#7");
1865 [ExpectedException (typeof (ArgumentException))] // The source '' is not registered on machine '.', ...
1866 public void DeleteEventSource2_Source_Empty ()
1868 if (EventLogImplType == NULL_IMPL)
1869 // allow test to pass with NULL implementation
1870 throw new ArgumentException ();
1872 EventLog.DeleteEventSource (string.Empty, ".");
1876 [ExpectedException (typeof (ArgumentException))] // The source '' is not registered on machine '.', ...
1877 public void DeleteEventSource2_Source_Null ()
1879 if (EventLogImplType == NULL_IMPL)
1880 // allow test to pass with NULL implementation
1881 throw new ArgumentException ();
1883 EventLog.DeleteEventSource (null, ".");
1887 public void Entries ()
1889 EventLogEntry entry = null;
1890 object current = null;
1892 if (EventLogImplType == NULL_IMPL)
1893 // test cannot pass with NULL implementation
1894 Assert.Ignore ("No EventLogImplType.");
1896 if (EventLog.SourceExists ("monotempsource", "."))
1897 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1899 if (EventLog.Exists ("monologtemp", "."))
1900 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1902 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1904 using (EventLog eventLog = new EventLog ("monologtemp", ".", string.Empty)) {
1905 Assert.IsNotNull (eventLog.Entries, "#A1");
1906 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
1908 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
1909 Assert.IsNotNull (enumerator, "#B");
1912 current = enumerator.Current;
1913 Assert.Fail ("#C1: " + current);
1914 } catch (InvalidOperationException ex) {
1915 // No current EventLog entry available, cursor is located
1916 // before the first or after the last element of the
1918 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1919 Assert.IsNotNull (ex.Message, "#C3");
1920 Assert.IsNull (ex.InnerException, "#C4");
1923 Assert.IsFalse (enumerator.MoveNext (), "#D");
1926 current = enumerator.Current;
1927 Assert.Fail ("#E1: " + current);
1928 } catch (InvalidOperationException ex) {
1929 // No current EventLog entry available, cursor is located
1930 // before the first or after the last element of the
1932 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
1933 Assert.IsNotNull (ex.Message, "#E3");
1934 Assert.IsNull (ex.InnerException, "#E4");
1937 EventLogEntry [] entries = new EventLogEntry [0];
1938 eventLog.Entries.CopyTo (entries, 0);
1940 EventLog.WriteEntry ("monotempsource", "Entries1");
1943 current = enumerator.Current;
1944 Assert.Fail ("#G1: " + current);
1945 } catch (InvalidOperationException ex) {
1946 // No current EventLog entry available, cursor is located
1947 // before the first or after the last element of the
1949 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
1950 Assert.IsNotNull (ex.Message, "#G3");
1951 Assert.IsNull (ex.InnerException, "#G4");
1954 Assert.IsFalse (enumerator.MoveNext (), "#H1");
1955 Assert.AreEqual (1, eventLog.Entries.Count, "#H2");
1956 enumerator.Reset ();
1958 entries = new EventLogEntry [0];
1960 eventLog.Entries.CopyTo (entries, 0);
1961 Assert.Fail ("#I1");
1962 } catch (ArgumentException ex) {
1963 // Destination array was not long enough. Check destIndex
1964 // and length, and the array's lower bounds
1965 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
1966 Assert.IsNotNull (ex.Message, "#I3");
1967 Assert.IsNull (ex.InnerException, "#I4");
1968 Assert.AreEqual ("", ex.ParamName, "#I5");
1971 entries = new EventLogEntry [1];
1972 eventLog.Entries.CopyTo (entries, 0);
1974 entry = entries [0];
1975 Assert.IsNotNull (entry, "#J1");
1976 Assert.IsNotNull (entry.Source, "#J2");
1977 Assert.AreEqual ("monotempsource", entry.Source, "#J3");
1978 Assert.IsNotNull (entry.ReplacementStrings, "#J4");
1979 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#J5");
1980 Assert.AreEqual ("Entries1", entry.ReplacementStrings [0], "#J6");
1982 Assert.IsTrue (enumerator.MoveNext (), "#K1");
1983 Assert.IsNotNull (enumerator.Current, "#K2");
1984 Assert.IsFalse (enumerator.MoveNext (), "#K3");
1985 enumerator.Reset ();
1986 Assert.IsTrue (enumerator.MoveNext (), "#K4");
1987 Assert.IsNotNull (enumerator.Current, "#K5");
1988 Assert.IsFalse (enumerator.MoveNext (), "#K6");
1990 EventLog.WriteEntry ("monotempsource", "Entries2");
1991 EventLog.WriteEntry ("monotempsource", "Entries3");
1993 Assert.IsTrue (enumerator.MoveNext (), "#L");
1995 entry = (EventLogEntry) enumerator.Current;
1996 Assert.IsNotNull (entry, "#M1");
1997 Assert.IsNotNull (entry.Source, "#M2");
1998 Assert.AreEqual ("monotempsource", entry.Source, "#M3");
1999 Assert.IsNotNull (entry.ReplacementStrings, "#M4");
2000 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#M5");
2001 Assert.AreEqual ("Entries3", entry.ReplacementStrings [0], "#M6");
2003 enumerator.Reset ();
2004 Assert.IsNotNull (enumerator.Current, "#N1");
2005 Assert.IsTrue (enumerator.MoveNext (), "#N2");
2006 Assert.IsNotNull (enumerator.Current, "#N3");
2007 Assert.IsTrue (enumerator.MoveNext (), "#N4");
2008 Assert.IsNotNull (enumerator.Current, "#N5");
2009 Assert.IsTrue (enumerator.MoveNext (), "#N6");
2010 Assert.IsNotNull (enumerator.Current, "#N7");
2011 Assert.IsFalse (enumerator.MoveNext (), "#N8");
2012 enumerator.Reset ();
2015 current = enumerator.Current;
2016 Assert.Fail ("#O1: " + current);
2017 } catch (InvalidOperationException ex) {
2018 // No current EventLog entry available, cursor is located
2019 // before the first or after the last element of the
2021 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#O2");
2022 Assert.IsNotNull (ex.Message, "#O3");
2023 Assert.IsNull (ex.InnerException, "#O4");
2026 Assert.IsTrue (enumerator.MoveNext (), "#P1");
2027 Assert.IsNotNull (enumerator.Current, "#P2");
2029 Assert.IsNotNull (enumerator.Current, "#P3");
2030 Assert.IsFalse (enumerator.MoveNext (), "#P4");
2031 Assert.AreEqual (0, eventLog.Entries.Count, "#P5");
2034 current = enumerator.Current;
2035 Assert.Fail ("#Q1: " + current);
2036 } catch (InvalidOperationException ex) {
2037 // No current EventLog entry available, cursor is located
2038 // before the first or after the last element of the
2040 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#Q2");
2041 Assert.IsNotNull (ex.Message, "#Q3");
2042 Assert.IsNull (ex.InnerException, "#Q4");
2045 Assert.IsFalse (enumerator.MoveNext (), "#R1");
2046 enumerator.Reset ();
2047 Assert.IsFalse (enumerator.MoveNext (), "#R2");
2050 if (EventLog.Exists ("monologtemp"))
2051 EventLog.Delete ("monologtemp");
2056 public void Entries_Log_DoesNotExist ()
2058 if (EventLogImplType == NULL_IMPL)
2059 // test cannot pass with NULL implementation
2060 Assert.Ignore ("No EventLogImplType.");
2062 if (EventLog.Exists ("monologtemp", "."))
2063 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2065 using (EventLog eventLog = new EventLog ("monologtemp", ".")) {
2066 Assert.IsNotNull (eventLog.Entries, "#A1");
2069 Assert.Fail ("#B1: " + eventLog.Entries.Count);
2070 } catch (InvalidOperationException ex) {
2071 // The event log 'monologtemp' on computer '.' does not exist
2072 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
2073 Assert.IsNotNull (ex.Message, "#B3");
2074 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B4");
2075 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
2076 Assert.IsNull (ex.InnerException, "#B6");
2078 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#B7");
2080 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2081 Assert.IsNotNull (enumerator, "#C");
2084 object current = enumerator.Current;
2085 Assert.Fail ("#D1: " + current);
2086 } catch (InvalidOperationException ex) {
2087 // No current EventLog entry available, cursor is located
2088 // before the first or after the last element of the
2090 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
2091 Assert.IsNotNull (ex.Message, "#D3");
2092 Assert.IsNull (ex.InnerException, "#D4");
2096 enumerator.MoveNext ();
2097 Assert.Fail ("#E1");
2098 } catch (InvalidOperationException ex) {
2099 // The event log 'monologtemp' on computer '.' does not exist
2100 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
2101 Assert.IsNotNull (ex.Message, "#E3");
2102 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#E4");
2103 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#E5");
2104 Assert.IsNull (ex.InnerException, "#E6");
2108 EventLogEntry [] entries = new EventLogEntry [0];
2109 eventLog.Entries.CopyTo (entries, 0);
2110 Assert.Fail ("#F1");
2111 } catch (InvalidOperationException ex) {
2112 // The event log 'monologtemp' on computer '.' does not exist
2113 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
2114 Assert.IsNotNull (ex.Message, "#F3");
2115 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#F4");
2116 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#F5");
2117 Assert.IsNull (ex.InnerException, "#F6");
2120 enumerator.Reset ();
2125 public void Entries_Log_Empty ()
2127 if (EventLogImplType == NULL_IMPL)
2128 // test cannot pass with NULL implementation
2129 Assert.Ignore ("No EventLogImplType.");
2131 if (EventLog.SourceExists ("monotempsource", "."))
2132 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2134 if (EventLog.SourceExists ("monoothersource", "."))
2135 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
2137 if (EventLog.Exists ("monologtemp", "."))
2138 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2140 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
2142 using (EventLog eventLog = new EventLog (string.Empty, ".")) {
2143 Assert.IsNotNull (eventLog.Entries, "#A1");
2146 Assert.Fail ("#B1: " + eventLog.Entries.Count);
2147 } catch (ArgumentException ex) {
2148 // Log property value has not been specified
2149 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
2150 Assert.IsNotNull (ex.Message, "#B3");
2151 Assert.IsNull (ex.InnerException, "#B4");
2152 Assert.IsNull (ex.ParamName, "#B5");
2155 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2156 Assert.IsNotNull (enumerator, "#C");
2159 object current = enumerator.Current;
2160 Assert.Fail ("#D1: " + current);
2161 } catch (InvalidOperationException ex) {
2162 // No current EventLog entry available, cursor is located
2163 // before the first or after the last element of the
2165 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
2166 Assert.IsNotNull (ex.Message, "#D3");
2167 Assert.IsNull (ex.InnerException, "#D4");
2171 enumerator.MoveNext ();
2172 Assert.Fail ("#E1");
2173 } catch (ArgumentException ex) {
2174 // Log property value has not been specified
2175 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
2176 Assert.IsNotNull (ex.Message, "#E3");
2177 Assert.IsNull (ex.InnerException, "#E4");
2178 Assert.IsNull (ex.ParamName, "#E5");
2182 EventLogEntry [] entries = new EventLogEntry [0];
2183 eventLog.Entries.CopyTo (entries, 0);
2184 Assert.Fail ("#F1");
2185 } catch (ArgumentException ex) {
2186 // Log property value has not been specified
2187 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
2188 Assert.IsNotNull (ex.Message, "#F3");
2189 Assert.IsNull (ex.InnerException, "#F4");
2190 Assert.IsNull (ex.ParamName, "#F5");
2193 enumerator.Reset ();
2195 // set non-existing source
2196 eventLog.Source = "monoothersource";
2199 Assert.Fail ("#G1: " + eventLog.Entries.Count);
2200 } catch (ArgumentException ex) {
2201 // Log property value has not been specified
2202 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#G2");
2203 Assert.IsNotNull (ex.Message, "#G3");
2204 Assert.IsNull (ex.InnerException, "#G4");
2205 Assert.IsNull (ex.ParamName, "#G5");
2208 enumerator = eventLog.Entries.GetEnumerator ();
2209 Assert.IsNotNull (enumerator, "#H");
2212 object current = enumerator.Current;
2213 Assert.Fail ("#I1: " + current);
2214 } catch (InvalidOperationException ex) {
2215 // No current EventLog entry available, cursor is located
2216 // before the first or after the last element of the
2218 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#I2");
2219 Assert.IsNotNull (ex.Message, "#I3");
2220 Assert.IsNull (ex.InnerException, "#I4");
2224 enumerator.MoveNext ();
2225 Assert.Fail ("#J1");
2226 } catch (ArgumentException ex) {
2227 // Log property value has not been specified
2228 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#J2");
2229 Assert.IsNotNull (ex.Message, "#J3");
2230 Assert.IsNull (ex.InnerException, "#J4");
2231 Assert.IsNull (ex.ParamName, "#J5");
2235 EventLogEntry [] entries = new EventLogEntry [0];
2236 eventLog.Entries.CopyTo (entries, 0);
2237 Assert.Fail ("#K1");
2238 } catch (ArgumentException ex) {
2239 // Log property value has not been specified
2240 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#K2");
2241 Assert.IsNotNull (ex.Message, "#K3");
2242 Assert.IsNull (ex.InnerException, "#K4");
2243 Assert.IsNull (ex.ParamName, "#K5");
2246 enumerator.Reset ();
2248 // set existing source
2249 eventLog.Source = "monotempsource";
2251 Assert.AreEqual (0, eventLog.Entries.Count, "#L1");
2252 enumerator = eventLog.Entries.GetEnumerator ();
2253 Assert.IsNotNull (enumerator, "#L2");
2256 object current = enumerator.Current;
2257 Assert.Fail ("#M1: " + current);
2258 } catch (InvalidOperationException ex) {
2259 // No current EventLog entry available, cursor is located
2260 // before the first or after the last element of the
2262 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#M2");
2263 Assert.IsNotNull (ex.Message, "#M3");
2264 Assert.IsNull (ex.InnerException, "#M4");
2267 Assert.IsFalse (enumerator.MoveNext ());
2270 object current = enumerator.Current;
2271 Assert.Fail ("#N1: " + current);
2272 } catch (InvalidOperationException ex) {
2273 // No current EventLog entry available, cursor is located
2274 // before the first or after the last element of the
2276 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
2277 Assert.IsNotNull (ex.Message, "#N3");
2278 Assert.IsNull (ex.InnerException, "#N4");
2281 enumerator.Reset ();
2284 if (EventLog.Exists ("monologtemp"))
2285 EventLog.Delete ("monologtemp");
2290 public void Entries_Source_DoesNotExist ()
2292 if (EventLogImplType == NULL_IMPL)
2293 // test cannot pass with NULL implementation
2294 Assert.Ignore ("No EventLogImplType.");
2296 if (EventLog.SourceExists ("monotempsource", "."))
2297 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2299 if (EventLog.SourceExists ("monoothersource", "."))
2300 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
2302 if (EventLog.Exists ("monologtemp", "."))
2303 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2305 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
2307 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monoothersource")) {
2308 Assert.IsNotNull (eventLog.Entries, "#A1");
2309 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
2310 EventLog.WriteEntry ("monotempsource", "Entries_Source_DoesNotExist1");
2311 Assert.AreEqual (1, eventLog.Entries.Count, "#A3");
2313 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2314 Assert.IsNotNull (enumerator, "#B");
2317 object current = enumerator.Current;
2318 Assert.Fail ("#C1: " + current);
2319 } catch (InvalidOperationException ex) {
2320 // No current EventLog entry available, cursor is located
2321 // before the first or after the last element of the
2323 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2324 Assert.IsNotNull (ex.Message, "#C3");
2325 Assert.IsNull (ex.InnerException, "#C4");
2328 Assert.IsTrue (enumerator.MoveNext (), "#D1");
2329 Assert.IsNotNull (enumerator.Current, "#D2");
2330 Assert.IsFalse (enumerator.MoveNext (), "#D3");
2332 EventLogEntry [] entries = new EventLogEntry [1];
2333 eventLog.Entries.CopyTo (entries, 0);
2335 EventLogEntry entry = entries [0];
2336 Assert.IsNotNull (entry, "#E1");
2337 Assert.IsNotNull (entry.Source, "#E2");
2338 Assert.AreEqual ("monotempsource", entry.Source, "#E3");
2339 Assert.IsNotNull (entry.ReplacementStrings, "#E4");
2340 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#E5");
2341 Assert.AreEqual ("Entries_Source_DoesNotExist1", entry.ReplacementStrings [0], "#E6");
2344 object current = enumerator.Current;
2345 Assert.Fail ("#E1: " + current);
2346 } catch (InvalidOperationException ex) {
2347 // No current EventLog entry available, cursor is located
2348 // before the first or after the last element of the
2350 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
2351 Assert.IsNotNull (ex.Message, "#E3");
2352 Assert.IsNull (ex.InnerException, "#E4");
2356 object current = enumerator.Current;
2357 Assert.Fail ("#F1: " + current);
2358 } catch (InvalidOperationException ex) {
2359 // No current EventLog entry available, cursor is located
2360 // before the first or after the last element of the
2362 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
2363 Assert.IsNotNull (ex.Message, "#F3");
2364 Assert.IsNull (ex.InnerException, "#F4");
2367 EventLog.WriteEntry ("monotempsource", "Entries_Source_DoesNotExist2");
2370 object current = enumerator.Current;
2371 Assert.Fail ("#G1: " + current);
2372 } catch (InvalidOperationException ex) {
2373 // No current EventLog entry available, cursor is located
2374 // before the first or after the last element of the
2376 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
2377 Assert.IsNotNull (ex.Message, "#G3");
2378 Assert.IsNull (ex.InnerException, "#G4");
2381 Assert.IsFalse (enumerator.MoveNext (), "#H1");
2382 Assert.AreEqual (2, eventLog.Entries.Count, "#H2");
2384 entries = new EventLogEntry [1];
2386 eventLog.Entries.CopyTo (entries, 0);
2387 Assert.Fail ("#I1");
2388 } catch (ArgumentException ex) {
2389 // Destination array was not long enough. Check destIndex
2390 // and length, and the array's lower bounds
2391 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
2392 Assert.IsNotNull (ex.Message, "#I3");
2393 Assert.IsNull (ex.InnerException, "#I4");
2394 Assert.AreEqual (string.Empty, ex.ParamName, "#I5");
2397 entries = new EventLogEntry [2];
2398 eventLog.Entries.CopyTo (entries, 0);
2400 entry = entries [0];
2401 Assert.IsNotNull (entry, "#J1");
2402 Assert.IsNotNull (entry.Source, "#J2");
2403 Assert.AreEqual ("monotempsource", entry.Source, "#J3");
2404 Assert.IsNotNull (entry.ReplacementStrings, "#J4");
2405 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#J5");
2406 Assert.AreEqual ("Entries_Source_DoesNotExist1", entry.ReplacementStrings [0], "#J6");
2408 entry = entries [1];
2409 Assert.IsNotNull (entry, "#K1");
2410 Assert.IsNotNull (entry.Source, "#K2");
2411 Assert.AreEqual ("monotempsource", entry.Source, "#K3");
2412 Assert.IsNotNull (entry.ReplacementStrings, "#K4");
2413 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#K5");
2414 Assert.AreEqual ("Entries_Source_DoesNotExist2", entry.ReplacementStrings [0], "#K6");
2416 Assert.IsFalse (enumerator.MoveNext (), "#L1");
2417 enumerator.Reset ();
2418 Assert.IsTrue (enumerator.MoveNext (), "#L2");
2419 Assert.IsNotNull (enumerator.Current, "#L3");
2420 Assert.IsTrue (enumerator.MoveNext (), "#L4");
2421 Assert.IsNotNull (enumerator.Current, "#L5");
2423 Assert.IsFalse (enumerator.MoveNext (), "#M1");
2424 enumerator.Reset ();
2425 Assert.IsTrue (enumerator.MoveNext (), "#M2");
2427 Assert.IsNotNull (enumerator.Current, "#M3");
2428 Assert.IsFalse (enumerator.MoveNext (), "#M4");
2431 object current = enumerator.Current;
2432 Assert.Fail ("#N1: " + current);
2433 } catch (InvalidOperationException ex) {
2434 // No current EventLog entry available, cursor is located
2435 // before the first or after the last element of the
2437 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
2438 Assert.IsNotNull (ex.Message, "#N3");
2439 Assert.IsNull (ex.InnerException, "#N4");
2442 Assert.IsFalse (enumerator.MoveNext (), "#O1");
2443 enumerator.Reset ();
2444 Assert.IsFalse (enumerator.MoveNext (), "#O2");
2447 if (EventLog.Exists ("monologtemp"))
2448 EventLog.Delete ("monologtemp");
2453 public void Entries_Source_Empty ()
2455 if (EventLogImplType == NULL_IMPL)
2456 // test cannot pass with NULL implementation
2457 Assert.Ignore ("No EventLogImplType.");
2459 if (EventLog.SourceExists ("monotempsource", "."))
2460 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2462 if (EventLog.Exists ("monologtemp", "."))
2463 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2465 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
2467 using (EventLog eventLog = new EventLog ("monologtemp", ".", string.Empty)) {
2468 Assert.IsNotNull (eventLog.Entries, "#A1");
2469 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
2470 EventLog.WriteEntry ("monotempsource", "Entries_Source_Empty1");
2471 Assert.AreEqual (1, eventLog.Entries.Count, "#A3");
2473 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2474 Assert.IsNotNull (enumerator, "#B");
2477 object current = enumerator.Current;
2478 Assert.Fail ("#C1: " + current);
2479 } catch (InvalidOperationException ex) {
2480 // No current EventLog entry available, cursor is located
2481 // before the first or after the last element of the
2483 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2484 Assert.IsNotNull (ex.Message, "#C3");
2485 Assert.IsNull (ex.InnerException, "#C4");
2488 Assert.IsTrue (enumerator.MoveNext (), "#D1");
2489 Assert.IsNotNull (enumerator.Current, "#D2");
2490 Assert.IsFalse (enumerator.MoveNext (), "#D3");
2492 EventLogEntry [] entries = new EventLogEntry [1];
2493 eventLog.Entries.CopyTo (entries, 0);
2495 EventLogEntry entry = entries [0];
2496 Assert.IsNotNull (entry, "#E1");
2497 Assert.IsNotNull (entry.Source, "#E2");
2498 Assert.AreEqual ("monotempsource", entry.Source, "#E3");
2499 Assert.IsNotNull (entry.ReplacementStrings, "#E4");
2500 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#E5");
2501 Assert.AreEqual ("Entries_Source_Empty1", entry.ReplacementStrings [0], "#E6");
2504 object current = enumerator.Current;
2505 Assert.Fail ("#E1: " + current);
2506 } catch (InvalidOperationException ex) {
2507 // No current EventLog entry available, cursor is located
2508 // before the first or after the last element of the
2510 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
2511 Assert.IsNotNull (ex.Message, "#E3");
2512 Assert.IsNull (ex.InnerException, "#E4");
2515 EventLog.WriteEntry ("monotempsource", "Entries_Source_Empty2");
2518 object current = enumerator.Current;
2519 Assert.Fail ("#G1: " + current);
2520 } catch (InvalidOperationException ex) {
2521 // No current EventLog entry available, cursor is located
2522 // before the first or after the last element of the
2524 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
2525 Assert.IsNotNull (ex.Message, "#G3");
2526 Assert.IsNull (ex.InnerException, "#G4");
2529 Assert.IsFalse (enumerator.MoveNext (), "#H1");
2530 Assert.AreEqual (2, eventLog.Entries.Count, "#H2");
2532 entries = new EventLogEntry [1];
2534 eventLog.Entries.CopyTo (entries, 0);
2535 Assert.Fail ("#I1");
2536 } catch (ArgumentException ex) {
2537 // Destination array was not long enough. Check destIndex
2538 // and length, and the array's lower bounds
2539 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
2540 Assert.IsNotNull (ex.Message, "#I3");
2541 Assert.IsNull (ex.InnerException, "#I4");
2542 Assert.AreEqual ("", ex.ParamName, "#I5");
2545 entries = new EventLogEntry [2];
2546 eventLog.Entries.CopyTo (entries, 0);
2548 entry = entries [0];
2549 Assert.IsNotNull (entry, "#J1");
2550 Assert.IsNotNull (entry.Source, "#J2");
2551 Assert.AreEqual ("monotempsource", entry.Source, "#J3");
2552 Assert.IsNotNull (entry.ReplacementStrings, "#J4");
2553 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#J5");
2554 Assert.AreEqual ("Entries_Source_Empty1", entry.ReplacementStrings [0], "#J6");
2556 entry = entries [1];
2557 Assert.IsNotNull (entry, "#K1");
2558 Assert.IsNotNull (entry.Source, "#K2");
2559 Assert.AreEqual ("monotempsource", entry.Source, "#K3");
2560 Assert.IsNotNull (entry.ReplacementStrings, "#K4");
2561 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#K5");
2562 Assert.AreEqual ("Entries_Source_Empty2", entry.ReplacementStrings [0], "#K6");
2564 Assert.IsFalse (enumerator.MoveNext (), "#L1");
2565 enumerator.Reset ();
2566 Assert.IsTrue (enumerator.MoveNext (), "#L2");
2567 Assert.IsNotNull (enumerator.Current, "#L3");
2568 Assert.IsTrue (enumerator.MoveNext (), "#L4");
2569 Assert.IsNotNull (enumerator.Current, "#L5");
2571 Assert.IsFalse (enumerator.MoveNext (), "#M1");
2572 enumerator.Reset ();
2573 Assert.IsTrue (enumerator.MoveNext (), "#M2");
2575 Assert.IsNotNull (enumerator.Current, "#M3");
2576 Assert.IsFalse (enumerator.MoveNext (), "#M4");
2579 object current = enumerator.Current;
2580 Assert.Fail ("#N1: " + current);
2581 } catch (InvalidOperationException ex) {
2582 // No current EventLog entry available, cursor is located
2583 // before the first or after the last element of the
2585 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
2586 Assert.IsNotNull (ex.Message, "#N3");
2587 Assert.IsNull (ex.InnerException, "#N4");
2590 Assert.IsFalse (enumerator.MoveNext (), "#O1");
2591 enumerator.Reset ();
2592 Assert.IsFalse (enumerator.MoveNext (), "#O2");
2595 if (EventLog.Exists ("monologtemp"))
2596 EventLog.Delete ("monologtemp");
2601 public void Entries_Source_Null ()
2603 if (EventLogImplType == NULL_IMPL)
2604 // test cannot pass with NULL implementation
2605 Assert.Ignore ("No EventLogImplType.");
2607 if (EventLog.SourceExists ("monotempsource", "."))
2608 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2610 if (EventLog.Exists ("monologtemp", "."))
2611 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2613 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
2615 using (EventLog eventLog = new EventLog ("monologtemp", ".", null)) {
2616 Assert.IsNotNull (eventLog.Entries, "#A1");
2617 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
2618 EventLog.WriteEntry ("monotempsource", "Entries_Source_Null1");
2619 Assert.AreEqual (1, eventLog.Entries.Count, "#A3");
2621 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2622 Assert.IsNotNull (enumerator, "#B");
2625 object current = enumerator.Current;
2626 Assert.Fail ("#C1: " + current);
2627 } catch (InvalidOperationException ex) {
2628 // No current EventLog entry available, cursor is located
2629 // before the first or after the last element of the
2631 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2632 Assert.IsNotNull (ex.Message, "#C3");
2633 Assert.IsNull (ex.InnerException, "#C4");
2636 Assert.IsTrue (enumerator.MoveNext (), "#D1");
2637 Assert.IsNotNull (enumerator.Current, "#D2");
2638 Assert.IsFalse (enumerator.MoveNext (), "#D3");
2640 EventLogEntry [] entries = new EventLogEntry [1];
2641 eventLog.Entries.CopyTo (entries, 0);
2643 EventLogEntry entry = entries [0];
2644 Assert.IsNotNull (entry, "#E1");
2645 Assert.IsNotNull (entry.Source, "#E2");
2646 Assert.AreEqual ("monotempsource", entry.Source, "#E3");
2647 Assert.IsNotNull (entry.ReplacementStrings, "#E4");
2648 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#E5");
2649 Assert.AreEqual ("Entries_Source_Null1", entry.ReplacementStrings [0], "#E6");
2652 object current = enumerator.Current;
2653 Assert.Fail ("#E1: " + current);
2654 } catch (InvalidOperationException ex) {
2655 // No current EventLog entry available, cursor is located
2656 // before the first or after the last element of the
2658 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
2659 Assert.IsNotNull (ex.Message, "#E3");
2660 Assert.IsNull (ex.InnerException, "#E4");
2664 object current = enumerator.Current;
2665 Assert.Fail ("#F1: " + current);
2666 } catch (InvalidOperationException ex) {
2667 // No current EventLog entry available, cursor is located
2668 // before the first or after the last element of the
2670 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
2671 Assert.IsNotNull (ex.Message, "#F3");
2672 Assert.IsNull (ex.InnerException, "#F4");
2675 EventLog.WriteEntry ("monotempsource", "Entries_Source_Null2");
2678 object current = enumerator.Current;
2679 Assert.Fail ("#G1: " + current);
2680 } catch (InvalidOperationException ex) {
2681 // No current EventLog entry available, cursor is located
2682 // before the first or after the last element of the
2684 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
2685 Assert.IsNotNull (ex.Message, "#G3");
2686 Assert.IsNull (ex.InnerException, "#G4");
2689 Assert.IsFalse (enumerator.MoveNext (), "#H1");
2690 Assert.AreEqual (2, eventLog.Entries.Count, "#H2");
2692 entries = new EventLogEntry [1];
2694 eventLog.Entries.CopyTo (entries, 0);
2695 Assert.Fail ("#I1");
2696 } catch (ArgumentException ex) {
2697 // Destination array was not long enough. Check destIndex
2698 // and length, and the array's lower bounds
2699 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
2700 Assert.IsNotNull (ex.Message, "#I3");
2701 Assert.IsNull (ex.InnerException, "#I4");
2702 Assert.AreEqual ("", ex.ParamName, "#I5");
2705 entries = new EventLogEntry [2];
2706 eventLog.Entries.CopyTo (entries, 0);
2708 entry = entries [0];
2709 Assert.IsNotNull (entry, "#J1");
2710 Assert.IsNotNull (entry.Source, "#J2");
2711 Assert.AreEqual ("monotempsource", entry.Source, "#J3");
2712 Assert.IsNotNull (entry.ReplacementStrings, "#J4");
2713 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#J5");
2714 Assert.AreEqual ("Entries_Source_Null1", entry.ReplacementStrings [0], "#J6");
2716 entry = entries [1];
2717 Assert.IsNotNull (entry, "#K1");
2718 Assert.IsNotNull (entry.Source, "#K2");
2719 Assert.AreEqual ("monotempsource", entry.Source, "#K3");
2720 Assert.IsNotNull (entry.ReplacementStrings, "#K4");
2721 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#K5");
2722 Assert.AreEqual ("Entries_Source_Null2", entry.ReplacementStrings [0], "#K6");
2724 Assert.IsFalse (enumerator.MoveNext (), "#L1");
2725 enumerator.Reset ();
2726 Assert.IsTrue (enumerator.MoveNext (), "#L2");
2727 Assert.IsNotNull (enumerator.Current, "#L3");
2728 Assert.IsTrue (enumerator.MoveNext (), "#L4");
2729 Assert.IsNotNull (enumerator.Current, "#L5");
2731 Assert.IsFalse (enumerator.MoveNext (), "#M1");
2732 enumerator.Reset ();
2733 Assert.IsTrue (enumerator.MoveNext (), "#M2");
2735 Assert.IsNotNull (enumerator.Current, "#M3");
2736 Assert.IsFalse (enumerator.MoveNext (), "#M4");
2739 object current = enumerator.Current;
2740 Assert.Fail ("#N1: " + current);
2741 } catch (InvalidOperationException ex) {
2742 // No current EventLog entry available, cursor is located
2743 // before the first or after the last element of the
2745 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
2746 Assert.IsNotNull (ex.Message, "#N3");
2747 Assert.IsNull (ex.InnerException, "#N4");
2750 Assert.IsFalse (enumerator.MoveNext (), "#O1");
2751 enumerator.Reset ();
2752 Assert.IsFalse (enumerator.MoveNext (), "#O2");
2755 if (EventLog.Exists ("monologtemp"))
2756 EventLog.Delete ("monologtemp");
2761 public void Exists1_Win32 ()
2763 if (EventLogImplType != WIN32_IMPL)
2764 // test can only pass with win32 implementation
2765 Assert.Ignore ("Wrong EventLogImplType.");
2767 using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
2769 Assert.Ignore ("Event log 'monotempsource' should not exist.");
2772 using (RegistryKey logKey = FindLogKeyByName ("monologtemp")) {
2774 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2777 using (RegistryKey logKey = FindLogKeyByName ("monologother")) {
2779 Assert.Ignore ("Event log 'monologother' should not exist.");
2782 using (RegistryKey sourceKey = FindSourceKeyByName ("monotempsource")) {
2783 if (sourceKey != null)
2784 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2787 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#A1");
2788 Assert.IsFalse (EventLog.Exists ("MonoLogTemp"), "#A2");
2789 Assert.IsFalse (EventLog.Exists ("monologother"), "#A3");
2790 Assert.IsFalse (EventLog.Exists ("MonoLogOther"), "#A4");
2792 using (RegistryKey eventLogKey = EventLogKey) {
2793 RegistryKey logKey = eventLogKey.CreateSubKey ("monologtemp");
2795 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#B1");
2796 Assert.IsTrue (EventLog.Exists ("MonoLogTemp"), "#B2");
2797 Assert.IsFalse (EventLog.Exists ("monologother"), "#B3");
2798 Assert.IsFalse (EventLog.Exists ("MonoLogOther"), "#B3");
2800 Assert.IsFalse (EventLog.Exists ("monotempsource"), "#BXXX");
2802 using (RegistryKey sourceKey = logKey.CreateSubKey ("monotempsource")) {
2805 Assert.IsFalse (EventLog.Exists ("monotempsource"), "#C1");
2806 Assert.IsFalse (EventLog.Exists ("MonoTempSource"), "#C2");
2808 if (logKey != null) {
2810 eventLogKey.DeleteSubKeyTree ("monologtemp");
2817 public void Exists1_Log_Empty ()
2819 Assert.IsFalse (EventLog.Exists (string.Empty));
2823 public void Exists1_Log_Null ()
2825 Assert.IsFalse (EventLog.Exists (null));
2829 public void Exists2_Win32 ()
2831 if (EventLogImplType != WIN32_IMPL)
2832 // test can only pass with win32 implementation
2833 Assert.Ignore ("Wrong EventLogImplType.");
2835 using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
2837 Assert.Ignore ("Event log 'monotempsource' should not exist.");
2840 using (RegistryKey logKey = FindLogKeyByName ("monologtemp")) {
2842 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2845 using (RegistryKey logKey = FindLogKeyByName ("monologother")) {
2847 Assert.Ignore ("Event log 'monologother' should not exist.");
2850 using (RegistryKey sourceKey = FindSourceKeyByName ("monotempsource")) {
2851 if (sourceKey != null)
2852 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2855 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#A1");
2856 Assert.IsFalse (EventLog.Exists ("MonoLogTemp", "."), "#A2");
2857 Assert.IsFalse (EventLog.Exists ("monologother", "."), "#A3");
2858 Assert.IsFalse (EventLog.Exists ("MonoLogOther", "."), "#A4");
2860 using (RegistryKey eventLogKey = EventLogKey) {
2861 RegistryKey logKey = eventLogKey.CreateSubKey ("monologtemp");
2863 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B1");
2864 Assert.IsTrue (EventLog.Exists ("MonoLogTemp", "."), "#B2");
2865 Assert.IsFalse (EventLog.Exists ("monologother", "."), "#B3");
2866 Assert.IsFalse (EventLog.Exists ("MonoLogOther", "."), "#B3");
2868 using (RegistryKey sourceKey = logKey.CreateSubKey ("monotempsource")) {
2871 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#C1");
2872 Assert.IsFalse (EventLog.Exists ("MonoTempSource", "."), "#C2");
2874 if (logKey != null) {
2876 eventLogKey.DeleteSubKeyTree ("monologtemp");
2883 public void Exists2_Log_Empty ()
2885 Assert.IsFalse (EventLog.Exists (string.Empty, "."));
2889 public void Exists2_Log_Null ()
2891 Assert.IsFalse (EventLog.Exists (null, "."));
2895 public void Exists2_MachineName_Empty ()
2898 EventLog.Exists ("monologtemp", string.Empty);
2899 Assert.Fail ("#A1");
2900 } catch (ArgumentException ex) {
2901 // Invalid format for argument machineName
2902 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
2903 Assert.IsNotNull (ex.Message, "#A3");
2904 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#A4");
2905 Assert.IsNull (ex.InnerException, "#A5");
2906 Assert.IsNull (ex.ParamName, "#A6");
2910 EventLog.Exists (string.Empty, string.Empty);
2911 Assert.Fail ("#B1");
2912 } catch (ArgumentException ex) {
2913 // Invalid format for argument machineName
2914 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
2915 Assert.IsNotNull (ex.Message, "#B3");
2916 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#B4");
2917 Assert.IsNull (ex.InnerException, "#B5");
2918 Assert.IsNull (ex.ParamName, "#B6");
2922 EventLog.Exists (null, string.Empty);
2923 Assert.Fail ("#C1");
2924 } catch (ArgumentException ex) {
2925 // Invalid format for argument machineName
2926 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
2927 Assert.IsNotNull (ex.Message, "#C3");
2928 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#C4");
2929 Assert.IsNull (ex.InnerException, "#C5");
2930 Assert.IsNull (ex.ParamName, "#C6");
2934 EventLog.Exists ("monologtemp", " \t\n");
2935 Assert.Fail ("#D1");
2936 } catch (ArgumentException ex) {
2937 // Invalid format for argument machineName
2938 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
2939 Assert.IsNotNull (ex.Message, "#D3");
2940 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#D4");
2941 Assert.IsNull (ex.InnerException, "#D5");
2942 Assert.IsNull (ex.ParamName, "#D6");
2947 public void Exists2_MachineName_Null ()
2950 EventLog.Exists ("monologtemp", null);
2951 Assert.Fail ("#A1");
2952 } catch (ArgumentException ex) {
2953 // Invalid format for argument machineName
2954 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
2955 Assert.IsNotNull (ex.Message, "#A3");
2956 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#A4");
2957 Assert.IsNull (ex.InnerException, "#A5");
2958 Assert.IsNull (ex.ParamName, "#A6");
2962 EventLog.Exists (string.Empty, null);
2963 Assert.Fail ("#B1");
2964 } catch (ArgumentException ex) {
2965 // Invalid format for argument machineName
2966 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
2967 Assert.IsNotNull (ex.Message, "#B3");
2968 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#B4");
2969 Assert.IsNull (ex.InnerException, "#B5");
2970 Assert.IsNull (ex.ParamName, "#B6");
2974 EventLog.Exists (null, null);
2975 Assert.Fail ("#C1");
2976 } catch (ArgumentException ex) {
2977 // Invalid format for argument machineName
2978 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
2979 Assert.IsNotNull (ex.Message, "#C3");
2980 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#C4");
2981 Assert.IsNull (ex.InnerException, "#C5");
2982 Assert.IsNull (ex.ParamName, "#C6");
2989 EventLog eventLog = new EventLog ();
2990 eventLog.Log = string.Empty;
2991 Assert.AreEqual (string.Empty, eventLog.Log, "#A1");
2992 Assert.AreEqual (string.Empty, eventLog.Source, "#A2");
2993 eventLog.Log = "monologtemp";
2994 Assert.AreEqual ("monologtemp", eventLog.Log, "#A3");
2995 Assert.AreEqual (string.Empty, eventLog.Source, "#A4");
2996 eventLog.Log = string.Empty;
2997 Assert.AreEqual (string.Empty, eventLog.Log, "#A5");
2998 Assert.AreEqual (string.Empty, eventLog.Source, "#A6");
3000 if (EventLog.SourceExists ("monotempsource", "."))
3001 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3003 if (EventLog.Exists ("monologtemp", "."))
3004 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3006 if (EventLog.Exists ("shouldnotexist", "."))
3007 Assert.Ignore ("Event log 'shouldnotexist' should not exist.");
3009 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
3011 eventLog.Log = "shouldnotexist";
3012 eventLog.Source = "monotempsource";
3013 Assert.AreEqual ("shouldnotexist", eventLog.Log, "#B1");
3014 eventLog.Log = string.Empty;
3015 Assert.AreEqual ("monologtemp", eventLog.Log, "#B2");
3016 eventLog.Source = null;
3017 Assert.AreEqual ("monologtemp", eventLog.Log, "#B3");
3018 eventLog.Log = "MONOLOGTEMP";
3019 Assert.AreEqual ("monologtemp", eventLog.Log, "#B4");
3021 if (EventLog.Exists ("monologtemp"))
3022 EventLog.Delete ("monologtemp");
3028 [ExpectedException (typeof (ArgumentNullException))]
3029 public void Log_Null ()
3031 EventLog eventLog = new EventLog ();
3032 eventLog.Log = null;
3036 public void LogNameFromSourceName ()
3038 if (EventLogImplType == NULL_IMPL)
3039 // test cannot pass with NULL implementation
3040 Assert.Ignore ("No EventLogImplType.");
3042 if (EventLog.SourceExists ("monotempsource", "."))
3043 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3045 if (EventLog.Exists ("monologtemp", "."))
3046 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3049 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3051 Assert.IsNotNull (EventLog.LogNameFromSourceName ("monotempsource", "."), "#1");
3052 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#2");
3053 Assert.IsNotNull (EventLog.LogNameFromSourceName ("monologtemp", "."), "#3");
3054 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monologtemp", "."), "#4");
3056 if (EventLog.Exists ("monologtemp"))
3057 EventLog.Delete ("monologtemp");
3062 public void LogNameFromSourceName_MachineName_Empty ()
3065 EventLog.LogNameFromSourceName ("monotempsource", string.Empty);
3066 Assert.Fail ("#A1");
3067 } catch (ArgumentException ex) {
3068 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3069 Assert.IsNotNull (ex.Message, "#A3");
3070 // Invalid value '' for parameter 'MachineName'
3071 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
3072 Assert.IsTrue (ex.Message.IndexOf ("'MachineName'") != -1, "#A5");
3073 Assert.IsNull (ex.InnerException, "#A6");
3074 Assert.IsNull (ex.ParamName, "#A7");
3078 EventLog.LogNameFromSourceName ("monotempsource", " \t\n");
3079 Assert.Fail ("#B1");
3080 } catch (ArgumentException ex) {
3081 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
3082 Assert.IsNotNull (ex.Message, "#B3");
3083 // Invalid value ' \t\n' for parameter 'MachineName'
3084 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
3085 Assert.IsTrue (ex.Message.IndexOf ("'MachineName'") != -1, "#B5");
3086 Assert.IsNull (ex.InnerException, "#B6");
3087 Assert.IsNull (ex.ParamName, "#B7");
3092 public void LogNameFromSourceName_MachineName_Null ()
3095 EventLog.LogNameFromSourceName ("monotempsource", null);
3096 Assert.Fail ("#A1");
3097 } catch (ArgumentException ex) {
3098 // Invalid value '' for parameter 'MachineName'
3099 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3100 Assert.IsNotNull (ex.Message, "#A3");
3101 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
3102 Assert.IsTrue (ex.Message.IndexOf ("'MachineName'") != -1, "#A5");
3103 Assert.IsNull (ex.InnerException, "#A6");
3104 Assert.IsNull (ex.ParamName, "#A7");
3109 public void LogNameFromSourceName_Source_DoesNotExist ()
3111 if (EventLogImplType == NULL_IMPL)
3112 // test cannot pass with NULL implementation
3113 Assert.Ignore ("No EventLogImplType.");
3115 if (EventLog.SourceExists ("monotempsource", "."))
3116 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3118 string logName = EventLog.LogNameFromSourceName ("monotempsource", ".");
3119 Assert.IsNotNull (logName, "#1");
3120 Assert.AreEqual (string.Empty, logName, "#2");
3124 public void LogNameFromSourceName_Source_Empty ()
3126 if (EventLogImplType == NULL_IMPL)
3127 // test cannot pass with NULL implementation
3128 Assert.Ignore ("No EventLogImplType.");
3130 string logName = EventLog.LogNameFromSourceName (string.Empty, ".");
3131 Assert.IsNotNull (logName, "#1");
3132 Assert.AreEqual (string.Empty, logName, "#2");
3136 public void LogNameFromSourceName_Source_Null ()
3138 if (EventLogImplType == NULL_IMPL)
3139 // test cannot pass with NULL implementation
3140 Assert.Ignore ("No EventLogImplType.");
3142 string logName = EventLog.LogNameFromSourceName (null, ".");
3143 Assert.IsNotNull (logName, "#1");
3144 Assert.AreEqual (string.Empty, logName, "#2");
3148 public void MachineName_Null ()
3150 EventLog eventLog = new EventLog ();
3153 eventLog.MachineName = null;
3155 } catch (ArgumentException ex) {
3156 // Invalid value for property MachineName
3157 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3158 Assert.IsNull (ex.InnerException, "#3");
3159 Assert.IsNotNull (ex.Message, "#4");
3160 Assert.IsTrue (ex.Message.IndexOf (" ") != -1, "#5");
3161 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#6");
3162 Assert.IsNull (ex.ParamName, "#7");
3167 public void MachineName ()
3169 string machineName = Environment.MachineName.ToLower ();
3171 EventLog eventLog = new EventLog ("Application", machineName);
3172 eventLog.EnableRaisingEvents = true;
3173 Assert.AreEqual (machineName, eventLog.MachineName, "#1");
3174 eventLog.MachineName = Environment.MachineName.ToUpper ();
3175 Assert.AreEqual (machineName, eventLog.MachineName, "#2");
3176 Assert.IsTrue (eventLog.EnableRaisingEvents, "#3");
3177 eventLog.MachineName = ".";
3178 Assert.AreEqual (".", eventLog.MachineName, "#4");
3179 Assert.IsFalse (eventLog.EnableRaisingEvents, "#5");
3183 public void MachineName_Empty ()
3185 EventLog eventLog = new EventLog ();
3188 eventLog.MachineName = string.Empty;
3189 Assert.Fail ("#A1");
3190 } catch (ArgumentException ex) {
3191 // Invalid value for property MachineName
3192 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3193 Assert.IsNull (ex.InnerException, "#A3");
3194 Assert.IsNotNull (ex.Message, "#A4");
3195 Assert.IsTrue (ex.Message.IndexOf (" ") != -1, "#A5");
3196 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#A6");
3197 Assert.IsNull (ex.ParamName, "#A7");
3201 eventLog.MachineName = " \t\n";
3202 Assert.Fail ("#B1");
3203 } catch (ArgumentException ex) {
3204 // Invalid value for property MachineName
3205 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
3206 Assert.IsNull (ex.InnerException, "#B3");
3207 Assert.IsNotNull (ex.Message, "#B4");
3208 Assert.IsTrue (ex.Message.IndexOf (" ") != -1, "#B5");
3209 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#B6");
3210 Assert.IsNull (ex.ParamName, "#B7");
3215 public void Source ()
3217 if (EventLogImplType == NULL_IMPL)
3218 // test cannot pass with NULL implementation
3219 Assert.Ignore ("No EventLogImplType.");
3221 if (EventLog.SourceExists ("monotempsource", "."))
3222 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3224 if (EventLog.Exists ("monologtemp", "."))
3225 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3227 using (EventLog eventLog = new EventLog ()) {
3228 eventLog.Source = null;
3229 Assert.AreEqual (string.Empty, eventLog.Source, "#A1");
3230 Assert.AreEqual (string.Empty, eventLog.Log, "#A2");
3231 eventLog.Source = "monotempsource";
3232 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3233 Assert.AreEqual (string.Empty, eventLog.Log, "#A4");
3234 eventLog.Source = null;
3235 Assert.AreEqual (string.Empty, eventLog.Source, "#A5");
3236 Assert.AreEqual (string.Empty, eventLog.Log, "#A6");
3238 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3240 Assert.AreEqual (string.Empty, eventLog.Source, "#B1");
3241 Assert.AreEqual (string.Empty, eventLog.Log, "#B2");
3242 eventLog.Source = "monotempsource";
3243 Assert.AreEqual ("monotempsource", eventLog.Source, "#B3");
3244 Assert.AreEqual ("monologtemp", eventLog.Log, "#B4");
3245 eventLog.Log = string.Empty;
3246 Assert.AreEqual ("monotempsource", eventLog.Source, "#B5");
3247 Assert.AreEqual ("monologtemp", eventLog.Log, "#B6");
3248 eventLog.Source = null;
3249 Assert.AreEqual (string.Empty, eventLog.Source, "#B7");
3250 Assert.AreEqual ("monologtemp", eventLog.Log, "#B8");
3251 eventLog.Log = string.Empty;
3252 Assert.AreEqual (string.Empty, eventLog.Source, "#B9");
3253 Assert.AreEqual (string.Empty, eventLog.Log, "#B10");
3255 EventLog.Delete ("monologtemp");
3258 eventLog.Source = "whatever";
3259 Assert.AreEqual ("whatever", eventLog.Source, "#C1");
3260 eventLog.Source = "WHATEVER";
3261 Assert.AreEqual ("whatever", eventLog.Source, "#C2");
3266 public void SourceExists1_Win32 ()
3268 if (EventLogImplType != WIN32_IMPL)
3269 // test can only pass with win32 implementation
3270 Assert.Ignore ("Wrong EventLogImplType.");
3272 using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
3274 Assert.Ignore ("Event log 'monotempsource' should not exist.");
3277 using (RegistryKey logKey = FindLogKeyByName ("monologtemp")) {
3279 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3282 using (RegistryKey sourceKey = FindSourceKeyByName ("monotempsource")) {
3283 if (sourceKey != null)
3284 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3287 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A1");
3288 Assert.IsFalse (EventLog.SourceExists ("MonoTempSource"), "#A2");
3290 using (RegistryKey eventLogKey = EventLogKey) {
3291 RegistryKey logKey = eventLogKey.CreateSubKey ("monotempsource");
3293 // make sure we do not mistake a log for a source
3294 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B1");
3295 Assert.IsFalse (EventLog.SourceExists ("MonoTempSource"), "#B2");
3297 if (logKey != null) {
3299 eventLogKey.DeleteSubKeyTree ("monotempsource");
3303 logKey = eventLogKey.CreateSubKey ("monologtemp");
3305 RegistryKey sourceKey = null;
3307 // create temporary source key
3308 sourceKey = logKey.CreateSubKey ("monotempsource");
3309 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#C1");
3310 Assert.IsTrue (EventLog.SourceExists ("MonoTempSource"), "#C2");
3312 if (sourceKey != null) {
3314 logKey.DeleteSubKeyTree ("monotempsource");
3318 if (logKey != null) {
3320 eventLogKey.DeleteSubKeyTree ("monologtemp");
3327 public void SourceExists1_Source_Empty ()
3329 Assert.IsFalse (EventLog.SourceExists (string.Empty));
3333 public void SourceExists1_Source_Null ()
3335 Assert.IsFalse (EventLog.SourceExists (null));
3339 public void SourceExists2_Win32 ()
3341 if (EventLogImplType != WIN32_IMPL)
3342 // test can only pass with win32 implementation
3343 Assert.Ignore ("Wrong EventLogImplType.");
3345 using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
3347 Assert.Ignore ("Event log 'monotempsource' should not exist.");
3350 using (RegistryKey logKey = FindLogKeyByName ("monologtemp")) {
3352 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3355 using (RegistryKey sourceKey = FindSourceKeyByName ("monotempsource")) {
3356 if (sourceKey != null)
3357 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3360 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#1");
3362 using (RegistryKey eventLogKey = EventLogKey) {
3363 RegistryKey logKey = eventLogKey.CreateSubKey ("monotempsource");
3365 // make sure we do not mistake a log for a source
3366 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#2");
3368 if (logKey != null) {
3370 eventLogKey.DeleteSubKeyTree ("monotempsource");
3374 logKey = eventLogKey.CreateSubKey ("monologtemp");
3376 RegistryKey sourceKey = null;
3378 // create temporary source key
3379 sourceKey = logKey.CreateSubKey ("monotempsource");
3380 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#3");
3382 if (sourceKey != null) {
3384 logKey.DeleteSubKeyTree ("monotempsource");
3388 if (logKey != null) {
3390 eventLogKey.DeleteSubKeyTree ("monologtemp");
3397 public void SourceExists2_MachineName_Empty ()
3400 EventLog.SourceExists ("monotempsource", string.Empty);
3401 Assert.Fail ("#A1");
3402 } catch (ArgumentException ex) {
3403 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3404 Assert.IsNotNull (ex.Message, "#A3");
3405 // Invalid value '' for parameter 'machineName'
3406 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
3407 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
3408 Assert.IsNull (ex.InnerException, "#A6");
3409 Assert.IsNull (ex.ParamName, "#A7");
3413 EventLog.SourceExists ("monotempsource", " \t\n");
3414 Assert.Fail ("#B1");
3415 } catch (ArgumentException ex) {
3416 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
3417 Assert.IsNotNull (ex.Message, "#B3");
3418 // Invalid value ' \t\n' for parameter 'machineName'
3419 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
3420 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#B5");
3421 Assert.IsNull (ex.InnerException, "#B6");
3422 Assert.IsNull (ex.ParamName, "#B7");
3427 public void SourceExists2_MachineName_Null ()
3430 EventLog.SourceExists ("monotempsource", null);
3432 } catch (ArgumentException ex) {
3433 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3434 Assert.IsNotNull (ex.Message, "#3");
3435 // Invalid value '' for parameter 'machineName'
3436 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#4");
3437 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#5");
3438 Assert.IsNull (ex.InnerException, "#6");
3439 Assert.IsNull (ex.ParamName, "#7");
3444 public void SourceExists2_Source_Empty ()
3446 Assert.IsFalse (EventLog.SourceExists (string.Empty, "."));
3450 public void SourceExists2_Source_Null ()
3452 Assert.IsFalse (EventLog.SourceExists (null, "."));
3456 public void WriteEntry1 ()
3458 if (EventLogImplType == NULL_IMPL)
3459 // test cannot pass with NULL implementation
3460 Assert.Ignore ("No EventLogImplType.");
3462 if (EventLog.SourceExists ("monotempsource", "."))
3463 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3465 if (EventLog.Exists ("monologtemp", "."))
3466 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3468 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3470 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3471 eventLog.WriteEntry ("WriteEntry1a");
3473 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3474 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3475 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3476 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3477 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3478 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3480 EventLogEntry entry = eventLog.Entries[eventLog.Entries.Count - 1];
3481 Assert.IsNotNull (entry, "#B1");
3482 Assert.IsNotNull (entry.Category, "#B2");
3483 Assert.AreEqual ("(0)", entry.Category, "#B3");
3484 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3485 Assert.IsNotNull (entry.Data, "#B5");
3486 Assert.AreEqual (0, entry.Data.Length, "#B6");
3487 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3488 Assert.AreEqual (0, entry.EventID, "#B8");
3489 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3490 Assert.IsNotNull (entry.MachineName, "#B10");
3491 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
3492 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3493 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3494 Assert.AreEqual ("WriteEntry1a", entry.ReplacementStrings[0], "#B14");
3495 Assert.IsNotNull (entry.Source, "#B15");
3496 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3497 Assert.IsNull (entry.UserName, "#B17");
3499 eventLog.WriteEntry ("WriteEntry1b" + Environment.NewLine + "ok");
3501 entry = eventLog.Entries [eventLog.Entries.Count - 1];
3502 Assert.IsNotNull (entry, "#C1");
3503 Assert.IsNotNull (entry.Category, "#C2");
3504 Assert.AreEqual ("(0)", entry.Category, "#C3");
3505 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
3506 Assert.IsNotNull (entry.Data, "#C5");
3507 Assert.AreEqual (0, entry.Data.Length, "#C6");
3508 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#C7");
3509 Assert.AreEqual (0, entry.EventID, "#C8");
3510 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
3511 Assert.IsNotNull (entry.MachineName, "#C10");
3512 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
3513 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
3514 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
3515 Assert.AreEqual ("WriteEntry1b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
3516 Assert.IsNotNull (entry.Source, "#C15");
3517 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
3518 Assert.IsNull (entry.UserName, "#C17");
3521 if (EventLog.Exists ("monologtemp"))
3522 EventLog.Delete ("monologtemp");
3527 public void WriteEntry1_Log_Empty ()
3529 if (EventLogImplType == NULL_IMPL)
3530 // test cannot pass with NULL implementation
3531 Assert.Ignore ("No EventLogImplType.");
3533 if (EventLog.SourceExists ("monotempsource", "."))
3534 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3536 bool applicationLogExists = EventLog.Exists ("Application", ".");
3538 // specified source does not exist, so use Application log
3540 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
3541 eventLog.WriteEntry ("WriteEntry1_Log_Empty");
3542 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3543 Assert.AreEqual ("Application", eventLog.Log, "#A2");
3544 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3545 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
3546 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3547 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3550 if (!applicationLogExists) {
3551 if (EventLog.Exists ("Application"))
3552 EventLog.Delete ("Application");
3554 if (EventLog.SourceExists ("monotempsource", "."))
3555 EventLog.DeleteEventSource ("monotempsource", ".");
3561 public void WriteEntry1_Log_Mismatch ()
3563 if (EventLogImplType == NULL_IMPL)
3564 // test cannot pass with NULL implementation
3565 Assert.Ignore ("No EventLogImplType.");
3567 if (EventLog.SourceExists ("monotempsource", "."))
3568 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3570 if (EventLog.Exists ("monologtemp", "."))
3571 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3573 if (EventLog.Exists ("monologother", "."))
3574 Assert.Ignore ("Event log 'monologother' should not exist.");
3576 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3578 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
3579 eventLog.WriteEntry ("WriteEntry1_Log_Mismatch");
3581 } catch (ArgumentException ex) {
3582 // The source 'monotempsource' is not registered in log
3583 // 'monologother' (it is registered in log 'monologtemp').
3584 // The Source and Log properties must be matched, or you may
3585 // set Log to the empty string, and it will automatically be
3586 // matched to the Source property
3587 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3588 Assert.IsNotNull (ex.Message, "#A3");
3589 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
3590 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
3591 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
3592 Assert.IsNull (ex.InnerException, "#A7");
3594 if (EventLog.Exists ("monologtemp"))
3595 EventLog.Delete ("monologtemp");
3597 if (EventLog.Exists ("monologother"))
3598 EventLog.Delete ("monologother");
3603 public void WriteEntry1_Message_Empty ()
3605 if (EventLogImplType == NULL_IMPL)
3606 // test cannot pass with NULL implementation
3607 Assert.Ignore ("No EventLogImplType.");
3609 if (EventLog.SourceExists ("monotempsource", "."))
3610 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3612 if (EventLog.Exists ("monologtemp", "."))
3613 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3615 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3617 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3618 eventLog.WriteEntry (string.Empty);
3619 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3620 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3621 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3622 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3623 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3624 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3626 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
3627 Assert.IsNotNull (entry, "#B1");
3628 Assert.IsNotNull (entry.Category, "#B2");
3629 Assert.AreEqual ("(0)", entry.Category, "#B3");
3630 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3631 Assert.IsNotNull (entry.Data, "#B5");
3632 Assert.AreEqual (0, entry.Data.Length, "#B6");
3633 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3634 Assert.AreEqual (0, entry.EventID, "#B8");
3635 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3636 Assert.IsNotNull (entry.MachineName, "#B10");
3637 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
3638 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3639 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3640 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
3641 Assert.IsNotNull (entry.Source, "#B15");
3642 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3643 Assert.IsNull (entry.UserName, "#B17");
3646 if (EventLog.Exists ("monologtemp"))
3647 EventLog.Delete ("monologtemp");
3652 public void WriteEntry1_Message_Null ()
3654 if (EventLogImplType == NULL_IMPL)
3655 // test cannot pass with NULL implementation
3656 Assert.Ignore ("No EventLogImplType.");
3658 if (EventLog.SourceExists ("monotempsource", "."))
3659 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3661 if (EventLog.Exists ("monologtemp", "."))
3662 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3664 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3666 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3667 eventLog.WriteEntry (null);
3668 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3669 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3670 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3671 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3672 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3673 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3675 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
3676 Assert.IsNotNull (entry, "#B1");
3677 Assert.IsNotNull (entry.Category, "#B2");
3678 Assert.AreEqual ("(0)", entry.Category, "#B3");
3679 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3680 Assert.IsNotNull (entry.Data, "#B5");
3681 Assert.AreEqual (0, entry.Data.Length, "#B6");
3682 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3683 Assert.AreEqual (0, entry.EventID, "#B8");
3684 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3685 Assert.IsNotNull (entry.MachineName, "#B10");
3686 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
3687 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3688 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3689 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
3690 Assert.IsNotNull (entry.Source, "#B15");
3691 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3692 Assert.IsNull (entry.UserName, "#B17");
3695 if (EventLog.Exists ("monologtemp"))
3696 EventLog.Delete ("monologtemp");
3701 public void WriteEntry1_Source_DoesNotExist ()
3703 if (EventLogImplType == NULL_IMPL)
3704 // test cannot pass with NULL implementation
3705 Assert.Ignore ("No EventLogImplType.");
3707 if (EventLog.SourceExists ("monotempsource", "."))
3708 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3710 if (EventLog.SourceExists ("monoothersource", "."))
3711 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
3713 if (EventLog.Exists ("monologtemp", "."))
3714 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3716 EventLog.CreateEventSource ("monoothersource", "monologtemp");
3718 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3719 eventLog.WriteEntry ("WriteEntry1");
3720 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3721 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3722 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3723 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3724 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3725 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3727 EventLogEntry entry = eventLog.Entries[eventLog.Entries.Count - 1];
3728 Assert.IsNotNull (entry, "#B1");
3729 Assert.IsNotNull (entry.Category, "#B2");
3730 Assert.AreEqual ("(0)", entry.Category, "#B3");
3731 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3732 Assert.IsNotNull (entry.Data, "#B5");
3733 Assert.AreEqual (0, entry.Data.Length, "#B6");
3734 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3735 Assert.AreEqual (0, entry.EventID, "#B8");
3736 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3737 Assert.IsNotNull (entry.MachineName, "#B10");
3738 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
3739 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3740 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3741 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings[0], "#B14");
3742 Assert.IsNotNull (entry.Source, "#B15");
3743 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3744 Assert.IsNull (entry.UserName, "#B17");
3747 if (EventLog.Exists ("monologtemp"))
3748 EventLog.Delete ("monologtemp");
3753 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
3754 public void WriteEntry1_Source_Empty ()
3756 EventLog eventLog = new EventLog ("monologtemp");
3757 eventLog.WriteEntry ("test");
3761 public void WriteEntry2 ()
3763 if (EventLogImplType == NULL_IMPL)
3764 // test cannot pass with NULL implementation
3765 Assert.Ignore ("No EventLogImplType.");
3767 if (EventLog.SourceExists ("monotempsource", "."))
3768 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3770 if (EventLog.Exists ("monologtemp", "."))
3771 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3773 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3775 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3776 eventLog.WriteEntry ("WriteEntry2a", EventLogEntryType.Information);
3778 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3779 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3780 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3781 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3782 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3783 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3785 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
3786 Assert.IsNotNull (entry, "#B1");
3787 Assert.IsNotNull (entry.Category, "#B2");
3788 Assert.AreEqual ("(0)", entry.Category, "#B3");
3789 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3790 Assert.IsNotNull (entry.Data, "#B5");
3791 Assert.AreEqual (0, entry.Data.Length, "#B6");
3792 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3793 Assert.AreEqual (0, entry.EventID, "#B8");
3794 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3795 Assert.IsNotNull (entry.MachineName, "#B10");
3796 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
3797 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3798 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3799 Assert.AreEqual ("WriteEntry2a", entry.ReplacementStrings [0], "#B14");
3800 Assert.IsNotNull (entry.Source, "#B15");
3801 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3802 Assert.IsNull (entry.UserName, "#B17");
3804 eventLog.WriteEntry ("WriteEntry2b" + Environment.NewLine + "ok", EventLogEntryType.Error);
3806 entry = eventLog.Entries [eventLog.Entries.Count - 1];
3807 Assert.IsNotNull (entry, "#C1");
3808 Assert.IsNotNull (entry.Category, "#C2");
3809 Assert.AreEqual ("(0)", entry.Category, "#C3");
3810 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
3811 Assert.IsNotNull (entry.Data, "#C5");
3812 Assert.AreEqual (0, entry.Data.Length, "#C6");
3813 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
3814 Assert.AreEqual (0, entry.EventID, "#C8");
3815 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
3816 Assert.IsNotNull (entry.MachineName, "#C10");
3817 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
3818 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
3819 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
3820 Assert.AreEqual ("WriteEntry2b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
3821 Assert.IsNotNull (entry.Source, "#C15");
3822 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
3823 Assert.IsNull (entry.UserName, "#C17");
3826 if (EventLog.Exists ("monologtemp"))
3827 EventLog.Delete ("monologtemp");
3832 public void WriteEntry2_Log_Empty ()
3834 if (EventLogImplType == NULL_IMPL)
3835 // test cannot pass with NULL implementation
3836 Assert.Ignore ("No EventLogImplType.");
3838 if (EventLog.SourceExists ("monotempsource", "."))
3839 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3841 bool applicationLogExists = EventLog.Exists ("Application", ".");
3843 // specified source does not exist, so use Application log
3845 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
3846 eventLog.WriteEntry ("WriteEntry1_Log_Empty", EventLogEntryType.Error);
3847 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3848 Assert.AreEqual ("Application", eventLog.Log, "#A2");
3849 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3850 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
3851 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3852 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3855 if (!applicationLogExists) {
3856 if (EventLog.Exists ("Application"))
3857 EventLog.Delete ("Application");
3859 if (EventLog.SourceExists ("monotempsource", "."))
3860 EventLog.DeleteEventSource ("monotempsource", ".");
3866 public void WriteEntry2_Log_Mismatch ()
3868 if (EventLogImplType == NULL_IMPL)
3869 // test cannot pass with NULL implementation
3870 Assert.Ignore ("No EventLogImplType.");
3872 if (EventLog.SourceExists ("monotempsource", "."))
3873 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3875 if (EventLog.Exists ("monologtemp", "."))
3876 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3878 if (EventLog.Exists ("monologother", "."))
3879 Assert.Ignore ("Event log 'monologother' should not exist.");
3881 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3883 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
3886 eventLog.WriteEntry ("WriteEntry2_Log_Mismatch1",
3887 EventLogEntryType.Error);
3888 Assert.Fail ("#A1");
3889 } catch (ArgumentException ex) {
3890 // The source 'monotempsource' is not registered in log
3891 // 'monologother' (it is registered in log 'monologtemp').
3892 // The Source and Log properties must be matched, or you may
3893 // set Log to the empty string, and it will automatically be
3894 // matched to the Source property
3895 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3896 Assert.IsNotNull (ex.Message, "#A3");
3897 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
3898 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
3899 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
3900 Assert.IsNull (ex.InnerException, "#A7");
3905 eventLog.WriteEntry ("WriteEntry2_Log_Mismatch2",
3906 (EventLogEntryType) 666);
3907 Assert.Fail ("#B1");
3908 } catch (InvalidEnumArgumentException) {
3912 if (EventLog.Exists ("monologtemp"))
3913 EventLog.Delete ("monologtemp");
3915 if (EventLog.Exists ("monologother"))
3916 EventLog.Delete ("monologother");
3921 public void WriteEntry2_Message_Empty ()
3923 if (EventLogImplType == NULL_IMPL)
3924 // test cannot pass with NULL implementation
3925 Assert.Ignore ("No EventLogImplType.");
3927 if (EventLog.SourceExists ("monotempsource", "."))
3928 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3930 if (EventLog.Exists ("monologtemp", "."))
3931 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3933 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3935 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3936 eventLog.WriteEntry (string.Empty, EventLogEntryType.FailureAudit);
3937 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3938 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3939 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3940 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3941 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3942 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3944 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
3945 Assert.IsNotNull (entry, "#B1");
3946 Assert.IsNotNull (entry.Category, "#B2");
3947 Assert.AreEqual ("(0)", entry.Category, "#B3");
3948 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3949 Assert.IsNotNull (entry.Data, "#B5");
3950 Assert.AreEqual (0, entry.Data.Length, "#B6");
3951 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
3952 Assert.AreEqual (0, entry.EventID, "#B8");
3953 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3954 Assert.IsNotNull (entry.MachineName, "#B10");
3955 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
3956 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3957 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3958 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
3959 Assert.IsNotNull (entry.Source, "#B15");
3960 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3961 Assert.IsNull (entry.UserName, "#B17");
3964 if (EventLog.Exists ("monologtemp"))
3965 EventLog.Delete ("monologtemp");
3970 public void WriteEntry2_Message_Null ()
3972 if (EventLogImplType == NULL_IMPL)
3973 // test cannot pass with NULL implementation
3974 Assert.Ignore ("No EventLogImplType.");
3976 if (EventLog.SourceExists ("monotempsource", "."))
3977 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3979 if (EventLog.Exists ("monologtemp", "."))
3980 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3982 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3984 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3985 eventLog.WriteEntry (null, EventLogEntryType.SuccessAudit);
3986 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3987 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3988 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3989 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3990 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3991 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3993 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
3994 Assert.IsNotNull (entry, "#B1");
3995 Assert.IsNotNull (entry.Category, "#B2");
3996 Assert.AreEqual ("(0)", entry.Category, "#B3");
3997 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3998 Assert.IsNotNull (entry.Data, "#B5");
3999 Assert.AreEqual (0, entry.Data.Length, "#B6");
4000 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
4001 Assert.AreEqual (0, entry.EventID, "#B8");
4002 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4003 Assert.IsNotNull (entry.MachineName, "#B10");
4004 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4005 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4006 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4007 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
4008 Assert.IsNotNull (entry.Source, "#B15");
4009 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4010 Assert.IsNull (entry.UserName, "#B17");
4013 if (EventLog.Exists ("monologtemp"))
4014 EventLog.Delete ("monologtemp");
4019 public void WriteEntry2_Source_DoesNotExist ()
4021 if (EventLogImplType == NULL_IMPL)
4022 // test cannot pass with NULL implementation
4023 Assert.Ignore ("No EventLogImplType.");
4025 if (EventLog.SourceExists ("monotempsource", "."))
4026 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4028 if (EventLog.SourceExists ("monoothersource", "."))
4029 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
4031 if (EventLog.Exists ("monologtemp", "."))
4032 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4034 EventLog.CreateEventSource ("monoothersource", "monologtemp");
4036 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4037 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Warning);
4038 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4039 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4040 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4041 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4042 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4043 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4045 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4046 Assert.IsNotNull (entry, "#B1");
4047 Assert.IsNotNull (entry.Category, "#B2");
4048 Assert.AreEqual ("(0)", entry.Category, "#B3");
4049 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4050 Assert.IsNotNull (entry.Data, "#B5");
4051 Assert.AreEqual (0, entry.Data.Length, "#B6");
4052 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
4053 Assert.AreEqual (0, entry.EventID, "#B8");
4054 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4055 Assert.IsNotNull (entry.MachineName, "#B10");
4056 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4057 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4058 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4059 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
4060 Assert.IsNotNull (entry.Source, "#B15");
4061 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4062 Assert.IsNull (entry.UserName, "#B17");
4065 if (EventLog.Exists ("monologtemp"))
4066 EventLog.Delete ("monologtemp");
4071 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4072 public void WriteEntry2_Source_Empty ()
4074 EventLog eventLog = new EventLog ("monologtemp");
4075 eventLog.WriteEntry ("test", EventLogEntryType.Information);
4079 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
4080 public void WriteEntry2_Type_NotDefined ()
4082 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
4083 eventLog.WriteEntry ("test", (EventLogEntryType) 666);
4087 public void WriteEntry3 ()
4089 if (EventLogImplType == NULL_IMPL)
4090 // test cannot pass with NULL implementation
4091 Assert.Ignore ("No EventLogImplType.");
4093 if (EventLog.SourceExists ("monotempsource", "."))
4094 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4096 if (EventLog.Exists ("monologtemp", "."))
4097 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4099 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4101 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4102 EventLog.WriteEntry ("monotempsource", "WriteEntry3a");
4104 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4105 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4106 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4107 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4108 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4109 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4111 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4112 Assert.IsNotNull (entry, "#B1");
4113 Assert.IsNotNull (entry.Category, "#B2");
4114 Assert.AreEqual ("(0)", entry.Category, "#B3");
4115 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4116 Assert.IsNotNull (entry.Data, "#B5");
4117 Assert.AreEqual (0, entry.Data.Length, "#B6");
4118 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
4119 Assert.AreEqual (0, entry.EventID, "#B8");
4120 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4121 Assert.IsNotNull (entry.MachineName, "#B10");
4122 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4123 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4124 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4125 Assert.AreEqual ("WriteEntry3a", entry.ReplacementStrings [0], "#B14");
4126 Assert.IsNotNull (entry.Source, "#B15");
4127 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4128 Assert.IsNull (entry.UserName, "#B17");
4130 EventLog.WriteEntry ("monotempsource", "WriteEntry3b"
4131 + Environment.NewLine + "ok");
4133 entry = eventLog.Entries [eventLog.Entries.Count - 1];
4134 Assert.IsNotNull (entry, "#C1");
4135 Assert.IsNotNull (entry.Category, "#C2");
4136 Assert.AreEqual ("(0)", entry.Category, "#C3");
4137 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
4138 Assert.IsNotNull (entry.Data, "#C5");
4139 Assert.AreEqual (0, entry.Data.Length, "#C6");
4140 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#C7");
4141 Assert.AreEqual (0, entry.EventID, "#C8");
4142 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
4143 Assert.IsNotNull (entry.MachineName, "#C10");
4144 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
4145 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
4146 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
4147 Assert.AreEqual ("WriteEntry3b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
4148 Assert.IsNotNull (entry.Source, "#C15");
4149 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
4150 Assert.IsNull (entry.UserName, "#C17");
4153 if (EventLog.Exists ("monologtemp"))
4154 EventLog.Delete ("monologtemp");
4159 public void WriteEntry3_Message_Empty ()
4161 if (EventLogImplType == NULL_IMPL)
4162 // test cannot pass with NULL implementation
4163 Assert.Ignore ("No EventLogImplType.");
4165 if (EventLog.SourceExists ("monotempsource", "."))
4166 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4168 if (EventLog.Exists ("monologtemp", "."))
4169 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4171 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4173 EventLog.WriteEntry ("monotempsource", string.Empty);
4175 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4176 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4177 Assert.IsNotNull (entry, "#A1");
4178 Assert.IsNotNull (entry.Category, "#A2");
4179 Assert.AreEqual ("(0)", entry.Category, "#A3");
4180 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
4181 Assert.IsNotNull (entry.Data, "#A5");
4182 Assert.AreEqual (0, entry.Data.Length, "#A6");
4183 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#A7");
4184 Assert.AreEqual (0, entry.EventID, "#A8");
4185 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
4186 Assert.IsNotNull (entry.MachineName, "#A10");
4187 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
4188 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
4189 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
4190 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
4191 Assert.IsNotNull (entry.Source, "#A15");
4192 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
4193 Assert.IsNull (entry.UserName, "#A17");
4196 if (EventLog.Exists ("monologtemp"))
4197 EventLog.Delete ("monologtemp");
4202 public void WriteEntry3_Message_Null ()
4204 if (EventLogImplType == NULL_IMPL)
4205 // test cannot pass with NULL implementation
4206 Assert.Ignore ("No EventLogImplType.");
4208 if (EventLog.SourceExists ("monotempsource", "."))
4209 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4211 if (EventLog.Exists ("monologtemp", "."))
4212 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4214 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4216 EventLog.WriteEntry ("monotempsource", null);
4218 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4219 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4220 Assert.IsNotNull (entry, "#A1");
4221 Assert.IsNotNull (entry.Category, "#A2");
4222 Assert.AreEqual ("(0)", entry.Category, "#A3");
4223 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
4224 Assert.IsNotNull (entry.Data, "#A5");
4225 Assert.AreEqual (0, entry.Data.Length, "#A6");
4226 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#A7");
4227 Assert.AreEqual (0, entry.EventID, "#A8");
4228 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
4229 Assert.IsNotNull (entry.MachineName, "#A10");
4230 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
4231 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
4232 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
4233 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
4234 Assert.IsNotNull (entry.Source, "#A15");
4235 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
4236 Assert.IsNull (entry.UserName, "#A17");
4239 if (EventLog.Exists ("monologtemp"))
4240 EventLog.Delete ("monologtemp");
4245 public void WriteEntry3_Source_DoesNotExist ()
4247 if (EventLogImplType == NULL_IMPL)
4248 // test cannot pass with NULL implementation
4249 Assert.Ignore ("No EventLogImplType.");
4251 if (EventLog.SourceExists ("monotempsource", "."))
4252 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4254 bool applicationLogExists = EventLog.Exists ("Application");
4256 EventLog.WriteEntry ("monotempsource", "test");
4258 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
4259 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
4260 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
4262 if (EventLogImplType == WIN32_IMPL)
4263 // win32 API does not return entries in order for
4267 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
4268 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4269 Assert.IsNotNull (entry, "#B1");
4270 Assert.IsNotNull (entry.Category, "#B2");
4271 Assert.AreEqual ("(0)", entry.Category, "#B3");
4272 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4273 Assert.IsNotNull (entry.Data, "#B5");
4274 Assert.AreEqual (0, entry.Data.Length, "#B6");
4275 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
4276 Assert.AreEqual (0, entry.EventID, "#B8");
4277 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4278 Assert.IsNotNull (entry.MachineName, "#B10");
4279 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4280 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4281 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4282 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
4283 Assert.IsNotNull (entry.Source, "#B15");
4284 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4285 Assert.IsNull (entry.UserName, "#B17");
4288 if (!applicationLogExists) {
4289 if (EventLog.Exists ("Application"))
4290 EventLog.Delete ("Application");
4292 if (EventLog.SourceExists ("monotempsource", "."))
4293 EventLog.DeleteEventSource ("monotempsource", ".");
4299 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4300 public void WriteEntry3_Source_Empty ()
4302 EventLog.WriteEntry (string.Empty, "test");
4306 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4307 public void WriteEntry3_Source_Null ()
4309 EventLog.WriteEntry (null, "test");
4313 public void WriteEntry4 ()
4315 if (EventLogImplType == NULL_IMPL)
4316 // test cannot pass with NULL implementation
4317 Assert.Ignore ("No EventLogImplType.");
4319 if (EventLog.SourceExists ("monotempsource", "."))
4320 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4322 if (EventLog.Exists ("monologtemp", "."))
4323 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4325 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4327 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4328 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Information, 56);
4329 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4330 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4331 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4332 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4333 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4334 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4336 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4337 Assert.IsNotNull (entry, "#B1");
4338 Assert.IsNotNull (entry.Category, "#B2");
4339 Assert.AreEqual ("(0)", entry.Category, "#B3");
4340 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4341 Assert.IsNotNull (entry.Data, "#B5");
4342 Assert.AreEqual (0, entry.Data.Length, "#B6");
4343 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
4344 Assert.AreEqual (56, entry.EventID, "#B8");
4345 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4346 Assert.IsNotNull (entry.MachineName, "#B10");
4347 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4348 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4349 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4350 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
4351 Assert.IsNotNull (entry.Source, "#B15");
4352 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4353 Assert.IsNull (entry.UserName, "#B17");
4355 eventLog.WriteEntry ("WriteEntry2", EventLogEntryType.Error, 0);
4357 entry = eventLog.Entries [eventLog.Entries.Count - 1];
4358 Assert.IsNotNull (entry, "#C1");
4359 Assert.IsNotNull (entry.Category, "#C2");
4360 Assert.AreEqual ("(0)", entry.Category, "#C3");
4361 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
4362 Assert.IsNotNull (entry.Data, "#C5");
4363 Assert.AreEqual (0, entry.Data.Length, "#C6");
4364 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
4365 Assert.AreEqual (0, entry.EventID, "#C8");
4366 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
4367 Assert.IsNotNull (entry.MachineName, "#C10");
4368 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
4369 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
4370 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
4371 Assert.AreEqual ("WriteEntry2", entry.ReplacementStrings [0], "#C14");
4372 Assert.IsNotNull (entry.Source, "#C15");
4373 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
4374 Assert.IsNull (entry.UserName, "#C17");
4376 eventLog.WriteEntry ("WriteEntry2", EventLogEntryType.Error, ushort.MaxValue);
4378 entry = eventLog.Entries [eventLog.Entries.Count - 1];
4379 Assert.IsNotNull (entry, "#D1");
4380 Assert.IsNotNull (entry.Category, "#D2");
4381 Assert.AreEqual ("(0)", entry.Category, "#D3");
4382 Assert.AreEqual (0, entry.CategoryNumber, "#D4");
4383 Assert.IsNotNull (entry.Data, "#D5");
4384 Assert.AreEqual (0, entry.Data.Length, "#D6");
4385 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
4386 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
4387 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
4388 Assert.IsNotNull (entry.MachineName, "#D10");
4389 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#D11");
4390 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
4391 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
4392 Assert.AreEqual ("WriteEntry2", entry.ReplacementStrings [0], "#D14");
4393 Assert.IsNotNull (entry.Source, "#D15");
4394 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
4395 Assert.IsNull (entry.UserName, "#D17");
4398 if (EventLog.Exists ("monologtemp"))
4399 EventLog.Delete ("monologtemp");
4404 public void WriteEntry4_EventID_Invalid ()
4406 if (EventLogImplType == NULL_IMPL)
4407 // test cannot pass with NULL implementation
4408 Assert.Ignore ("No EventLogImplType.");
4410 if (EventLog.SourceExists ("monotempsource", "."))
4411 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4413 if (EventLog.Exists ("monologtemp", "."))
4414 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4416 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
4419 eventLog.WriteEntry ("test", EventLogEntryType.Information, -1);
4420 Assert.Fail ("#A1");
4421 } catch (ArgumentException ex) {
4422 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
4423 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
4424 Assert.IsNotNull (ex.Message, "#A3");
4425 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
4426 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
4427 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
4428 Assert.IsNull (ex.InnerException, "#A7");
4429 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#A8");
4430 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
4431 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
4433 if (EventLog.Exists ("monologtemp"))
4434 EventLog.Delete ("monologtemp");
4438 eventLog.WriteEntry ("test", EventLogEntryType.Information, 65536);
4439 Assert.Fail ("#B1");
4440 } catch (ArgumentException ex) {
4441 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
4442 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
4443 Assert.IsNotNull (ex.Message, "#B3");
4444 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
4445 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
4446 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
4447 Assert.IsNull (ex.InnerException, "#B7");
4448 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#B8");
4449 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
4450 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
4452 if (EventLog.Exists ("monologtemp"))
4453 EventLog.Delete ("monologtemp");
4458 public void WriteEntry4_Log_Empty ()
4460 if (EventLogImplType == NULL_IMPL)
4461 // test cannot pass with NULL implementation
4462 Assert.Ignore ("No EventLogImplType.");
4464 if (EventLog.SourceExists ("monotempsource", "."))
4465 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4467 bool applicationLogExists = EventLog.Exists ("Application", ".");
4469 // specified source does not exist, so use Application log
4471 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
4472 eventLog.WriteEntry ("WriteEntry1_Log_Empty", EventLogEntryType.Error, 555);
4473 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4474 Assert.AreEqual ("Application", eventLog.Log, "#A2");
4475 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4476 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
4477 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4478 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4481 if (!applicationLogExists) {
4482 if (EventLog.Exists ("Application"))
4483 EventLog.Delete ("Application");
4485 if (EventLog.SourceExists ("monotempsource", "."))
4486 EventLog.DeleteEventSource ("monotempsource", ".");
4492 public void WriteEntry4_Log_Mismatch ()
4494 if (EventLogImplType == NULL_IMPL)
4495 // test cannot pass with NULL implementation
4496 Assert.Ignore ("No EventLogImplType.");
4498 if (EventLog.SourceExists ("monotempsource", "."))
4499 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4501 if (EventLog.Exists ("monologtemp", "."))
4502 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4504 if (EventLog.Exists ("monologother", "."))
4505 Assert.Ignore ("Event log 'monologother' should not exist.");
4507 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4509 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
4512 eventLog.WriteEntry ("WriteEntry4_Log_Mismatch1",
4513 EventLogEntryType.Error, 555);
4514 Assert.Fail ("#A1");
4515 } catch (ArgumentException ex) {
4516 // The source 'monotempsource' is not registered in log
4517 // 'monologother' (it is registered in log 'monologtemp').
4518 // The Source and Log properties must be matched, or you may
4519 // set Log to the empty string, and it will automatically be
4520 // matched to the Source property
4521 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
4522 Assert.IsNotNull (ex.Message, "#A3");
4523 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
4524 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
4525 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
4526 Assert.IsNull (ex.InnerException, "#A7");
4531 eventLog.WriteEntry ("WriteEntry4_Log_Mismatch2",
4532 (EventLogEntryType) 666, 555);
4533 Assert.Fail ("#B1");
4534 } catch (InvalidEnumArgumentException) {
4539 eventLog.WriteEntry ("WriteEntry4_Log_Mismatch3",
4540 EventLogEntryType.Error, -1);
4541 Assert.Fail ("#C1");
4542 } catch (ArgumentException ex) {
4543 // The source 'monotempsource' is not registered in log
4544 // 'monologother' (it is registered in log 'monologtemp').
4545 // The Source and Log properties must be matched, or you may
4546 // set Log to the empty string, and it will automatically be
4547 // matched to the Source property
4548 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
4549 Assert.IsNotNull (ex.Message, "#C3");
4550 Assert.IsFalse (ex.Message.IndexOf ("'monotempsource'") != -1, "#C4");
4551 Assert.IsFalse (ex.Message.IndexOf ("'monologother'") != -1, "#C5");
4552 Assert.IsFalse (ex.Message.IndexOf ("'monologtemp'") != -1, "#C6");
4553 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#C7");
4554 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#C8");
4555 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#C9");
4556 Assert.IsNull (ex.InnerException, "#C10");
4560 if (EventLog.Exists ("monologtemp"))
4561 EventLog.Delete ("monologtemp");
4563 if (EventLog.Exists ("monologother"))
4564 EventLog.Delete ("monologother");
4569 public void WriteEntry4_Message_Empty ()
4571 if (EventLogImplType == NULL_IMPL)
4572 // test cannot pass with NULL implementation
4573 Assert.Ignore ("No EventLogImplType.");
4575 if (EventLog.SourceExists ("monotempsource", "."))
4576 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4578 if (EventLog.Exists ("monologtemp", "."))
4579 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4581 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4583 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4584 eventLog.WriteEntry (string.Empty, EventLogEntryType.FailureAudit, 888);
4585 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4586 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4587 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4588 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4589 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4590 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4592 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4593 Assert.IsNotNull (entry, "#B1");
4594 Assert.IsNotNull (entry.Category, "#B2");
4595 Assert.AreEqual ("(0)", entry.Category, "#B3");
4596 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4597 Assert.IsNotNull (entry.Data, "#B5");
4598 Assert.AreEqual (0, entry.Data.Length, "#B6");
4599 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
4600 Assert.AreEqual (888, entry.EventID, "#B8");
4601 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4602 Assert.IsNotNull (entry.MachineName, "#B10");
4603 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4604 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4605 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4606 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
4607 Assert.IsNotNull (entry.Source, "#B15");
4608 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4609 Assert.IsNull (entry.UserName, "#B17");
4612 if (EventLog.Exists ("monologtemp"))
4613 EventLog.Delete ("monologtemp");
4618 public void WriteEntry4_Message_Null ()
4620 if (EventLogImplType == NULL_IMPL)
4621 // test cannot pass with NULL implementation
4622 Assert.Ignore ("No EventLogImplType.");
4624 if (EventLog.SourceExists ("monotempsource", "."))
4625 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4627 if (EventLog.Exists ("monologtemp", "."))
4628 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4630 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4632 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4633 eventLog.WriteEntry (null, EventLogEntryType.SuccessAudit, 343);
4634 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4635 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4636 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4637 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4638 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4639 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4641 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4642 Assert.IsNotNull (entry, "#B1");
4643 Assert.IsNotNull (entry.Category, "#B2");
4644 Assert.AreEqual ("(0)", entry.Category, "#B3");
4645 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4646 Assert.IsNotNull (entry.Data, "#B5");
4647 Assert.AreEqual (0, entry.Data.Length, "#B6");
4648 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
4649 Assert.AreEqual (343, entry.EventID, "#B8");
4650 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4651 Assert.IsNotNull (entry.MachineName, "#B10");
4652 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4653 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4654 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4655 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
4656 Assert.IsNotNull (entry.Source, "#B15");
4657 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4658 Assert.IsNull (entry.UserName, "#B17");
4661 if (EventLog.Exists ("monologtemp"))
4662 EventLog.Delete ("monologtemp");
4667 public void WriteEntry4_Source_DoesNotExist ()
4669 if (EventLogImplType == NULL_IMPL)
4670 // test cannot pass with NULL implementation
4671 Assert.Ignore ("No EventLogImplType.");
4673 if (EventLog.SourceExists ("monotempsource", "."))
4674 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4676 if (EventLog.SourceExists ("monoothersource", "."))
4677 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
4679 if (EventLog.Exists ("monologtemp", "."))
4680 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4682 EventLog.CreateEventSource ("monoothersource", "monologtemp");
4684 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4685 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Warning, 2);
4686 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4687 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4688 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4689 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4690 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4691 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4693 if (EventLogImplType == WIN32_IMPL)
4694 // win32 API does not return entries in order for
4698 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4699 Assert.IsNotNull (entry, "#B1");
4700 Assert.IsNotNull (entry.Category, "#B2");
4701 Assert.AreEqual ("(0)", entry.Category, "#B3");
4702 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4703 Assert.IsNotNull (entry.Data, "#B5");
4704 Assert.AreEqual (0, entry.Data.Length, "#B6");
4705 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
4706 Assert.AreEqual (2, entry.EventID, "#B8");
4707 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4708 Assert.IsNotNull (entry.MachineName, "#B10");
4709 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4710 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4711 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4712 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
4713 Assert.IsNotNull (entry.Source, "#B15");
4714 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4715 Assert.IsNull (entry.UserName, "#B17");
4718 if (EventLog.Exists ("monologtemp"))
4719 EventLog.Delete ("monologtemp");
4724 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4725 public void WriteEntry4_Source_Empty ()
4727 EventLog eventLog = new EventLog ("monologtemp");
4728 eventLog.WriteEntry ("test", EventLogEntryType.Information, 56);
4732 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
4733 public void WriteEntry4_Type_NotDefined ()
4735 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
4736 eventLog.WriteEntry ("test", (EventLogEntryType) 666, 44);
4740 public void WriteEntry5 ()
4742 if (EventLogImplType == NULL_IMPL)
4743 // test cannot pass with NULL implementation
4744 Assert.Ignore ("No EventLogImplType.");
4746 if (EventLog.SourceExists ("monotempsource", "."))
4747 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4749 if (EventLog.Exists ("monologtemp", "."))
4750 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4752 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4754 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4755 EventLog.WriteEntry ("monotempsource", "WriteEntry3a",
4756 EventLogEntryType.Information);
4758 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4759 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4760 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4761 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4762 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4763 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4765 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4766 Assert.IsNotNull (entry, "#B1");
4767 Assert.IsNotNull (entry.Category, "#B2");
4768 Assert.AreEqual ("(0)", entry.Category, "#B3");
4769 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4770 Assert.IsNotNull (entry.Data, "#B5");
4771 Assert.AreEqual (0, entry.Data.Length, "#B6");
4772 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
4773 Assert.AreEqual (0, entry.EventID, "#B8");
4774 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4775 Assert.IsNotNull (entry.MachineName, "#B10");
4776 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4777 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4778 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4779 Assert.AreEqual ("WriteEntry3a", entry.ReplacementStrings [0], "#B14");
4780 Assert.IsNotNull (entry.Source, "#B15");
4781 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4782 Assert.IsNull (entry.UserName, "#B17");
4784 EventLog.WriteEntry ("monotempsource", "WriteEntry3b"
4785 + Environment.NewLine + "ok", EventLogEntryType.Error);
4787 entry = eventLog.Entries [eventLog.Entries.Count - 1];
4788 Assert.IsNotNull (entry, "#C1");
4789 Assert.IsNotNull (entry.Category, "#C2");
4790 Assert.AreEqual ("(0)", entry.Category, "#C3");
4791 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
4792 Assert.IsNotNull (entry.Data, "#C5");
4793 Assert.AreEqual (0, entry.Data.Length, "#C6");
4794 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
4795 Assert.AreEqual (0, entry.EventID, "#C8");
4796 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
4797 Assert.IsNotNull (entry.MachineName, "#C10");
4798 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
4799 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
4800 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
4801 Assert.AreEqual ("WriteEntry3b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
4802 Assert.IsNotNull (entry.Source, "#C15");
4803 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
4804 Assert.IsNull (entry.UserName, "#C17");
4807 if (EventLog.Exists ("monologtemp"))
4808 EventLog.Delete ("monologtemp");
4813 public void WriteEntry5_Message_Empty ()
4815 if (EventLogImplType == NULL_IMPL)
4816 // test cannot pass with NULL implementation
4817 Assert.Ignore ("No EventLogImplType.");
4819 if (EventLog.SourceExists ("monotempsource", "."))
4820 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4822 if (EventLog.Exists ("monologtemp", "."))
4823 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4825 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4827 EventLog.WriteEntry ("monotempsource", string.Empty, EventLogEntryType.Error);
4829 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4830 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4831 Assert.IsNotNull (entry, "#A1");
4832 Assert.IsNotNull (entry.Category, "#A2");
4833 Assert.AreEqual ("(0)", entry.Category, "#A3");
4834 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
4835 Assert.IsNotNull (entry.Data, "#A5");
4836 Assert.AreEqual (0, entry.Data.Length, "#A6");
4837 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#A7");
4838 Assert.AreEqual (0, entry.EventID, "#A8");
4839 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
4840 Assert.IsNotNull (entry.MachineName, "#A10");
4841 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
4842 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
4843 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
4844 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
4845 Assert.IsNotNull (entry.Source, "#A15");
4846 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
4847 Assert.IsNull (entry.UserName, "#A17");
4850 if (EventLog.Exists ("monologtemp"))
4851 EventLog.Delete ("monologtemp");
4856 public void WriteEntry5_Message_Null ()
4858 if (EventLogImplType == NULL_IMPL)
4859 // test cannot pass with NULL implementation
4860 Assert.Ignore ("No EventLogImplType.");
4862 if (EventLog.SourceExists ("monotempsource", "."))
4863 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4865 if (EventLog.Exists ("monologtemp", "."))
4866 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4868 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4870 EventLog.WriteEntry ("monotempsource", null, EventLogEntryType.FailureAudit);
4872 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4873 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4874 Assert.IsNotNull (entry, "#A1");
4875 Assert.IsNotNull (entry.Category, "#A2");
4876 Assert.AreEqual ("(0)", entry.Category, "#A3");
4877 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
4878 Assert.IsNotNull (entry.Data, "#A5");
4879 Assert.AreEqual (0, entry.Data.Length, "#A6");
4880 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#A7");
4881 Assert.AreEqual (0, entry.EventID, "#A8");
4882 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
4883 Assert.IsNotNull (entry.MachineName, "#A10");
4884 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
4885 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
4886 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
4887 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
4888 Assert.IsNotNull (entry.Source, "#A15");
4889 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
4890 Assert.IsNull (entry.UserName, "#A17");
4893 if (EventLog.Exists ("monologtemp"))
4894 EventLog.Delete ("monologtemp");
4899 public void WriteEntry5_Source_DoesNotExist ()
4901 if (EventLogImplType == NULL_IMPL)
4902 // test cannot pass with NULL implementation
4903 Assert.Ignore ("No EventLogImplType.");
4905 if (EventLog.SourceExists ("monotempsource", "."))
4906 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4908 bool applicationLogExists = EventLog.Exists ("Application");
4910 EventLog.WriteEntry ("monotempsource", "test", EventLogEntryType.SuccessAudit);
4912 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
4913 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
4914 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
4916 if (EventLogImplType == WIN32_IMPL)
4917 // win32 API does not return entries in order for
4921 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
4922 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4923 Assert.IsNotNull (entry, "#B1");
4924 Assert.IsNotNull (entry.Category, "#B2");
4925 Assert.AreEqual ("(0)", entry.Category, "#B3");
4926 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4927 Assert.IsNotNull (entry.Data, "#B5");
4928 Assert.AreEqual (0, entry.Data.Length, "#B6");
4929 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
4930 Assert.AreEqual (0, entry.EventID, "#B8");
4931 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4932 Assert.IsNotNull (entry.MachineName, "#B10");
4933 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
4934 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4935 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4936 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
4937 Assert.IsNotNull (entry.Source, "#B15");
4938 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4939 Assert.IsNull (entry.UserName, "#B17");
4942 if (!applicationLogExists) {
4943 if (EventLog.Exists ("Application"))
4944 EventLog.Delete ("Application");
4946 if (EventLog.SourceExists ("monotempsource", "."))
4947 EventLog.DeleteEventSource ("monotempsource", ".");
4953 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4954 public void WriteEntry5_Source_Empty ()
4956 EventLog.WriteEntry (string.Empty, "test", EventLogEntryType.Warning);
4960 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4961 public void WriteEntry5_Source_Null ()
4963 EventLog.WriteEntry (null, "test", EventLogEntryType.Error);
4967 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
4968 public void WriteEntry5_Type_NotDefined ()
4970 EventLog.WriteEntry ("monotempsource", "test", (EventLogEntryType) 666);
4974 public void WriteEntry6 ()
4976 if (EventLogImplType == NULL_IMPL)
4977 // test cannot pass with NULL implementation
4978 Assert.Ignore ("No EventLogImplType.");
4980 if (EventLog.SourceExists ("monotempsource", "."))
4981 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4983 if (EventLog.Exists ("monologtemp", "."))
4984 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4986 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4988 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4989 eventLog.WriteEntry ("WriteEntry6a", EventLogEntryType.Information, 56, 3);
4991 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4992 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4993 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4994 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4995 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4996 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4998 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4999 Assert.IsNotNull (entry, "#B1");
5000 Assert.IsNotNull (entry.Category, "#B2");
5001 Assert.AreEqual ("(3)", entry.Category, "#B3");
5002 Assert.AreEqual (3, entry.CategoryNumber, "#B4");
5003 Assert.IsNotNull (entry.Data, "#B5");
5004 Assert.AreEqual (0, entry.Data.Length, "#B6");
5005 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
5006 Assert.AreEqual (56, entry.EventID, "#B8");
5007 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5008 Assert.IsNotNull (entry.MachineName, "#B10");
5009 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
5010 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5011 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5012 Assert.AreEqual ("WriteEntry6a", entry.ReplacementStrings [0], "#B14");
5013 Assert.IsNotNull (entry.Source, "#B15");
5014 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5015 Assert.IsNull (entry.UserName, "#B17");
5017 eventLog.WriteEntry ("WriteEntry6b" + Environment.NewLine + "ok",
5018 EventLogEntryType.Error, 0, 0);
5020 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5021 Assert.IsNotNull (entry, "#C1");
5022 Assert.IsNotNull (entry.Category, "#C2");
5023 Assert.AreEqual ("(0)", entry.Category, "#C3");
5024 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
5025 Assert.IsNotNull (entry.Data, "#C5");
5026 Assert.AreEqual (0, entry.Data.Length, "#C6");
5027 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
5028 Assert.AreEqual (0, entry.EventID, "#C8");
5029 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
5030 Assert.IsNotNull (entry.MachineName, "#C10");
5031 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
5032 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
5033 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
5034 Assert.AreEqual ("WriteEntry6b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
5035 Assert.IsNotNull (entry.Source, "#C15");
5036 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
5037 Assert.IsNull (entry.UserName, "#C17");
5039 eventLog.WriteEntry ("WriteEntry6c", EventLogEntryType.Error,
5040 ushort.MaxValue, short.MaxValue);
5042 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5043 Assert.IsNotNull (entry, "#D1");
5044 Assert.IsNotNull (entry.Category, "#D2");
5045 Assert.AreEqual ("(32767)", entry.Category, "#D3");
5046 Assert.AreEqual (short.MaxValue, entry.CategoryNumber, "#D4");
5047 Assert.IsNotNull (entry.Data, "#D5");
5048 Assert.AreEqual (0, entry.Data.Length, "#D6");
5049 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
5050 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
5051 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
5052 Assert.IsNotNull (entry.MachineName, "#D10");
5053 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#D11");
5054 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
5055 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
5056 Assert.AreEqual ("WriteEntry6c", entry.ReplacementStrings [0], "#D14");
5057 Assert.IsNotNull (entry.Source, "#D15");
5058 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
5059 Assert.IsNull (entry.UserName, "#D17");
5062 if (EventLog.Exists ("monologtemp"))
5063 EventLog.Delete ("monologtemp");
5068 public void WriteEntry6_EventID_Invalid ()
5070 if (EventLogImplType == NULL_IMPL)
5071 // test cannot pass with NULL implementation
5072 Assert.Ignore ("No EventLogImplType.");
5074 if (EventLog.SourceExists ("monotempsource", "."))
5075 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5077 if (EventLog.Exists ("monologtemp", "."))
5078 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5080 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
5083 eventLog.WriteEntry ("test", EventLogEntryType.Information, -1, 5);
5084 Assert.Fail ("#A1");
5085 } catch (ArgumentException ex) {
5086 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
5087 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5088 Assert.IsNotNull (ex.Message, "#A3");
5089 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
5090 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
5091 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
5092 Assert.IsNull (ex.InnerException, "#A7");
5093 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#A8");
5094 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
5095 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
5097 if (EventLog.Exists ("monologtemp"))
5098 EventLog.Delete ("monologtemp");
5102 eventLog.WriteEntry ("test", EventLogEntryType.Information, 65536, 5);
5103 Assert.Fail ("#B1");
5104 } catch (ArgumentException ex) {
5105 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
5106 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
5107 Assert.IsNotNull (ex.Message, "#B3");
5108 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
5109 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
5110 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
5111 Assert.IsNull (ex.InnerException, "#B7");
5112 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#B8");
5113 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
5114 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
5116 if (EventLog.Exists ("monologtemp"))
5117 EventLog.Delete ("monologtemp");
5122 public void WriteEntry6_Log_Empty ()
5124 if (EventLogImplType == NULL_IMPL)
5125 // test cannot pass with NULL implementation
5126 Assert.Ignore ("No EventLogImplType.");
5128 if (EventLog.SourceExists ("monotempsource", "."))
5129 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5131 bool applicationLogExists = EventLog.Exists ("Application", ".");
5133 // specified source does not exist, so use Application log
5135 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
5136 eventLog.WriteEntry ("WriteEntry1_Log_Empty", EventLogEntryType.Error, 555, 5);
5137 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5138 Assert.AreEqual ("Application", eventLog.Log, "#A2");
5139 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5140 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
5141 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5142 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5145 if (!applicationLogExists) {
5146 if (EventLog.Exists ("Application"))
5147 EventLog.Delete ("Application");
5149 if (EventLog.SourceExists ("monotempsource", "."))
5150 EventLog.DeleteEventSource ("monotempsource", ".");
5156 public void WriteEntry6_Log_Mismatch ()
5158 if (EventLogImplType == NULL_IMPL)
5159 // test cannot pass with NULL implementation
5160 Assert.Ignore ("No EventLogImplType.");
5162 if (EventLog.SourceExists ("monotempsource", "."))
5163 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5165 if (EventLog.Exists ("monologtemp", "."))
5166 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5168 if (EventLog.Exists ("monologother", "."))
5169 Assert.Ignore ("Event log 'monologother' should not exist.");
5171 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5173 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
5176 eventLog.WriteEntry ("WriteEntry6_Log_Mismatch1",
5177 EventLogEntryType.Error, 555, 5);
5178 Assert.Fail ("#A1");
5179 } catch (ArgumentException ex) {
5180 // The source 'monotempsource' is not registered in log
5181 // 'monologother' (it is registered in log 'monologtemp').
5182 // The Source and Log properties must be matched, or you may
5183 // set Log to the empty string, and it will automatically be
5184 // matched to the Source property
5185 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5186 Assert.IsNotNull (ex.Message, "#A3");
5187 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
5188 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
5189 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
5190 Assert.IsNull (ex.InnerException, "#A7");
5195 eventLog.WriteEntry ("WriteEntry6_Log_Mismatch2",
5196 (EventLogEntryType) 666, 555, 5);
5197 Assert.Fail ("#B1");
5198 } catch (InvalidEnumArgumentException) {
5203 eventLog.WriteEntry ("WriteEntry6_Log_Mismatch3",
5204 EventLogEntryType.Error, -1, 5);
5205 Assert.Fail ("#C1");
5206 } catch (ArgumentException ex) {
5207 // The source 'monotempsource' is not registered in log
5208 // 'monologother' (it is registered in log 'monologtemp').
5209 // The Source and Log properties must be matched, or you may
5210 // set Log to the empty string, and it will automatically be
5211 // matched to the Source property
5212 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
5213 Assert.IsNotNull (ex.Message, "#C3");
5214 Assert.IsFalse (ex.Message.IndexOf ("'monotempsource'") != -1, "#C4");
5215 Assert.IsFalse (ex.Message.IndexOf ("'monologother'") != -1, "#C5");
5216 Assert.IsFalse (ex.Message.IndexOf ("'monologtemp'") != -1, "#C6");
5217 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#C7");
5218 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#C8");
5219 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#C9");
5220 Assert.IsNull (ex.InnerException, "#C10");
5224 if (EventLog.Exists ("monologtemp"))
5225 EventLog.Delete ("monologtemp");
5227 if (EventLog.Exists ("monologother"))
5228 EventLog.Delete ("monologother");
5233 public void WriteEntry6_Message_Empty ()
5235 if (EventLogImplType == NULL_IMPL)
5236 // test cannot pass with NULL implementation
5237 Assert.Ignore ("No EventLogImplType.");
5239 if (EventLog.SourceExists ("monotempsource", "."))
5240 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5242 if (EventLog.Exists ("monologtemp", "."))
5243 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5245 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5247 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5248 eventLog.WriteEntry (string.Empty, EventLogEntryType.FailureAudit, 888, 6);
5249 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5250 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5251 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5252 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5253 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5254 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5256 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5257 Assert.IsNotNull (entry, "#B1");
5258 Assert.IsNotNull (entry.Category, "#B2");
5259 Assert.AreEqual ("(6)", entry.Category, "#B3");
5260 Assert.AreEqual (6, entry.CategoryNumber, "#B4");
5261 Assert.IsNotNull (entry.Data, "#B5");
5262 Assert.AreEqual (0, entry.Data.Length, "#B6");
5263 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
5264 Assert.AreEqual (888, entry.EventID, "#B8");
5265 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5266 Assert.IsNotNull (entry.MachineName, "#B10");
5267 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
5268 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5269 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5270 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
5271 Assert.IsNotNull (entry.Source, "#B15");
5272 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5273 Assert.IsNull (entry.UserName, "#B17");
5276 if (EventLog.Exists ("monologtemp"))
5277 EventLog.Delete ("monologtemp");
5282 public void WriteEntry6_Message_Null ()
5284 if (EventLogImplType == NULL_IMPL)
5285 // test cannot pass with NULL implementation
5286 Assert.Ignore ("No EventLogImplType.");
5288 if (EventLog.SourceExists ("monotempsource", "."))
5289 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5291 if (EventLog.Exists ("monologtemp", "."))
5292 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5294 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5296 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5297 eventLog.WriteEntry (null, EventLogEntryType.SuccessAudit, 343, 8);
5298 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5299 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5300 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5301 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5302 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5303 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5305 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5306 Assert.IsNotNull (entry, "#B1");
5307 Assert.IsNotNull (entry.Category, "#B2");
5308 Assert.AreEqual ("(8)", entry.Category, "#B3");
5309 Assert.AreEqual (8, entry.CategoryNumber, "#B4");
5310 Assert.IsNotNull (entry.Data, "#B5");
5311 Assert.AreEqual (0, entry.Data.Length, "#B6");
5312 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
5313 Assert.AreEqual (343, entry.EventID, "#B8");
5314 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5315 Assert.IsNotNull (entry.MachineName, "#B10");
5316 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
5317 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5318 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5319 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
5320 Assert.IsNotNull (entry.Source, "#B15");
5321 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5322 Assert.IsNull (entry.UserName, "#B17");
5325 if (EventLog.Exists ("monologtemp"))
5326 EventLog.Delete ("monologtemp");
5331 public void WriteEntry6_Source_DoesNotExist ()
5333 if (EventLogImplType == NULL_IMPL)
5334 // test cannot pass with NULL implementation
5335 Assert.Ignore ("No EventLogImplType.");
5337 if (EventLog.SourceExists ("monotempsource", "."))
5338 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5340 if (EventLog.SourceExists ("monoothersource", "."))
5341 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
5343 if (EventLog.Exists ("monologtemp", "."))
5344 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5346 EventLog.CreateEventSource ("monoothersource", "monologtemp");
5348 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5349 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Warning, 2, 4);
5350 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5351 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5352 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5353 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5354 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5355 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5357 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5358 Assert.IsNotNull (entry, "#B1");
5359 Assert.IsNotNull (entry.Category, "#B2");
5360 Assert.AreEqual ("(4)", entry.Category, "#B3");
5361 Assert.AreEqual (4, entry.CategoryNumber, "#B4");
5362 Assert.IsNotNull (entry.Data, "#B5");
5363 Assert.AreEqual (0, entry.Data.Length, "#B6");
5364 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
5365 Assert.AreEqual (2, entry.EventID, "#B8");
5366 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5367 Assert.IsNotNull (entry.MachineName, "#B10");
5368 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
5369 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5370 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5371 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
5372 Assert.IsNotNull (entry.Source, "#B15");
5373 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5374 Assert.IsNull (entry.UserName, "#B17");
5377 if (EventLog.Exists ("monologtemp"))
5378 EventLog.Delete ("monologtemp");
5383 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
5384 public void WriteEntry6_Source_Empty ()
5386 EventLog eventLog = new EventLog ("monologtemp");
5387 eventLog.WriteEntry ("test", EventLogEntryType.Information, 56, 5);
5391 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
5392 public void WriteEntry6_Type_NotDefined ()
5394 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
5395 eventLog.WriteEntry ("test", (EventLogEntryType) 666, 44, 8);
5399 public void WriteEntry7 ()
5401 if (EventLogImplType == NULL_IMPL)
5402 // test cannot pass with NULL implementation
5403 Assert.Ignore ("No EventLogImplType.");
5405 if (EventLog.SourceExists ("monotempsource", "."))
5406 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5408 if (EventLog.Exists ("monologtemp", "."))
5409 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5411 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5413 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5414 EventLog.WriteEntry ("monotempsource", "WriteEntry7a",
5415 EventLogEntryType.Information, 54);
5417 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5418 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5419 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5420 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5421 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5422 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5424 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5425 Assert.IsNotNull (entry, "#B1");
5426 Assert.IsNotNull (entry.Category, "#B2");
5427 Assert.AreEqual ("(0)", entry.Category, "#B3");
5428 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
5429 Assert.IsNotNull (entry.Data, "#B5");
5430 Assert.AreEqual (0, entry.Data.Length, "#B6");
5431 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
5432 Assert.AreEqual (54, entry.EventID, "#B8");
5433 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5434 Assert.IsNotNull (entry.MachineName, "#B10");
5435 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
5436 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5437 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5438 Assert.AreEqual ("WriteEntry7a", entry.ReplacementStrings [0], "#B14");
5439 Assert.IsNotNull (entry.Source, "#B15");
5440 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5441 Assert.IsNull (entry.UserName, "#B17");
5443 EventLog.WriteEntry ("monotempsource", "WriteEntry7b"
5444 + Environment.NewLine + "ok", EventLogEntryType.Error, 0);
5446 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5447 Assert.IsNotNull (entry, "#C1");
5448 Assert.IsNotNull (entry.Category, "#C2");
5449 Assert.AreEqual ("(0)", entry.Category, "#C3");
5450 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
5451 Assert.IsNotNull (entry.Data, "#C5");
5452 Assert.AreEqual (0, entry.Data.Length, "#C6");
5453 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
5454 Assert.AreEqual (0, entry.EventID, "#C8");
5455 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
5456 Assert.IsNotNull (entry.MachineName, "#C10");
5457 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
5458 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
5459 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
5460 Assert.AreEqual ("WriteEntry7b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
5461 Assert.IsNotNull (entry.Source, "#C15");
5462 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
5463 Assert.IsNull (entry.UserName, "#C17");
5465 EventLog.WriteEntry ("monotempsource", "WriteEntry7c"
5466 + Environment.NewLine + "ok", EventLogEntryType.Error,
5469 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5470 Assert.IsNotNull (entry, "#D1");
5471 Assert.IsNotNull (entry.Category, "#D2");
5472 Assert.AreEqual ("(0)", entry.Category, "#D3");
5473 Assert.AreEqual (0, entry.CategoryNumber, "#D4");
5474 Assert.IsNotNull (entry.Data, "#D5");
5475 Assert.AreEqual (0, entry.Data.Length, "#D6");
5476 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
5477 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
5478 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
5479 Assert.IsNotNull (entry.MachineName, "#D10");
5480 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#D11");
5481 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
5482 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
5483 Assert.AreEqual ("WriteEntry7c" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#D14");
5484 Assert.IsNotNull (entry.Source, "#D15");
5485 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
5486 Assert.IsNull (entry.UserName, "#D17");
5489 if (EventLog.Exists ("monologtemp"))
5490 EventLog.Delete ("monologtemp");
5495 public void WriteEntry7_EventID_Invalid ()
5497 if (EventLogImplType == NULL_IMPL)
5498 // test cannot pass with NULL implementation
5499 Assert.Ignore ("No EventLogImplType.");
5501 if (EventLog.SourceExists ("monotempsource", "."))
5502 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5504 bool applicationLogExists = EventLog.Exists ("Application", ".");
5506 EventLog.WriteEntry ("monotempsource", "test",
5507 EventLogEntryType.Information, -1);
5508 Assert.Fail ("#A1");
5509 } catch (ArgumentException ex) {
5510 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
5511 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5512 Assert.IsNotNull (ex.Message, "#A3");
5513 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
5514 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
5515 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
5516 Assert.IsNull (ex.InnerException, "#A7");
5517 if (!applicationLogExists)
5518 Assert.IsFalse (EventLog.Exists ("Application"), "#A8");
5519 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
5520 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
5522 if (!applicationLogExists) {
5523 if (EventLog.Exists ("Application", "."))
5524 EventLog.Delete ("Application", ".");
5526 if (EventLog.SourceExists ("monotempsource", "."))
5527 EventLog.DeleteEventSource ("monotempsource", ".");
5532 EventLog.WriteEntry ("monotempsource", "test",
5533 EventLogEntryType.Information, 65536);
5534 Assert.Fail ("#B1");
5535 } catch (ArgumentException ex) {
5536 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
5537 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
5538 Assert.IsNotNull (ex.Message, "#B3");
5539 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
5540 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
5541 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
5542 Assert.IsNull (ex.InnerException, "#B7");
5543 if (!applicationLogExists)
5544 Assert.IsFalse (EventLog.Exists ("Application"), "#B8");
5545 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
5546 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
5548 if (!applicationLogExists) {
5549 if (EventLog.Exists ("Application", "."))
5550 EventLog.Delete ("Application", ".");
5552 if (EventLog.SourceExists ("monotempsource", "."))
5553 EventLog.DeleteEventSource ("monotempsource", ".");
5559 public void WriteEntry7_Message_Empty ()
5561 if (EventLogImplType == NULL_IMPL)
5562 // test cannot pass with NULL implementation
5563 Assert.Ignore ("No EventLogImplType.");
5565 if (EventLog.SourceExists ("monotempsource", "."))
5566 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5568 if (EventLog.Exists ("monologtemp", "."))
5569 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5571 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5573 EventLog.WriteEntry ("monotempsource", string.Empty,
5574 EventLogEntryType.Error, 56);
5576 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5577 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5578 Assert.IsNotNull (entry, "#A1");
5579 Assert.IsNotNull (entry.Category, "#A2");
5580 Assert.AreEqual ("(0)", entry.Category, "#A3");
5581 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
5582 Assert.IsNotNull (entry.Data, "#A5");
5583 Assert.AreEqual (0, entry.Data.Length, "#A6");
5584 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#A7");
5585 Assert.AreEqual (56, entry.EventID, "#A8");
5586 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
5587 Assert.IsNotNull (entry.MachineName, "#A10");
5588 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
5589 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
5590 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
5591 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
5592 Assert.IsNotNull (entry.Source, "#A15");
5593 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
5594 Assert.IsNull (entry.UserName, "#A17");
5597 if (EventLog.Exists ("monologtemp"))
5598 EventLog.Delete ("monologtemp");
5603 public void WriteEntry7_Message_Null ()
5605 if (EventLogImplType == NULL_IMPL)
5606 // test cannot pass with NULL implementation
5607 Assert.Ignore ("No EventLogImplType.");
5609 if (EventLog.SourceExists ("monotempsource", "."))
5610 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5612 if (EventLog.Exists ("monologtemp", "."))
5613 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5615 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5617 EventLog.WriteEntry ("monotempsource", null,
5618 EventLogEntryType.FailureAudit, 76);
5620 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5621 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5622 Assert.IsNotNull (entry, "#A1");
5623 Assert.IsNotNull (entry.Category, "#A2");
5624 Assert.AreEqual ("(0)", entry.Category, "#A3");
5625 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
5626 Assert.IsNotNull (entry.Data, "#A5");
5627 Assert.AreEqual (0, entry.Data.Length, "#A6");
5628 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#A7");
5629 Assert.AreEqual (76, entry.EventID, "#A8");
5630 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
5631 Assert.IsNotNull (entry.MachineName, "#A10");
5632 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
5633 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
5634 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
5635 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
5636 Assert.IsNotNull (entry.Source, "#A15");
5637 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
5638 Assert.IsNull (entry.UserName, "#A17");
5641 if (EventLog.Exists ("monologtemp"))
5642 EventLog.Delete ("monologtemp");
5647 public void WriteEntry7_Source_DoesNotExist ()
5649 if (EventLogImplType == NULL_IMPL)
5650 // test cannot pass with NULL implementation
5651 Assert.Ignore ("No EventLogImplType.");
5653 if (EventLog.SourceExists ("monotempsource", "."))
5654 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5656 bool applicationLogExists = EventLog.Exists ("Application");
5658 EventLog.WriteEntry ("monotempsource", "test",
5659 EventLogEntryType.SuccessAudit, 89);
5661 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
5662 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
5663 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
5665 if (EventLogImplType == WIN32_IMPL)
5666 // win32 API does not return entries in order for
5670 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
5671 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5672 Assert.IsNotNull (entry, "#B1");
5673 Assert.IsNotNull (entry.Category, "#B2");
5674 Assert.AreEqual ("(0)", entry.Category, "#B3");
5675 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
5676 Assert.IsNotNull (entry.Data, "#B5");
5677 Assert.AreEqual (0, entry.Data.Length, "#B6");
5678 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
5679 Assert.AreEqual (89, entry.EventID, "#B8");
5680 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5681 Assert.IsNotNull (entry.MachineName, "#B10");
5682 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
5683 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5684 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5685 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
5686 Assert.IsNotNull (entry.Source, "#B15");
5687 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5688 Assert.IsNull (entry.UserName, "#B17");
5691 if (!applicationLogExists) {
5692 if (EventLog.Exists ("Application"))
5693 EventLog.Delete ("Application");
5695 if (EventLog.SourceExists ("monotempsource", "."))
5696 EventLog.DeleteEventSource ("monotempsource", ".");
5702 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
5703 public void WriteEntry7_Source_Empty ()
5705 EventLog.WriteEntry (string.Empty, "test", EventLogEntryType.Warning, 5);
5709 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
5710 public void WriteEntry7_Source_Null ()
5712 EventLog.WriteEntry (null, "test", EventLogEntryType.Error, 5);
5716 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
5717 public void WriteEntry7_Type_NotDefined ()
5719 EventLog.WriteEntry ("monotempsource", "test", (EventLogEntryType) 666, 4);
5723 public void WriteEntry8 ()
5725 if (EventLogImplType == NULL_IMPL)
5726 // test cannot pass with NULL implementation
5727 Assert.Ignore ("No EventLogImplType.");
5729 if (EventLog.SourceExists ("monotempsource", "."))
5730 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5732 if (EventLog.Exists ("monologtemp", "."))
5733 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5735 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5737 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5738 byte [] data = new byte [] { 56, 55, 23, 24 };
5740 eventLog.WriteEntry ("WriteEntry8a", EventLogEntryType.Information, 56, 3, data);
5742 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5743 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5744 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5745 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5746 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5747 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5749 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5750 Assert.IsNotNull (entry, "#B1");
5751 Assert.IsNotNull (entry.Category, "#B2");
5752 Assert.AreEqual ("(3)", entry.Category, "#B3");
5753 Assert.AreEqual (3, entry.CategoryNumber, "#B4");
5754 Assert.IsNotNull (entry.Data, "#B5");
5755 Assert.AreEqual (data, entry.Data, "#B6");
5756 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
5757 Assert.AreEqual (56, entry.EventID, "#B8");
5758 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5759 Assert.IsNotNull (entry.MachineName, "#B10");
5760 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
5761 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5762 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5763 Assert.AreEqual ("WriteEntry8a", entry.ReplacementStrings [0], "#B14");
5764 Assert.IsNotNull (entry.Source, "#B15");
5765 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5766 Assert.IsNull (entry.UserName, "#B17");
5768 eventLog.WriteEntry ("WriteEntry8b" + Environment.NewLine + "ok",
5769 EventLogEntryType.Error, 0, 0, new byte [0]);
5771 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5772 Assert.IsNotNull (entry, "#C1");
5773 Assert.IsNotNull (entry.Category, "#C2");
5774 Assert.AreEqual ("(0)", entry.Category, "#C3");
5775 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
5776 Assert.IsNotNull (entry.Data, "#C5");
5777 Assert.AreEqual (0, entry.Data.Length, "#C6");
5778 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
5779 Assert.AreEqual (0, entry.EventID, "#C8");
5780 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
5781 Assert.IsNotNull (entry.MachineName, "#C10");
5782 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
5783 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
5784 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
5785 Assert.AreEqual ("WriteEntry8b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
5786 Assert.IsNotNull (entry.Source, "#C15");
5787 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
5788 Assert.IsNull (entry.UserName, "#C17");
5790 eventLog.WriteEntry ("WriteEntry8c", EventLogEntryType.Error,
5791 ushort.MaxValue, short.MaxValue, null);
5793 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5794 Assert.IsNotNull (entry, "#D1");
5795 Assert.IsNotNull (entry.Category, "#D2");
5796 Assert.AreEqual ("(32767)", entry.Category, "#D3");
5797 Assert.AreEqual (short.MaxValue, entry.CategoryNumber, "#D4");
5798 Assert.IsNotNull (entry.Data, "#D5");
5799 Assert.AreEqual (0, entry.Data.Length, "#D6");
5800 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
5801 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
5802 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
5803 Assert.IsNotNull (entry.MachineName, "#D10");
5804 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#D11");
5805 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
5806 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
5807 Assert.AreEqual ("WriteEntry8c", entry.ReplacementStrings [0], "#D14");
5808 Assert.IsNotNull (entry.Source, "#D15");
5809 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
5810 Assert.IsNull (entry.UserName, "#D17");
5813 if (EventLog.Exists ("monologtemp"))
5814 EventLog.Delete ("monologtemp");
5819 public void WriteEntry8_EventID_Invalid ()
5821 if (EventLogImplType == NULL_IMPL)
5822 // test cannot pass with NULL implementation
5823 Assert.Ignore ("No EventLogImplType.");
5825 if (EventLog.SourceExists ("monotempsource", "."))
5826 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5828 if (EventLog.Exists ("monologtemp", "."))
5829 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5831 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
5834 eventLog.WriteEntry ("test", EventLogEntryType.Information, -1,
5836 Assert.Fail ("#A1");
5837 } catch (ArgumentException ex) {
5838 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
5839 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5840 Assert.IsNotNull (ex.Message, "#A3");
5841 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
5842 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
5843 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
5844 Assert.IsNull (ex.InnerException, "#A7");
5845 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#A8");
5846 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
5847 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
5849 if (EventLog.Exists ("monologtemp"))
5850 EventLog.Delete ("monologtemp");
5854 eventLog.WriteEntry ("test", EventLogEntryType.Information, 65536,
5856 Assert.Fail ("#B1");
5857 } catch (ArgumentException ex) {
5858 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
5859 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
5860 Assert.IsNotNull (ex.Message, "#B3");
5861 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
5862 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
5863 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
5864 Assert.IsNull (ex.InnerException, "#B7");
5865 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#B8");
5866 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
5867 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
5869 if (EventLog.Exists ("monologtemp"))
5870 EventLog.Delete ("monologtemp");
5875 public void WriteEntry8_Log_Empty ()
5877 if (EventLogImplType == NULL_IMPL)
5878 // test cannot pass with NULL implementation
5879 Assert.Ignore ("No EventLogImplType.");
5881 if (EventLog.SourceExists ("monotempsource", "."))
5882 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5884 bool applicationLogExists = EventLog.Exists ("Application", ".");
5886 // specified source does not exist, so use Application log
5888 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
5889 eventLog.WriteEntry ("WriteEntry1_Log_Empty", EventLogEntryType.Error, 555, 5, new byte [0]);
5890 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5891 Assert.AreEqual ("Application", eventLog.Log, "#A2");
5892 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5893 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
5894 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5895 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5898 if (!applicationLogExists) {
5899 if (EventLog.Exists ("Application"))
5900 EventLog.Delete ("Application");
5902 if (EventLog.SourceExists ("monotempsource", "."))
5903 EventLog.DeleteEventSource ("monotempsource", ".");
5909 public void WriteEntry8_Log_Mismatch ()
5911 if (EventLogImplType == NULL_IMPL)
5912 // test cannot pass with NULL implementation
5913 Assert.Ignore ("No EventLogImplType.");
5915 if (EventLog.SourceExists ("monotempsource", "."))
5916 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5918 if (EventLog.Exists ("monologtemp", "."))
5919 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5921 if (EventLog.Exists ("monologother", "."))
5922 Assert.Ignore ("Event log 'monologother' should not exist.");
5924 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5926 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
5929 eventLog.WriteEntry ("WriteEntry8_Log_Mismatch1",
5930 EventLogEntryType.Error, 555, 5, new byte [0]);
5931 Assert.Fail ("#A1");
5932 } catch (ArgumentException ex) {
5933 // The source 'monotempsource' is not registered in log
5934 // 'monologother' (it is registered in log 'monologtemp').
5935 // The Source and Log properties must be matched, or you may
5936 // set Log to the empty string, and it will automatically be
5937 // matched to the Source property
5938 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5939 Assert.IsNotNull (ex.Message, "#A3");
5940 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
5941 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
5942 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
5943 Assert.IsNull (ex.InnerException, "#A7");
5948 eventLog.WriteEntry ("WriteEntry8_Log_Mismatch2",
5949 (EventLogEntryType) 666, 555, 5, new byte [0]);
5950 Assert.Fail ("#B1");
5951 } catch (InvalidEnumArgumentException) {
5956 eventLog.WriteEntry ("WriteEntry8_Log_Mismatch3",
5957 EventLogEntryType.Error, -1, 5, new byte [0]);
5958 Assert.Fail ("#C1");
5959 } catch (ArgumentException ex) {
5960 // The source 'monotempsource' is not registered in log
5961 // 'monologother' (it is registered in log 'monologtemp').
5962 // The Source and Log properties must be matched, or you may
5963 // set Log to the empty string, and it will automatically be
5964 // matched to the Source property
5965 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
5966 Assert.IsNotNull (ex.Message, "#C3");
5967 Assert.IsFalse (ex.Message.IndexOf ("'monotempsource'") != -1, "#C4");
5968 Assert.IsFalse (ex.Message.IndexOf ("'monologother'") != -1, "#C5");
5969 Assert.IsFalse (ex.Message.IndexOf ("'monologtemp'") != -1, "#C6");
5970 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#C7");
5971 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#C8");
5972 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#C9");
5973 Assert.IsNull (ex.InnerException, "#C10");
5977 if (EventLog.Exists ("monologtemp"))
5978 EventLog.Delete ("monologtemp");
5980 if (EventLog.Exists ("monologother"))
5981 EventLog.Delete ("monologother");
5986 public void WriteEntry8_Message_Empty ()
5988 if (EventLogImplType == NULL_IMPL)
5989 // test cannot pass with NULL implementation
5990 Assert.Ignore ("No EventLogImplType.");
5992 if (EventLog.SourceExists ("monotempsource", "."))
5993 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5995 if (EventLog.Exists ("monologtemp", "."))
5996 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5998 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6000 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6001 eventLog.WriteEntry (string.Empty, EventLogEntryType.FailureAudit, 888, 6, new byte [0]);
6002 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6003 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6004 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6005 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6006 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6007 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6009 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6010 Assert.IsNotNull (entry, "#B1");
6011 Assert.IsNotNull (entry.Category, "#B2");
6012 Assert.AreEqual ("(6)", entry.Category, "#B3");
6013 Assert.AreEqual (6, entry.CategoryNumber, "#B4");
6014 Assert.IsNotNull (entry.Data, "#B5");
6015 Assert.AreEqual (0, entry.Data.Length, "#B6");
6016 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
6017 Assert.AreEqual (888, entry.EventID, "#B8");
6018 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6019 Assert.IsNotNull (entry.MachineName, "#B10");
6020 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6021 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6022 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6023 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
6024 Assert.IsNotNull (entry.Source, "#B15");
6025 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6026 Assert.IsNull (entry.UserName, "#B17");
6029 if (EventLog.Exists ("monologtemp"))
6030 EventLog.Delete ("monologtemp");
6035 public void WriteEntry8_Message_Null ()
6037 if (EventLogImplType == NULL_IMPL)
6038 // test cannot pass with NULL implementation
6039 Assert.Ignore ("No EventLogImplType.");
6041 if (EventLog.SourceExists ("monotempsource", "."))
6042 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6044 if (EventLog.Exists ("monologtemp", "."))
6045 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6047 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6049 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6050 eventLog.WriteEntry (null, EventLogEntryType.SuccessAudit, 343, 8, new byte [0]);
6051 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6052 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6053 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6054 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6055 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6056 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6058 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6059 Assert.IsNotNull (entry, "#B1");
6060 Assert.IsNotNull (entry.Category, "#B2");
6061 Assert.AreEqual ("(8)", entry.Category, "#B3");
6062 Assert.AreEqual (8, entry.CategoryNumber, "#B4");
6063 Assert.IsNotNull (entry.Data, "#B5");
6064 Assert.AreEqual (0, entry.Data.Length, "#B6");
6065 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
6066 Assert.AreEqual (343, entry.EventID, "#B8");
6067 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6068 Assert.IsNotNull (entry.MachineName, "#B10");
6069 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6070 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6071 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6072 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
6073 Assert.IsNotNull (entry.Source, "#B15");
6074 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6075 Assert.IsNull (entry.UserName, "#B17");
6078 if (EventLog.Exists ("monologtemp"))
6079 EventLog.Delete ("monologtemp");
6084 public void WriteEntry8_Source_DoesNotExist ()
6086 if (EventLogImplType == NULL_IMPL)
6087 // test cannot pass with NULL implementation
6088 Assert.Ignore ("No EventLogImplType.");
6090 if (EventLog.SourceExists ("monotempsource", "."))
6091 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6093 if (EventLog.SourceExists ("monoothersource", "."))
6094 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
6096 if (EventLog.Exists ("monologtemp", "."))
6097 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6099 EventLog.CreateEventSource ("monoothersource", "monologtemp");
6101 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6102 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Warning, 2, 4, new byte [0]);
6103 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6104 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6105 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6106 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6107 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6108 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6110 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6111 Assert.IsNotNull (entry, "#B1");
6112 Assert.IsNotNull (entry.Category, "#B2");
6113 Assert.AreEqual ("(4)", entry.Category, "#B3");
6114 Assert.AreEqual (4, entry.CategoryNumber, "#B4");
6115 Assert.IsNotNull (entry.Data, "#B5");
6116 Assert.AreEqual (0, entry.Data.Length, "#B6");
6117 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
6118 Assert.AreEqual (2, entry.EventID, "#B8");
6119 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6120 Assert.IsNotNull (entry.MachineName, "#B10");
6121 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6122 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6123 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6124 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
6125 Assert.IsNotNull (entry.Source, "#B15");
6126 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6127 Assert.IsNull (entry.UserName, "#B17");
6130 if (EventLog.Exists ("monologtemp"))
6131 EventLog.Delete ("monologtemp");
6136 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6137 public void WriteEntry8_Source_Empty ()
6139 EventLog eventLog = new EventLog ("monologtemp");
6140 eventLog.WriteEntry ("test", EventLogEntryType.Information, 56, 5, new byte [0]);
6144 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
6145 public void WriteEntry8_Type_NotDefined ()
6147 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
6148 eventLog.WriteEntry ("test", (EventLogEntryType) 666, 44, 8, new byte [0]);
6152 public void WriteEntry9 ()
6154 if (EventLogImplType == NULL_IMPL)
6155 // test cannot pass with NULL implementation
6156 Assert.Ignore ("No EventLogImplType.");
6158 if (EventLog.SourceExists ("monotempsource", "."))
6159 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6161 if (EventLog.Exists ("monologtemp", "."))
6162 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6164 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6166 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6167 EventLog.WriteEntry ("monotempsource", "WriteEntry9a",
6168 EventLogEntryType.Information, 54, 5);
6170 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6171 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6172 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6173 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6174 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6175 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6177 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6178 Assert.IsNotNull (entry, "#B1");
6179 Assert.IsNotNull (entry.Category, "#B2");
6180 Assert.AreEqual ("(5)", entry.Category, "#B3");
6181 Assert.AreEqual (5, entry.CategoryNumber, "#B4");
6182 Assert.IsNotNull (entry.Data, "#B5");
6183 Assert.AreEqual (0, entry.Data.Length, "#B6");
6184 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
6185 Assert.AreEqual (54, entry.EventID, "#B8");
6186 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6187 Assert.IsNotNull (entry.MachineName, "#B10");
6188 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6189 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6190 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6191 Assert.AreEqual ("WriteEntry9a", entry.ReplacementStrings [0], "#B14");
6192 Assert.IsNotNull (entry.Source, "#B15");
6193 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6194 Assert.IsNull (entry.UserName, "#B17");
6196 EventLog.WriteEntry ("monotempsource", "WriteEntry9b"
6197 + Environment.NewLine + "ok", EventLogEntryType.Error,
6200 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6201 Assert.IsNotNull (entry, "#C1");
6202 Assert.IsNotNull (entry.Category, "#C2");
6203 Assert.AreEqual ("(0)", entry.Category, "#C3");
6204 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
6205 Assert.IsNotNull (entry.Data, "#C5");
6206 Assert.AreEqual (0, entry.Data.Length, "#C6");
6207 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
6208 Assert.AreEqual (0, entry.EventID, "#C8");
6209 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
6210 Assert.IsNotNull (entry.MachineName, "#C10");
6211 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
6212 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
6213 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
6214 Assert.AreEqual ("WriteEntry9b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
6215 Assert.IsNotNull (entry.Source, "#C15");
6216 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
6217 Assert.IsNull (entry.UserName, "#C17");
6219 EventLog.WriteEntry ("monotempsource", "WriteEntry9c"
6220 + Environment.NewLine + "ok", EventLogEntryType.Error,
6221 ushort.MaxValue, short.MaxValue);
6223 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6224 Assert.IsNotNull (entry, "#D1");
6225 Assert.IsNotNull (entry.Category, "#D2");
6226 Assert.AreEqual ("(32767)", entry.Category, "#D3");
6227 Assert.AreEqual (32767, entry.CategoryNumber, "#D4");
6228 Assert.IsNotNull (entry.Data, "#D5");
6229 Assert.AreEqual (0, entry.Data.Length, "#D6");
6230 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
6231 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
6232 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
6233 Assert.IsNotNull (entry.MachineName, "#D10");
6234 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#D11");
6235 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
6236 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
6237 Assert.AreEqual ("WriteEntry9c" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#D14");
6238 Assert.IsNotNull (entry.Source, "#D15");
6239 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
6240 Assert.IsNull (entry.UserName, "#D17");
6243 if (EventLog.Exists ("monologtemp"))
6244 EventLog.Delete ("monologtemp");
6249 public void WriteEntry9_EventID_Invalid ()
6251 if (EventLogImplType == NULL_IMPL)
6252 // test cannot pass with NULL implementation
6253 Assert.Ignore ("No EventLogImplType.");
6255 if (EventLog.SourceExists ("monotempsource", "."))
6256 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6258 bool applicationLogExists = EventLog.Exists ("Application", ".");
6260 EventLog.WriteEntry ("monotempsource", "test",
6261 EventLogEntryType.Information, -1, 5);
6262 Assert.Fail ("#A1");
6263 } catch (ArgumentException ex) {
6264 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
6265 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
6266 Assert.IsNotNull (ex.Message, "#A3");
6267 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
6268 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
6269 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
6270 Assert.IsNull (ex.InnerException, "#A7");
6271 if (!applicationLogExists)
6272 Assert.IsFalse (EventLog.Exists ("Application"), "#A8");
6273 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
6274 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
6276 if (!applicationLogExists) {
6277 if (EventLog.Exists ("Application", "."))
6278 EventLog.Delete ("Application", ".");
6280 if (EventLog.SourceExists ("monotempsource", "."))
6281 EventLog.DeleteEventSource ("monotempsource", ".");
6286 EventLog.WriteEntry ("monotempsource", "test",
6287 EventLogEntryType.Information, 65536, 5);
6288 Assert.Fail ("#B1");
6289 } catch (ArgumentException ex) {
6290 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
6291 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
6292 Assert.IsNotNull (ex.Message, "#B3");
6293 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
6294 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
6295 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
6296 Assert.IsNull (ex.InnerException, "#B7");
6297 if (!applicationLogExists)
6298 Assert.IsFalse (EventLog.Exists ("Application"), "#B8");
6299 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
6300 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
6302 if (!applicationLogExists) {
6303 if (EventLog.Exists ("Application", "."))
6304 EventLog.Delete ("Application", ".");
6306 if (EventLog.SourceExists ("monotempsource", "."))
6307 EventLog.DeleteEventSource ("monotempsource", ".");
6313 public void WriteEntry9_Message_Empty ()
6315 if (EventLogImplType == NULL_IMPL)
6316 // test cannot pass with NULL implementation
6317 Assert.Ignore ("No EventLogImplType.");
6319 if (EventLog.SourceExists ("monotempsource", "."))
6320 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6322 if (EventLog.Exists ("monologtemp", "."))
6323 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6325 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6327 EventLog.WriteEntry ("monotempsource", string.Empty,
6328 EventLogEntryType.Error, 56, 5);
6330 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6331 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6332 Assert.IsNotNull (entry, "#A1");
6333 Assert.IsNotNull (entry.Category, "#A2");
6334 Assert.AreEqual ("(5)", entry.Category, "#A3");
6335 Assert.AreEqual (5, entry.CategoryNumber, "#A4");
6336 Assert.IsNotNull (entry.Data, "#A5");
6337 Assert.AreEqual (0, entry.Data.Length, "#A6");
6338 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#A7");
6339 Assert.AreEqual (56, entry.EventID, "#A8");
6340 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
6341 Assert.IsNotNull (entry.MachineName, "#A10");
6342 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
6343 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
6344 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
6345 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
6346 Assert.IsNotNull (entry.Source, "#A15");
6347 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
6348 Assert.IsNull (entry.UserName, "#A17");
6351 if (EventLog.Exists ("monologtemp"))
6352 EventLog.Delete ("monologtemp");
6357 public void WriteEntry9_Message_Null ()
6359 if (EventLogImplType == NULL_IMPL)
6360 // test cannot pass with NULL implementation
6361 Assert.Ignore ("No EventLogImplType.");
6363 if (EventLog.SourceExists ("monotempsource", "."))
6364 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6366 if (EventLog.Exists ("monologtemp", "."))
6367 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6369 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6371 EventLog.WriteEntry ("monotempsource", null,
6372 EventLogEntryType.FailureAudit, 76, 8);
6374 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6375 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6376 Assert.IsNotNull (entry, "#A1");
6377 Assert.IsNotNull (entry.Category, "#A2");
6378 Assert.AreEqual ("(8)", entry.Category, "#A3");
6379 Assert.AreEqual (8, entry.CategoryNumber, "#A4");
6380 Assert.IsNotNull (entry.Data, "#A5");
6381 Assert.AreEqual (0, entry.Data.Length, "#A6");
6382 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#A7");
6383 Assert.AreEqual (76, entry.EventID, "#A8");
6384 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
6385 Assert.IsNotNull (entry.MachineName, "#A10");
6386 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
6387 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
6388 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
6389 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
6390 Assert.IsNotNull (entry.Source, "#A15");
6391 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
6392 Assert.IsNull (entry.UserName, "#A17");
6395 if (EventLog.Exists ("monologtemp"))
6396 EventLog.Delete ("monologtemp");
6401 public void WriteEntry9_Source_DoesNotExist ()
6403 if (EventLogImplType == NULL_IMPL)
6404 // test cannot pass with NULL implementation
6405 Assert.Ignore ("No EventLogImplType.");
6407 if (EventLog.SourceExists ("monotempsource", "."))
6408 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6410 bool applicationLogExists = EventLog.Exists ("Application");
6412 EventLog.WriteEntry ("monotempsource", "test",
6413 EventLogEntryType.SuccessAudit, 89, 3);
6415 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
6416 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
6417 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
6419 if (EventLogImplType == WIN32_IMPL)
6420 // win32 API does not return entries in order for
6424 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
6425 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6426 Assert.IsNotNull (entry, "#B1");
6427 Assert.IsNotNull (entry.Category, "#B2");
6428 Assert.AreEqual ("(3)", entry.Category, "#B3");
6429 Assert.AreEqual (3, entry.CategoryNumber, "#B4");
6430 Assert.IsNotNull (entry.Data, "#B5");
6431 Assert.AreEqual (0, entry.Data.Length, "#B6");
6432 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
6433 Assert.AreEqual (89, entry.EventID, "#B8");
6434 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6435 Assert.IsNotNull (entry.MachineName, "#B10");
6436 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6437 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6438 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6439 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
6440 Assert.IsNotNull (entry.Source, "#B15");
6441 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6442 Assert.IsNull (entry.UserName, "#B17");
6445 if (!applicationLogExists) {
6446 if (EventLog.Exists ("Application"))
6447 EventLog.Delete ("Application");
6449 if (EventLog.SourceExists ("monotempsource", "."))
6450 EventLog.DeleteEventSource ("monotempsource", ".");
6456 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6457 public void WriteEntry9_Source_Empty ()
6459 EventLog.WriteEntry (string.Empty, "test", EventLogEntryType.Warning,
6464 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6465 public void WriteEntry9_Source_Null ()
6467 EventLog.WriteEntry (null, "test", EventLogEntryType.Error, 5, 4);
6471 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
6472 public void WriteEntry9_Type_NotDefined ()
6474 EventLog.WriteEntry ("monotempsource", "test", (EventLogEntryType) 666, 4, 3);
6478 public void WriteEntry10 ()
6480 if (EventLogImplType == NULL_IMPL)
6481 // test cannot pass with NULL implementation
6482 Assert.Ignore ("No EventLogImplType.");
6484 if (EventLog.SourceExists ("monotempsource", "."))
6485 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6487 if (EventLog.Exists ("monologtemp", "."))
6488 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6490 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6492 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6493 byte [] data = new byte [] { 56, 55, 23, 24 };
6495 EventLog.WriteEntry ("monotempsource", "WriteEntry9a",
6496 EventLogEntryType.Information, 54, 5, data);
6498 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6499 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6500 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6501 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6502 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6503 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6505 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6506 Assert.IsNotNull (entry, "#B1");
6507 Assert.IsNotNull (entry.Category, "#B2");
6508 Assert.AreEqual ("(5)", entry.Category, "#B3");
6509 Assert.AreEqual (5, entry.CategoryNumber, "#B4");
6510 Assert.IsNotNull (entry.Data, "#B5");
6511 Assert.AreEqual (data, entry.Data, "#B6");
6512 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
6513 Assert.AreEqual (54, entry.EventID, "#B8");
6514 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6515 Assert.IsNotNull (entry.MachineName, "#B10");
6516 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6517 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6518 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6519 Assert.AreEqual ("WriteEntry9a", entry.ReplacementStrings [0], "#B14");
6520 Assert.IsNotNull (entry.Source, "#B15");
6521 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6522 Assert.IsNull (entry.UserName, "#B17");
6524 EventLog.WriteEntry ("monotempsource", "WriteEntry9b"
6525 + Environment.NewLine + "ok", EventLogEntryType.Error,
6526 0, 0, new byte [0]);
6528 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6529 Assert.IsNotNull (entry, "#C1");
6530 Assert.IsNotNull (entry.Category, "#C2");
6531 Assert.AreEqual ("(0)", entry.Category, "#C3");
6532 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
6533 Assert.IsNotNull (entry.Data, "#C5");
6534 Assert.AreEqual (0, entry.Data.Length, "#C6");
6535 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
6536 Assert.AreEqual (0, entry.EventID, "#C8");
6537 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
6538 Assert.IsNotNull (entry.MachineName, "#C10");
6539 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
6540 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
6541 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
6542 Assert.AreEqual ("WriteEntry9b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
6543 Assert.IsNotNull (entry.Source, "#C15");
6544 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
6545 Assert.IsNull (entry.UserName, "#C17");
6547 EventLog.WriteEntry ("monotempsource", "WriteEntry9c"
6548 + Environment.NewLine + "ok", EventLogEntryType.Error,
6549 ushort.MaxValue, short.MaxValue, null);
6551 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6552 Assert.IsNotNull (entry, "#D1");
6553 Assert.IsNotNull (entry.Category, "#D2");
6554 Assert.AreEqual ("(32767)", entry.Category, "#D3");
6555 Assert.AreEqual (32767, entry.CategoryNumber, "#D4");
6556 Assert.IsNotNull (entry.Data, "#D5");
6557 Assert.AreEqual (0, entry.Data.Length, "#D6");
6558 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
6559 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
6560 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
6561 Assert.IsNotNull (entry.MachineName, "#D10");
6562 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#D11");
6563 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
6564 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
6565 Assert.AreEqual ("WriteEntry9c" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#D14");
6566 Assert.IsNotNull (entry.Source, "#D15");
6567 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
6568 Assert.IsNull (entry.UserName, "#D17");
6571 if (EventLog.Exists ("monologtemp"))
6572 EventLog.Delete ("monologtemp");
6577 public void WriteEntry10_EventID_Invalid ()
6579 if (EventLogImplType == NULL_IMPL)
6580 // test cannot pass with NULL implementation
6581 Assert.Ignore ("No EventLogImplType.");
6583 if (EventLog.SourceExists ("monotempsource", "."))
6584 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6586 bool applicationLogExists = EventLog.Exists ("Application", ".");
6588 EventLog.WriteEntry ("monotempsource", "test",
6589 EventLogEntryType.Information, -1, 5, new byte[0]);
6590 Assert.Fail ("#A1");
6591 } catch (ArgumentException ex) {
6592 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
6593 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
6594 Assert.IsNotNull (ex.Message, "#A3");
6595 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
6596 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
6597 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
6598 Assert.IsNull (ex.InnerException, "#A7");
6599 if (!applicationLogExists)
6600 Assert.IsFalse (EventLog.Exists ("Application"), "#A8");
6601 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
6602 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
6604 if (!applicationLogExists) {
6605 if (EventLog.Exists ("Application", "."))
6606 EventLog.Delete ("Application", ".");
6608 if (EventLog.SourceExists ("monotempsource", "."))
6609 EventLog.DeleteEventSource ("monotempsource", ".");
6614 EventLog.WriteEntry ("monotempsource", "test",
6615 EventLogEntryType.Information, 65536, 5, new byte[0]);
6616 Assert.Fail ("#B1");
6617 } catch (ArgumentException ex) {
6618 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
6619 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
6620 Assert.IsNotNull (ex.Message, "#B3");
6621 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
6622 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
6623 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
6624 Assert.IsNull (ex.InnerException, "#B7");
6625 if (!applicationLogExists)
6626 Assert.IsFalse (EventLog.Exists ("Application"), "#B8");
6627 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
6628 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
6630 if (!applicationLogExists) {
6631 if (EventLog.Exists ("Application", "."))
6632 EventLog.Delete ("Application", ".");
6634 if (EventLog.SourceExists ("monotempsource", "."))
6635 EventLog.DeleteEventSource ("monotempsource", ".");
6641 public void WriteEntry10_Message_Empty ()
6643 if (EventLogImplType == NULL_IMPL)
6644 // test cannot pass with NULL implementation
6645 Assert.Ignore ("No EventLogImplType.");
6647 if (EventLog.SourceExists ("monotempsource", "."))
6648 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6650 if (EventLog.Exists ("monologtemp", "."))
6651 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6653 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6655 EventLog.WriteEntry ("monotempsource", string.Empty,
6656 EventLogEntryType.Error, 56, 5, new byte [0]);
6658 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6659 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6660 Assert.IsNotNull (entry, "#A1");
6661 Assert.IsNotNull (entry.Category, "#A2");
6662 Assert.AreEqual ("(5)", entry.Category, "#A3");
6663 Assert.AreEqual (5, entry.CategoryNumber, "#A4");
6664 Assert.IsNotNull (entry.Data, "#A5");
6665 Assert.AreEqual (0, entry.Data.Length, "#A6");
6666 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#A7");
6667 Assert.AreEqual (56, entry.EventID, "#A8");
6668 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
6669 Assert.IsNotNull (entry.MachineName, "#A10");
6670 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
6671 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
6672 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
6673 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
6674 Assert.IsNotNull (entry.Source, "#A15");
6675 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
6676 Assert.IsNull (entry.UserName, "#A17");
6679 if (EventLog.Exists ("monologtemp"))
6680 EventLog.Delete ("monologtemp");
6685 public void WriteEntry10_Message_Null ()
6687 if (EventLogImplType == NULL_IMPL)
6688 // test cannot pass with NULL implementation
6689 Assert.Ignore ("No EventLogImplType.");
6691 if (EventLog.SourceExists ("monotempsource", "."))
6692 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6694 if (EventLog.Exists ("monologtemp", "."))
6695 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6697 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6699 EventLog.WriteEntry ("monotempsource", null,
6700 EventLogEntryType.FailureAudit, 76, 8, new byte [0]);
6702 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6703 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6704 Assert.IsNotNull (entry, "#A1");
6705 Assert.IsNotNull (entry.Category, "#A2");
6706 Assert.AreEqual ("(8)", entry.Category, "#A3");
6707 Assert.AreEqual (8, entry.CategoryNumber, "#A4");
6708 Assert.IsNotNull (entry.Data, "#A5");
6709 Assert.AreEqual (0, entry.Data.Length, "#A6");
6710 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#A7");
6711 Assert.AreEqual (76, entry.EventID, "#A8");
6712 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
6713 Assert.IsNotNull (entry.MachineName, "#A10");
6714 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#A11");
6715 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
6716 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
6717 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
6718 Assert.IsNotNull (entry.Source, "#A15");
6719 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
6720 Assert.IsNull (entry.UserName, "#A17");
6723 if (EventLog.Exists ("monologtemp"))
6724 EventLog.Delete ("monologtemp");
6729 public void WriteEntry10_Source_DoesNotExist ()
6731 if (EventLogImplType == NULL_IMPL)
6732 // test cannot pass with NULL implementation
6733 Assert.Ignore ("No EventLogImplType.");
6735 if (EventLog.SourceExists ("monotempsource", "."))
6736 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6738 bool applicationLogExists = EventLog.Exists ("Application");
6740 EventLog.WriteEntry ("monotempsource", "test",
6741 EventLogEntryType.SuccessAudit, 89, 3, new byte [0]);
6743 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
6744 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
6745 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
6747 if (EventLogImplType == WIN32_IMPL)
6748 // win32 API does not return entries in order for
6752 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
6753 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6754 Assert.IsNotNull (entry, "#B1");
6755 Assert.IsNotNull (entry.Category, "#B2");
6756 Assert.AreEqual ("(3)", entry.Category, "#B3");
6757 Assert.AreEqual (3, entry.CategoryNumber, "#B4");
6758 Assert.IsNotNull (entry.Data, "#B5");
6759 Assert.AreEqual (0, entry.Data.Length, "#B6");
6760 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
6761 Assert.AreEqual (89, entry.EventID, "#B8");
6762 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6763 Assert.IsNotNull (entry.MachineName, "#B10");
6764 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6765 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6766 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6767 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
6768 Assert.IsNotNull (entry.Source, "#B15");
6769 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6770 Assert.IsNull (entry.UserName, "#B17");
6773 if (!applicationLogExists) {
6774 if (EventLog.Exists ("Application"))
6775 EventLog.Delete ("Application");
6777 if (EventLog.SourceExists ("monotempsource", "."))
6778 EventLog.DeleteEventSource ("monotempsource", ".");
6784 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6785 public void WriteEntry10_Source_Empty ()
6787 EventLog.WriteEntry (string.Empty, "test", EventLogEntryType.Warning,
6788 5, 4, new byte [0]);
6792 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6793 public void WriteEntry10_Source_Null ()
6795 EventLog.WriteEntry (null, "test", EventLogEntryType.Error, 5, 4,
6800 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
6801 public void WriteEntry10_Type_NotDefined ()
6803 EventLog.WriteEntry ("monotempsource", "test", (EventLogEntryType) 666,
6804 4, 3, new byte [0]);
6808 public void WriteEvent1 ()
6810 if (EventLog.SourceExists ("monotempsource", "."))
6811 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6813 if (EventLog.Exists ("monologtemp", "."))
6814 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6816 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6818 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6819 EventInstance instance = new EventInstance (5, 666,
6820 EventLogEntryType.FailureAudit);
6821 eventLog.WriteEvent (instance, 5, "new" + Environment.NewLine + "line", true, null);
6823 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6824 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6825 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6826 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6827 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6828 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
6829 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
6831 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6832 Assert.IsNotNull (entry, "#B1");
6833 Assert.IsNotNull (entry.Category, "#B2");
6834 Assert.AreEqual ("(666)", entry.Category, "#B3");
6835 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
6836 Assert.IsNotNull (entry.Data, "#B5");
6837 Assert.AreEqual (0, entry.Data.Length, "#B6");
6838 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
6839 Assert.AreEqual (5, entry.EventID, "#B8");
6840 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6841 Assert.IsNotNull (entry.MachineName, "#B10");
6842 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6843 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6844 Assert.AreEqual (4, entry.ReplacementStrings.Length, "#B13");
6845 Assert.AreEqual ("5", entry.ReplacementStrings [0], "#B14");
6846 Assert.AreEqual ("new" + Environment.NewLine + "line", entry.ReplacementStrings [1], "#B15");
6847 Assert.AreEqual (true.ToString (), entry.ReplacementStrings [2], "#B16");
6848 Assert.AreEqual (string.Empty, entry.ReplacementStrings [3], "#B17");
6849 Assert.IsNotNull (entry.Source, "#B18");
6850 Assert.AreEqual ("monotempsource", entry.Source, "#B19");
6851 Assert.IsNull (entry.UserName, "#B20");
6853 eventLog.WriteEvent (instance);
6855 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6856 Assert.IsNotNull (entry, "#C1");
6857 Assert.IsNotNull (entry.Category, "#C2");
6858 Assert.AreEqual ("(666)", entry.Category, "#C3");
6859 Assert.AreEqual (666, entry.CategoryNumber, "#C4");
6860 Assert.IsNotNull (entry.Data, "#C5");
6861 Assert.AreEqual (0, entry.Data.Length, "#C6");
6862 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#C7");
6863 Assert.AreEqual (5, entry.EventID, "#C8");
6864 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
6865 Assert.IsNotNull (entry.MachineName, "#C10");
6866 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
6867 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
6868 Assert.AreEqual (0, entry.ReplacementStrings.Length, "#C13");
6869 Assert.IsNotNull (entry.Source, "#C14");
6870 Assert.AreEqual ("monotempsource", entry.Source, "#C15");
6871 Assert.IsNull (entry.UserName, "#C16");
6874 if (EventLog.Exists ("monologtemp"))
6875 EventLog.Delete ("monologtemp");
6880 [ExpectedException (typeof (ArgumentNullException))]
6881 public void WriteEvent1_Instance_Null ()
6883 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6884 eventLog.WriteEvent (null, "replace");
6889 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6890 public void WriteEvent1_Source_Empty ()
6892 using (EventLog eventLog = new EventLog ("monologtemp")) {
6893 EventInstance instance = new EventInstance (5, 1,
6894 EventLogEntryType.Information);
6895 eventLog.WriteEvent (instance, "replace");
6900 public void WriteEvent1_Source_DoesNotExist ()
6902 if (EventLogImplType == NULL_IMPL)
6903 // test cannot pass with NULL implementation
6904 Assert.Ignore ("No EventLogImplType.");
6906 if (EventLog.SourceExists ("monotempsource", "."))
6907 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6909 if (EventLog.SourceExists ("monoothersource", "."))
6910 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
6912 if (EventLog.Exists ("monologtemp", "."))
6913 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6915 EventLog.CreateEventSource ("monoothersource", "monologtemp");
6917 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6918 EventInstance instance = new EventInstance (5, 1,
6919 EventLogEntryType.Error);
6920 eventLog.WriteEvent (instance, "replace1", "replace2");
6922 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6923 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6924 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6925 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6926 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6927 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6929 EventLogEntry entry = eventLog.Entries[eventLog.Entries.Count - 1];
6930 Assert.IsNotNull (entry, "#B1");
6931 Assert.IsNotNull (entry.Category, "#B2");
6932 Assert.AreEqual ("(1)", entry.Category, "#B3");
6933 Assert.AreEqual (1, entry.CategoryNumber, "#B4");
6934 Assert.IsNotNull (entry.Data, "#B5");
6935 Assert.AreEqual (0, entry.Data.Length, "#B6");
6936 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
6937 Assert.AreEqual (5, entry.EventID, "#B8");
6938 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6939 Assert.IsNotNull (entry.MachineName, "#B10");
6940 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6941 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6942 Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
6943 Assert.AreEqual ("replace1", entry.ReplacementStrings[0], "#B14");
6944 Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
6945 Assert.IsNotNull (entry.Source, "#B16");
6946 Assert.AreEqual ("monotempsource", entry.Source, "#B17");
6947 Assert.IsNull (entry.UserName, "#B18");
6950 if (EventLog.Exists ("monologtemp"))
6951 EventLog.Delete ("monologtemp");
6956 public void WriteEvent1_Values_Null ()
6958 if (EventLog.SourceExists ("monotempsource", "."))
6959 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6961 if (EventLog.Exists ("monologtemp", "."))
6962 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6964 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6966 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6967 EventInstance instance = new EventInstance (5, 666,
6968 EventLogEntryType.Warning);
6969 eventLog.WriteEvent (instance, (object) null);
6971 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6972 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6973 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6974 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6975 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6976 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
6977 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
6979 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6980 Assert.IsNotNull (entry, "#B1");
6981 Assert.IsNotNull (entry.Category, "#B2");
6982 Assert.AreEqual ("(666)", entry.Category, "#B3");
6983 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
6984 Assert.IsNotNull (entry.Data, "#B5");
6985 Assert.AreEqual (0, entry.Data.Length, "#B6");
6986 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
6987 Assert.AreEqual (5, entry.EventID, "#B8");
6988 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6989 Assert.IsNotNull (entry.MachineName, "#B10");
6990 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
6991 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6992 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6993 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
6994 Assert.IsNotNull (entry.Source, "#B15");
6995 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6996 Assert.IsNull (entry.UserName, "#B17");
6999 if (EventLog.Exists ("monologtemp"))
7000 EventLog.Delete ("monologtemp");
7005 public void WriteEvent2 ()
7007 if (EventLog.SourceExists ("monotempsource", "."))
7008 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7010 if (EventLog.Exists ("monologtemp", "."))
7011 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7013 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7015 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7016 byte [] data = new byte [] { 23, 54 };
7017 EventInstance instance = new EventInstance (5, 666,
7018 EventLogEntryType.FailureAudit);
7019 eventLog.WriteEvent (instance, data, 5, "new" + Environment.NewLine + "line", true, null);
7021 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7022 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7023 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7024 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7025 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7026 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7027 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7029 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7030 Assert.IsNotNull (entry, "#B1");
7031 Assert.IsNotNull (entry.Category, "#B2");
7032 Assert.AreEqual ("(666)", entry.Category, "#B3");
7033 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7034 Assert.IsNotNull (entry.Data, "#B5");
7035 Assert.AreEqual (data, entry.Data, "#B6");
7036 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
7037 Assert.AreEqual (5, entry.EventID, "#B8");
7038 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7039 Assert.IsNotNull (entry.MachineName, "#B10");
7040 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7041 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7042 Assert.AreEqual (4, entry.ReplacementStrings.Length, "#B13");
7043 Assert.AreEqual ("5", entry.ReplacementStrings [0], "#B14");
7044 Assert.AreEqual ("new" + Environment.NewLine + "line", entry.ReplacementStrings [1], "#B15");
7045 Assert.AreEqual (true.ToString (), entry.ReplacementStrings [2], "#B16");
7046 Assert.AreEqual (string.Empty, entry.ReplacementStrings [3], "#B17");
7047 Assert.IsNotNull (entry.Source, "#B18");
7048 Assert.AreEqual ("monotempsource", entry.Source, "#B19");
7049 Assert.IsNull (entry.UserName, "#B20");
7051 eventLog.WriteEvent (instance, data);
7053 entry = eventLog.Entries [eventLog.Entries.Count - 1];
7054 Assert.IsNotNull (entry, "#C1");
7055 Assert.IsNotNull (entry.Category, "#C2");
7056 Assert.AreEqual ("(666)", entry.Category, "#C3");
7057 Assert.AreEqual (666, entry.CategoryNumber, "#C4");
7058 Assert.IsNotNull (entry.Data, "#C5");
7059 Assert.AreEqual (data, entry.Data, "#C6");
7060 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#C7");
7061 Assert.AreEqual (5, entry.EventID, "#C8");
7062 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
7063 Assert.IsNotNull (entry.MachineName, "#C10");
7064 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
7065 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
7066 Assert.AreEqual (0, entry.ReplacementStrings.Length, "#C13");
7067 Assert.IsNotNull (entry.Source, "#C14");
7068 Assert.AreEqual ("monotempsource", entry.Source, "#C15");
7069 Assert.IsNull (entry.UserName, "#C16");
7072 if (EventLog.Exists ("monologtemp"))
7073 EventLog.Delete ("monologtemp");
7078 public void WriteEvent2_Data_Null ()
7080 if (EventLog.SourceExists ("monotempsource", "."))
7081 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7083 if (EventLog.Exists ("monologtemp", "."))
7084 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7086 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7088 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7089 EventInstance instance = new EventInstance (5, 444,
7090 EventLogEntryType.Warning);
7091 eventLog.WriteEvent (instance, null, "replace1", null, "replace3");
7093 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7094 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7095 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7096 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7097 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7098 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7099 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7101 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7102 Assert.IsNotNull (entry, "#B1");
7103 Assert.IsNotNull (entry.Category, "#B2");
7104 Assert.AreEqual ("(444)", entry.Category, "#B3");
7105 Assert.AreEqual (444, entry.CategoryNumber, "#B4");
7106 Assert.IsNotNull (entry.Data, "#B5");
7107 Assert.AreEqual (0, entry.Data.Length, "#B6");
7108 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7109 Assert.AreEqual (5, entry.EventID, "#B8");
7110 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7111 Assert.IsNotNull (entry.MachineName, "#B10");
7112 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7113 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7114 Assert.AreEqual (3, entry.ReplacementStrings.Length, "#B13");
7115 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7116 Assert.AreEqual (string.Empty, entry.ReplacementStrings [1], "#B15");
7117 Assert.AreEqual ("replace3", entry.ReplacementStrings [2], "#B16");
7118 Assert.IsNotNull (entry.Source, "#B17");
7119 Assert.AreEqual ("monotempsource", entry.Source, "#B18");
7120 Assert.IsNull (entry.UserName, "#B19");
7123 if (EventLog.Exists ("monologtemp"))
7124 EventLog.Delete ("monologtemp");
7130 [ExpectedException (typeof (ArgumentNullException))]
7131 public void WriteEvent2_Instance_Null ()
7133 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7134 eventLog.WriteEvent (null, new byte [0], "replace");
7139 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
7140 public void WriteEvent2_Source_Empty ()
7142 using (EventLog eventLog = new EventLog ("monologtemp")) {
7143 EventInstance instance = new EventInstance (5, 1,
7144 EventLogEntryType.Information);
7145 eventLog.WriteEvent (instance, new byte [0], "replace");
7150 public void WriteEvent2_Source_DoesNotExist ()
7152 if (EventLogImplType == NULL_IMPL)
7153 // test cannot pass with NULL implementation
7154 Assert.Ignore ("No EventLogImplType.");
7156 if (EventLog.SourceExists ("monotempsource", "."))
7157 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7159 if (EventLog.SourceExists ("monoothersource", "."))
7160 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
7162 if (EventLog.Exists ("monologtemp", "."))
7163 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7165 EventLog.CreateEventSource ("monoothersource", "monologtemp");
7167 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7168 byte [] data = new byte [] { 23, 54 };
7169 EventInstance instance = new EventInstance (5, 1,
7170 EventLogEntryType.Error);
7171 eventLog.WriteEvent (instance, data, "replace1", "replace2");
7173 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7174 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7175 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7176 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7177 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7178 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7179 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7181 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7182 Assert.IsNotNull (entry, "#B1");
7183 Assert.IsNotNull (entry.Category, "#B2");
7184 Assert.AreEqual ("(1)", entry.Category, "#B3");
7185 Assert.AreEqual (1, entry.CategoryNumber, "#B4");
7186 Assert.IsNotNull (entry.Data, "#B5");
7187 Assert.AreEqual (data, entry.Data, "#B6");
7188 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
7189 Assert.AreEqual (5, entry.EventID, "#B8");
7190 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7191 Assert.IsNotNull (entry.MachineName, "#B10");
7192 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7193 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7194 Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
7195 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7196 Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
7197 Assert.IsNotNull (entry.Source, "#B16");
7198 Assert.AreEqual ("monotempsource", entry.Source, "#B17");
7199 Assert.IsNull (entry.UserName, "#B18");
7202 if (EventLog.Exists ("monologtemp"))
7203 EventLog.Delete ("monologtemp");
7208 public void WriteEvent2_Values_Null ()
7210 if (EventLog.SourceExists ("monotempsource", "."))
7211 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7213 if (EventLog.Exists ("monologtemp", "."))
7214 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7216 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7218 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7219 byte [] data = new byte [] { 23, 54 };
7220 EventInstance instance = new EventInstance (5, 556,
7221 EventLogEntryType.Warning);
7222 eventLog.WriteEvent (instance, data, (object) null);
7224 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7225 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7226 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7227 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7228 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7229 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7230 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7232 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7233 Assert.IsNotNull (entry, "#B1");
7234 Assert.IsNotNull (entry.Category, "#B2");
7235 Assert.AreEqual ("(556)", entry.Category, "#B3");
7236 Assert.AreEqual (556, entry.CategoryNumber, "#B4");
7237 Assert.IsNotNull (entry.Data, "#B5");
7238 Assert.AreEqual (data, entry.Data, "#B6");
7239 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7240 Assert.AreEqual (5, entry.EventID, "#B8");
7241 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7242 Assert.IsNotNull (entry.MachineName, "#B10");
7243 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7244 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7245 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
7246 Assert.IsNotNull (entry.Source, "#B14");
7247 Assert.AreEqual ("monotempsource", entry.Source, "#B15");
7248 Assert.IsNull (entry.UserName, "#B16");
7251 if (EventLog.Exists ("monologtemp"))
7252 EventLog.Delete ("monologtemp");
7257 public void WriteEvent3 ()
7259 if (EventLog.SourceExists ("monotempsource", "."))
7260 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7262 if (EventLog.Exists ("monologtemp", "."))
7263 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7265 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7267 EventInstance instance = new EventInstance (5, 666,
7268 EventLogEntryType.FailureAudit);
7269 EventLog.WriteEvent ("monotempsource", instance, 5, "new"
7270 + Environment.NewLine + "line", true, null);
7272 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7273 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7274 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7275 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7276 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7277 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7278 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7279 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7281 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7282 Assert.IsNotNull (entry, "#B1");
7283 Assert.IsNotNull (entry.Category, "#B2");
7284 Assert.AreEqual ("(666)", entry.Category, "#B3");
7285 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7286 Assert.IsNotNull (entry.Data, "#B5");
7287 Assert.AreEqual (0, entry.Data.Length, "#B6");
7288 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
7289 Assert.AreEqual (5, entry.EventID, "#B8");
7290 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7291 Assert.IsNotNull (entry.MachineName, "#B10");
7292 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7293 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7294 Assert.AreEqual (4, entry.ReplacementStrings.Length, "#B13");
7295 Assert.AreEqual ("5", entry.ReplacementStrings [0], "#B14");
7296 Assert.AreEqual ("new" + Environment.NewLine + "line", entry.ReplacementStrings [1], "#B15");
7297 Assert.AreEqual (true.ToString (), entry.ReplacementStrings [2], "#B16");
7298 Assert.AreEqual (string.Empty, entry.ReplacementStrings [3], "#B17");
7299 Assert.IsNotNull (entry.Source, "#B18");
7300 Assert.AreEqual ("monotempsource", entry.Source, "#B19");
7301 Assert.IsNull (entry.UserName, "#B20");
7303 EventLog.WriteEvent ("monotempsource", instance);
7305 entry = eventLog.Entries [eventLog.Entries.Count - 1];
7306 Assert.IsNotNull (entry, "#C1");
7307 Assert.IsNotNull (entry.Category, "#C2");
7308 Assert.AreEqual ("(666)", entry.Category, "#C3");
7309 Assert.AreEqual (666, entry.CategoryNumber, "#C4");
7310 Assert.IsNotNull (entry.Data, "#C5");
7311 Assert.AreEqual (0, entry.Data.Length, "#C6");
7312 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#C7");
7313 Assert.AreEqual (5, entry.EventID, "#C8");
7314 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
7315 Assert.IsNotNull (entry.MachineName, "#C10");
7316 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
7317 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
7318 Assert.AreEqual (0, entry.ReplacementStrings.Length, "#C13");
7319 Assert.IsNotNull (entry.Source, "#C14");
7320 Assert.AreEqual ("monotempsource", entry.Source, "#C15");
7321 Assert.IsNull (entry.UserName, "#C16");
7324 if (EventLog.Exists ("monologtemp"))
7325 EventLog.Delete ("monologtemp");
7330 [ExpectedException (typeof (ArgumentNullException))]
7331 public void WriteEvent3_Instance_Null ()
7333 EventLog.WriteEvent ("monotempsource", null);
7337 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
7338 public void WriteEvent3_Source_Empty ()
7340 EventInstance instance = new EventInstance (5, 1,
7341 EventLogEntryType.Information);
7342 EventLog.WriteEvent (string.Empty, instance);
7346 public void WriteEvent3_Source_DoesNotExist ()
7348 if (EventLogImplType == NULL_IMPL)
7349 // test cannot pass with NULL implementation
7350 Assert.Ignore ("No EventLogImplType.");
7352 if (EventLog.SourceExists ("monotempsource", "."))
7353 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7355 bool applicationLogExists = EventLog.Exists ("Application");
7357 EventInstance instance = new EventInstance (666, 1,
7358 EventLogEntryType.Error);
7359 EventLog.WriteEvent ("monotempsource", instance, "replace1", "replace2");
7361 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
7362 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
7363 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
7365 if (EventLogImplType == WIN32_IMPL)
7366 // win32 API does not return entries in order for
7370 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
7371 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7372 Assert.IsNotNull (entry, "#B1");
7373 Assert.IsNotNull (entry.Category, "#B2");
7374 Assert.AreEqual ("(1)", entry.Category, "#B3");
7375 Assert.AreEqual (1, entry.CategoryNumber, "#B4");
7376 Assert.IsNotNull (entry.Data, "#B5");
7377 Assert.AreEqual (0, entry.Data.Length, "#B6");
7378 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
7379 Assert.AreEqual (666, entry.EventID, "#B8");
7380 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7381 Assert.IsNotNull (entry.MachineName, "#B10");
7382 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7383 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7384 Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
7385 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7386 Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
7387 Assert.IsNotNull (entry.Source, "#B16");
7388 Assert.AreEqual ("monotempsource", entry.Source, "#B17");
7389 Assert.IsNull (entry.UserName, "#B18");
7392 if (!applicationLogExists) {
7393 if (EventLog.Exists ("Application"))
7394 EventLog.Delete ("Application");
7396 if (EventLog.SourceExists ("monotempsource", "."))
7397 EventLog.DeleteEventSource ("monotempsource", ".");
7403 public void WriteEvent3_Values_Null ()
7405 if (EventLog.SourceExists ("monotempsource", "."))
7406 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7408 if (EventLog.Exists ("monologtemp", "."))
7409 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7411 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7413 EventInstance instance = new EventInstance (5, 666,
7414 EventLogEntryType.Warning);
7415 EventLog.WriteEvent ("monotempsource", instance, (object) null);
7417 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7418 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7419 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7420 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7421 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7422 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7423 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7424 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7426 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7427 Assert.IsNotNull (entry, "#B1");
7428 Assert.IsNotNull (entry.Category, "#B2");
7429 Assert.AreEqual ("(666)", entry.Category, "#B3");
7430 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7431 Assert.IsNotNull (entry.Data, "#B5");
7432 Assert.AreEqual (0, entry.Data.Length, "#B6");
7433 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7434 Assert.AreEqual (5, entry.EventID, "#B8");
7435 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7436 Assert.IsNotNull (entry.MachineName, "#B10");
7437 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7438 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7439 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
7440 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
7441 Assert.IsNotNull (entry.Source, "#B15");
7442 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
7443 Assert.IsNull (entry.UserName, "#B17");
7446 if (EventLog.Exists ("monologtemp"))
7447 EventLog.Delete ("monologtemp");
7452 public void WriteEvent4 ()
7454 if (EventLog.SourceExists ("monotempsource", "."))
7455 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7457 if (EventLog.Exists ("monologtemp", "."))
7458 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7460 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7462 byte [] data = new byte [] { 23, 54 };
7463 EventInstance instance = new EventInstance (5, 666,
7464 EventLogEntryType.FailureAudit);
7465 EventLog.WriteEvent ("monotempsource", instance, data, 5, "new"
7466 + Environment.NewLine + "line", true, null);
7468 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7469 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7470 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7471 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7472 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7473 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7474 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7475 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7477 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7478 Assert.IsNotNull (entry, "#B1");
7479 Assert.IsNotNull (entry.Category, "#B2");
7480 Assert.AreEqual ("(666)", entry.Category, "#B3");
7481 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7482 Assert.IsNotNull (entry.Data, "#B5");
7483 Assert.AreEqual (data, entry.Data, "#B6");
7484 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
7485 Assert.AreEqual (5, entry.EventID, "#B8");
7486 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7487 Assert.IsNotNull (entry.MachineName, "#B10");
7488 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7489 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7490 Assert.AreEqual (4, entry.ReplacementStrings.Length, "#B13");
7491 Assert.AreEqual ("5", entry.ReplacementStrings [0], "#B14");
7492 Assert.AreEqual ("new" + Environment.NewLine + "line", entry.ReplacementStrings [1], "#B15");
7493 Assert.AreEqual (true.ToString (), entry.ReplacementStrings [2], "#B16");
7494 Assert.AreEqual (string.Empty, entry.ReplacementStrings [3], "#B17");
7495 Assert.IsNotNull (entry.Source, "#B18");
7496 Assert.AreEqual ("monotempsource", entry.Source, "#B19");
7497 Assert.IsNull (entry.UserName, "#B20");
7499 EventLog.WriteEvent ("monotempsource", instance, data);
7501 entry = eventLog.Entries [eventLog.Entries.Count - 1];
7502 Assert.IsNotNull (entry, "#C1");
7503 Assert.IsNotNull (entry.Category, "#C2");
7504 Assert.AreEqual ("(666)", entry.Category, "#C3");
7505 Assert.AreEqual (666, entry.CategoryNumber, "#C4");
7506 Assert.IsNotNull (entry.Data, "#C5");
7507 Assert.AreEqual (data, entry.Data, "#C6");
7508 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#C7");
7509 Assert.AreEqual (5, entry.EventID, "#C8");
7510 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
7511 Assert.IsNotNull (entry.MachineName, "#C10");
7512 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
7513 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
7514 Assert.AreEqual (0, entry.ReplacementStrings.Length, "#C13");
7515 Assert.IsNotNull (entry.Source, "#C14");
7516 Assert.AreEqual ("monotempsource", entry.Source, "#C15");
7517 Assert.IsNull (entry.UserName, "#C16");
7520 if (EventLog.Exists ("monologtemp"))
7521 EventLog.Delete ("monologtemp");
7526 public void WriteEvent4_Data_Null ()
7528 if (EventLog.SourceExists ("monotempsource", "."))
7529 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7531 if (EventLog.Exists ("monologtemp", "."))
7532 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7534 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7536 EventInstance instance = new EventInstance (5, 444,
7537 EventLogEntryType.Warning);
7538 EventLog.WriteEvent ("monotempsource", instance, null, "replace1", null, "replace3");
7540 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7541 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7542 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7543 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7544 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7545 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7546 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7547 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7549 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7550 Assert.IsNotNull (entry, "#B1");
7551 Assert.IsNotNull (entry.Category, "#B2");
7552 Assert.AreEqual ("(444)", entry.Category, "#B3");
7553 Assert.AreEqual (444, entry.CategoryNumber, "#B4");
7554 Assert.IsNotNull (entry.Data, "#B5");
7555 Assert.AreEqual (0, entry.Data.Length, "#B6");
7556 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7557 Assert.AreEqual (5, entry.EventID, "#B8");
7558 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7559 Assert.IsNotNull (entry.MachineName, "#B10");
7560 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7561 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7562 Assert.AreEqual (3, entry.ReplacementStrings.Length, "#B13");
7563 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7564 Assert.AreEqual (string.Empty, entry.ReplacementStrings [1], "#B15");
7565 Assert.AreEqual ("replace3", entry.ReplacementStrings [2], "#B16");
7566 Assert.IsNotNull (entry.Source, "#B17");
7567 Assert.AreEqual ("monotempsource", entry.Source, "#B18");
7568 Assert.IsNull (entry.UserName, "#B19");
7571 if (EventLog.Exists ("monologtemp"))
7572 EventLog.Delete ("monologtemp");
7577 [ExpectedException (typeof (ArgumentNullException))]
7578 public void WriteEvent4_Instance_Null ()
7580 EventLog.WriteEvent ("monotempsource", null, new byte [0]);
7584 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
7585 public void WriteEvent4_Source_Empty ()
7587 EventInstance instance = new EventInstance (5, 1,
7588 EventLogEntryType.Information);
7589 EventLog.WriteEvent (string.Empty, instance, new byte [0]);
7593 public void WriteEvent4_Source_DoesNotExist ()
7595 if (EventLogImplType == NULL_IMPL)
7596 // test cannot pass with NULL implementation
7597 Assert.Ignore ("No EventLogImplType.");
7599 if (EventLog.SourceExists ("monotempsource", "."))
7600 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7602 bool applicationLogExists = EventLog.Exists ("Application");
7604 byte [] data = new byte [] { 23, 54 };
7605 EventInstance instance = new EventInstance (666, 1,
7606 EventLogEntryType.Error);
7607 EventLog.WriteEvent ("monotempsource", instance, data, "replace1", "replace2");
7609 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
7610 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
7611 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
7613 if (EventLogImplType == WIN32_IMPL)
7614 // win32 API does not return entries in order for
7618 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
7619 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7620 Assert.IsNotNull (entry, "#B1");
7621 Assert.IsNotNull (entry.Category, "#B2");
7622 Assert.AreEqual ("(1)", entry.Category, "#B3");
7623 Assert.AreEqual (1, entry.CategoryNumber, "#B4");
7624 Assert.IsNotNull (entry.Data, "#B5");
7625 Assert.AreEqual (data, entry.Data, "#B6");
7626 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
7627 Assert.AreEqual (666, entry.EventID, "#B8");
7628 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7629 Assert.IsNotNull (entry.MachineName, "#B10");
7630 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7631 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7632 Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
7633 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7634 Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
7635 Assert.IsNotNull (entry.Source, "#B16");
7636 Assert.AreEqual ("monotempsource", entry.Source, "#B17");
7637 Assert.IsNull (entry.UserName, "#B18");
7640 if (!applicationLogExists) {
7641 if (EventLog.Exists ("Application"))
7642 EventLog.Delete ("Application");
7644 if (EventLog.SourceExists ("monotempsource", "."))
7645 EventLog.DeleteEventSource ("monotempsource", ".");
7651 public void WriteEvent4_Values_Null ()
7653 if (EventLog.SourceExists ("monotempsource", "."))
7654 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7656 if (EventLog.Exists ("monologtemp", "."))
7657 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7659 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7661 byte [] data = new byte [] { 23, 54 };
7662 EventInstance instance = new EventInstance (5, 666,
7663 EventLogEntryType.Warning);
7664 EventLog.WriteEvent ("monotempsource", instance, data, (object) null);
7666 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7667 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7668 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7669 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7670 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7671 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7672 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7673 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7675 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7676 Assert.IsNotNull (entry, "#B1");
7677 Assert.IsNotNull (entry.Category, "#B2");
7678 Assert.AreEqual ("(666)", entry.Category, "#B3");
7679 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7680 Assert.IsNotNull (entry.Data, "#B5");
7681 Assert.AreEqual (data, entry.Data, "#B6");
7682 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7683 Assert.AreEqual (5, entry.EventID, "#B8");
7684 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7685 Assert.IsNotNull (entry.MachineName, "#B10");
7686 Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
7687 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7688 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
7689 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
7690 Assert.IsNotNull (entry.Source, "#B15");
7691 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
7692 Assert.IsNull (entry.UserName, "#B17");
7695 if (EventLog.Exists ("monologtemp"))
7696 EventLog.Delete ("monologtemp");
7700 private static RegistryKey EventLogKey {
7702 return Registry.LocalMachine.OpenSubKey (@"SYSTEM\CurrentControlSet\Services\EventLog", true);
7706 private static RegistryKey FindLogKeyByName (string logName)
7708 RegistryKey eventLogKey = null;
7710 eventLogKey = EventLogKey;
7711 if (eventLogKey == null)
7712 Assert.Fail ("Event log key does not exist");
7714 RegistryKey logKey = eventLogKey.OpenSubKey (logName, true);
7719 if (eventLogKey != null)
7720 eventLogKey.Close ();
7724 private static RegistryKey FindSourceKeyByName (string source) {
7725 RegistryKey eventLogKey = null;
7727 eventLogKey = EventLogKey;
7728 if (eventLogKey == null)
7729 Assert.Fail ("Event log key does not exist");
7731 string[] subKeys = eventLogKey.GetSubKeyNames ();
7732 for (int i = 0; i < subKeys.Length; i++) {
7733 using (RegistryKey logKey = eventLogKey.OpenSubKey (subKeys[i], true)) {
7734 if (logKey != null) {
7735 RegistryKey sourceKey = logKey.OpenSubKey (source, true);
7736 if (sourceKey != null)
7743 if (eventLogKey != null)
7744 eventLogKey.Close ();
7748 private static bool Win32EventLogEnabled {
7750 return (Environment.OSVersion.Platform == PlatformID.Win32NT);
7754 // IMPORTANT: keep this in sync with System.Diagnostics.EventLog.EventLogImplType
7755 private static string EventLogImplType {
7757 string implType = Environment.GetEnvironmentVariable (EVENTLOG_TYPE_VAR);
7758 if (implType == null) {
7759 if (Win32EventLogEnabled)
7761 implType = NULL_IMPL;
7763 if (Win32EventLogEnabled && string.Compare (implType, WIN32_IMPL, true) == 0)
7764 implType = WIN32_IMPL;
7765 else if (string.Compare (implType, NULL_IMPL, true) == 0)
7766 implType = NULL_IMPL;
7767 else if (string.Compare (implType, 0, LOCAL_FILE_IMPL, 0, LOCAL_FILE_IMPL.Length, true) == 0)
7768 implType = LOCAL_FILE_IMPL;
7770 throw new NotSupportedException (string.Format (
7771 CultureInfo.InvariantCulture, "Eventlog implementation"
7772 + " '{0}' is not supported.", implType));