?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update readme (#21797)
[mono-project.git] / mcs / class / System / Test / System.Diagnostics / EventLogTest.cs
blobfcc32e1fca9260d846b766bcfdb15968acc70ed5
1 //
2 // EventLogTest.cs -
3 // NUnit Test Cases for System.Diagnostics.EventLog
4 //
5 // Author:
6 // Gert Driesen <driesen@users.sourceforge.net>
7 //
8 // Copyright (C) 2006 Novell, Inc (http://www.novell.com)
9 //
10 //
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:
18 //
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
21 //
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.
29 //
30 // TODO:
31 // - Close (?)
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)
40 //
41
42 #if !MOBILE
43
44 using System;
45 using System.Collections;
46 using System.ComponentModel;
47 using System.Diagnostics;
48 using System.Globalization;
49 using System.IO;
50 using System.Security;
51 using System.Security.AccessControl;
52 using System.Security.Principal;
53 using System.Threading;
54
55 using Microsoft.Win32;
56
57 using NUnit.Framework;
58
59 using MonoTests.Helpers;
60
61 namespace MonoTests.System.Diagnostics
62 {
63 [TestFixture]
64 public class EventLogTest
65 {
66 private TempDirectory _temp;
67 private string _originalEventLogImpl;
68 private string _eventLogStore;
69
70 private const string EVENTLOG_TYPE_VAR = "MONO_EVENTLOG_TYPE";
71
72 // IMPORTANT: also update constants in EventLogTest
73 private const string LOCAL_FILE_IMPL = "local";
74 private const string WIN32_IMPL = "win32";
75 private const string NULL_IMPL = "null";
76
77 private static bool IsAzurePipelines => Environment.GetEnvironmentVariable("TF_BUILD") != null;
78
79 [SetUp]
80 public void SetUp ()
81 {
82 if (Win32EventLogEnabled)
83 {
84 // EventLog requires admin permissions on Windows
85 WindowsIdentity identity = WindowsIdentity.GetCurrent ();
86 WindowsPrincipal principal = new WindowsPrincipal (identity);
87 if (!principal.IsInRole (WindowsBuiltInRole.Administrator)) {
88 Assert.Ignore ("Not running as Administrator");
89 }
90
91 return;
92 }
93
94 // determine temp directory for eventlog store
95 _temp = new TempDirectory ();
96 _eventLogStore = _temp.Path;
97
98 // save original eventlog implementation type (if set)
99 _originalEventLogImpl = Environment.GetEnvironmentVariable (
100 EVENTLOG_TYPE_VAR);
101
102 // use local file implementation
103 Environment.SetEnvironmentVariable (EVENTLOG_TYPE_VAR, "local:"
104 + _eventLogStore);
105 }
106
107 [TearDown]
108 public void TearDown ()
109 {
110 if (Win32EventLogEnabled)
111 return;
112
113 // restore original eventlog implementation type
114 Environment.SetEnvironmentVariable (EVENTLOG_TYPE_VAR,
115 _originalEventLogImpl);
116
117 // delete temp directory for eventlog store
118 _temp.Dispose ();
119 }
120
121 [Test]
122 public void Clear ()
123 {
124 if (EventLogImplType == NULL_IMPL)
125 // test cannot pass with NULL implementation
126 Assert.Ignore ("No EventLogImplType.");
127
128 if (EventLog.SourceExists ("monotempsource", "."))
129 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
130
131 if (EventLog.SourceExists ("monoothersource", "."))
132 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
133
134 if (EventLog.Exists ("monologtemp", "."))
135 Assert.Ignore ("Event log 'monologtemp' should not exist.");
136
137 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
138 EventLog.CreateEventSource ("monoothersource", "monologtemp", ".");
139 try {
140 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
141 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A1");
142 eventLog.Clear ();
143 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
144 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A3");
145 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
146 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A5");
147 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A6");
148 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A7");
149
150 EventLog.WriteEntry ("monotempsource", "Clear1");
151
152 Assert.AreEqual (1, eventLog.Entries.Count, "#B1");
153 eventLog.Clear ();
154 Assert.AreEqual (0, eventLog.Entries.Count, "#B2");
155 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B3");
156 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
157 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B5");
158 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B6");
159 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B7");
160
161 EventLog.WriteEntry ("monotempsource", "Clear2");
162 eventLog.Clear ();
163 EventLog.WriteEntry ("monotempsource", "Clear3");
164 EventLog.WriteEntry ("monoothersource", "Clear4");
165
166 Assert.AreEqual (2, eventLog.Entries.Count, "#C1");
167 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#C2");
168 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#C3");
169 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#C4");
170 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#C5");
171 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#C6");
172
173 EventLogEntry entry = eventLog.Entries [0];
174 Assert.IsNotNull (entry, "#D1");
175 Assert.IsNotNull (entry.Category, "#D2");
176 Assert.AreEqual ("(0)", entry.Category, "#D3");
177 Assert.AreEqual (0, entry.CategoryNumber, "#D4");
178 Assert.IsNotNull (entry.Data, "#D5");
179 Assert.AreEqual (0, entry.Data.Length, "#D6");
180 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#D7");
181 Assert.AreEqual (0, entry.EventID, "#D8");
182 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
183 Assert.IsNotNull (entry.MachineName, "#D10");
184 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#D11");
185 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
186 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
187 Assert.AreEqual ("Clear3", entry.ReplacementStrings [0], "#D14");
188 Assert.IsNotNull (entry.Source, "#D15");
189 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
190 Assert.IsNull (entry.UserName, "#D17");
191
192 entry = eventLog.Entries [1];
193 Assert.IsNotNull (entry, "#E1");
194 Assert.IsNotNull (entry.Category, "#E2");
195 Assert.AreEqual ("(0)", entry.Category, "#E3");
196 Assert.AreEqual (0, entry.CategoryNumber, "#E4");
197 Assert.IsNotNull (entry.Data, "#E5");
198 Assert.AreEqual (0, entry.Data.Length, "#E6");
199 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#E7");
200 Assert.AreEqual (0, entry.EventID, "#E8");
201 Assert.AreEqual (entry.EventID, entry.InstanceId, "#E9");
202 Assert.IsNotNull (entry.MachineName, "#E10");
203 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#E11");
204 Assert.IsNotNull (entry.ReplacementStrings, "#E12");
205 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#E13");
206 Assert.AreEqual ("Clear4", entry.ReplacementStrings [0], "#E14");
207 Assert.IsNotNull (entry.Source, "#E15");
208 Assert.AreEqual ("monoothersource", entry.Source, "#E16");
209 Assert.IsNull (entry.UserName, "#E17");
210
211 eventLog.Clear ();
212 Assert.AreEqual (0, eventLog.Entries.Count, "#F1");
213 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#F2");
214 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#F3");
215 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#F4");
216 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#F5");
217 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#F6");
218 }
219 } finally {
220 if (EventLog.Exists ("monologtemp"))
221 EventLog.Delete ("monologtemp");
222 }
223 }
224
225 [Test]
226 public void Clear_Log_DoesNotExist ()
227 {
228 if (EventLogImplType == NULL_IMPL)
229 // test cannot pass with NULL implementation
230 Assert.Ignore ("No EventLogImplType.");
231
232 if (EventLog.Exists ("monologtemp", "."))
233 Assert.Ignore ("Event log 'monologtemp' should not exist.");
234
235 using (EventLog eventLog = new EventLog ("monologtemp", ".")) {
236 try {
237 eventLog.Clear ();
238 Assert.Fail ("#1");
239 } catch (InvalidOperationException ex) {
240 // The event log 'monologtemp' on computer '.' does not exist
241 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
242 Assert.IsNotNull (ex.Message, "#3");
243 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#4");
244 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
245 Assert.IsNull (ex.InnerException, "#6");
246 }
247 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#7");
248 }
249 }
250
251 [Test]
252 public void Clear_Log_Empty ()
253 {
254 if (EventLogImplType == NULL_IMPL)
255 // test cannot pass with NULL implementation
256 Assert.Ignore ("No EventLogImplType.");
257
258 if (EventLog.SourceExists ("monotempsource", "."))
259 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
260
261 if (EventLog.SourceExists ("monoothersource", "."))
262 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
263
264 if (EventLog.Exists ("monologtemp", "."))
265 Assert.Ignore ("Event log 'monologtemp' should not exist.");
266
267 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
268 try {
269 using (EventLog eventLog = new EventLog (string.Empty, ".")) {
270 EventLog.WriteEntry ("monotempsource", "Clear_Log_Empty");
271
272 // both source & log are not set
273 try {
274 eventLog.Clear ();
275 Assert.Fail ("#A1");
276 } catch (ArgumentException ex) {
277 // Log property value has not been specified.
278 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
279 Assert.IsNotNull (ex.Message, "#A3");
280 Assert.IsNull (ex.InnerException, "#A4");
281 Assert.IsNull (ex.ParamName, "#A5");
282 }
283 Assert.AreEqual (string.Empty, eventLog.Log, "#A6");
284
285 // set non-existing source
286 eventLog.Source = "monoothersource";
287
288 try {
289 eventLog.Clear ();
290 Assert.Fail ("#B1");
291 } catch (ArgumentException ex) {
292 // Log property value has not been specified.
293 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
294 Assert.IsNotNull (ex.Message, "#B3");
295 Assert.IsNull (ex.InnerException, "#B4");
296 Assert.IsNull (ex.ParamName, "#B5");
297 }
298 Assert.AreEqual (string.Empty, eventLog.Log, "#B6");
299
300 // set existing source
301 eventLog.Source = "monotempsource";
302
303 Assert.IsTrue (eventLog.Entries.Count > 0, "#C1");
304 eventLog.Clear ();
305 Assert.AreEqual ("monologtemp", eventLog.Log, "#C2");
306 Assert.AreEqual (0, eventLog.Entries.Count, "#C3");
307 }
308 } finally {
309 if (EventLog.Exists ("monologtemp"))
310 EventLog.Delete ("monologtemp");
311 }
312 }
313
314 [Test]
315 public void Clear_Source_DoesNotExist ()
316 {
317 if (EventLogImplType == NULL_IMPL)
318 // test cannot pass with NULL implementation
319 Assert.Ignore ("No EventLogImplType.");
320
321 if (EventLog.SourceExists ("monotempsource", "."))
322 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
323
324 if (EventLog.SourceExists ("monoothersource", "."))
325 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
326
327 if (EventLog.Exists ("monologtemp", "."))
328 Assert.Ignore ("Event log 'monologtemp' should not exist.");
329
330 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
331 try {
332 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monoothersource")) {
333 EventLog.WriteEntry ("monotempsource", "Clear_Source_DoesNotExist");
334
335 Assert.IsTrue (eventLog.Entries.Count > 0, "#1");
336 eventLog.Clear ();
337 Assert.AreEqual (0, eventLog.Entries.Count, "#2");
338 Assert.IsFalse (EventLog.SourceExists ("monoothersource", "."), "#3");
339 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#4");
340 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#5");
341 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#6");
342 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#7");
343 }
344 } finally {
345 if (EventLog.Exists ("monologtemp"))
346 EventLog.Delete ("monologtemp");
347 }
348 }
349
350 [Test]
351 public void Clear_Source_Empty ()
352 {
353 if (EventLogImplType == NULL_IMPL)
354 // test cannot pass with NULL implementation
355 Assert.Ignore ("No EventLogImplType.");
356
357 if (EventLog.SourceExists ("monotempsource", "."))
358 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
359
360 if (EventLog.Exists ("monologtemp", "."))
361 Assert.Ignore ("Event log 'monologtemp' should not exist.");
362
363 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
364 try {
365 using (EventLog eventLog = new EventLog ("monologtemp", ".", string.Empty)) {
366 EventLog.WriteEntry ("monotempsource", "Clear_Source_Empty");
367
368 Assert.IsTrue (eventLog.Entries.Count > 0, "#1");
369 eventLog.Clear ();
370 Assert.AreEqual (0, eventLog.Entries.Count, "#2");
371 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#3");
372 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#4");
373 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#5");
374 }
375 } finally {
376 if (EventLog.Exists ("monologtemp"))
377 EventLog.Delete ("monologtemp");
378 }
379 }
380
381 [Test]
382 public void Clear_Source_Null ()
383 {
384 if (EventLogImplType == NULL_IMPL)
385 // test cannot pass with NULL implementation
386 Assert.Ignore ("No EventLogImplType.");
387
388 if (EventLog.SourceExists ("monotempsource", "."))
389 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
390
391 if (EventLog.Exists ("monologtemp", "."))
392 Assert.Ignore ("Event log 'monologtemp' should not exist.");
393
394 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
395 try {
396 using (EventLog eventLog = new EventLog ("monologtemp", ".", null)) {
397 EventLog.WriteEntry ("monotempsource", "Clear_Source_Null");
398
399 Assert.IsTrue (eventLog.Entries.Count > 0, "#1");
400 eventLog.Clear ();
401 Assert.AreEqual (0, eventLog.Entries.Count, "#2");
402 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#3");
403 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#4");
404 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#5");
405 }
406 } finally {
407 if (EventLog.Exists ("monologtemp"))
408 EventLog.Delete ("monologtemp");
409 }
410 }
411
412 [Test]
413 public void Constructor1 ()
414 {
415 if (EventLogImplType == NULL_IMPL)
416 // test cannot pass with NULL implementation
417 Assert.Ignore ("No EventLogImplType.");
418
419 EventLog eventLog = new EventLog ();
420 Assert.IsFalse (eventLog.EnableRaisingEvents, "#1");
421 Assert.IsNotNull (eventLog.Entries, "#2");
422 try {
423 eventLog.Entries.GetEnumerator ().MoveNext ();
424 Assert.Fail ("#3a");
425 } catch (ArgumentException ex) {
426 // Log property is not set (zero-length string)
427 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#3b");
428 Assert.IsNotNull (ex.Message, "#3c");
429 Assert.IsNull (ex.InnerException, "#3d");
430 Assert.IsNull (ex.ParamName, "#3e");
431 }
432 Assert.IsNotNull (eventLog.Log, "#4");
433 Assert.AreEqual (string.Empty, eventLog.Log, "#5");
434 try {
435 string displayName = eventLog.LogDisplayName;
436 Assert.Fail ("#6a: " + displayName);
437 } catch (InvalidOperationException ex) {
438 // Event log names must consist of printable characters and
439 // cannot contain \, *, ?, or spaces
440 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#6b");
441 Assert.IsNotNull (ex.Message, "#6c");
442 Assert.IsNull (ex.InnerException, "#6d");
443 }
444 Assert.IsNotNull (eventLog.MachineName, "#7");
445 Assert.AreEqual (".", eventLog.MachineName, "#8");
446 Assert.IsNotNull (eventLog.Source, "#9");
447 Assert.AreEqual (string.Empty, eventLog.Source, "#10");
448 eventLog.Close ();
449 }
450
451 [Test]
452 public void Constructor2 ()
453 {
454 if (EventLogImplType == NULL_IMPL)
455 // test cannot pass with NULL implementation
456 Assert.Ignore ("No EventLogImplType.");
457
458 if (EventLog.SourceExists ("monotempsource", "."))
459 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
460
461 if (EventLog.Exists ("monologtemp", "."))
462 Assert.Ignore ("Event log 'monologtemp' should not exist.");
463
464 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
465 try {
466 using (EventLog eventLog = new EventLog ("monologtemp")) {
467 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
468 Assert.IsNotNull (eventLog.Entries, "#B2");
469 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#B3");
470 Assert.IsNotNull (eventLog.Log, "#B4");
471 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
472 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#B6");
473 Assert.IsNotNull (eventLog.MachineName, "#B7");
474 Assert.AreEqual (".", eventLog.MachineName, "#B8");
475 Assert.IsNotNull (eventLog.Source, "#B9");
476 Assert.AreEqual (string.Empty, eventLog.Source, "#B10");
477 }
478 } finally {
479 EventLog.Delete ("monologtemp");
480 }
481 }
482
483 [Test]
484 public void Constructor2_Log_DoesNotExist ()
485 {
486 if (EventLogImplType == NULL_IMPL)
487 // test cannot pass with NULL implementation
488 Assert.Ignore ("No EventLogImplType.");
489
490 if (EventLog.Exists ("monologtemp", "."))
491 Assert.Ignore ("Event log 'monologtemp' should not exist.");
492
493 EventLog eventLog = new EventLog ("monologtemp");
494 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
495 Assert.IsNotNull (eventLog.Entries, "#B2");
496 try {
497 eventLog.Entries.GetEnumerator ().MoveNext ();
498 Assert.Fail ("#B3a");
499 } catch (InvalidOperationException ex) {
500 // The event log 'monologtemp' on computer '.' does not exist
501 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B3b");
502 Assert.IsNotNull (ex.Message, "#B3c");
503 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B3d");
504 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B3e");
505 Assert.IsNull (ex.InnerException, "#B3f");
506 }
507 Assert.IsNotNull (eventLog.Log, "#B4");
508 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
509 try {
510 string displayName = eventLog.LogDisplayName;
511 Assert.Fail ("#B6a: " + displayName);
512 } catch (InvalidOperationException ex) {
513 // Cannot find Log monologtemp on computer .
514 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B6b");
515 Assert.IsNotNull (ex.Message, "#B6c");
516 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#B6d");
517 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#B6e");
518 Assert.IsNull (ex.InnerException, "#B6f");
519 }
520 Assert.IsNotNull (eventLog.MachineName, "#B7");
521 Assert.AreEqual (".", eventLog.MachineName, "#B8");
522 Assert.IsNotNull (eventLog.Source, "#B9");
523 Assert.AreEqual (string.Empty, eventLog.Source, "#B10");
524 eventLog.Close ();
525 }
526
527 [Test]
528 public void Constructor2_Log_Empty ()
529 {
530 if (EventLogImplType == NULL_IMPL)
531 // test cannot pass with NULL implementation
532 Assert.Ignore ("No EventLogImplType.");
533
534 EventLog eventLog = new EventLog (string.Empty);
535 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
536 Assert.IsNotNull (eventLog.Entries, "#A2");
537 try {
538 eventLog.Entries.GetEnumerator ().MoveNext ();
539 Assert.Fail ("#A3a");
540 } catch (ArgumentException ex) {
541 // Log property is not set (zero-length string)
542 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A3b");
543 Assert.IsNotNull (ex.Message, "#A3c");
544 Assert.IsNull (ex.InnerException, "#A3d");
545 Assert.IsNull (ex.ParamName, "#A3e");
546 }
547 Assert.IsNotNull (eventLog.Log, "#A4");
548 Assert.AreEqual (string.Empty, eventLog.Log, "#A5");
549 try {
550 string displayName = eventLog.LogDisplayName;
551 Assert.Fail ("#A6a: " + displayName);
552 } catch (InvalidOperationException ex) {
553 // Event log names must consist of printable characters and
554 // cannot contain \, *, ?, or spaces
555 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A6b");
556 Assert.IsNotNull (ex.Message, "#A6c");
557 Assert.IsNull (ex.InnerException, "#A6d");
558 }
559 Assert.IsNotNull (eventLog.MachineName, "#A7");
560 Assert.AreEqual (".", eventLog.MachineName, "#A8");
561 Assert.IsNotNull (eventLog.Source, "#A9");
562 Assert.AreEqual (string.Empty, eventLog.Source, "#A10");
563 eventLog.Close ();
564 }
565
566 [Test]
567 [ExpectedException (typeof (ArgumentNullException))]
568 public void Constructor2_Log_Null ()
569 {
570 new EventLog (null);
571 }
572
573 [Test]
574 public void Constructor3 ()
575 {
576 if (EventLogImplType == NULL_IMPL)
577 // test cannot pass with NULL implementation
578 Assert.Ignore ("No EventLogImplType.");
579
580 if (EventLog.SourceExists ("monotempsource", "."))
581 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
582
583 if (EventLog.Exists ("monologtemp", "."))
584 Assert.Ignore ("Event log 'monologtemp' should not exist.");
585
586 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
587 try {
588 using (EventLog eventLog = new EventLog ("monologtemp", ".")) {
589 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
590 Assert.IsNotNull (eventLog.Entries, "#B2");
591 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#B3");
592 Assert.IsNotNull (eventLog.Log, "#B4");
593 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
594 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#B6");
595 Assert.IsNotNull (eventLog.MachineName, "#B7");
596 Assert.AreEqual (".", eventLog.MachineName, "#B8");
597 Assert.IsNotNull (eventLog.Source, "#B9");
598 Assert.AreEqual (string.Empty, eventLog.Source, "#B10");
599 }
600 } finally {
601 EventLog.Delete ("monologtemp");
602 }
603 }
604
605 [Test]
606 public void Constructor3_Log_DoesNotExist ()
607 {
608 if (EventLogImplType == NULL_IMPL)
609 // test cannot pass with NULL implementation
610 Assert.Ignore ("No EventLogImplType.");
611
612 if (EventLog.Exists ("monologtemp", "."))
613 Assert.Ignore ("Event log 'monologtemp' should not exist.");
614
615 EventLog eventLog = new EventLog ("monologtemp", ".");
616 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
617 Assert.IsNotNull (eventLog.Entries, "#B2");
618 try {
619 eventLog.Entries.GetEnumerator ().MoveNext ();
620 Assert.Fail ("#B3a");
621 } catch (InvalidOperationException ex) {
622 // The event log 'monologtemp' on computer '.' does not exist
623 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B3b");
624 Assert.IsNotNull (ex.Message, "#B3c");
625 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B3d");
626 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B3e");
627 Assert.IsNull (ex.InnerException, "#B3f");
628 }
629 Assert.IsNotNull (eventLog.Log, "#B4");
630 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
631 try {
632 string displayName = eventLog.LogDisplayName;
633 Assert.Fail ("#B6a: " + displayName);
634 } catch (InvalidOperationException ex) {
635 // Cannot find Log monologtemp on computer .
636 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B6b");
637 Assert.IsNotNull (ex.Message, "#B6c");
638 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#B6d");
639 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#B6e");
640 Assert.IsNull (ex.InnerException, "#B6f");
641 }
642 Assert.IsNotNull (eventLog.MachineName, "#B7");
643 Assert.AreEqual (".", eventLog.MachineName, "#B8");
644 Assert.IsNotNull (eventLog.Source, "#B9");
645 Assert.AreEqual (string.Empty, eventLog.Source, "#B10");
646 eventLog.Close ();
647 }
648
649 [Test]
650 public void Constructor3_Log_Empty ()
651 {
652 if (EventLogImplType == NULL_IMPL)
653 // test cannot pass with NULL implementation
654 Assert.Ignore ("No EventLogImplType.");
655
656 EventLog eventLog = new EventLog (string.Empty, ".");
657 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
658 Assert.IsNotNull (eventLog.Entries, "#A2");
659 try {
660 eventLog.Entries.GetEnumerator ().MoveNext ();
661 Assert.Fail ("#A3a");
662 } catch (ArgumentException ex) {
663 // Log property is not set (zero-length string)
664 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A3b");
665 Assert.IsNotNull (ex.Message, "#A3c");
666 Assert.IsNull (ex.InnerException, "#A3d");
667 Assert.IsNull (ex.ParamName, "#A3e");
668 }
669 Assert.IsNotNull (eventLog.Log, "#A4");
670 Assert.AreEqual (string.Empty, eventLog.Log, "#A5");
671 try {
672 string displayName = eventLog.LogDisplayName;
673 Assert.Fail ("#A6a: " + displayName);
674 } catch (InvalidOperationException ex) {
675 // Event log names must consist of printable characters and
676 // cannot contain \, *, ?, or spaces
677 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A6b");
678 Assert.IsNotNull (ex.Message, "#A6c");
679 Assert.IsNull (ex.InnerException, "#A6d");
680 }
681 Assert.IsNotNull (eventLog.MachineName, "#A7");
682 Assert.AreEqual (".", eventLog.MachineName, "#A8");
683 Assert.IsNotNull (eventLog.Source, "#A9");
684 Assert.AreEqual (string.Empty, eventLog.Source, "#A10");
685 eventLog.Close ();
686 }
687
688 [Test]
689 [ExpectedException (typeof (ArgumentNullException))]
690 public void Constructor3_Log_Null ()
691 {
692 new EventLog (null, ".");
693 }
694
695 [Test]
696 public void Constructor3_MachineName_Empty ()
697 {
698 try {
699 new EventLog ("monologtemp", string.Empty);
700 Assert.Fail ("#A1");
701 } catch (ArgumentException ex) {
702 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
703 Assert.IsNotNull (ex.Message, "#A3");
704 // Invalid value '' for parameter 'machineName'
705 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
706 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
707 Assert.IsNull (ex.InnerException, "#A6");
708 Assert.IsNull (ex.ParamName, "#A7");
709 }
710
711 try {
712 new EventLog ("monologtemp", " \t\n");
713 Assert.Fail ("#B1");
714 } catch (ArgumentException ex) {
715 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
716 Assert.IsNotNull (ex.Message, "#B3");
717 // Invalid value ' \t\n' for parameter 'machineName'
718 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
719 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#B5");
720 Assert.IsNull (ex.InnerException, "#B6");
721 Assert.IsNull (ex.ParamName, "#B7");
722 }
723 }
724
725 [Test]
726 public void Constructor3_MachineName_Null ()
727 {
728 try {
729 new EventLog ("monologtemp", null);
730 Assert.Fail ("#A1");
731 } catch (ArgumentException ex) {
732 // Invalid value '' for parameter 'machineName'
733 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
734 Assert.IsNotNull (ex.Message, "#A3");
735 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
736 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
737 Assert.IsNull (ex.InnerException, "#A6");
738 Assert.IsNull (ex.ParamName, "#A7");
739 }
740 }
741
742 [Test]
743 public void Constructor4 ()
744 {
745 if (EventLogImplType == NULL_IMPL)
746 // test cannot pass with NULL implementation
747 Assert.Ignore ("No EventLogImplType.");
748
749 if (EventLog.SourceExists ("monotempsource", "."))
750 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
751
752 if (EventLog.Exists ("monologtemp", "."))
753 Assert.Ignore ("Event log 'monologtemp' should not exist.");
754
755 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
756 try {
757 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
758 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
759 Assert.IsNotNull (eventLog.Entries, "#A2");
760 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A3");
761 Assert.IsNotNull (eventLog.Log, "#A4");
762 Assert.AreEqual ("monologtemp", eventLog.Log, "#A5");
763 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#A6");
764 Assert.IsNotNull (eventLog.MachineName, "#A7");
765 Assert.AreEqual (".", eventLog.MachineName, "#A8");
766 Assert.IsNotNull (eventLog.Source, "#A9");
767 Assert.AreEqual ("monotempsource", eventLog.Source, "#A10");
768 }
769
770 using (EventLog eventLog = new EventLog ("monologtemp", ".", "whatever")) {
771 Assert.AreEqual ("monologtemp", eventLog.Log, "#B1");
772 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#B2");
773 }
774 } finally {
775 EventLog.Delete ("monologtemp");
776 }
777 }
778
779 [Test]
780 public void Constructor4_Log_DoesNotExist ()
781 {
782 if (EventLogImplType == NULL_IMPL)
783 // test cannot pass with NULL implementation
784 Assert.Ignore ("No EventLogImplType.");
785
786 if (EventLog.Exists ("monologtemp", "."))
787 Assert.Ignore ("Event log 'monologtemp' should not exist.");
788
789 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
790 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
791 Assert.IsNotNull (eventLog.Entries, "#B2");
792 try {
793 eventLog.Entries.GetEnumerator ().MoveNext ();
794 Assert.Fail ("#B3a");
795 } catch (InvalidOperationException ex) {
796 // The event log 'monologtemp' on computer '.' does not exist
797 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B3b");
798 Assert.IsNotNull (ex.Message, "#B3c");
799 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B3d");
800 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B3e");
801 Assert.IsNull (ex.InnerException, "#B3f");
802 }
803 Assert.IsNotNull (eventLog.Log, "#B4");
804 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
805 try {
806 string displayName = eventLog.LogDisplayName;
807 Assert.Fail ("#B6a: " + displayName);
808 } catch (InvalidOperationException ex) {
809 // Cannot find Log monologtemp on computer .
810 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B6b");
811 Assert.IsNotNull (ex.Message, "#B6c");
812 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#B6d");
813 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#B6e");
814 Assert.IsNull (ex.InnerException, "#B6f");
815 }
816 Assert.IsNotNull (eventLog.MachineName, "#B7");
817 Assert.AreEqual (".", eventLog.MachineName, "#B8");
818 Assert.IsNotNull (eventLog.Source, "#B9");
819 Assert.AreEqual ("monotempsource", eventLog.Source, "#B10");
820 eventLog.Close ();
821 }
822
823 [Test]
824 public void Constructor4_Log_Empty ()
825 {
826 if (EventLogImplType == NULL_IMPL)
827 // test cannot pass with NULL implementation
828 Assert.Ignore ("No EventLogImplType.");
829
830 if (EventLog.SourceExists ("monotempsource", "."))
831 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
832
833 bool applicationLogExists = EventLog.Exists ("Application");
834 try {
835 EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource");
836 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
837 Assert.IsNotNull (eventLog.Entries, "#A2");
838 try {
839 eventLog.Entries.GetEnumerator ().MoveNext ();
840 Assert.Fail ("#A3a");
841 } catch (ArgumentException ex) {
842 // Log property is not set (zero-length string)
843 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A3b");
844 Assert.IsNotNull (ex.Message, "#A3c");
845 Assert.IsNull (ex.InnerException, "#A3d");
846 Assert.IsNull (ex.ParamName, "#A3e");
847 }
848 Assert.IsNotNull (eventLog.Log, "#A4");
849 Assert.AreEqual (string.Empty, eventLog.Log, "#A5");
850 try {
851 string displayName = eventLog.LogDisplayName;
852 Assert.Fail ("#A6a: " + displayName);
853 } catch (InvalidOperationException ex) {
854 // Event log names must consist of printable characters and
855 // cannot contain \, *, ?, or spaces
856 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A6b");
857 Assert.IsNotNull (ex.Message, "#A6c");
858 Assert.IsNull (ex.InnerException, "#A6d");
859 }
860 Assert.IsNotNull (eventLog.MachineName, "#A7");
861 Assert.AreEqual (".", eventLog.MachineName, "#A8");
862 Assert.IsNotNull (eventLog.Source, "#A9");
863 Assert.AreEqual ("monotempsource", eventLog.Source, "#A10");
864 eventLog.Close ();
865 } finally {
866 if (!applicationLogExists) {
867 if (EventLog.Exists ("Application"))
868 EventLog.Delete ("Application");
869 } else {
870 if (EventLog.SourceExists ("monotempsource", "."))
871 EventLog.DeleteEventSource ("monotempsource", ".");
872 }
873 }
874 }
875
876 [Test]
877 [ExpectedException (typeof (ArgumentNullException))]
878 public void Constructor4_Log_Null ()
879 {
880 new EventLog (null, ".", "monotempsource");
881 }
882
883 [Test]
884 public void Constructor4_MachineName_Empty ()
885 {
886 try {
887 new EventLog ("monologtemp", string.Empty, "monotempsource");
888 Assert.Fail ("#A1");
889 } catch (ArgumentException ex) {
890 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
891 Assert.IsNotNull (ex.Message, "#A3");
892 // Invalid value '' for parameter 'machineName'
893 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
894 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
895 Assert.IsNull (ex.InnerException, "#A6");
896 Assert.IsNull (ex.ParamName, "#A7");
897 }
898
899 try {
900 new EventLog ("monologtemp", " \t\n", "monotempsource");
901 Assert.Fail ("#B1");
902 } catch (ArgumentException ex) {
903 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
904 Assert.IsNotNull (ex.Message, "#B3");
905 // Invalid value ' \t\n' for parameter 'machineName'
906 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
907 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#B5");
908 Assert.IsNull (ex.InnerException, "#B6");
909 Assert.IsNull (ex.ParamName, "#B7");
910 }
911 }
912
913 [Test]
914 public void Constructor4_MachineName_Null ()
915 {
916 try {
917 new EventLog ("monologtemp", null, "monotempsource");
918 Assert.Fail ("#A1");
919 } catch (ArgumentException ex) {
920 // Invalid value '' for parameter 'machineName'
921 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
922 Assert.IsNotNull (ex.Message, "#A3");
923 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
924 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
925 Assert.IsNull (ex.InnerException, "#A6");
926 Assert.IsNull (ex.ParamName, "#A7");
927 }
928 }
929
930 [Test]
931 public void Constructor4_Source_DoesNotExist ()
932 {
933 if (EventLogImplType == NULL_IMPL)
934 // test cannot pass with NULL implementation
935 Assert.Ignore ("No EventLogImplType.");
936
937 if (EventLog.SourceExists ("monoothersource", "."))
938 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
939
940 if (EventLog.SourceExists ("monotempsource", "."))
941 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
942
943 if (EventLog.Exists ("monologtemp", "."))
944 Assert.Ignore ("Event log 'monologtemp' should not exist.");
945
946 EventLog.CreateEventSource ("monoothersource", "monologtemp", ".");
947 try {
948 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
949 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
950 Assert.IsNotNull (eventLog.Entries, "#A2");
951 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A3");
952 Assert.IsNotNull (eventLog.Log, "#A4");
953 Assert.AreEqual ("monologtemp", eventLog.Log, "#A5");
954 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#A6");
955 Assert.IsNotNull (eventLog.MachineName, "#A7");
956 Assert.AreEqual (".", eventLog.MachineName, "#A8");
957 Assert.IsNotNull (eventLog.Source, "#A9");
958 Assert.AreEqual ("monotempsource", eventLog.Source, "#A10");
959 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A11");
960 Assert.IsTrue (EventLog.SourceExists ("monoothersource"), "#A12");
961 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A13");
962 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A14");
963 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A15");
964 }
965 } finally {
966 if (EventLog.Exists ("monologtemp"))
967 EventLog.Delete ("monologtemp");
968 }
969 }
970
971 [Test]
972 public void Constructor4_Source_Empty ()
973 {
974 if (EventLogImplType == NULL_IMPL)
975 // test cannot pass with NULL implementation
976 Assert.Ignore ("No EventLogImplType.");
977
978 if (EventLog.SourceExists ("monotempsource", "."))
979 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
980
981 if (EventLog.Exists ("monologtemp", "."))
982 Assert.Ignore ("Event log 'monologtemp' should not exist.");
983
984 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
985 try {
986 using (EventLog eventLog = new EventLog ("monologtemp", ".", string.Empty)) {
987 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
988 Assert.IsNotNull (eventLog.Entries, "#A2");
989 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A3");
990 Assert.IsNotNull (eventLog.Log, "#A4");
991 Assert.AreEqual ("monologtemp", eventLog.Log, "#A5");
992 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#A6");
993 Assert.IsNotNull (eventLog.MachineName, "#A7");
994 Assert.AreEqual (".", eventLog.MachineName, "#A8");
995 Assert.IsNotNull (eventLog.Source, "#A9");
996 Assert.AreEqual (string.Empty, eventLog.Source, "#A10");
997 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A11");
998 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A12");
999 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A13");
1000 }
1001 } finally {
1002 if (EventLog.Exists ("monologtemp"))
1003 EventLog.Delete ("monologtemp");
1004 }
1005 }
1006
1007 [Test]
1008 public void Constructor4_Source_Null ()
1009 {
1010 if (EventLogImplType == NULL_IMPL)
1011 // test cannot pass with NULL implementation
1012 Assert.Ignore ("No EventLogImplType.");
1013
1014 if (EventLog.SourceExists ("monotempsource", "."))
1015 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1016
1017 if (EventLog.Exists ("monologtemp", "."))
1018 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1019
1020 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1021 try {
1022 using (EventLog eventLog = new EventLog ("monologtemp", ".", null)) {
1023 Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
1024 Assert.IsNotNull (eventLog.Entries, "#A2");
1025 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#A3");
1026 Assert.IsNotNull (eventLog.Log, "#A4");
1027 Assert.AreEqual ("monologtemp", eventLog.Log, "#A5");
1028 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#A6");
1029 Assert.IsNotNull (eventLog.MachineName, "#A7");
1030 Assert.AreEqual (".", eventLog.MachineName, "#A8");
1031 Assert.IsNull (eventLog.Source, "#A9");
1032 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A10");
1033 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A11");
1034 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A12");
1035 }
1036 } finally {
1037 if (EventLog.Exists ("monologtemp"))
1038 EventLog.Delete ("monologtemp");
1039 }
1040 }
1041
1042 [Test]
1043 public void CreateEventSource1 ()
1044 {
1045 if (EventLogImplType == NULL_IMPL)
1046 // test cannot pass with NULL implementation
1047 Assert.Ignore ("No EventLogImplType.");
1048
1049 if (EventLog.SourceExists ("monotempsource", "."))
1050 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1051
1052 if (EventLog.SourceExists ("monologtemp", "."))
1053 Assert.Ignore ("Event log source 'monologtemp' should not exist.");
1054
1055 if (EventLog.Exists ("monologtemp", "."))
1056 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1057
1058 if (EventLog.Exists ("monologother", "."))
1059 Assert.Ignore ("Event log 'monologother' should not exist.");
1060
1061 try {
1062 EventLog.CreateEventSource ("monotempsource", "monologtemp");
1063 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A1");
1064 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A2");
1065 Assert.IsTrue (EventLog.SourceExists ("monologtemp", "."), "#A3");
1066 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A4");
1067
1068 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
1069 Assert.IsFalse (eventLog.EnableRaisingEvents, "#B1");
1070 Assert.IsNotNull (eventLog.Entries, "#B2");
1071 // MSBUG: Assert.AreEqual (0, eventLog.Entries.Count, "#B3");
1072 Assert.IsNotNull (eventLog.Log, "#B4");
1073 Assert.AreEqual ("monologtemp", eventLog.Log, "#B5");
1074 Assert.IsNotNull (eventLog.LogDisplayName, "#B6");
1075 Assert.AreEqual ("monologtemp", eventLog.LogDisplayName, "#B7");
1076 Assert.IsNotNull (eventLog.MachineName, "#B8");
1077 Assert.AreEqual (".", eventLog.MachineName, "#B9");
1078 Assert.IsNotNull (eventLog.Source, "#B10");
1079 Assert.AreEqual ("monotempsource", eventLog.Source, "#B11");
1080 }
1081
1082 try {
1083 EventLog.CreateEventSource ("monologtemp", "monologother");
1084 Assert.Fail ("#C1");
1085 } catch (ArgumentException ex) {
1086 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1087 Assert.IsNotNull (ex.Message, "#C3");
1088 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#C4");
1089 Assert.IsTrue (ex.Message.IndexOf ("monologother") == -1, "#C5");
1090 Assert.IsNull (ex.InnerException, "#C6");
1091 Assert.IsNull (ex.ParamName, "#C7");
1092 }
1093
1094 try {
1095 EventLog.CreateEventSource ("monotempsource", "monologother");
1096 Assert.Fail ("#D1");
1097 } catch (ArgumentException ex) {
1098 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
1099 Assert.IsNotNull (ex.Message, "#D3");
1100 Assert.IsTrue (ex.Message.IndexOf ("monotempsource") != -1, "#D4");
1101 Assert.IsTrue (ex.Message.IndexOf ("monologother") == -1, "#D5");
1102 Assert.IsNull (ex.InnerException, "#D6");
1103 Assert.IsNull (ex.ParamName, "#D7");
1104 }
1105
1106 try {
1107 EventLog.CreateEventSource ("MonoTempSource", "monologother");
1108 Assert.Fail ("#E1");
1109 } catch (ArgumentException ex) {
1110 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
1111 Assert.IsNotNull (ex.Message, "#E3");
1112 Assert.IsTrue (ex.Message.IndexOf ("MonoTempSource") != -1, "#E4");
1113 Assert.IsTrue (ex.Message.IndexOf ("monologother") == -1, "#E5");
1114 Assert.IsNull (ex.InnerException, "#E6");
1115 Assert.IsNull (ex.ParamName, "#E7");
1116 }
1117 } finally {
1118 if (EventLog.Exists ("monologtemp", "."))
1119 EventLog.Delete ("monologtemp", ".");
1120
1121 if (EventLog.Exists ("monologother", "."))
1122 EventLog.Delete ("monologother", ".");
1123 }
1124 }
1125
1126 [Test]
1127 [ExpectedException (typeof (ArgumentException))] // Must specify value for source
1128 public void CreateEventSource1_Source_Empty ()
1129 {
1130 EventLog.CreateEventSource (string.Empty, "monologtemp");
1131 }
1132
1133 [Test]
1134 [ExpectedException (typeof (ArgumentException))] // Must specify value for source
1135 public void CreateEventSource1_Source_Null ()
1136 {
1137 EventLog.CreateEventSource (null, "monologtemp");
1138 }
1139
1140 [Test]
1141 public void CreateEventSource1_Log_Empty ()
1142 {
1143 if (EventLogImplType == NULL_IMPL)
1144 // test cannot pass with NULL implementation
1145 Assert.Ignore ("No EventLogImplType.");
1146
1147 if (EventLog.SourceExists ("monotempsource", "."))
1148 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1149
1150 bool logExists = EventLog.Exists ("Application", ".");
1151 try {
1152 EventLog.CreateEventSource ("monotempsource", string.Empty);
1153 string logName = EventLog.LogNameFromSourceName ("monotempsource", ".");
1154 Assert.IsNotNull (logName, "#1");
1155 Assert.AreEqual ("Application", logName, "#2");
1156 } finally {
1157 if (!logExists) {
1158 if (EventLog.Exists ("Application", ".")) {
1159 EventLog.Delete ("Application", ".");
1160 }
1161 } else {
1162 if (EventLog.SourceExists ("monotempsource", "."))
1163 EventLog.DeleteEventSource ("monotempsource", ".");
1164 }
1165 }
1166 }
1167
1168 [Test]
1169 public void CreateEventSource1_Log_ExistsAsSource ()
1170 {
1171 if (EventLogImplType == NULL_IMPL)
1172 // test cannot pass with NULL implementation
1173 Assert.Ignore ("No EventLogImplType.");
1174
1175 if (EventLog.SourceExists ("monotempsource", "."))
1176 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1177
1178 if (EventLog.SourceExists ("monologtemp", "."))
1179 Assert.Ignore ("Event log source 'monologtemp' should not exist.");
1180
1181 if (EventLog.Exists ("monologtemp", "."))
1182 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1183
1184 if (EventLog.Exists ("monologother", "."))
1185 Assert.Ignore ("Event log 'monologother' should not exist.");
1186
1187 try {
1188 EventLog.CreateEventSource ("monologtemp", "monologother", ".");
1189 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A1");
1190 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#A2");
1191 Assert.IsTrue (EventLog.SourceExists ("monologtemp", "."), "#A3");
1192 Assert.IsTrue (EventLog.SourceExists ("monologother", "."), "#A4");
1193
1194 try {
1195 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1196 Assert.Fail ("#B1");
1197 } catch (ArgumentException ex) {
1198 // Log monologtemp has already been registered as a source
1199 // on the local computer
1200 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1201 Assert.IsNotNull (ex.Message, "#B3");
1202 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#B4");
1203 Assert.IsNull (ex.InnerException, "#B5");
1204 Assert.IsNull (ex.ParamName, "#B6");
1205 }
1206 } finally {
1207 if (EventLog.Exists ("monologtemp", "."))
1208 EventLog.Delete ("monologtemp", ".");
1209
1210 if (EventLog.Exists ("monologother", "."))
1211 EventLog.Delete ("monologother", ".");
1212 }
1213 }
1214
1215 [Test]
1216 public void CreateEventSource1_Log_InvalidCustomerLog ()
1217 {
1218 if (EventLogImplType == NULL_IMPL)
1219 // test cannot pass with NULL implementation
1220 Assert.Ignore ("No EventLogImplType.");
1221
1222 if (EventLog.SourceExists ("monotempsource", "."))
1223 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1224
1225 if (EventLog.Exists ("AppEvent", "."))
1226 Assert.Ignore ("Event log 'AppEvent' should not exist.");
1227
1228 try {
1229 EventLog.CreateEventSource ("monotempsource", "AppEvent");
1230 Assert.Fail ("#A1");
1231 } catch (ArgumentException ex) {
1232 // The log name: 'AppEvent' is invalid for customer log creation
1233 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1234 Assert.IsNotNull (ex.Message, "#A3");
1235 Assert.IsTrue (ex.Message.IndexOf ("'AppEvent'") != -1, "#A4");
1236 Assert.IsNull (ex.InnerException, "#A5");
1237 Assert.IsNull (ex.ParamName, "#A6");
1238 }
1239
1240 try {
1241 EventLog.CreateEventSource ("monotempsource", "appevent");
1242 Assert.Fail ("#B1");
1243 } catch (ArgumentException ex) {
1244 // The log name: 'appevent' is invalid for customer log creation
1245 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1246 Assert.IsNotNull (ex.Message, "#B3");
1247 Assert.IsTrue (ex.Message.IndexOf ("'appevent'") != -1, "#B4");
1248 Assert.IsNull (ex.InnerException, "#B5");
1249 Assert.IsNull (ex.ParamName, "#B6");
1250 }
1251
1252 if (EventLog.Exists ("SysEvent", "."))
1253 Assert.Ignore ("Event log 'SysEvent' should not exist.");
1254
1255 try {
1256 EventLog.CreateEventSource ("monotempsource", "SysEvent");
1257 Assert.Fail ("#C1");
1258 } catch (ArgumentException ex) {
1259 // The log name: 'SysEvent' is invalid for customer log creation
1260 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1261 Assert.IsNotNull (ex.Message, "#C3");
1262 Assert.IsTrue (ex.Message.IndexOf ("'SysEvent'") != -1, "#C4");
1263 Assert.IsNull (ex.InnerException, "#C5");
1264 Assert.IsNull (ex.ParamName, "#C6");
1265 }
1266
1267 try {
1268 EventLog.CreateEventSource ("monotempsource", "sysevent");
1269 Assert.Fail ("#D1");
1270 } catch (ArgumentException ex) {
1271 // The log name: 'sysEvent' is invalid for customer log creation
1272 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
1273 Assert.IsNotNull (ex.Message, "#D3");
1274 Assert.IsTrue (ex.Message.IndexOf ("'sysevent'") != -1, "#D4");
1275 Assert.IsNull (ex.InnerException, "#D5");
1276 Assert.IsNull (ex.ParamName, "#D6");
1277 }
1278
1279 if (EventLog.Exists ("SecEvent", "."))
1280 Assert.Ignore ("Event log 'SecEvent' should not exist.");
1281
1282 try {
1283 EventLog.CreateEventSource ("monotempsource", "SecEvent");
1284 Assert.Fail ("#E1");
1285 } catch (ArgumentException ex) {
1286 // The log name: 'SecEvent' is invalid for customer log creation
1287 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
1288 Assert.IsNotNull (ex.Message, "#E3");
1289 Assert.IsTrue (ex.Message.IndexOf ("'SecEvent'") != -1, "#E4");
1290 Assert.IsNull (ex.InnerException, "#E5");
1291 Assert.IsNull (ex.ParamName, "#E6");
1292 }
1293
1294 try {
1295 EventLog.CreateEventSource ("monotempsource", "secevent");
1296 Assert.Fail ("#F1");
1297 } catch (ArgumentException ex) {
1298 // The log name: 'secevent' is invalid for customer log creation
1299 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
1300 Assert.IsNotNull (ex.Message, "#F3");
1301 Assert.IsTrue (ex.Message.IndexOf ("'secevent'") != -1, "#F4");
1302 Assert.IsNull (ex.InnerException, "#F5");
1303 Assert.IsNull (ex.ParamName, "#F6");
1304 }
1305
1306 if (EventLog.Exists ("AppEventA", "."))
1307 Assert.Ignore ("Event log 'AppEventA' should not exist.");
1308
1309 try {
1310 EventLog.CreateEventSource ("monotempsource", "AppEventA");
1311 Assert.Fail ("#G1");
1312 } catch (ArgumentException ex) {
1313 // The log name: 'AppEventA' is invalid for customer log creation
1314 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#G2");
1315 Assert.IsNotNull (ex.Message, "#G3");
1316 Assert.IsTrue (ex.Message.IndexOf ("'AppEventA'") != -1, "#G4");
1317 Assert.IsNull (ex.InnerException, "#G5");
1318 Assert.IsNull (ex.ParamName, "#G6");
1319 }
1320
1321 if (EventLog.Exists ("SysEventA", "."))
1322 Assert.Ignore ("Event log 'SysEventA' should not exist.");
1323
1324 try {
1325 EventLog.CreateEventSource ("monotempsource", "SysEventA");
1326 Assert.Fail ("#H1");
1327 } catch (ArgumentException ex) {
1328 // The log name: 'SysEventA' is invalid for customer log creation
1329 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#H2");
1330 Assert.IsNotNull (ex.Message, "#H3");
1331 Assert.IsTrue (ex.Message.IndexOf ("'SysEventA'") != -1, "#H4");
1332 Assert.IsNull (ex.InnerException, "#H5");
1333 Assert.IsNull (ex.ParamName, "#H6");
1334 }
1335
1336 if (EventLog.Exists ("SecEventA", "."))
1337 Assert.Ignore ("Event log 'SecEventA' should not exist.");
1338
1339 try {
1340 EventLog.CreateEventSource ("monotempsource", "SecEventA");
1341 Assert.Fail ("#I1");
1342 } catch (ArgumentException ex) {
1343 // The log name: 'SecEventA' is invalid for customer log creation
1344 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
1345 Assert.IsNotNull (ex.Message, "#I3");
1346 Assert.IsTrue (ex.Message.IndexOf ("'SecEventA'") != -1, "#I4");
1347 Assert.IsNull (ex.InnerException, "#I5");
1348 Assert.IsNull (ex.ParamName, "#I6");
1349 }
1350 }
1351
1352 [Test]
1353 public void CreateEventSource1_Log_NotUnique ()
1354 {
1355 if (EventLogImplType == NULL_IMPL)
1356 // test cannot pass with NULL implementation
1357 Assert.Ignore ("No EventLogImplType.");
1358
1359 if (EventLog.SourceExists ("monotempsource", "."))
1360 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1361
1362 if (EventLog.SourceExists ("monotestsource", "."))
1363 Assert.Ignore ("Event log source 'monotestsource' should not exist.");
1364
1365 if (EventLog.SourceExists ("monoothersource", "."))
1366 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1367
1368 if (EventLog.Exists ("monologtemp", "."))
1369 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1370
1371 if (EventLog.Exists ("monologtest", "."))
1372 Assert.Ignore ("Event log 'monologtest' should not exist.");
1373
1374 if (EventLog.Exists ("monologother", "."))
1375 Assert.Ignore ("Event log 'monologother' should not exist.");
1376
1377 // the 8th character of the log name differs
1378 try {
1379 EventLog.CreateEventSource ("monoothersource", "monologother");
1380 EventLog.CreateEventSource ("monotempsource", "monologtemp");
1381 } finally {
1382 if (EventLog.Exists ("monologother"))
1383 EventLog.Delete ("monologother");
1384 if (EventLog.Exists ("monologtemp"))
1385 EventLog.Delete ("monologtemp");
1386 }
1387
1388 // the first 8 characters match
1389 try {
1390 EventLog.CreateEventSource ("monotestsource", "monologtest");
1391 EventLog.CreateEventSource ("monotempsource", "monologtemp");
1392 Assert.Fail ("#A1");
1393 } catch (ArgumentException ex) {
1394 // Only the first eight characters of a custom log name are
1395 // significant, and there is already another log on the system
1396 // using the first eight characters of the name given.
1397 // Name given: 'monologtemp', name of existing log: 'monologtest'
1398 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1399 Assert.IsNotNull (ex.Message, "#B3");
1400 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B4");
1401 Assert.IsTrue (ex.Message.IndexOf ("'monologtest'") != -1, "#B5");
1402 Assert.IsNull (ex.InnerException, "#B6");
1403 Assert.IsNull (ex.ParamName, "#B7");
1404 } finally {
1405 if (EventLog.Exists ("monologtest"))
1406 EventLog.Delete ("monologtest");
1407 if (EventLog.Exists ("monologtemp"))
1408 EventLog.Delete ("monologtemp");
1409 }
1410 }
1411
1412 [Test]
1413 public void CreateEventSource1_Log_Null ()
1414 {
1415 if (EventLogImplType == NULL_IMPL)
1416 // test cannot pass with NULL implementation
1417 Assert.Ignore ("No EventLogImplType.");
1418
1419 if (EventLog.SourceExists ("monotempsource", "."))
1420 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1421
1422 bool logExists = EventLog.Exists ("Application", ".");
1423 try {
1424 EventLog.CreateEventSource ("monotempsource", null);
1425 string logName = EventLog.LogNameFromSourceName ("monotempsource", ".");
1426 Assert.IsNotNull (logName, "#1");
1427 Assert.AreEqual ("Application", logName, "#2");
1428 } finally {
1429 if (!logExists) {
1430 if (EventLog.Exists ("Application"))
1431 EventLog.Delete ("Application");
1432 } else {
1433 if (EventLog.SourceExists ("monotempsource", "."))
1434 EventLog.DeleteEventSource ("monotempsource", ".");
1435 }
1436 }
1437 }
1438
1439 [Test]
1440 public void Delete1 ()
1441 {
1442 if (EventLogImplType == NULL_IMPL)
1443 // test cannot pass with NULL implementation
1444 Assert.Ignore ("No EventLogImplType.");
1445
1446 if (EventLog.SourceExists ("monotempsource", "."))
1447 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1448
1449 if (EventLog.SourceExists ("monoothersource", "."))
1450 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
1451
1452 if (EventLog.Exists ("monologtemp", "."))
1453 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1454
1455 if (EventLog.Exists ("monologother", "."))
1456 Assert.Ignore ("Event log 'monologother' should not exist.");
1457
1458 try {
1459 EventLog.CreateEventSource ("monoothersource", "monologother", ".");
1460 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1461
1462 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A1");
1463 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A2");
1464 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A3");
1465 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
1466 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A5");
1467 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A6");
1468 EventLog.Delete ("monologtemp");
1469 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#A7");
1470 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A8");
1471 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#A9");
1472 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A10");
1473 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A11");
1474 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A12");
1475
1476 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1477
1478 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B1");
1479 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#B2");
1480 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B3");
1481 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
1482 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B5");
1483 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B6");
1484 EventLog.Delete ("MonoLogTemp");
1485 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#B7");
1486 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#B8");
1487 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#B9");
1488 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B10");
1489 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B11");
1490 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B12");
1491 } finally {
1492 if (EventLog.Exists ("monologother"))
1493 EventLog.Delete ("monologother");
1494 }
1495 }
1496
1497 [Test]
1498 public void Delete1_Log_DoesNotExist ()
1499 {
1500 if (EventLogImplType == NULL_IMPL)
1501 // test cannot pass with NULL implementation
1502 Assert.Ignore ("No EventLogImplType.");
1503
1504 if (EventLog.SourceExists ("monotempsource", "."))
1505 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1506
1507 if (EventLog.Exists ("monologtemp", "."))
1508 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1509
1510 try {
1511 EventLog.Delete ("monologtemp");
1512 Assert.Fail ("#1");
1513 } catch (InvalidOperationException ex) {
1514 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1515 Assert.IsNotNull (ex.Message, "#3");
1516 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#4");
1517 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#5");
1518 Assert.IsNull (ex.InnerException, "#6");
1519 }
1520 }
1521
1522 [Test]
1523 [ExpectedException (typeof (ArgumentException))] // Log to delete was not specified
1524 public void Delete1_Log_Empty ()
1525 {
1526 EventLog.Delete (string.Empty);
1527 }
1528
1529 [Test]
1530 [ExpectedException (typeof (ArgumentException))] // Log to delete was not specified
1531 public void Delete1_Log_Null ()
1532 {
1533 EventLog.Delete (null);
1534 }
1535
1536 [Test]
1537 public void Delete2 ()
1538 {
1539 if (EventLogImplType == NULL_IMPL)
1540 // test cannot pass with NULL implementation
1541 Assert.Ignore ("No EventLogImplType.");
1542
1543 if (EventLog.SourceExists ("monotempsource", "."))
1544 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1545
1546 if (EventLog.SourceExists ("monoothersource", "."))
1547 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
1548
1549 if (EventLog.Exists ("monologtemp", "."))
1550 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1551
1552 if (EventLog.Exists ("monologother", "."))
1553 Assert.Ignore ("Event log 'monologother' should not exist.");
1554
1555 try {
1556 EventLog.CreateEventSource ("monoothersource", "monologother", ".");
1557 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1558
1559 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A1");
1560 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A2");
1561 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A3");
1562 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
1563 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A5");
1564 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A6");
1565 EventLog.Delete ("monologtemp", ".");
1566 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#A7");
1567 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#A8");
1568 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#A9");
1569 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A10");
1570 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A11");
1571 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A12");
1572
1573 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1574
1575 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B1");
1576 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#B2");
1577 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B3");
1578 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
1579 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B5");
1580 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B6");
1581 EventLog.Delete ("MonoLogTemp", ".");
1582 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#B7");
1583 Assert.IsTrue (EventLog.Exists ("monologother", "."), "#B8");
1584 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#B9");
1585 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B10");
1586 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B11");
1587 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B12");
1588 } finally {
1589 if (EventLog.Exists ("monologother"))
1590 EventLog.Delete ("monologother");
1591 }
1592 }
1593
1594 [Test]
1595 public void Delete2_Log_DoesNotExist ()
1596 {
1597 if (EventLogImplType == NULL_IMPL)
1598 // test cannot pass with NULL implementation
1599 Assert.Ignore ("No EventLogImplType.");
1600
1601 if (EventLog.SourceExists ("monotempsource", "."))
1602 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1603
1604 if (EventLog.Exists ("monologtemp", "."))
1605 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1606
1607 try {
1608 EventLog.Delete ("monologtemp", ".");
1609 Assert.Fail ("#1");
1610 } catch (InvalidOperationException ex) {
1611 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1612 Assert.IsNotNull (ex.Message, "#3");
1613 Assert.IsTrue (ex.Message.IndexOf ("monologtemp") != -1, "#4");
1614 Assert.IsTrue (ex.Message.IndexOf (".") != -1, "#5");
1615 Assert.IsNull (ex.InnerException, "#6");
1616 }
1617 }
1618
1619 [Test]
1620 [ExpectedException (typeof (ArgumentException))] // Log to delete was not specified
1621 public void Delete2_Log_Empty ()
1622 {
1623 EventLog.Delete (string.Empty, ".");
1624 }
1625
1626 [Test]
1627 [ExpectedException (typeof (ArgumentException))] // Log to delete was not specified
1628 public void Delete2_Log_Null ()
1629 {
1630 EventLog.Delete (null, ".");
1631 }
1632
1633 [Test]
1634 public void Delete2_MachineName_Empty ()
1635 {
1636 try {
1637 EventLog.Delete ("monologtemp", string.Empty);
1638 Assert.Fail ("#A1");
1639 } catch (ArgumentException ex) {
1640 // // Invalid format for argument machineName
1641 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1642 Assert.IsNotNull (ex.Message, "#A3");
1643 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#A4");
1644 Assert.IsNull (ex.InnerException, "#A5");
1645 Assert.IsNull (ex.ParamName, "#A6");
1646 }
1647
1648 try {
1649 EventLog.Delete ("monologtemp", " \t\n");
1650 Assert.Fail ("#B1");
1651 } catch (ArgumentException ex) {
1652 // // Invalid format for argument machineName
1653 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1654 Assert.IsNotNull (ex.Message, "#B3");
1655 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#B4");
1656 Assert.IsNull (ex.InnerException, "#B5");
1657 Assert.IsNull (ex.ParamName, "#B6");
1658 }
1659 }
1660
1661 [Test]
1662 public void Delete2_MachineName_Null ()
1663 {
1664 try {
1665 EventLog.Delete ("monologtemp", null);
1666 Assert.Fail ("#1");
1667 } catch (ArgumentException ex) {
1668 // // Invalid format for argument machineName
1669 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1670 Assert.IsNotNull (ex.Message, "#3");
1671 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#4");
1672 Assert.IsNull (ex.InnerException, "#5");
1673 Assert.IsNull (ex.ParamName, "#6");
1674 }
1675 }
1676
1677 [Test]
1678 public void DeleteEventSource1 ()
1679 {
1680 if (EventLogImplType == NULL_IMPL)
1681 // test cannot pass with NULL implementation
1682 Assert.Ignore ("No EventLogImplType.");
1683
1684 if (EventLog.SourceExists ("monotempsource", "."))
1685 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1686
1687 if (EventLog.SourceExists ("monoothersource", "."))
1688 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
1689
1690 bool monologtempExists = EventLog.Exists ("monologtemp", ".");
1691 try {
1692 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1693 EventLog.CreateEventSource ("monoothersource", "monologtemp", ".");
1694
1695 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A1");
1696 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A2");
1697 EventLog.DeleteEventSource ("monotempsource");
1698 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#A3");
1699 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
1700 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A5");
1701 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A6");
1702 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A7");
1703
1704 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1705
1706 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B1");
1707 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A2");
1708 EventLog.DeleteEventSource ("MonoTempSource");
1709 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#B3");
1710 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
1711 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B5");
1712 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B6");
1713 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B7");
1714 } finally {
1715 if (!monologtempExists) {
1716 EventLog.Delete ("monologtemp");
1717 }
1718 }
1719 }
1720
1721 [Test]
1722 public void DeleteEventSource1_Source_DoesNotExist ()
1723 {
1724 if (EventLogImplType == NULL_IMPL)
1725 // test cannot pass with NULL implementation
1726 Assert.Ignore ("No EventLogImplType.");
1727
1728 if (EventLog.SourceExists ("monotempsource", "."))
1729 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1730
1731 try {
1732 EventLog.DeleteEventSource ("monotempsource");
1733 Assert.Fail ("#1");
1734 } catch (ArgumentException ex) {
1735 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1736 Assert.IsNotNull (ex.Message, "#3");
1737 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#4");
1738 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
1739 Assert.IsNull (ex.InnerException, "#6");
1740 Assert.IsNull (ex.ParamName, "#7");
1741 } catch (SecurityException) {
1742 if (IsAzurePipelines) Assert.Ignore ("Azure Pipelines fails with: Requested registry access is not allowed on.");
1743 throw;
1744 }
1745 }
1746
1747 [Test]
1748 [ExpectedException (typeof (ArgumentException))] // The source '' is not registered on machine '.', ...
1749 public void DeleteEventSource1_Source_Empty ()
1750 {
1751 if (EventLogImplType == NULL_IMPL)
1752 // allow test to pass with NULL implementation
1753 throw new ArgumentException ();
1754
1755 EventLog.DeleteEventSource (string.Empty);
1756 }
1757
1758 [Test]
1759 [ExpectedException (typeof (ArgumentException))] // The source '' is not registered on machine '.', ...
1760 public void DeleteEventSource1_Source_Null ()
1761 {
1762 if (EventLogImplType == NULL_IMPL)
1763 // allow test to pass with NULL implementation
1764 throw new ArgumentException ();
1765
1766 EventLog.DeleteEventSource (null);
1767 }
1768
1769 [Test]
1770 public void DeleteEventSource2 ()
1771 {
1772 if (EventLogImplType == NULL_IMPL)
1773 // test cannot pass with NULL implementation
1774 Assert.Ignore ("No EventLogImplType.");
1775
1776 if (EventLog.SourceExists ("monotempsource", "."))
1777 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1778
1779 if (EventLog.SourceExists ("monoothersource", "."))
1780 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
1781
1782 bool monologtempExists = EventLog.Exists ("monologtemp", ".");
1783 try {
1784 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1785 EventLog.CreateEventSource ("monoothersource", "monologtemp", ".");
1786
1787 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#A1");
1788 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A2");
1789 EventLog.DeleteEventSource ("monotempsource");
1790 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#A3");
1791 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A4");
1792 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#A5");
1793 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#A6");
1794 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#A7");
1795
1796 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1797
1798 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#B1");
1799 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#A2");
1800 EventLog.DeleteEventSource ("MonoTempSource");
1801 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#B3");
1802 Assert.IsTrue (EventLog.SourceExists ("monoothersource", "."), "#B4");
1803 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B5");
1804 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#B6");
1805 Assert.IsFalse (EventLog.Exists ("monoothersource", "."), "#B7");
1806 } finally {
1807 if (!monologtempExists) {
1808 EventLog.Delete ("monologtemp");
1809 }
1810 }
1811 }
1812
1813 [Test]
1814 public void DeleteEventSource2_MachineName_Empty ()
1815 {
1816 try {
1817 EventLog.DeleteEventSource ("monotempsource", string.Empty);
1818 Assert.Fail ("#A1");
1819 } catch (ArgumentException ex) {
1820 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1821 Assert.IsNotNull (ex.Message, "#A3");
1822 // Invalid value '' for parameter 'machineName'
1823 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
1824 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
1825 Assert.IsNull (ex.InnerException, "#A6");
1826 Assert.IsNull (ex.ParamName, "#A7");
1827 }
1828
1829 try {
1830 EventLog.DeleteEventSource ("monotempsource", " \t\n");
1831 Assert.Fail ("#B1");
1832 } catch (ArgumentException ex) {
1833 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1834 Assert.IsNotNull (ex.Message, "#B3");
1835 // Invalid value ' \t\n' for parameter 'machineName'
1836 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
1837 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#B5");
1838 Assert.IsNull (ex.InnerException, "#B6");
1839 Assert.IsNull (ex.ParamName, "#B7");
1840 }
1841 }
1842
1843 [Test]
1844 public void DeleteEventSource2_MachineName_Null ()
1845 {
1846 try {
1847 EventLog.DeleteEventSource ("monotempsource", null);
1848 Assert.Fail ("#A1");
1849 } catch (ArgumentException ex) {
1850 // Invalid value '' for parameter 'machineName'
1851 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1852 Assert.IsNotNull (ex.Message, "#A3");
1853 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
1854 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
1855 Assert.IsNull (ex.InnerException, "#A6");
1856 Assert.IsNull (ex.ParamName, "#A7");
1857 }
1858 }
1859
1860 [Test]
1861 public void DeleteEventSource2_Source_DoesNotExist ()
1862 {
1863 if (EventLogImplType == NULL_IMPL)
1864 // test cannot pass with NULL implementation
1865 Assert.Ignore ("No EventLogImplType.");
1866
1867 if (EventLog.SourceExists ("monotempsource", "."))
1868 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1869
1870 try {
1871 EventLog.DeleteEventSource ("monotempsource", ".");
1872 Assert.Fail ("#1");
1873 } catch (ArgumentException ex) {
1874 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1875 Assert.IsNotNull (ex.Message, "#3");
1876 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#4");
1877 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
1878 Assert.IsNull (ex.InnerException, "#6");
1879 Assert.IsNull (ex.ParamName, "#7");
1880 } catch (SecurityException) {
1881 if (IsAzurePipelines) Assert.Ignore ("Azure Pipelines fails with: Requested registry access is not allowed.");
1882 throw;
1883 }
1884 }
1885
1886 [Test]
1887 [ExpectedException (typeof (ArgumentException))] // The source '' is not registered on machine '.', ...
1888 public void DeleteEventSource2_Source_Empty ()
1889 {
1890 if (EventLogImplType == NULL_IMPL)
1891 // allow test to pass with NULL implementation
1892 throw new ArgumentException ();
1893
1894 EventLog.DeleteEventSource (string.Empty, ".");
1895 }
1896
1897 [Test]
1898 [ExpectedException (typeof (ArgumentException))] // The source '' is not registered on machine '.', ...
1899 public void DeleteEventSource2_Source_Null ()
1900 {
1901 if (EventLogImplType == NULL_IMPL)
1902 // allow test to pass with NULL implementation
1903 throw new ArgumentException ();
1904
1905 EventLog.DeleteEventSource (null, ".");
1906 }
1907
1908 [Test]
1909 public void Entries ()
1910 {
1911 EventLogEntry entry = null;
1912 object current = null;
1913
1914 if (EventLogImplType == NULL_IMPL)
1915 // test cannot pass with NULL implementation
1916 Assert.Ignore ("No EventLogImplType.");
1917
1918 if (EventLog.SourceExists ("monotempsource", "."))
1919 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
1920
1921 if (EventLog.Exists ("monologtemp", "."))
1922 Assert.Ignore ("Event log 'monologtemp' should not exist.");
1923
1924 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
1925 try {
1926 using (EventLog eventLog = new EventLog ("monologtemp", ".", string.Empty)) {
1927 Assert.IsNotNull (eventLog.Entries, "#A1");
1928 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
1929
1930 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
1931 Assert.IsNotNull (enumerator, "#B");
1932
1933 try {
1934 current = enumerator.Current;
1935 Assert.Fail ("#C1: " + current);
1936 } catch (InvalidOperationException ex) {
1937 // No current EventLog entry available, cursor is located
1938 // before the first or after the last element of the
1939 // enumeration
1940 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1941 Assert.IsNotNull (ex.Message, "#C3");
1942 Assert.IsNull (ex.InnerException, "#C4");
1943 }
1944
1945 Assert.IsFalse (enumerator.MoveNext (), "#D");
1946
1947 try {
1948 current = enumerator.Current;
1949 Assert.Fail ("#E1: " + current);
1950 } catch (InvalidOperationException ex) {
1951 // No current EventLog entry available, cursor is located
1952 // before the first or after the last element of the
1953 // enumeration
1954 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
1955 Assert.IsNotNull (ex.Message, "#E3");
1956 Assert.IsNull (ex.InnerException, "#E4");
1957 }
1958
1959 EventLogEntry [] entries = new EventLogEntry [0];
1960 eventLog.Entries.CopyTo (entries, 0);
1961
1962 EventLog.WriteEntry ("monotempsource", "Entries1");
1963
1964 try {
1965 current = enumerator.Current;
1966 Assert.Fail ("#G1: " + current);
1967 } catch (InvalidOperationException ex) {
1968 // No current EventLog entry available, cursor is located
1969 // before the first or after the last element of the
1970 // enumeration
1971 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
1972 Assert.IsNotNull (ex.Message, "#G3");
1973 Assert.IsNull (ex.InnerException, "#G4");
1974 }
1975
1976 Assert.IsFalse (enumerator.MoveNext (), "#H1");
1977 Assert.AreEqual (1, eventLog.Entries.Count, "#H2");
1978 enumerator.Reset ();
1979
1980 entries = new EventLogEntry [0];
1981 try {
1982 eventLog.Entries.CopyTo (entries, 0);
1983 Assert.Fail ("#I1");
1984 } catch (ArgumentException ex) {
1985 // Destination array was not long enough. Check destIndex
1986 // and length, and the array's lower bounds
1987 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
1988 Assert.IsNotNull (ex.Message, "#I3");
1989 Assert.IsNull (ex.InnerException, "#I4");
1990 Assert.AreEqual ("destinationArray", ex.ParamName, "#I5");
1991 }
1992
1993 entries = new EventLogEntry [1];
1994 eventLog.Entries.CopyTo (entries, 0);
1995
1996 entry = entries [0];
1997 Assert.IsNotNull (entry, "#J1");
1998 Assert.IsNotNull (entry.Source, "#J2");
1999 Assert.AreEqual ("monotempsource", entry.Source, "#J3");
2000 Assert.IsNotNull (entry.ReplacementStrings, "#J4");
2001 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#J5");
2002 Assert.AreEqual ("Entries1", entry.ReplacementStrings [0], "#J6");
2003
2004 Assert.IsTrue (enumerator.MoveNext (), "#K1");
2005 Assert.IsNotNull (enumerator.Current, "#K2");
2006 Assert.IsFalse (enumerator.MoveNext (), "#K3");
2007 enumerator.Reset ();
2008 Assert.IsTrue (enumerator.MoveNext (), "#K4");
2009 Assert.IsNotNull (enumerator.Current, "#K5");
2010 Assert.IsFalse (enumerator.MoveNext (), "#K6");
2011
2012 EventLog.WriteEntry ("monotempsource", "Entries2");
2013 EventLog.WriteEntry ("monotempsource", "Entries3");
2014
2015 Assert.IsTrue (enumerator.MoveNext (), "#L");
2016
2017 entry = (EventLogEntry) enumerator.Current;
2018 Assert.IsNotNull (entry, "#M1");
2019 Assert.IsNotNull (entry.Source, "#M2");
2020 Assert.AreEqual ("monotempsource", entry.Source, "#M3");
2021 Assert.IsNotNull (entry.ReplacementStrings, "#M4");
2022 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#M5");
2023 Assert.AreEqual ("Entries3", entry.ReplacementStrings [0], "#M6");
2024
2025 enumerator.Reset ();
2026 Assert.IsNotNull (enumerator.Current, "#N1");
2027 Assert.IsTrue (enumerator.MoveNext (), "#N2");
2028 Assert.IsNotNull (enumerator.Current, "#N3");
2029 Assert.IsTrue (enumerator.MoveNext (), "#N4");
2030 Assert.IsNotNull (enumerator.Current, "#N5");
2031 Assert.IsTrue (enumerator.MoveNext (), "#N6");
2032 Assert.IsNotNull (enumerator.Current, "#N7");
2033 Assert.IsFalse (enumerator.MoveNext (), "#N8");
2034 enumerator.Reset ();
2035
2036 try {
2037 current = enumerator.Current;
2038 Assert.Fail ("#O1: " + current);
2039 } catch (InvalidOperationException ex) {
2040 // No current EventLog entry available, cursor is located
2041 // before the first or after the last element of the
2042 // enumeration
2043 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#O2");
2044 Assert.IsNotNull (ex.Message, "#O3");
2045 Assert.IsNull (ex.InnerException, "#O4");
2046 }
2047
2048 Assert.IsTrue (enumerator.MoveNext (), "#P1");
2049 Assert.IsNotNull (enumerator.Current, "#P2");
2050 eventLog.Clear ();
2051 Assert.IsNotNull (enumerator.Current, "#P3");
2052 Assert.IsFalse (enumerator.MoveNext (), "#P4");
2053 Assert.AreEqual (0, eventLog.Entries.Count, "#P5");
2054
2055 try {
2056 current = enumerator.Current;
2057 Assert.Fail ("#Q1: " + current);
2058 } catch (InvalidOperationException ex) {
2059 // No current EventLog entry available, cursor is located
2060 // before the first or after the last element of the
2061 // enumeration
2062 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#Q2");
2063 Assert.IsNotNull (ex.Message, "#Q3");
2064 Assert.IsNull (ex.InnerException, "#Q4");
2065 }
2066
2067 Assert.IsFalse (enumerator.MoveNext (), "#R1");
2068 enumerator.Reset ();
2069 Assert.IsFalse (enumerator.MoveNext (), "#R2");
2070 }
2071 } finally {
2072 if (EventLog.Exists ("monologtemp"))
2073 EventLog.Delete ("monologtemp");
2074 }
2075 }
2076
2077 [Test]
2078 public void Entries_Log_DoesNotExist ()
2079 {
2080 if (EventLogImplType == NULL_IMPL)
2081 // test cannot pass with NULL implementation
2082 Assert.Ignore ("No EventLogImplType.");
2083
2084 if (EventLog.Exists ("monologtemp", "."))
2085 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2086
2087 using (EventLog eventLog = new EventLog ("monologtemp", ".")) {
2088 Assert.IsNotNull (eventLog.Entries, "#A1");
2089
2090 try {
2091 Assert.Fail ("#B1: " + eventLog.Entries.Count);
2092 } catch (InvalidOperationException ex) {
2093 // The event log 'monologtemp' on computer '.' does not exist
2094 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
2095 Assert.IsNotNull (ex.Message, "#B3");
2096 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#B4");
2097 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
2098 Assert.IsNull (ex.InnerException, "#B6");
2099 }
2100 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#B7");
2101
2102 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2103 Assert.IsNotNull (enumerator, "#C");
2104
2105 try {
2106 object current = enumerator.Current;
2107 Assert.Fail ("#D1: " + current);
2108 } catch (InvalidOperationException ex) {
2109 // No current EventLog entry available, cursor is located
2110 // before the first or after the last element of the
2111 // enumeration.
2112 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
2113 Assert.IsNotNull (ex.Message, "#D3");
2114 Assert.IsNull (ex.InnerException, "#D4");
2115 }
2116
2117 try {
2118 enumerator.MoveNext ();
2119 Assert.Fail ("#E1");
2120 } catch (InvalidOperationException ex) {
2121 // The event log 'monologtemp' on computer '.' does not exist
2122 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
2123 Assert.IsNotNull (ex.Message, "#E3");
2124 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#E4");
2125 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#E5");
2126 Assert.IsNull (ex.InnerException, "#E6");
2127 }
2128
2129 try {
2130 EventLogEntry [] entries = new EventLogEntry [0];
2131 eventLog.Entries.CopyTo (entries, 0);
2132 Assert.Fail ("#F1");
2133 } catch (InvalidOperationException ex) {
2134 // The event log 'monologtemp' on computer '.' does not exist
2135 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
2136 Assert.IsNotNull (ex.Message, "#F3");
2137 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#F4");
2138 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#F5");
2139 Assert.IsNull (ex.InnerException, "#F6");
2140 }
2141
2142 enumerator.Reset ();
2143 }
2144 }
2145
2146 [Test]
2147 public void Entries_Log_Empty ()
2148 {
2149 if (EventLogImplType == NULL_IMPL)
2150 // test cannot pass with NULL implementation
2151 Assert.Ignore ("No EventLogImplType.");
2152
2153 if (EventLog.SourceExists ("monotempsource", "."))
2154 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2155
2156 if (EventLog.SourceExists ("monoothersource", "."))
2157 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
2158
2159 if (EventLog.Exists ("monologtemp", "."))
2160 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2161
2162 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
2163 try {
2164 using (EventLog eventLog = new EventLog (string.Empty, ".")) {
2165 Assert.IsNotNull (eventLog.Entries, "#A1");
2166
2167 try {
2168 Assert.Fail ("#B1: " + eventLog.Entries.Count);
2169 } catch (ArgumentException ex) {
2170 // Log property value has not been specified
2171 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
2172 Assert.IsNotNull (ex.Message, "#B3");
2173 Assert.IsNull (ex.InnerException, "#B4");
2174 Assert.IsNull (ex.ParamName, "#B5");
2175 }
2176
2177 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2178 Assert.IsNotNull (enumerator, "#C");
2179
2180 try {
2181 object current = enumerator.Current;
2182 Assert.Fail ("#D1: " + current);
2183 } catch (InvalidOperationException ex) {
2184 // No current EventLog entry available, cursor is located
2185 // before the first or after the last element of the
2186 // enumeration
2187 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
2188 Assert.IsNotNull (ex.Message, "#D3");
2189 Assert.IsNull (ex.InnerException, "#D4");
2190 }
2191
2192 try {
2193 enumerator.MoveNext ();
2194 Assert.Fail ("#E1");
2195 } catch (ArgumentException ex) {
2196 // Log property value has not been specified
2197 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
2198 Assert.IsNotNull (ex.Message, "#E3");
2199 Assert.IsNull (ex.InnerException, "#E4");
2200 Assert.IsNull (ex.ParamName, "#E5");
2201 }
2202
2203 try {
2204 EventLogEntry [] entries = new EventLogEntry [0];
2205 eventLog.Entries.CopyTo (entries, 0);
2206 Assert.Fail ("#F1");
2207 } catch (ArgumentException ex) {
2208 // Log property value has not been specified
2209 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
2210 Assert.IsNotNull (ex.Message, "#F3");
2211 Assert.IsNull (ex.InnerException, "#F4");
2212 Assert.IsNull (ex.ParamName, "#F5");
2213 }
2214
2215 enumerator.Reset ();
2216
2217 // set non-existing source
2218 eventLog.Source = "monoothersource";
2219
2220 try {
2221 Assert.Fail ("#G1: " + eventLog.Entries.Count);
2222 } catch (ArgumentException ex) {
2223 // Log property value has not been specified
2224 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#G2");
2225 Assert.IsNotNull (ex.Message, "#G3");
2226 Assert.IsNull (ex.InnerException, "#G4");
2227 Assert.IsNull (ex.ParamName, "#G5");
2228 }
2229
2230 enumerator = eventLog.Entries.GetEnumerator ();
2231 Assert.IsNotNull (enumerator, "#H");
2232
2233 try {
2234 object current = enumerator.Current;
2235 Assert.Fail ("#I1: " + current);
2236 } catch (InvalidOperationException ex) {
2237 // No current EventLog entry available, cursor is located
2238 // before the first or after the last element of the
2239 // enumeration
2240 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#I2");
2241 Assert.IsNotNull (ex.Message, "#I3");
2242 Assert.IsNull (ex.InnerException, "#I4");
2243 }
2244
2245 try {
2246 enumerator.MoveNext ();
2247 Assert.Fail ("#J1");
2248 } catch (ArgumentException ex) {
2249 // Log property value has not been specified
2250 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#J2");
2251 Assert.IsNotNull (ex.Message, "#J3");
2252 Assert.IsNull (ex.InnerException, "#J4");
2253 Assert.IsNull (ex.ParamName, "#J5");
2254 }
2255
2256 try {
2257 EventLogEntry [] entries = new EventLogEntry [0];
2258 eventLog.Entries.CopyTo (entries, 0);
2259 Assert.Fail ("#K1");
2260 } catch (ArgumentException ex) {
2261 // Log property value has not been specified
2262 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#K2");
2263 Assert.IsNotNull (ex.Message, "#K3");
2264 Assert.IsNull (ex.InnerException, "#K4");
2265 Assert.IsNull (ex.ParamName, "#K5");
2266 }
2267
2268 enumerator.Reset ();
2269
2270 // set existing source
2271 eventLog.Source = "monotempsource";
2272
2273 Assert.AreEqual (0, eventLog.Entries.Count, "#L1");
2274 enumerator = eventLog.Entries.GetEnumerator ();
2275 Assert.IsNotNull (enumerator, "#L2");
2276
2277 try {
2278 object current = enumerator.Current;
2279 Assert.Fail ("#M1: " + current);
2280 } catch (InvalidOperationException ex) {
2281 // No current EventLog entry available, cursor is located
2282 // before the first or after the last element of the
2283 // enumeration
2284 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#M2");
2285 Assert.IsNotNull (ex.Message, "#M3");
2286 Assert.IsNull (ex.InnerException, "#M4");
2287 }
2288
2289 Assert.IsFalse (enumerator.MoveNext ());
2290
2291 try {
2292 object current = enumerator.Current;
2293 Assert.Fail ("#N1: " + current);
2294 } catch (InvalidOperationException ex) {
2295 // No current EventLog entry available, cursor is located
2296 // before the first or after the last element of the
2297 // enumeration
2298 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
2299 Assert.IsNotNull (ex.Message, "#N3");
2300 Assert.IsNull (ex.InnerException, "#N4");
2301 }
2302
2303 enumerator.Reset ();
2304 }
2305 } finally {
2306 if (EventLog.Exists ("monologtemp"))
2307 EventLog.Delete ("monologtemp");
2308 }
2309 }
2310
2311 [Test]
2312 public void Entries_Source_DoesNotExist ()
2313 {
2314 if (EventLogImplType == NULL_IMPL)
2315 // test cannot pass with NULL implementation
2316 Assert.Ignore ("No EventLogImplType.");
2317
2318 if (EventLog.SourceExists ("monotempsource", "."))
2319 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2320
2321 if (EventLog.SourceExists ("monoothersource", "."))
2322 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
2323
2324 if (EventLog.Exists ("monologtemp", "."))
2325 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2326
2327 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
2328 try {
2329 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monoothersource")) {
2330 Assert.IsNotNull (eventLog.Entries, "#A1");
2331 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
2332 EventLog.WriteEntry ("monotempsource", "Entries_Source_DoesNotExist1");
2333 Assert.AreEqual (1, eventLog.Entries.Count, "#A3");
2334
2335 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2336 Assert.IsNotNull (enumerator, "#B");
2337
2338 try {
2339 object current = enumerator.Current;
2340 Assert.Fail ("#C1: " + current);
2341 } catch (InvalidOperationException ex) {
2342 // No current EventLog entry available, cursor is located
2343 // before the first or after the last element of the
2344 // enumeration
2345 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2346 Assert.IsNotNull (ex.Message, "#C3");
2347 Assert.IsNull (ex.InnerException, "#C4");
2348 }
2349
2350 Assert.IsTrue (enumerator.MoveNext (), "#D1");
2351 Assert.IsNotNull (enumerator.Current, "#D2");
2352 Assert.IsFalse (enumerator.MoveNext (), "#D3");
2353
2354 EventLogEntry [] entries = new EventLogEntry [1];
2355 eventLog.Entries.CopyTo (entries, 0);
2356
2357 EventLogEntry entry = entries [0];
2358 Assert.IsNotNull (entry, "#E1");
2359 Assert.IsNotNull (entry.Source, "#E2");
2360 Assert.AreEqual ("monotempsource", entry.Source, "#E3");
2361 Assert.IsNotNull (entry.ReplacementStrings, "#E4");
2362 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#E5");
2363 Assert.AreEqual ("Entries_Source_DoesNotExist1", entry.ReplacementStrings [0], "#E6");
2364
2365 try {
2366 object current = enumerator.Current;
2367 Assert.Fail ("#E1: " + current);
2368 } catch (InvalidOperationException ex) {
2369 // No current EventLog entry available, cursor is located
2370 // before the first or after the last element of the
2371 // enumeration
2372 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
2373 Assert.IsNotNull (ex.Message, "#E3");
2374 Assert.IsNull (ex.InnerException, "#E4");
2375 }
2376
2377 try {
2378 object current = enumerator.Current;
2379 Assert.Fail ("#F1: " + current);
2380 } catch (InvalidOperationException ex) {
2381 // No current EventLog entry available, cursor is located
2382 // before the first or after the last element of the
2383 // enumeration
2384 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
2385 Assert.IsNotNull (ex.Message, "#F3");
2386 Assert.IsNull (ex.InnerException, "#F4");
2387 }
2388
2389 EventLog.WriteEntry ("monotempsource", "Entries_Source_DoesNotExist2");
2390
2391 try {
2392 object current = enumerator.Current;
2393 Assert.Fail ("#G1: " + current);
2394 } catch (InvalidOperationException ex) {
2395 // No current EventLog entry available, cursor is located
2396 // before the first or after the last element of the
2397 // enumeration
2398 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
2399 Assert.IsNotNull (ex.Message, "#G3");
2400 Assert.IsNull (ex.InnerException, "#G4");
2401 }
2402
2403 Assert.IsFalse (enumerator.MoveNext (), "#H1");
2404 Assert.AreEqual (2, eventLog.Entries.Count, "#H2");
2405
2406 entries = new EventLogEntry [1];
2407 try {
2408 eventLog.Entries.CopyTo (entries, 0);
2409 Assert.Fail ("#I1");
2410 } catch (ArgumentException ex) {
2411 // Destination array was not long enough. Check destIndex
2412 // and length, and the array's lower bounds
2413 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
2414 Assert.IsNotNull (ex.Message, "#I3");
2415 Assert.IsNull (ex.InnerException, "#I4");
2416 Assert.AreEqual ("destinationArray", ex.ParamName, "#I5");
2417 }
2418
2419 entries = new EventLogEntry [2];
2420 eventLog.Entries.CopyTo (entries, 0);
2421
2422 entry = entries [0];
2423 Assert.IsNotNull (entry, "#J1");
2424 Assert.IsNotNull (entry.Source, "#J2");
2425 Assert.AreEqual ("monotempsource", entry.Source, "#J3");
2426 Assert.IsNotNull (entry.ReplacementStrings, "#J4");
2427 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#J5");
2428 Assert.AreEqual ("Entries_Source_DoesNotExist1", entry.ReplacementStrings [0], "#J6");
2429
2430 entry = entries [1];
2431 Assert.IsNotNull (entry, "#K1");
2432 Assert.IsNotNull (entry.Source, "#K2");
2433 Assert.AreEqual ("monotempsource", entry.Source, "#K3");
2434 Assert.IsNotNull (entry.ReplacementStrings, "#K4");
2435 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#K5");
2436 Assert.AreEqual ("Entries_Source_DoesNotExist2", entry.ReplacementStrings [0], "#K6");
2437
2438 Assert.IsFalse (enumerator.MoveNext (), "#L1");
2439 enumerator.Reset ();
2440 Assert.IsTrue (enumerator.MoveNext (), "#L2");
2441 Assert.IsNotNull (enumerator.Current, "#L3");
2442 Assert.IsTrue (enumerator.MoveNext (), "#L4");
2443 Assert.IsNotNull (enumerator.Current, "#L5");
2444
2445 Assert.IsFalse (enumerator.MoveNext (), "#M1");
2446 enumerator.Reset ();
2447 Assert.IsTrue (enumerator.MoveNext (), "#M2");
2448 eventLog.Clear ();
2449 Assert.IsNotNull (enumerator.Current, "#M3");
2450 Assert.IsFalse (enumerator.MoveNext (), "#M4");
2451
2452 try {
2453 object current = enumerator.Current;
2454 Assert.Fail ("#N1: " + current);
2455 } catch (InvalidOperationException ex) {
2456 // No current EventLog entry available, cursor is located
2457 // before the first or after the last element of the
2458 // enumeration
2459 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
2460 Assert.IsNotNull (ex.Message, "#N3");
2461 Assert.IsNull (ex.InnerException, "#N4");
2462 }
2463
2464 Assert.IsFalse (enumerator.MoveNext (), "#O1");
2465 enumerator.Reset ();
2466 Assert.IsFalse (enumerator.MoveNext (), "#O2");
2467 }
2468 } finally {
2469 if (EventLog.Exists ("monologtemp"))
2470 EventLog.Delete ("monologtemp");
2471 }
2472 }
2473
2474 [Test]
2475 public void Entries_Source_Empty ()
2476 {
2477 if (EventLogImplType == NULL_IMPL)
2478 // test cannot pass with NULL implementation
2479 Assert.Ignore ("No EventLogImplType.");
2480
2481 if (EventLog.SourceExists ("monotempsource", "."))
2482 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2483
2484 if (EventLog.Exists ("monologtemp", "."))
2485 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2486
2487 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
2488 try {
2489 using (EventLog eventLog = new EventLog ("monologtemp", ".", string.Empty)) {
2490 Assert.IsNotNull (eventLog.Entries, "#A1");
2491 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
2492 EventLog.WriteEntry ("monotempsource", "Entries_Source_Empty1");
2493 Assert.AreEqual (1, eventLog.Entries.Count, "#A3");
2494
2495 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2496 Assert.IsNotNull (enumerator, "#B");
2497
2498 try {
2499 object current = enumerator.Current;
2500 Assert.Fail ("#C1: " + current);
2501 } catch (InvalidOperationException ex) {
2502 // No current EventLog entry available, cursor is located
2503 // before the first or after the last element of the
2504 // enumeration
2505 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2506 Assert.IsNotNull (ex.Message, "#C3");
2507 Assert.IsNull (ex.InnerException, "#C4");
2508 }
2509
2510 Assert.IsTrue (enumerator.MoveNext (), "#D1");
2511 Assert.IsNotNull (enumerator.Current, "#D2");
2512 Assert.IsFalse (enumerator.MoveNext (), "#D3");
2513
2514 EventLogEntry [] entries = new EventLogEntry [1];
2515 eventLog.Entries.CopyTo (entries, 0);
2516
2517 EventLogEntry entry = entries [0];
2518 Assert.IsNotNull (entry, "#E1");
2519 Assert.IsNotNull (entry.Source, "#E2");
2520 Assert.AreEqual ("monotempsource", entry.Source, "#E3");
2521 Assert.IsNotNull (entry.ReplacementStrings, "#E4");
2522 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#E5");
2523 Assert.AreEqual ("Entries_Source_Empty1", entry.ReplacementStrings [0], "#E6");
2524
2525 try {
2526 object current = enumerator.Current;
2527 Assert.Fail ("#E1: " + current);
2528 } catch (InvalidOperationException ex) {
2529 // No current EventLog entry available, cursor is located
2530 // before the first or after the last element of the
2531 // enumeration
2532 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
2533 Assert.IsNotNull (ex.Message, "#E3");
2534 Assert.IsNull (ex.InnerException, "#E4");
2535 }
2536
2537 EventLog.WriteEntry ("monotempsource", "Entries_Source_Empty2");
2538
2539 try {
2540 object current = enumerator.Current;
2541 Assert.Fail ("#G1: " + current);
2542 } catch (InvalidOperationException ex) {
2543 // No current EventLog entry available, cursor is located
2544 // before the first or after the last element of the
2545 // enumeration
2546 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
2547 Assert.IsNotNull (ex.Message, "#G3");
2548 Assert.IsNull (ex.InnerException, "#G4");
2549 }
2550
2551 Assert.IsFalse (enumerator.MoveNext (), "#H1");
2552 Assert.AreEqual (2, eventLog.Entries.Count, "#H2");
2553
2554 entries = new EventLogEntry [1];
2555 try {
2556 eventLog.Entries.CopyTo (entries, 0);
2557 Assert.Fail ("#I1");
2558 } catch (ArgumentException ex) {
2559 // Destination array was not long enough. Check destIndex
2560 // and length, and the array's lower bounds
2561 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
2562 Assert.IsNotNull (ex.Message, "#I3");
2563 Assert.IsNull (ex.InnerException, "#I4");
2564 Assert.AreEqual ("destinationArray", ex.ParamName, "#I5");
2565 }
2566
2567 entries = new EventLogEntry [2];
2568 eventLog.Entries.CopyTo (entries, 0);
2569
2570 entry = entries [0];
2571 Assert.IsNotNull (entry, "#J1");
2572 Assert.IsNotNull (entry.Source, "#J2");
2573 Assert.AreEqual ("monotempsource", entry.Source, "#J3");
2574 Assert.IsNotNull (entry.ReplacementStrings, "#J4");
2575 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#J5");
2576 Assert.AreEqual ("Entries_Source_Empty1", entry.ReplacementStrings [0], "#J6");
2577
2578 entry = entries [1];
2579 Assert.IsNotNull (entry, "#K1");
2580 Assert.IsNotNull (entry.Source, "#K2");
2581 Assert.AreEqual ("monotempsource", entry.Source, "#K3");
2582 Assert.IsNotNull (entry.ReplacementStrings, "#K4");
2583 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#K5");
2584 Assert.AreEqual ("Entries_Source_Empty2", entry.ReplacementStrings [0], "#K6");
2585
2586 Assert.IsFalse (enumerator.MoveNext (), "#L1");
2587 enumerator.Reset ();
2588 Assert.IsTrue (enumerator.MoveNext (), "#L2");
2589 Assert.IsNotNull (enumerator.Current, "#L3");
2590 Assert.IsTrue (enumerator.MoveNext (), "#L4");
2591 Assert.IsNotNull (enumerator.Current, "#L5");
2592
2593 Assert.IsFalse (enumerator.MoveNext (), "#M1");
2594 enumerator.Reset ();
2595 Assert.IsTrue (enumerator.MoveNext (), "#M2");
2596 eventLog.Clear ();
2597 Assert.IsNotNull (enumerator.Current, "#M3");
2598 Assert.IsFalse (enumerator.MoveNext (), "#M4");
2599
2600 try {
2601 object current = enumerator.Current;
2602 Assert.Fail ("#N1: " + current);
2603 } catch (InvalidOperationException ex) {
2604 // No current EventLog entry available, cursor is located
2605 // before the first or after the last element of the
2606 // enumeration
2607 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
2608 Assert.IsNotNull (ex.Message, "#N3");
2609 Assert.IsNull (ex.InnerException, "#N4");
2610 }
2611
2612 Assert.IsFalse (enumerator.MoveNext (), "#O1");
2613 enumerator.Reset ();
2614 Assert.IsFalse (enumerator.MoveNext (), "#O2");
2615 }
2616 } finally {
2617 if (EventLog.Exists ("monologtemp"))
2618 EventLog.Delete ("monologtemp");
2619 }
2620 }
2621
2622 [Test]
2623 public void Entries_Source_Null ()
2624 {
2625 if (EventLogImplType == NULL_IMPL)
2626 // test cannot pass with NULL implementation
2627 Assert.Ignore ("No EventLogImplType.");
2628
2629 if (EventLog.SourceExists ("monotempsource", "."))
2630 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2631
2632 if (EventLog.Exists ("monologtemp", "."))
2633 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2634
2635 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
2636 try {
2637 using (EventLog eventLog = new EventLog ("monologtemp", ".", null)) {
2638 Assert.IsNotNull (eventLog.Entries, "#A1");
2639 Assert.AreEqual (0, eventLog.Entries.Count, "#A2");
2640 EventLog.WriteEntry ("monotempsource", "Entries_Source_Null1");
2641 Assert.AreEqual (1, eventLog.Entries.Count, "#A3");
2642
2643 IEnumerator enumerator = eventLog.Entries.GetEnumerator ();
2644 Assert.IsNotNull (enumerator, "#B");
2645
2646 try {
2647 object current = enumerator.Current;
2648 Assert.Fail ("#C1: " + current);
2649 } catch (InvalidOperationException ex) {
2650 // No current EventLog entry available, cursor is located
2651 // before the first or after the last element of the
2652 // enumeration
2653 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2654 Assert.IsNotNull (ex.Message, "#C3");
2655 Assert.IsNull (ex.InnerException, "#C4");
2656 }
2657
2658 Assert.IsTrue (enumerator.MoveNext (), "#D1");
2659 Assert.IsNotNull (enumerator.Current, "#D2");
2660 Assert.IsFalse (enumerator.MoveNext (), "#D3");
2661
2662 EventLogEntry [] entries = new EventLogEntry [1];
2663 eventLog.Entries.CopyTo (entries, 0);
2664
2665 EventLogEntry entry = entries [0];
2666 Assert.IsNotNull (entry, "#E1");
2667 Assert.IsNotNull (entry.Source, "#E2");
2668 Assert.AreEqual ("monotempsource", entry.Source, "#E3");
2669 Assert.IsNotNull (entry.ReplacementStrings, "#E4");
2670 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#E5");
2671 Assert.AreEqual ("Entries_Source_Null1", entry.ReplacementStrings [0], "#E6");
2672
2673 try {
2674 object current = enumerator.Current;
2675 Assert.Fail ("#E1: " + current);
2676 } catch (InvalidOperationException ex) {
2677 // No current EventLog entry available, cursor is located
2678 // before the first or after the last element of the
2679 // enumeration
2680 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
2681 Assert.IsNotNull (ex.Message, "#E3");
2682 Assert.IsNull (ex.InnerException, "#E4");
2683 }
2684
2685 try {
2686 object current = enumerator.Current;
2687 Assert.Fail ("#F1: " + current);
2688 } catch (InvalidOperationException ex) {
2689 // No current EventLog entry available, cursor is located
2690 // before the first or after the last element of the
2691 // enumeration
2692 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
2693 Assert.IsNotNull (ex.Message, "#F3");
2694 Assert.IsNull (ex.InnerException, "#F4");
2695 }
2696
2697 EventLog.WriteEntry ("monotempsource", "Entries_Source_Null2");
2698
2699 try {
2700 object current = enumerator.Current;
2701 Assert.Fail ("#G1: " + current);
2702 } catch (InvalidOperationException ex) {
2703 // No current EventLog entry available, cursor is located
2704 // before the first or after the last element of the
2705 // enumeration
2706 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
2707 Assert.IsNotNull (ex.Message, "#G3");
2708 Assert.IsNull (ex.InnerException, "#G4");
2709 }
2710
2711 Assert.IsFalse (enumerator.MoveNext (), "#H1");
2712 Assert.AreEqual (2, eventLog.Entries.Count, "#H2");
2713
2714 entries = new EventLogEntry [1];
2715 try {
2716 eventLog.Entries.CopyTo (entries, 0);
2717 Assert.Fail ("#I1");
2718 } catch (ArgumentException ex) {
2719 // Destination array was not long enough. Check destIndex
2720 // and length, and the array's lower bounds
2721 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
2722 Assert.IsNotNull (ex.Message, "#I3");
2723 Assert.IsNull (ex.InnerException, "#I4");
2724 Assert.AreEqual ("destinationArray", ex.ParamName, "#I5");
2725 }
2726
2727 entries = new EventLogEntry [2];
2728 eventLog.Entries.CopyTo (entries, 0);
2729
2730 entry = entries [0];
2731 Assert.IsNotNull (entry, "#J1");
2732 Assert.IsNotNull (entry.Source, "#J2");
2733 Assert.AreEqual ("monotempsource", entry.Source, "#J3");
2734 Assert.IsNotNull (entry.ReplacementStrings, "#J4");
2735 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#J5");
2736 Assert.AreEqual ("Entries_Source_Null1", entry.ReplacementStrings [0], "#J6");
2737
2738 entry = entries [1];
2739 Assert.IsNotNull (entry, "#K1");
2740 Assert.IsNotNull (entry.Source, "#K2");
2741 Assert.AreEqual ("monotempsource", entry.Source, "#K3");
2742 Assert.IsNotNull (entry.ReplacementStrings, "#K4");
2743 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#K5");
2744 Assert.AreEqual ("Entries_Source_Null2", entry.ReplacementStrings [0], "#K6");
2745
2746 Assert.IsFalse (enumerator.MoveNext (), "#L1");
2747 enumerator.Reset ();
2748 Assert.IsTrue (enumerator.MoveNext (), "#L2");
2749 Assert.IsNotNull (enumerator.Current, "#L3");
2750 Assert.IsTrue (enumerator.MoveNext (), "#L4");
2751 Assert.IsNotNull (enumerator.Current, "#L5");
2752
2753 Assert.IsFalse (enumerator.MoveNext (), "#M1");
2754 enumerator.Reset ();
2755 Assert.IsTrue (enumerator.MoveNext (), "#M2");
2756 eventLog.Clear ();
2757 Assert.IsNotNull (enumerator.Current, "#M3");
2758 Assert.IsFalse (enumerator.MoveNext (), "#M4");
2759
2760 try {
2761 object current = enumerator.Current;
2762 Assert.Fail ("#N1: " + current);
2763 } catch (InvalidOperationException ex) {
2764 // No current EventLog entry available, cursor is located
2765 // before the first or after the last element of the
2766 // enumeration
2767 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
2768 Assert.IsNotNull (ex.Message, "#N3");
2769 Assert.IsNull (ex.InnerException, "#N4");
2770 }
2771
2772 Assert.IsFalse (enumerator.MoveNext (), "#O1");
2773 enumerator.Reset ();
2774 Assert.IsFalse (enumerator.MoveNext (), "#O2");
2775 }
2776 } finally {
2777 if (EventLog.Exists ("monologtemp"))
2778 EventLog.Delete ("monologtemp");
2779 }
2780 }
2781
2782 [Test]
2783 public void Exists1_Win32 ()
2784 {
2785 if (EventLogImplType != WIN32_IMPL)
2786 // test can only pass with win32 implementation
2787 Assert.Ignore ("Wrong EventLogImplType.");
2788
2789 using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
2790 if (logKey != null)
2791 Assert.Ignore ("Event log 'monotempsource' should not exist.");
2792 }
2793
2794 using (RegistryKey logKey = FindLogKeyByName ("monologtemp")) {
2795 if (logKey != null)
2796 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2797 }
2798
2799 using (RegistryKey logKey = FindLogKeyByName ("monologother")) {
2800 if (logKey != null)
2801 Assert.Ignore ("Event log 'monologother' should not exist.");
2802 }
2803
2804 try {
2805 using (RegistryKey sourceKey = FindSourceKeyByName ("monotempsource")) {
2806 if (sourceKey != null)
2807 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2808 }
2809 }
2810 catch (SecurityException) {
2811 if (IsAzurePipelines) Assert.Ignore ("Azure Pipelines fails with: Requested registry access is not allowed.");
2812 throw;
2813 }
2814
2815 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#A1");
2816 Assert.IsFalse (EventLog.Exists ("MonoLogTemp"), "#A2");
2817 Assert.IsFalse (EventLog.Exists ("monologother"), "#A3");
2818 Assert.IsFalse (EventLog.Exists ("MonoLogOther"), "#A4");
2819
2820 using (RegistryKey eventLogKey = EventLogKey) {
2821 RegistryKey logKey = eventLogKey.CreateSubKey ("monologtemp");
2822 try {
2823 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#B1");
2824 Assert.IsTrue (EventLog.Exists ("MonoLogTemp"), "#B2");
2825 Assert.IsFalse (EventLog.Exists ("monologother"), "#B3");
2826 Assert.IsFalse (EventLog.Exists ("MonoLogOther"), "#B3");
2827
2828 Assert.IsFalse (EventLog.Exists ("monotempsource"), "#BXXX");
2829
2830 using (RegistryKey sourceKey = logKey.CreateSubKey ("monotempsource")) {
2831 }
2832
2833 Assert.IsFalse (EventLog.Exists ("monotempsource"), "#C1");
2834 Assert.IsFalse (EventLog.Exists ("MonoTempSource"), "#C2");
2835 } finally {
2836 if (logKey != null) {
2837 logKey.Close ();
2838 eventLogKey.DeleteSubKeyTree ("monologtemp");
2839 }
2840 }
2841 }
2842 }
2843
2844 [Test]
2845 public void Exists1_Log_Empty ()
2846 {
2847 Assert.IsFalse (EventLog.Exists (string.Empty));
2848 }
2849
2850 [Test]
2851 public void Exists1_Log_Null ()
2852 {
2853 Assert.IsFalse (EventLog.Exists (null));
2854 }
2855
2856 [Test]
2857 public void Exists2_Win32 ()
2858 {
2859 if (EventLogImplType != WIN32_IMPL)
2860 // test can only pass with win32 implementation
2861 Assert.Ignore ("Wrong EventLogImplType.");
2862
2863 using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
2864 if (logKey != null)
2865 Assert.Ignore ("Event log 'monotempsource' should not exist.");
2866 }
2867
2868 using (RegistryKey logKey = FindLogKeyByName ("monologtemp")) {
2869 if (logKey != null)
2870 Assert.Ignore ("Event log 'monologtemp' should not exist.");
2871 }
2872
2873 using (RegistryKey logKey = FindLogKeyByName ("monologother")) {
2874 if (logKey != null)
2875 Assert.Ignore ("Event log 'monologother' should not exist.");
2876 }
2877
2878 try {
2879 using (RegistryKey sourceKey = FindSourceKeyByName ("monotempsource")) {
2880 if (sourceKey != null)
2881 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
2882 }
2883 } catch (SecurityException) {
2884 if (IsAzurePipelines) Assert.Ignore ("Azure Pipelines fails with: Requested registry access is not allowed.");
2885 throw;
2886 }
2887
2888 Assert.IsFalse (EventLog.Exists ("monologtemp", "."), "#A1");
2889 Assert.IsFalse (EventLog.Exists ("MonoLogTemp", "."), "#A2");
2890 Assert.IsFalse (EventLog.Exists ("monologother", "."), "#A3");
2891 Assert.IsFalse (EventLog.Exists ("MonoLogOther", "."), "#A4");
2892
2893 using (RegistryKey eventLogKey = EventLogKey) {
2894 RegistryKey logKey = eventLogKey.CreateSubKey ("monologtemp");
2895 try {
2896 Assert.IsTrue (EventLog.Exists ("monologtemp", "."), "#B1");
2897 Assert.IsTrue (EventLog.Exists ("MonoLogTemp", "."), "#B2");
2898 Assert.IsFalse (EventLog.Exists ("monologother", "."), "#B3");
2899 Assert.IsFalse (EventLog.Exists ("MonoLogOther", "."), "#B3");
2900
2901 using (RegistryKey sourceKey = logKey.CreateSubKey ("monotempsource")) {
2902 }
2903
2904 Assert.IsFalse (EventLog.Exists ("monotempsource", "."), "#C1");
2905 Assert.IsFalse (EventLog.Exists ("MonoTempSource", "."), "#C2");
2906 } finally {
2907 if (logKey != null) {
2908 logKey.Close ();
2909 eventLogKey.DeleteSubKeyTree ("monologtemp");
2910 }
2911 }
2912 }
2913 }
2914
2915 [Test]
2916 public void Exists2_Log_Empty ()
2917 {
2918 Assert.IsFalse (EventLog.Exists (string.Empty, "."));
2919 }
2920
2921 [Test]
2922 public void Exists2_Log_Null ()
2923 {
2924 Assert.IsFalse (EventLog.Exists (null, "."));
2925 }
2926
2927 [Test]
2928 public void Exists2_MachineName_Empty ()
2929 {
2930 try {
2931 EventLog.Exists ("monologtemp", string.Empty);
2932 Assert.Fail ("#A1");
2933 } catch (ArgumentException ex) {
2934 // Invalid format for argument machineName
2935 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
2936 Assert.IsNotNull (ex.Message, "#A3");
2937 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#A4");
2938 Assert.IsNull (ex.InnerException, "#A5");
2939 Assert.IsNull (ex.ParamName, "#A6");
2940 }
2941
2942 try {
2943 EventLog.Exists (string.Empty, string.Empty);
2944 Assert.Fail ("#B1");
2945 } catch (ArgumentException ex) {
2946 // Invalid format for argument machineName
2947 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
2948 Assert.IsNotNull (ex.Message, "#B3");
2949 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#B4");
2950 Assert.IsNull (ex.InnerException, "#B5");
2951 Assert.IsNull (ex.ParamName, "#B6");
2952 }
2953
2954 try {
2955 EventLog.Exists (null, string.Empty);
2956 Assert.Fail ("#C1");
2957 } catch (ArgumentException ex) {
2958 // Invalid format for argument machineName
2959 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
2960 Assert.IsNotNull (ex.Message, "#C3");
2961 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#C4");
2962 Assert.IsNull (ex.InnerException, "#C5");
2963 Assert.IsNull (ex.ParamName, "#C6");
2964 }
2965
2966 try {
2967 EventLog.Exists ("monologtemp", " \t\n");
2968 Assert.Fail ("#D1");
2969 } catch (ArgumentException ex) {
2970 // Invalid format for argument machineName
2971 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
2972 Assert.IsNotNull (ex.Message, "#D3");
2973 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#D4");
2974 Assert.IsNull (ex.InnerException, "#D5");
2975 Assert.IsNull (ex.ParamName, "#D6");
2976 }
2977 }
2978
2979 [Test]
2980 public void Exists2_MachineName_Null ()
2981 {
2982 try {
2983 EventLog.Exists ("monologtemp", null);
2984 Assert.Fail ("#A1");
2985 } catch (ArgumentException ex) {
2986 // Invalid format for argument machineName
2987 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
2988 Assert.IsNotNull (ex.Message, "#A3");
2989 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#A4");
2990 Assert.IsNull (ex.InnerException, "#A5");
2991 Assert.IsNull (ex.ParamName, "#A6");
2992 }
2993
2994 try {
2995 EventLog.Exists (string.Empty, null);
2996 Assert.Fail ("#B1");
2997 } catch (ArgumentException ex) {
2998 // Invalid format for argument machineName
2999 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
3000 Assert.IsNotNull (ex.Message, "#B3");
3001 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#B4");
3002 Assert.IsNull (ex.InnerException, "#B5");
3003 Assert.IsNull (ex.ParamName, "#B6");
3004 }
3005
3006 try {
3007 EventLog.Exists (null, null);
3008 Assert.Fail ("#C1");
3009 } catch (ArgumentException ex) {
3010 // Invalid format for argument machineName
3011 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
3012 Assert.IsNotNull (ex.Message, "#C3");
3013 Assert.IsTrue (ex.Message.IndexOf ("machineName") != -1, "#C4");
3014 Assert.IsNull (ex.InnerException, "#C5");
3015 Assert.IsNull (ex.ParamName, "#C6");
3016 }
3017 }
3018
3019 [Test]
3020 public void Log ()
3021 {
3022 EventLog eventLog = new EventLog ();
3023 eventLog.Log = string.Empty;
3024 Assert.AreEqual (string.Empty, eventLog.Log, "#A1");
3025 Assert.AreEqual (string.Empty, eventLog.Source, "#A2");
3026 eventLog.Log = "monologtemp";
3027 Assert.AreEqual ("monologtemp", eventLog.Log, "#A3");
3028 Assert.AreEqual (string.Empty, eventLog.Source, "#A4");
3029 eventLog.Log = string.Empty;
3030 Assert.AreEqual (string.Empty, eventLog.Log, "#A5");
3031 Assert.AreEqual (string.Empty, eventLog.Source, "#A6");
3032
3033 if (EventLog.SourceExists ("monotempsource", "."))
3034 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3035
3036 if (EventLog.Exists ("monologtemp", "."))
3037 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3038
3039 if (EventLog.Exists ("shouldnotexist", "."))
3040 Assert.Ignore ("Event log 'shouldnotexist' should not exist.");
3041
3042 EventLog.CreateEventSource ("monotempsource", "monologtemp", ".");
3043 try {
3044 eventLog.Log = "shouldnotexist";
3045 eventLog.Source = "monotempsource";
3046 Assert.AreEqual ("shouldnotexist", eventLog.Log, "#B1");
3047 eventLog.Log = string.Empty;
3048 Assert.AreEqual ("monologtemp", eventLog.Log, "#B2");
3049 eventLog.Source = null;
3050 Assert.AreEqual ("monologtemp", eventLog.Log, "#B3");
3051 eventLog.Log = "MONOLOGTEMP";
3052 Assert.AreEqual ("monologtemp", eventLog.Log, "#B4");
3053 } finally {
3054 if (EventLog.Exists ("monologtemp"))
3055 EventLog.Delete ("monologtemp");
3056 eventLog.Close ();
3057 }
3058 }
3059
3060 [Test]
3061 [ExpectedException (typeof (ArgumentNullException))]
3062 public void Log_Null ()
3063 {
3064 EventLog eventLog = new EventLog ();
3065 eventLog.Log = null;
3066 }
3067
3068 [Test]
3069 public void LogNameFromSourceName ()
3070 {
3071 if (EventLogImplType == NULL_IMPL)
3072 // test cannot pass with NULL implementation
3073 Assert.Ignore ("No EventLogImplType.");
3074
3075 if (EventLog.SourceExists ("monotempsource", "."))
3076 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3077
3078 if (EventLog.Exists ("monologtemp", "."))
3079 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3080
3081
3082 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3083 try {
3084 Assert.IsNotNull (EventLog.LogNameFromSourceName ("monotempsource", "."), "#1");
3085 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#2");
3086 Assert.IsNotNull (EventLog.LogNameFromSourceName ("monologtemp", "."), "#3");
3087 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monologtemp", "."), "#4");
3088 } finally {
3089 if (EventLog.Exists ("monologtemp"))
3090 EventLog.Delete ("monologtemp");
3091 }
3092 }
3093
3094 [Test]
3095 public void LogNameFromSourceName_MachineName_Empty ()
3096 {
3097 try {
3098 EventLog.LogNameFromSourceName ("monotempsource", string.Empty);
3099 Assert.Fail ("#A1");
3100 } catch (ArgumentException ex) {
3101 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3102 Assert.IsNotNull (ex.Message, "#A3");
3103 // Invalid value '' for parameter 'MachineName'
3104 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
3105 Assert.IsTrue (ex.Message.IndexOf ("'MachineName'") != -1, "#A5");
3106 Assert.IsNull (ex.InnerException, "#A6");
3107 Assert.IsNull (ex.ParamName, "#A7");
3108 }
3109
3110 try {
3111 EventLog.LogNameFromSourceName ("monotempsource", " \t\n");
3112 Assert.Fail ("#B1");
3113 } catch (ArgumentException ex) {
3114 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
3115 Assert.IsNotNull (ex.Message, "#B3");
3116 // Invalid value ' \t\n' for parameter 'MachineName'
3117 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
3118 Assert.IsTrue (ex.Message.IndexOf ("'MachineName'") != -1, "#B5");
3119 Assert.IsNull (ex.InnerException, "#B6");
3120 Assert.IsNull (ex.ParamName, "#B7");
3121 }
3122 }
3123
3124 [Test]
3125 public void LogNameFromSourceName_MachineName_Null ()
3126 {
3127 try {
3128 EventLog.LogNameFromSourceName ("monotempsource", null);
3129 Assert.Fail ("#A1");
3130 } catch (ArgumentException ex) {
3131 // Invalid value '' for parameter 'MachineName'
3132 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3133 Assert.IsNotNull (ex.Message, "#A3");
3134 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
3135 Assert.IsTrue (ex.Message.IndexOf ("'MachineName'") != -1, "#A5");
3136 Assert.IsNull (ex.InnerException, "#A6");
3137 Assert.IsNull (ex.ParamName, "#A7");
3138 }
3139 }
3140
3141 [Test]
3142 public void LogNameFromSourceName_Source_DoesNotExist ()
3143 {
3144 if (EventLogImplType == NULL_IMPL)
3145 // test cannot pass with NULL implementation
3146 Assert.Ignore ("No EventLogImplType.");
3147
3148 if (EventLog.SourceExists ("monotempsource", "."))
3149 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3150
3151 string logName = EventLog.LogNameFromSourceName ("monotempsource", ".");
3152 Assert.IsNotNull (logName, "#1");
3153 Assert.AreEqual (string.Empty, logName, "#2");
3154 }
3155
3156 [Test]
3157 public void LogNameFromSourceName_Source_Empty ()
3158 {
3159 if (EventLogImplType == NULL_IMPL)
3160 // test cannot pass with NULL implementation
3161 Assert.Ignore ("No EventLogImplType.");
3162
3163 string logName = EventLog.LogNameFromSourceName (string.Empty, ".");
3164 Assert.IsNotNull (logName, "#1");
3165 Assert.AreEqual (string.Empty, logName, "#2");
3166 }
3167
3168 [Test]
3169 public void LogNameFromSourceName_Source_Null ()
3170 {
3171 if (EventLogImplType == NULL_IMPL)
3172 // test cannot pass with NULL implementation
3173 Assert.Ignore ("No EventLogImplType.");
3174
3175 string logName = EventLog.LogNameFromSourceName (null, ".");
3176 Assert.IsNotNull (logName, "#1");
3177 Assert.AreEqual (string.Empty, logName, "#2");
3178 }
3179
3180 [Test]
3181 public void MachineName_Null ()
3182 {
3183 EventLog eventLog = new EventLog ();
3184
3185 try {
3186 eventLog.MachineName = null;
3187 Assert.Fail ("#1");
3188 } catch (ArgumentException ex) {
3189 // Invalid value for property MachineName
3190 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3191 Assert.IsNull (ex.InnerException, "#3");
3192 Assert.IsNotNull (ex.Message, "#4");
3193 Assert.IsTrue (ex.Message.IndexOf (" ") != -1, "#5");
3194 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#6");
3195 Assert.IsNull (ex.ParamName, "#7");
3196 }
3197 }
3198
3199 [Test]
3200 public void MachineName ()
3201 {
3202 string machineName = Environment.MachineName.ToLower ();
3203
3204 EventLog eventLog = new EventLog ("Application", machineName);
3205 eventLog.EnableRaisingEvents = true;
3206 Assert.AreEqual (machineName, eventLog.MachineName, "#1");
3207 eventLog.MachineName = Environment.MachineName.ToUpper ();
3208 Assert.AreEqual (machineName, eventLog.MachineName, "#2");
3209 Assert.IsTrue (eventLog.EnableRaisingEvents, "#3");
3210 eventLog.MachineName = ".";
3211 Assert.AreEqual (".", eventLog.MachineName, "#4");
3212 Assert.IsFalse (eventLog.EnableRaisingEvents, "#5");
3213 }
3214
3215 [Test]
3216 public void MachineName_Empty ()
3217 {
3218 EventLog eventLog = new EventLog ();
3219
3220 try {
3221 eventLog.MachineName = string.Empty;
3222 Assert.Fail ("#A1");
3223 } catch (ArgumentException ex) {
3224 // Invalid value for property MachineName
3225 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3226 Assert.IsNull (ex.InnerException, "#A3");
3227 Assert.IsNotNull (ex.Message, "#A4");
3228 Assert.IsTrue (ex.Message.IndexOf (" ") != -1, "#A5");
3229 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#A6");
3230 Assert.IsNull (ex.ParamName, "#A7");
3231 }
3232
3233 try {
3234 eventLog.MachineName = " \t\n";
3235 Assert.Fail ("#B1");
3236 } catch (ArgumentException ex) {
3237 // Invalid value for property MachineName
3238 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
3239 Assert.IsNull (ex.InnerException, "#B3");
3240 Assert.IsNotNull (ex.Message, "#B4");
3241 Assert.IsTrue (ex.Message.IndexOf (" ") != -1, "#B5");
3242 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#B6");
3243 Assert.IsNull (ex.ParamName, "#B7");
3244 }
3245 }
3246
3247 [Test]
3248 public void Source ()
3249 {
3250 if (EventLogImplType == NULL_IMPL)
3251 // test cannot pass with NULL implementation
3252 Assert.Ignore ("No EventLogImplType.");
3253
3254 if (EventLog.SourceExists ("monotempsource", "."))
3255 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3256
3257 if (EventLog.Exists ("monologtemp", "."))
3258 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3259
3260 using (EventLog eventLog = new EventLog ()) {
3261 eventLog.Source = null;
3262 Assert.AreEqual (string.Empty, eventLog.Source, "#A1");
3263 Assert.AreEqual (string.Empty, eventLog.Log, "#A2");
3264 eventLog.Source = "monotempsource";
3265 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3266 Assert.AreEqual (string.Empty, eventLog.Log, "#A4");
3267 eventLog.Source = null;
3268 Assert.AreEqual (string.Empty, eventLog.Source, "#A5");
3269 Assert.AreEqual (string.Empty, eventLog.Log, "#A6");
3270
3271 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3272 try {
3273 Assert.AreEqual (string.Empty, eventLog.Source, "#B1");
3274 Assert.AreEqual (string.Empty, eventLog.Log, "#B2");
3275 eventLog.Source = "monotempsource";
3276 Assert.AreEqual ("monotempsource", eventLog.Source, "#B3");
3277 Assert.AreEqual ("monologtemp", eventLog.Log, "#B4");
3278 eventLog.Log = string.Empty;
3279 Assert.AreEqual ("monotempsource", eventLog.Source, "#B5");
3280 Assert.AreEqual ("monologtemp", eventLog.Log, "#B6");
3281 eventLog.Source = null;
3282 Assert.AreEqual (string.Empty, eventLog.Source, "#B7");
3283 Assert.AreEqual ("monologtemp", eventLog.Log, "#B8");
3284 eventLog.Log = string.Empty;
3285 Assert.AreEqual (string.Empty, eventLog.Source, "#B9");
3286 Assert.AreEqual (string.Empty, eventLog.Log, "#B10");
3287 } finally {
3288 EventLog.Delete ("monologtemp");
3289 }
3290
3291 eventLog.Source = "whatever";
3292 Assert.AreEqual ("whatever", eventLog.Source, "#C1");
3293 eventLog.Source = "WHATEVER";
3294 Assert.AreEqual ("whatever", eventLog.Source, "#C2");
3295 }
3296 }
3297
3298 [Test]
3299 public void SourceExists1_Win32 ()
3300 {
3301 if (EventLogImplType != WIN32_IMPL)
3302 // test can only pass with win32 implementation
3303 Assert.Ignore ("Wrong EventLogImplType.");
3304
3305 using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
3306 if (logKey != null)
3307 Assert.Ignore ("Event log 'monotempsource' should not exist.");
3308 }
3309
3310 using (RegistryKey logKey = FindLogKeyByName ("monologtemp")) {
3311 if (logKey != null)
3312 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3313 }
3314
3315 try {
3316 using (RegistryKey sourceKey = FindSourceKeyByName ("monotempsource")) {
3317 if (sourceKey != null)
3318 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3319 }
3320 } catch (SecurityException) {
3321 if (IsAzurePipelines) Assert.Ignore ("Azure Pipelines fails with: Requested registry access is not allowed.");
3322 throw;
3323 }
3324
3325 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A1");
3326 Assert.IsFalse (EventLog.SourceExists ("MonoTempSource"), "#A2");
3327
3328 using (RegistryKey eventLogKey = EventLogKey) {
3329 RegistryKey logKey = eventLogKey.CreateSubKey ("monotempsource");
3330 try {
3331 // make sure we do not mistake a log for a source
3332 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B1");
3333 Assert.IsFalse (EventLog.SourceExists ("MonoTempSource"), "#B2");
3334 } finally {
3335 if (logKey != null) {
3336 logKey.Close ();
3337 eventLogKey.DeleteSubKeyTree ("monotempsource");
3338 }
3339 }
3340
3341 logKey = eventLogKey.CreateSubKey ("monologtemp");
3342 try {
3343 RegistryKey sourceKey = null;
3344 try {
3345 // create temporary source key
3346 sourceKey = logKey.CreateSubKey ("monotempsource");
3347 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#C1");
3348 Assert.IsTrue (EventLog.SourceExists ("MonoTempSource"), "#C2");
3349 } finally {
3350 if (sourceKey != null) {
3351 sourceKey.Close ();
3352 logKey.DeleteSubKeyTree ("monotempsource");
3353 }
3354 }
3355 } finally {
3356 if (logKey != null) {
3357 logKey.Close ();
3358 eventLogKey.DeleteSubKeyTree ("monologtemp");
3359 }
3360 }
3361 }
3362 }
3363
3364 [Test]
3365 public void SourceExists1_Source_Empty ()
3366 {
3367 Assert.IsFalse (EventLog.SourceExists (string.Empty));
3368 }
3369
3370 [Test]
3371 public void SourceExists1_Source_Null ()
3372 {
3373 Assert.IsFalse (EventLog.SourceExists (null));
3374 }
3375
3376 [Test]
3377 public void SourceExists2_Win32 ()
3378 {
3379 if (EventLogImplType != WIN32_IMPL)
3380 // test can only pass with win32 implementation
3381 Assert.Ignore ("Wrong EventLogImplType.");
3382
3383 using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
3384 if (logKey != null)
3385 Assert.Ignore ("Event log 'monotempsource' should not exist.");
3386 }
3387
3388 using (RegistryKey logKey = FindLogKeyByName ("monologtemp")) {
3389 if (logKey != null)
3390 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3391 }
3392
3393 try {
3394 using (RegistryKey sourceKey = FindSourceKeyByName ("monotempsource")) {
3395 if (sourceKey != null)
3396 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3397 }
3398 } catch (SecurityException) {
3399 if (IsAzurePipelines) Assert.Ignore ("Azure Pipelines fails with: Requested registry access is not allowed.");
3400 throw;
3401 }
3402
3403 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#1");
3404
3405 using (RegistryKey eventLogKey = EventLogKey) {
3406 RegistryKey logKey = eventLogKey.CreateSubKey ("monotempsource");
3407 try {
3408 // make sure we do not mistake a log for a source
3409 Assert.IsFalse (EventLog.SourceExists ("monotempsource", "."), "#2");
3410 } finally {
3411 if (logKey != null) {
3412 logKey.Close ();
3413 eventLogKey.DeleteSubKeyTree ("monotempsource");
3414 }
3415 }
3416
3417 logKey = eventLogKey.CreateSubKey ("monologtemp");
3418 try {
3419 RegistryKey sourceKey = null;
3420 try {
3421 // create temporary source key
3422 sourceKey = logKey.CreateSubKey ("monotempsource");
3423 Assert.IsTrue (EventLog.SourceExists ("monotempsource", "."), "#3");
3424 } finally {
3425 if (sourceKey != null) {
3426 sourceKey.Close ();
3427 logKey.DeleteSubKeyTree ("monotempsource");
3428 }
3429 }
3430 } finally {
3431 if (logKey != null) {
3432 logKey.Close ();
3433 eventLogKey.DeleteSubKeyTree ("monologtemp");
3434 }
3435 }
3436 }
3437 }
3438
3439 [Test]
3440 public void SourceExists2_MachineName_Empty ()
3441 {
3442 try {
3443 EventLog.SourceExists ("monotempsource", string.Empty);
3444 Assert.Fail ("#A1");
3445 } catch (ArgumentException ex) {
3446 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3447 Assert.IsNotNull (ex.Message, "#A3");
3448 // Invalid value '' for parameter 'machineName'
3449 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A4");
3450 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#A5");
3451 Assert.IsNull (ex.InnerException, "#A6");
3452 Assert.IsNull (ex.ParamName, "#A7");
3453 }
3454
3455 try {
3456 EventLog.SourceExists ("monotempsource", " \t\n");
3457 Assert.Fail ("#B1");
3458 } catch (ArgumentException ex) {
3459 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
3460 Assert.IsNotNull (ex.Message, "#B3");
3461 // Invalid value ' \t\n' for parameter 'machineName'
3462 Assert.IsTrue (ex.Message.IndexOf ("' \t\n'") != -1, "#B4");
3463 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#B5");
3464 Assert.IsNull (ex.InnerException, "#B6");
3465 Assert.IsNull (ex.ParamName, "#B7");
3466 }
3467 }
3468
3469 [Test]
3470 public void SourceExists2_MachineName_Null ()
3471 {
3472 try {
3473 EventLog.SourceExists ("monotempsource", null);
3474 Assert.Fail ("#1");
3475 } catch (ArgumentException ex) {
3476 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3477 Assert.IsNotNull (ex.Message, "#3");
3478 // Invalid value '' for parameter 'machineName'
3479 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#4");
3480 Assert.IsTrue (ex.Message.IndexOf ("'machineName'") != -1, "#5");
3481 Assert.IsNull (ex.InnerException, "#6");
3482 Assert.IsNull (ex.ParamName, "#7");
3483 }
3484 }
3485
3486 [Test]
3487 public void SourceExists2_Source_Empty ()
3488 {
3489 Assert.IsFalse (EventLog.SourceExists (string.Empty, "."));
3490 }
3491
3492 [Test]
3493 public void SourceExists2_Source_Null ()
3494 {
3495 Assert.IsFalse (EventLog.SourceExists (null, "."));
3496 }
3497
3498 [Test]
3499 public void WriteEntry1 ()
3500 {
3501 if (EventLogImplType == NULL_IMPL)
3502 // test cannot pass with NULL implementation
3503 Assert.Ignore ("No EventLogImplType.");
3504
3505 if (EventLog.SourceExists ("monotempsource", "."))
3506 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3507
3508 if (EventLog.Exists ("monologtemp", "."))
3509 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3510
3511 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3512 try {
3513 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3514 eventLog.WriteEntry ("WriteEntry1a");
3515
3516 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3517 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3518 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3519 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3520 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3521 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3522
3523 EventLogEntry entry = eventLog.Entries[eventLog.Entries.Count - 1];
3524 Assert.IsNotNull (entry, "#B1");
3525 Assert.IsNotNull (entry.Category, "#B2");
3526 Assert.AreEqual ("(0)", entry.Category, "#B3");
3527 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3528 Assert.IsNotNull (entry.Data, "#B5");
3529 Assert.AreEqual (0, entry.Data.Length, "#B6");
3530 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3531 Assert.AreEqual (0, entry.EventID, "#B8");
3532 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3533 Assert.IsNotNull (entry.MachineName, "#B10");
3534 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
3535 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3536 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3537 Assert.AreEqual ("WriteEntry1a", entry.ReplacementStrings[0], "#B14");
3538 Assert.IsNotNull (entry.Source, "#B15");
3539 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3540 Assert.IsNull (entry.UserName, "#B17");
3541
3542 eventLog.WriteEntry ("WriteEntry1b" + Environment.NewLine + "ok");
3543
3544 entry = eventLog.Entries [eventLog.Entries.Count - 1];
3545 Assert.IsNotNull (entry, "#C1");
3546 Assert.IsNotNull (entry.Category, "#C2");
3547 Assert.AreEqual ("(0)", entry.Category, "#C3");
3548 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
3549 Assert.IsNotNull (entry.Data, "#C5");
3550 Assert.AreEqual (0, entry.Data.Length, "#C6");
3551 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#C7");
3552 Assert.AreEqual (0, entry.EventID, "#C8");
3553 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
3554 Assert.IsNotNull (entry.MachineName, "#C10");
3555 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
3556 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
3557 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
3558 Assert.AreEqual ("WriteEntry1b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
3559 Assert.IsNotNull (entry.Source, "#C15");
3560 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
3561 Assert.IsNull (entry.UserName, "#C17");
3562 }
3563 } finally {
3564 if (EventLog.Exists ("monologtemp"))
3565 EventLog.Delete ("monologtemp");
3566 }
3567 }
3568
3569 [Test]
3570 public void WriteEntry1_Log_Empty ()
3571 {
3572 if (EventLogImplType == NULL_IMPL)
3573 // test cannot pass with NULL implementation
3574 Assert.Ignore ("No EventLogImplType.");
3575
3576 if (EventLog.SourceExists ("monotempsource", "."))
3577 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3578
3579 bool applicationLogExists = EventLog.Exists ("Application", ".");
3580
3581 // specified source does not exist, so use Application log
3582 try {
3583 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
3584 eventLog.WriteEntry ("WriteEntry1_Log_Empty");
3585 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3586 Assert.AreEqual ("Application", eventLog.Log, "#A2");
3587 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3588 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
3589 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3590 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3591 }
3592 } finally {
3593 if (!applicationLogExists) {
3594 if (EventLog.Exists ("Application"))
3595 EventLog.Delete ("Application");
3596 } else {
3597 if (EventLog.SourceExists ("monotempsource", "."))
3598 EventLog.DeleteEventSource ("monotempsource", ".");
3599 }
3600 }
3601 }
3602
3603 [Test]
3604 public void WriteEntry1_Log_Mismatch ()
3605 {
3606 if (EventLogImplType == NULL_IMPL)
3607 // test cannot pass with NULL implementation
3608 Assert.Ignore ("No EventLogImplType.");
3609
3610 if (EventLog.SourceExists ("monotempsource", "."))
3611 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3612
3613 if (EventLog.Exists ("monologtemp", "."))
3614 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3615
3616 if (EventLog.Exists ("monologother", "."))
3617 Assert.Ignore ("Event log 'monologother' should not exist.");
3618
3619 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3620 try {
3621 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
3622 eventLog.WriteEntry ("WriteEntry1_Log_Mismatch");
3623 }
3624 } catch (ArgumentException ex) {
3625 // The source 'monotempsource' is not registered in log
3626 // 'monologother' (it is registered in log 'monologtemp').
3627 // The Source and Log properties must be matched, or you may
3628 // set Log to the empty string, and it will automatically be
3629 // matched to the Source property
3630 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3631 Assert.IsNotNull (ex.Message, "#A3");
3632 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
3633 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
3634 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
3635 Assert.IsNull (ex.InnerException, "#A7");
3636 } finally {
3637 if (EventLog.Exists ("monologtemp"))
3638 EventLog.Delete ("monologtemp");
3639
3640 if (EventLog.Exists ("monologother"))
3641 EventLog.Delete ("monologother");
3642 }
3643 }
3644
3645 [Test]
3646 public void WriteEntry1_Message_Empty ()
3647 {
3648 if (EventLogImplType == NULL_IMPL)
3649 // test cannot pass with NULL implementation
3650 Assert.Ignore ("No EventLogImplType.");
3651
3652 if (EventLog.SourceExists ("monotempsource", "."))
3653 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3654
3655 if (EventLog.Exists ("monologtemp", "."))
3656 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3657
3658 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3659 try {
3660 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3661 eventLog.WriteEntry (string.Empty);
3662 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3663 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3664 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3665 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3666 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3667 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3668
3669 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
3670 Assert.IsNotNull (entry, "#B1");
3671 Assert.IsNotNull (entry.Category, "#B2");
3672 Assert.AreEqual ("(0)", entry.Category, "#B3");
3673 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3674 Assert.IsNotNull (entry.Data, "#B5");
3675 Assert.AreEqual (0, entry.Data.Length, "#B6");
3676 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3677 Assert.AreEqual (0, entry.EventID, "#B8");
3678 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3679 Assert.IsNotNull (entry.MachineName, "#B10");
3680 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
3681 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3682 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3683 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
3684 Assert.IsNotNull (entry.Source, "#B15");
3685 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3686 Assert.IsNull (entry.UserName, "#B17");
3687 }
3688 } finally {
3689 if (EventLog.Exists ("monologtemp"))
3690 EventLog.Delete ("monologtemp");
3691 }
3692 }
3693
3694 [Test]
3695 public void WriteEntry1_Message_Null ()
3696 {
3697 if (EventLogImplType == NULL_IMPL)
3698 // test cannot pass with NULL implementation
3699 Assert.Ignore ("No EventLogImplType.");
3700
3701 if (EventLog.SourceExists ("monotempsource", "."))
3702 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3703
3704 if (EventLog.Exists ("monologtemp", "."))
3705 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3706
3707 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3708 try {
3709 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3710 eventLog.WriteEntry (null);
3711 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3712 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3713 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3714 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3715 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3716 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3717
3718 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
3719 Assert.IsNotNull (entry, "#B1");
3720 Assert.IsNotNull (entry.Category, "#B2");
3721 Assert.AreEqual ("(0)", entry.Category, "#B3");
3722 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3723 Assert.IsNotNull (entry.Data, "#B5");
3724 Assert.AreEqual (0, entry.Data.Length, "#B6");
3725 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3726 Assert.AreEqual (0, entry.EventID, "#B8");
3727 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3728 Assert.IsNotNull (entry.MachineName, "#B10");
3729 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
3730 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3731 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3732 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
3733 Assert.IsNotNull (entry.Source, "#B15");
3734 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3735 Assert.IsNull (entry.UserName, "#B17");
3736 }
3737 } finally {
3738 if (EventLog.Exists ("monologtemp"))
3739 EventLog.Delete ("monologtemp");
3740 }
3741 }
3742
3743 [Test]
3744 public void WriteEntry1_Source_DoesNotExist ()
3745 {
3746 if (EventLogImplType == NULL_IMPL)
3747 // test cannot pass with NULL implementation
3748 Assert.Ignore ("No EventLogImplType.");
3749
3750 if (EventLog.SourceExists ("monotempsource", "."))
3751 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3752
3753 if (EventLog.SourceExists ("monoothersource", "."))
3754 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
3755
3756 if (EventLog.Exists ("monologtemp", "."))
3757 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3758
3759 EventLog.CreateEventSource ("monoothersource", "monologtemp");
3760 try {
3761 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3762 eventLog.WriteEntry ("WriteEntry1");
3763 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3764 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3765 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3766 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3767 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3768 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3769
3770 EventLogEntry entry = eventLog.Entries[eventLog.Entries.Count - 1];
3771 Assert.IsNotNull (entry, "#B1");
3772 Assert.IsNotNull (entry.Category, "#B2");
3773 Assert.AreEqual ("(0)", entry.Category, "#B3");
3774 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3775 Assert.IsNotNull (entry.Data, "#B5");
3776 Assert.AreEqual (0, entry.Data.Length, "#B6");
3777 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3778 Assert.AreEqual (0, entry.EventID, "#B8");
3779 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3780 Assert.IsNotNull (entry.MachineName, "#B10");
3781 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
3782 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3783 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3784 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings[0], "#B14");
3785 Assert.IsNotNull (entry.Source, "#B15");
3786 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3787 Assert.IsNull (entry.UserName, "#B17");
3788 }
3789 } finally {
3790 if (EventLog.Exists ("monologtemp"))
3791 EventLog.Delete ("monologtemp");
3792 }
3793 }
3794
3795 [Test]
3796 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
3797 public void WriteEntry1_Source_Empty ()
3798 {
3799 EventLog eventLog = new EventLog ("monologtemp");
3800 eventLog.WriteEntry ("test");
3801 }
3802
3803 [Test]
3804 public void WriteEntry2 ()
3805 {
3806 if (EventLogImplType == NULL_IMPL)
3807 // test cannot pass with NULL implementation
3808 Assert.Ignore ("No EventLogImplType.");
3809
3810 if (EventLog.SourceExists ("monotempsource", "."))
3811 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3812
3813 if (EventLog.Exists ("monologtemp", "."))
3814 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3815
3816 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3817 try {
3818 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3819 eventLog.WriteEntry ("WriteEntry2a", EventLogEntryType.Information);
3820
3821 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3822 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3823 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3824 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3825 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3826 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3827
3828 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
3829 Assert.IsNotNull (entry, "#B1");
3830 Assert.IsNotNull (entry.Category, "#B2");
3831 Assert.AreEqual ("(0)", entry.Category, "#B3");
3832 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3833 Assert.IsNotNull (entry.Data, "#B5");
3834 Assert.AreEqual (0, entry.Data.Length, "#B6");
3835 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
3836 Assert.AreEqual (0, entry.EventID, "#B8");
3837 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3838 Assert.IsNotNull (entry.MachineName, "#B10");
3839 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
3840 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
3841 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
3842 Assert.AreEqual ("WriteEntry2a", entry.ReplacementStrings [0], "#B14");
3843 Assert.IsNotNull (entry.Source, "#B15");
3844 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
3845 Assert.IsNull (entry.UserName, "#B17");
3846
3847 eventLog.WriteEntry ("WriteEntry2b" + Environment.NewLine + "ok", EventLogEntryType.Error);
3848
3849 entry = eventLog.Entries [eventLog.Entries.Count - 1];
3850 Assert.IsNotNull (entry, "#C1");
3851 Assert.IsNotNull (entry.Category, "#C2");
3852 Assert.AreEqual ("(0)", entry.Category, "#C3");
3853 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
3854 Assert.IsNotNull (entry.Data, "#C5");
3855 Assert.AreEqual (0, entry.Data.Length, "#C6");
3856 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
3857 Assert.AreEqual (0, entry.EventID, "#C8");
3858 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
3859 Assert.IsNotNull (entry.MachineName, "#C10");
3860 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
3861 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
3862 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
3863 Assert.AreEqual ("WriteEntry2b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
3864 Assert.IsNotNull (entry.Source, "#C15");
3865 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
3866 Assert.IsNull (entry.UserName, "#C17");
3867 }
3868 } finally {
3869 if (EventLog.Exists ("monologtemp"))
3870 EventLog.Delete ("monologtemp");
3871 }
3872 }
3873
3874 [Test]
3875 public void WriteEntry2_Log_Empty ()
3876 {
3877 if (EventLogImplType == NULL_IMPL)
3878 // test cannot pass with NULL implementation
3879 Assert.Ignore ("No EventLogImplType.");
3880
3881 if (EventLog.SourceExists ("monotempsource", "."))
3882 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3883
3884 bool applicationLogExists = EventLog.Exists ("Application", ".");
3885
3886 // specified source does not exist, so use Application log
3887 try {
3888 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
3889 eventLog.WriteEntry ("WriteEntry1_Log_Empty", EventLogEntryType.Error);
3890 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3891 Assert.AreEqual ("Application", eventLog.Log, "#A2");
3892 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3893 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
3894 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3895 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3896 }
3897 } finally {
3898 if (!applicationLogExists) {
3899 if (EventLog.Exists ("Application"))
3900 EventLog.Delete ("Application");
3901 } else {
3902 if (EventLog.SourceExists ("monotempsource", "."))
3903 EventLog.DeleteEventSource ("monotempsource", ".");
3904 }
3905 }
3906 }
3907
3908 [Test]
3909 public void WriteEntry2_Log_Mismatch ()
3910 {
3911 if (EventLogImplType == NULL_IMPL)
3912 // test cannot pass with NULL implementation
3913 Assert.Ignore ("No EventLogImplType.");
3914
3915 if (EventLog.SourceExists ("monotempsource", "."))
3916 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3917
3918 if (EventLog.Exists ("monologtemp", "."))
3919 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3920
3921 if (EventLog.Exists ("monologother", "."))
3922 Assert.Ignore ("Event log 'monologother' should not exist.");
3923
3924 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3925 try {
3926 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
3927 // valid message
3928 try {
3929 eventLog.WriteEntry ("WriteEntry2_Log_Mismatch1",
3930 EventLogEntryType.Error);
3931 Assert.Fail ("#A1");
3932 } catch (ArgumentException ex) {
3933 // The source 'monotempsource' is not registered in log
3934 // 'monologother' (it is registered in log 'monologtemp').
3935 // The Source and Log properties must be matched, or you may
3936 // set Log to the empty string, and it will automatically be
3937 // matched to the Source property
3938 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3939 Assert.IsNotNull (ex.Message, "#A3");
3940 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
3941 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
3942 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
3943 Assert.IsNull (ex.InnerException, "#A7");
3944 }
3945
3946 // invalid type
3947 try {
3948 eventLog.WriteEntry ("WriteEntry2_Log_Mismatch2",
3949 (EventLogEntryType) 666);
3950 Assert.Fail ("#B1");
3951 } catch (InvalidEnumArgumentException) {
3952 }
3953 }
3954 } finally {
3955 if (EventLog.Exists ("monologtemp"))
3956 EventLog.Delete ("monologtemp");
3957
3958 if (EventLog.Exists ("monologother"))
3959 EventLog.Delete ("monologother");
3960 }
3961 }
3962
3963 [Test]
3964 public void WriteEntry2_Message_Empty ()
3965 {
3966 if (EventLogImplType == NULL_IMPL)
3967 // test cannot pass with NULL implementation
3968 Assert.Ignore ("No EventLogImplType.");
3969
3970 if (EventLog.SourceExists ("monotempsource", "."))
3971 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
3972
3973 if (EventLog.Exists ("monologtemp", "."))
3974 Assert.Ignore ("Event log 'monologtemp' should not exist.");
3975
3976 EventLog.CreateEventSource ("monotempsource", "monologtemp");
3977 try {
3978 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
3979 eventLog.WriteEntry (string.Empty, EventLogEntryType.FailureAudit);
3980 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
3981 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
3982 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
3983 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
3984 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
3985 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
3986
3987 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
3988 Assert.IsNotNull (entry, "#B1");
3989 Assert.IsNotNull (entry.Category, "#B2");
3990 Assert.AreEqual ("(0)", entry.Category, "#B3");
3991 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
3992 Assert.IsNotNull (entry.Data, "#B5");
3993 Assert.AreEqual (0, entry.Data.Length, "#B6");
3994 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
3995 Assert.AreEqual (0, entry.EventID, "#B8");
3996 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
3997 Assert.IsNotNull (entry.MachineName, "#B10");
3998 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
3999 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4000 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4001 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
4002 Assert.IsNotNull (entry.Source, "#B15");
4003 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4004 Assert.IsNull (entry.UserName, "#B17");
4005 }
4006 } finally {
4007 if (EventLog.Exists ("monologtemp"))
4008 EventLog.Delete ("monologtemp");
4009 }
4010 }
4011
4012 [Test]
4013 public void WriteEntry2_Message_Null ()
4014 {
4015 if (EventLogImplType == NULL_IMPL)
4016 // test cannot pass with NULL implementation
4017 Assert.Ignore ("No EventLogImplType.");
4018
4019 if (EventLog.SourceExists ("monotempsource", "."))
4020 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4021
4022 if (EventLog.Exists ("monologtemp", "."))
4023 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4024
4025 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4026 try {
4027 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4028 eventLog.WriteEntry (null, EventLogEntryType.SuccessAudit);
4029 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4030 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4031 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4032 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4033 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4034 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4035
4036 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4037 Assert.IsNotNull (entry, "#B1");
4038 Assert.IsNotNull (entry.Category, "#B2");
4039 Assert.AreEqual ("(0)", entry.Category, "#B3");
4040 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4041 Assert.IsNotNull (entry.Data, "#B5");
4042 Assert.AreEqual (0, entry.Data.Length, "#B6");
4043 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
4044 Assert.AreEqual (0, entry.EventID, "#B8");
4045 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4046 Assert.IsNotNull (entry.MachineName, "#B10");
4047 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4048 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4049 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4050 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
4051 Assert.IsNotNull (entry.Source, "#B15");
4052 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4053 Assert.IsNull (entry.UserName, "#B17");
4054 }
4055 } finally {
4056 if (EventLog.Exists ("monologtemp"))
4057 EventLog.Delete ("monologtemp");
4058 }
4059 }
4060
4061 [Test]
4062 public void WriteEntry2_Source_DoesNotExist ()
4063 {
4064 if (EventLogImplType == NULL_IMPL)
4065 // test cannot pass with NULL implementation
4066 Assert.Ignore ("No EventLogImplType.");
4067
4068 if (EventLog.SourceExists ("monotempsource", "."))
4069 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4070
4071 if (EventLog.SourceExists ("monoothersource", "."))
4072 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
4073
4074 if (EventLog.Exists ("monologtemp", "."))
4075 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4076
4077 EventLog.CreateEventSource ("monoothersource", "monologtemp");
4078 try {
4079 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4080 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Warning);
4081 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4082 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4083 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4084 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4085 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4086 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4087
4088 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4089 Assert.IsNotNull (entry, "#B1");
4090 Assert.IsNotNull (entry.Category, "#B2");
4091 Assert.AreEqual ("(0)", entry.Category, "#B3");
4092 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4093 Assert.IsNotNull (entry.Data, "#B5");
4094 Assert.AreEqual (0, entry.Data.Length, "#B6");
4095 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
4096 Assert.AreEqual (0, entry.EventID, "#B8");
4097 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4098 Assert.IsNotNull (entry.MachineName, "#B10");
4099 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4100 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4101 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4102 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
4103 Assert.IsNotNull (entry.Source, "#B15");
4104 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4105 Assert.IsNull (entry.UserName, "#B17");
4106 }
4107 } finally {
4108 if (EventLog.Exists ("monologtemp"))
4109 EventLog.Delete ("monologtemp");
4110 }
4111 }
4112
4113 [Test]
4114 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4115 public void WriteEntry2_Source_Empty ()
4116 {
4117 EventLog eventLog = new EventLog ("monologtemp");
4118 eventLog.WriteEntry ("test", EventLogEntryType.Information);
4119 }
4120
4121 [Test]
4122 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
4123 public void WriteEntry2_Type_NotDefined ()
4124 {
4125 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
4126 eventLog.WriteEntry ("test", (EventLogEntryType) 666);
4127 }
4128
4129 [Test]
4130 public void WriteEntry3 ()
4131 {
4132 if (EventLogImplType == NULL_IMPL)
4133 // test cannot pass with NULL implementation
4134 Assert.Ignore ("No EventLogImplType.");
4135
4136 if (EventLog.SourceExists ("monotempsource", "."))
4137 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4138
4139 if (EventLog.Exists ("monologtemp", "."))
4140 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4141
4142 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4143 try {
4144 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4145 EventLog.WriteEntry ("monotempsource", "WriteEntry3a");
4146
4147 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4148 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4149 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4150 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4151 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4152 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4153
4154 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4155 Assert.IsNotNull (entry, "#B1");
4156 Assert.IsNotNull (entry.Category, "#B2");
4157 Assert.AreEqual ("(0)", entry.Category, "#B3");
4158 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4159 Assert.IsNotNull (entry.Data, "#B5");
4160 Assert.AreEqual (0, entry.Data.Length, "#B6");
4161 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
4162 Assert.AreEqual (0, entry.EventID, "#B8");
4163 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4164 Assert.IsNotNull (entry.MachineName, "#B10");
4165 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4166 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4167 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4168 Assert.AreEqual ("WriteEntry3a", entry.ReplacementStrings [0], "#B14");
4169 Assert.IsNotNull (entry.Source, "#B15");
4170 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4171 Assert.IsNull (entry.UserName, "#B17");
4172
4173 EventLog.WriteEntry ("monotempsource", "WriteEntry3b"
4174 + Environment.NewLine + "ok");
4175
4176 entry = eventLog.Entries [eventLog.Entries.Count - 1];
4177 Assert.IsNotNull (entry, "#C1");
4178 Assert.IsNotNull (entry.Category, "#C2");
4179 Assert.AreEqual ("(0)", entry.Category, "#C3");
4180 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
4181 Assert.IsNotNull (entry.Data, "#C5");
4182 Assert.AreEqual (0, entry.Data.Length, "#C6");
4183 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#C7");
4184 Assert.AreEqual (0, entry.EventID, "#C8");
4185 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
4186 Assert.IsNotNull (entry.MachineName, "#C10");
4187 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
4188 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
4189 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
4190 Assert.AreEqual ("WriteEntry3b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
4191 Assert.IsNotNull (entry.Source, "#C15");
4192 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
4193 Assert.IsNull (entry.UserName, "#C17");
4194 }
4195 } finally {
4196 if (EventLog.Exists ("monologtemp"))
4197 EventLog.Delete ("monologtemp");
4198 }
4199 }
4200
4201 [Test]
4202 public void WriteEntry3_Message_Empty ()
4203 {
4204 if (EventLogImplType == NULL_IMPL)
4205 // test cannot pass with NULL implementation
4206 Assert.Ignore ("No EventLogImplType.");
4207
4208 if (EventLog.SourceExists ("monotempsource", "."))
4209 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4210
4211 if (EventLog.Exists ("monologtemp", "."))
4212 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4213
4214 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4215 try {
4216 EventLog.WriteEntry ("monotempsource", string.Empty);
4217
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.ToUpper(), entry.MachineName.ToUpper(), "#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");
4237 }
4238 } finally {
4239 if (EventLog.Exists ("monologtemp"))
4240 EventLog.Delete ("monologtemp");
4241 }
4242 }
4243
4244 [Test]
4245 public void WriteEntry3_Message_Null ()
4246 {
4247 if (EventLogImplType == NULL_IMPL)
4248 // test cannot pass with NULL implementation
4249 Assert.Ignore ("No EventLogImplType.");
4250
4251 if (EventLog.SourceExists ("monotempsource", "."))
4252 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4253
4254 if (EventLog.Exists ("monologtemp", "."))
4255 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4256
4257 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4258 try {
4259 EventLog.WriteEntry ("monotempsource", null);
4260
4261 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4262 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4263 Assert.IsNotNull (entry, "#A1");
4264 Assert.IsNotNull (entry.Category, "#A2");
4265 Assert.AreEqual ("(0)", entry.Category, "#A3");
4266 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
4267 Assert.IsNotNull (entry.Data, "#A5");
4268 Assert.AreEqual (0, entry.Data.Length, "#A6");
4269 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#A7");
4270 Assert.AreEqual (0, entry.EventID, "#A8");
4271 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
4272 Assert.IsNotNull (entry.MachineName, "#A10");
4273 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#A11");
4274 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
4275 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
4276 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
4277 Assert.IsNotNull (entry.Source, "#A15");
4278 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
4279 Assert.IsNull (entry.UserName, "#A17");
4280 }
4281 } finally {
4282 if (EventLog.Exists ("monologtemp"))
4283 EventLog.Delete ("monologtemp");
4284 }
4285 }
4286
4287 [Test]
4288 public void WriteEntry3_Source_DoesNotExist ()
4289 {
4290 if (EventLogImplType == NULL_IMPL)
4291 // test cannot pass with NULL implementation
4292 Assert.Ignore ("No EventLogImplType.");
4293
4294 if (EventLog.SourceExists ("monotempsource", "."))
4295 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4296
4297 bool applicationLogExists = EventLog.Exists ("Application");
4298 try {
4299 EventLog.WriteEntry ("monotempsource", "test");
4300
4301 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
4302 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
4303 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
4304
4305 if (EventLogImplType == WIN32_IMPL)
4306 // win32 API does not return entries in order for
4307 // Application log
4308 return;
4309
4310 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
4311 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4312 Assert.IsNotNull (entry, "#B1");
4313 Assert.IsNotNull (entry.Category, "#B2");
4314 Assert.AreEqual ("(0)", entry.Category, "#B3");
4315 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4316 Assert.IsNotNull (entry.Data, "#B5");
4317 Assert.AreEqual (0, entry.Data.Length, "#B6");
4318 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
4319 Assert.AreEqual (0, entry.EventID, "#B8");
4320 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4321 Assert.IsNotNull (entry.MachineName, "#B10");
4322 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4323 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4324 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4325 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
4326 Assert.IsNotNull (entry.Source, "#B15");
4327 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4328 Assert.IsNull (entry.UserName, "#B17");
4329 }
4330 } finally {
4331 if (!applicationLogExists) {
4332 if (EventLog.Exists ("Application"))
4333 EventLog.Delete ("Application");
4334 } else {
4335 if (EventLog.SourceExists ("monotempsource", "."))
4336 EventLog.DeleteEventSource ("monotempsource", ".");
4337 }
4338 }
4339 }
4340
4341 [Test]
4342 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4343 public void WriteEntry3_Source_Empty ()
4344 {
4345 EventLog.WriteEntry (string.Empty, "test");
4346 }
4347
4348 [Test]
4349 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4350 public void WriteEntry3_Source_Null ()
4351 {
4352 EventLog.WriteEntry (null, "test");
4353 }
4354
4355 [Test]
4356 public void WriteEntry4 ()
4357 {
4358 if (EventLogImplType == NULL_IMPL)
4359 // test cannot pass with NULL implementation
4360 Assert.Ignore ("No EventLogImplType.");
4361
4362 if (EventLog.SourceExists ("monotempsource", "."))
4363 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4364
4365 if (EventLog.Exists ("monologtemp", "."))
4366 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4367
4368 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4369 try {
4370 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4371 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Information, 56);
4372 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4373 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4374 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4375 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4376 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4377 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4378
4379 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4380 Assert.IsNotNull (entry, "#B1");
4381 Assert.IsNotNull (entry.Category, "#B2");
4382 Assert.AreEqual ("(0)", entry.Category, "#B3");
4383 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4384 Assert.IsNotNull (entry.Data, "#B5");
4385 Assert.AreEqual (0, entry.Data.Length, "#B6");
4386 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
4387 Assert.AreEqual (56, entry.EventID, "#B8");
4388 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4389 Assert.IsNotNull (entry.MachineName, "#B10");
4390 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4391 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4392 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4393 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
4394 Assert.IsNotNull (entry.Source, "#B15");
4395 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4396 Assert.IsNull (entry.UserName, "#B17");
4397
4398 eventLog.WriteEntry ("WriteEntry2", EventLogEntryType.Error, 0);
4399
4400 entry = eventLog.Entries [eventLog.Entries.Count - 1];
4401 Assert.IsNotNull (entry, "#C1");
4402 Assert.IsNotNull (entry.Category, "#C2");
4403 Assert.AreEqual ("(0)", entry.Category, "#C3");
4404 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
4405 Assert.IsNotNull (entry.Data, "#C5");
4406 Assert.AreEqual (0, entry.Data.Length, "#C6");
4407 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
4408 Assert.AreEqual (0, entry.EventID, "#C8");
4409 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
4410 Assert.IsNotNull (entry.MachineName, "#C10");
4411 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
4412 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
4413 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
4414 Assert.AreEqual ("WriteEntry2", entry.ReplacementStrings [0], "#C14");
4415 Assert.IsNotNull (entry.Source, "#C15");
4416 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
4417 Assert.IsNull (entry.UserName, "#C17");
4418
4419 eventLog.WriteEntry ("WriteEntry2", EventLogEntryType.Error, ushort.MaxValue);
4420
4421 entry = eventLog.Entries [eventLog.Entries.Count - 1];
4422 Assert.IsNotNull (entry, "#D1");
4423 Assert.IsNotNull (entry.Category, "#D2");
4424 Assert.AreEqual ("(0)", entry.Category, "#D3");
4425 Assert.AreEqual (0, entry.CategoryNumber, "#D4");
4426 Assert.IsNotNull (entry.Data, "#D5");
4427 Assert.AreEqual (0, entry.Data.Length, "#D6");
4428 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
4429 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
4430 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
4431 Assert.IsNotNull (entry.MachineName, "#D10");
4432 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#D11");
4433 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
4434 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
4435 Assert.AreEqual ("WriteEntry2", entry.ReplacementStrings [0], "#D14");
4436 Assert.IsNotNull (entry.Source, "#D15");
4437 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
4438 Assert.IsNull (entry.UserName, "#D17");
4439 }
4440 } finally {
4441 if (EventLog.Exists ("monologtemp"))
4442 EventLog.Delete ("monologtemp");
4443 }
4444 }
4445
4446 [Test]
4447 public void WriteEntry4_EventID_Invalid ()
4448 {
4449 if (EventLogImplType == NULL_IMPL)
4450 // test cannot pass with NULL implementation
4451 Assert.Ignore ("No EventLogImplType.");
4452
4453 if (EventLog.SourceExists ("monotempsource", "."))
4454 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4455
4456 if (EventLog.Exists ("monologtemp", "."))
4457 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4458
4459 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
4460
4461 try {
4462 eventLog.WriteEntry ("test", EventLogEntryType.Information, -1);
4463 Assert.Fail ("#A1");
4464 } catch (ArgumentException ex) {
4465 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
4466 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
4467 Assert.IsNotNull (ex.Message, "#A3");
4468 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
4469 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
4470 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
4471 Assert.IsNull (ex.InnerException, "#A7");
4472 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#A8");
4473 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
4474 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
4475 } finally {
4476 if (EventLog.Exists ("monologtemp"))
4477 EventLog.Delete ("monologtemp");
4478 }
4479
4480 try {
4481 eventLog.WriteEntry ("test", EventLogEntryType.Information, 65536);
4482 Assert.Fail ("#B1");
4483 } catch (ArgumentException ex) {
4484 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
4485 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
4486 Assert.IsNotNull (ex.Message, "#B3");
4487 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
4488 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
4489 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
4490 Assert.IsNull (ex.InnerException, "#B7");
4491 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#B8");
4492 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
4493 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
4494 } finally {
4495 if (EventLog.Exists ("monologtemp"))
4496 EventLog.Delete ("monologtemp");
4497 }
4498 }
4499
4500 [Test]
4501 public void WriteEntry4_Log_Empty ()
4502 {
4503 if (EventLogImplType == NULL_IMPL)
4504 // test cannot pass with NULL implementation
4505 Assert.Ignore ("No EventLogImplType.");
4506
4507 if (EventLog.SourceExists ("monotempsource", "."))
4508 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4509
4510 bool applicationLogExists = EventLog.Exists ("Application", ".");
4511
4512 // specified source does not exist, so use Application log
4513 try {
4514 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
4515 eventLog.WriteEntry ("WriteEntry1_Log_Empty", EventLogEntryType.Error, 555);
4516 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4517 Assert.AreEqual ("Application", eventLog.Log, "#A2");
4518 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4519 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
4520 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4521 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4522 }
4523 } finally {
4524 if (!applicationLogExists) {
4525 if (EventLog.Exists ("Application"))
4526 EventLog.Delete ("Application");
4527 } else {
4528 if (EventLog.SourceExists ("monotempsource", "."))
4529 EventLog.DeleteEventSource ("monotempsource", ".");
4530 }
4531 }
4532 }
4533
4534 [Test]
4535 public void WriteEntry4_Log_Mismatch ()
4536 {
4537 if (EventLogImplType == NULL_IMPL)
4538 // test cannot pass with NULL implementation
4539 Assert.Ignore ("No EventLogImplType.");
4540
4541 if (EventLog.SourceExists ("monotempsource", "."))
4542 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4543
4544 if (EventLog.Exists ("monologtemp", "."))
4545 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4546
4547 if (EventLog.Exists ("monologother", "."))
4548 Assert.Ignore ("Event log 'monologother' should not exist.");
4549
4550 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4551 try {
4552 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
4553 // valid message
4554 try {
4555 eventLog.WriteEntry ("WriteEntry4_Log_Mismatch1",
4556 EventLogEntryType.Error, 555);
4557 Assert.Fail ("#A1");
4558 } catch (ArgumentException ex) {
4559 // The source 'monotempsource' is not registered in log
4560 // 'monologother' (it is registered in log 'monologtemp').
4561 // The Source and Log properties must be matched, or you may
4562 // set Log to the empty string, and it will automatically be
4563 // matched to the Source property
4564 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
4565 Assert.IsNotNull (ex.Message, "#A3");
4566 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
4567 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
4568 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
4569 Assert.IsNull (ex.InnerException, "#A7");
4570 }
4571
4572 // invalid type
4573 try {
4574 eventLog.WriteEntry ("WriteEntry4_Log_Mismatch2",
4575 (EventLogEntryType) 666, 555);
4576 Assert.Fail ("#B1");
4577 } catch (InvalidEnumArgumentException) {
4578 }
4579
4580 // invalid eventID
4581 try {
4582 eventLog.WriteEntry ("WriteEntry4_Log_Mismatch3",
4583 EventLogEntryType.Error, -1);
4584 Assert.Fail ("#C1");
4585 } catch (ArgumentException ex) {
4586 // The source 'monotempsource' is not registered in log
4587 // 'monologother' (it is registered in log 'monologtemp').
4588 // The Source and Log properties must be matched, or you may
4589 // set Log to the empty string, and it will automatically be
4590 // matched to the Source property
4591 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
4592 Assert.IsNotNull (ex.Message, "#C3");
4593 Assert.IsFalse (ex.Message.IndexOf ("'monotempsource'") != -1, "#C4");
4594 Assert.IsFalse (ex.Message.IndexOf ("'monologother'") != -1, "#C5");
4595 Assert.IsFalse (ex.Message.IndexOf ("'monologtemp'") != -1, "#C6");
4596 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#C7");
4597 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#C8");
4598 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#C9");
4599 Assert.IsNull (ex.InnerException, "#C10");
4600 }
4601 }
4602 } finally {
4603 if (EventLog.Exists ("monologtemp"))
4604 EventLog.Delete ("monologtemp");
4605
4606 if (EventLog.Exists ("monologother"))
4607 EventLog.Delete ("monologother");
4608 }
4609 }
4610
4611 [Test]
4612 public void WriteEntry4_Message_Empty ()
4613 {
4614 if (EventLogImplType == NULL_IMPL)
4615 // test cannot pass with NULL implementation
4616 Assert.Ignore ("No EventLogImplType.");
4617
4618 if (EventLog.SourceExists ("monotempsource", "."))
4619 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4620
4621 if (EventLog.Exists ("monologtemp", "."))
4622 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4623
4624 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4625 try {
4626 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4627 eventLog.WriteEntry (string.Empty, EventLogEntryType.FailureAudit, 888);
4628 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4629 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4630 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4631 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4632 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4633 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4634
4635 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4636 Assert.IsNotNull (entry, "#B1");
4637 Assert.IsNotNull (entry.Category, "#B2");
4638 Assert.AreEqual ("(0)", entry.Category, "#B3");
4639 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4640 Assert.IsNotNull (entry.Data, "#B5");
4641 Assert.AreEqual (0, entry.Data.Length, "#B6");
4642 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
4643 Assert.AreEqual (888, entry.EventID, "#B8");
4644 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4645 Assert.IsNotNull (entry.MachineName, "#B10");
4646 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4647 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4648 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4649 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
4650 Assert.IsNotNull (entry.Source, "#B15");
4651 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4652 Assert.IsNull (entry.UserName, "#B17");
4653 }
4654 } finally {
4655 if (EventLog.Exists ("monologtemp"))
4656 EventLog.Delete ("monologtemp");
4657 }
4658 }
4659
4660 [Test]
4661 public void WriteEntry4_Message_Null ()
4662 {
4663 if (EventLogImplType == NULL_IMPL)
4664 // test cannot pass with NULL implementation
4665 Assert.Ignore ("No EventLogImplType.");
4666
4667 if (EventLog.SourceExists ("monotempsource", "."))
4668 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4669
4670 if (EventLog.Exists ("monologtemp", "."))
4671 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4672
4673 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4674 try {
4675 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4676 eventLog.WriteEntry (null, EventLogEntryType.SuccessAudit, 343);
4677 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4678 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4679 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4680 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4681 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4682 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4683
4684 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4685 Assert.IsNotNull (entry, "#B1");
4686 Assert.IsNotNull (entry.Category, "#B2");
4687 Assert.AreEqual ("(0)", entry.Category, "#B3");
4688 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4689 Assert.IsNotNull (entry.Data, "#B5");
4690 Assert.AreEqual (0, entry.Data.Length, "#B6");
4691 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
4692 Assert.AreEqual (343, entry.EventID, "#B8");
4693 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4694 Assert.IsNotNull (entry.MachineName, "#B10");
4695 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4696 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4697 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4698 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
4699 Assert.IsNotNull (entry.Source, "#B15");
4700 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4701 Assert.IsNull (entry.UserName, "#B17");
4702 }
4703 } finally {
4704 if (EventLog.Exists ("monologtemp"))
4705 EventLog.Delete ("monologtemp");
4706 }
4707 }
4708
4709 [Test]
4710 public void WriteEntry4_Source_DoesNotExist ()
4711 {
4712 if (EventLogImplType == NULL_IMPL)
4713 // test cannot pass with NULL implementation
4714 Assert.Ignore ("No EventLogImplType.");
4715
4716 if (EventLog.SourceExists ("monotempsource", "."))
4717 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4718
4719 if (EventLog.SourceExists ("monoothersource", "."))
4720 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
4721
4722 if (EventLog.Exists ("monologtemp", "."))
4723 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4724
4725 EventLog.CreateEventSource ("monoothersource", "monologtemp");
4726 try {
4727 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4728 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Warning, 2);
4729 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4730 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4731 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4732 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4733 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4734 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4735
4736 if (EventLogImplType == WIN32_IMPL)
4737 // win32 API does not return entries in order for
4738 // Application log
4739 return;
4740
4741 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4742 Assert.IsNotNull (entry, "#B1");
4743 Assert.IsNotNull (entry.Category, "#B2");
4744 Assert.AreEqual ("(0)", entry.Category, "#B3");
4745 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4746 Assert.IsNotNull (entry.Data, "#B5");
4747 Assert.AreEqual (0, entry.Data.Length, "#B6");
4748 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
4749 Assert.AreEqual (2, entry.EventID, "#B8");
4750 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4751 Assert.IsNotNull (entry.MachineName, "#B10");
4752 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4753 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4754 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4755 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
4756 Assert.IsNotNull (entry.Source, "#B15");
4757 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4758 Assert.IsNull (entry.UserName, "#B17");
4759 }
4760 } finally {
4761 if (EventLog.Exists ("monologtemp"))
4762 EventLog.Delete ("monologtemp");
4763 }
4764 }
4765
4766 [Test]
4767 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4768 public void WriteEntry4_Source_Empty ()
4769 {
4770 EventLog eventLog = new EventLog ("monologtemp");
4771 eventLog.WriteEntry ("test", EventLogEntryType.Information, 56);
4772 }
4773
4774 [Test]
4775 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
4776 public void WriteEntry4_Type_NotDefined ()
4777 {
4778 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
4779 eventLog.WriteEntry ("test", (EventLogEntryType) 666, 44);
4780 }
4781
4782 [Test]
4783 public void WriteEntry5 ()
4784 {
4785 if (EventLogImplType == NULL_IMPL)
4786 // test cannot pass with NULL implementation
4787 Assert.Ignore ("No EventLogImplType.");
4788
4789 if (EventLog.SourceExists ("monotempsource", "."))
4790 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4791
4792 if (EventLog.Exists ("monologtemp", "."))
4793 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4794
4795 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4796 try {
4797 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4798 EventLog.WriteEntry ("monotempsource", "WriteEntry3a",
4799 EventLogEntryType.Information);
4800
4801 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
4802 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
4803 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
4804 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
4805 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
4806 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
4807
4808 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4809 Assert.IsNotNull (entry, "#B1");
4810 Assert.IsNotNull (entry.Category, "#B2");
4811 Assert.AreEqual ("(0)", entry.Category, "#B3");
4812 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4813 Assert.IsNotNull (entry.Data, "#B5");
4814 Assert.AreEqual (0, entry.Data.Length, "#B6");
4815 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
4816 Assert.AreEqual (0, entry.EventID, "#B8");
4817 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4818 Assert.IsNotNull (entry.MachineName, "#B10");
4819 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4820 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4821 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4822 Assert.AreEqual ("WriteEntry3a", entry.ReplacementStrings [0], "#B14");
4823 Assert.IsNotNull (entry.Source, "#B15");
4824 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4825 Assert.IsNull (entry.UserName, "#B17");
4826
4827 EventLog.WriteEntry ("monotempsource", "WriteEntry3b"
4828 + Environment.NewLine + "ok", EventLogEntryType.Error);
4829
4830 entry = eventLog.Entries [eventLog.Entries.Count - 1];
4831 Assert.IsNotNull (entry, "#C1");
4832 Assert.IsNotNull (entry.Category, "#C2");
4833 Assert.AreEqual ("(0)", entry.Category, "#C3");
4834 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
4835 Assert.IsNotNull (entry.Data, "#C5");
4836 Assert.AreEqual (0, entry.Data.Length, "#C6");
4837 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
4838 Assert.AreEqual (0, entry.EventID, "#C8");
4839 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
4840 Assert.IsNotNull (entry.MachineName, "#C10");
4841 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
4842 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
4843 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
4844 Assert.AreEqual ("WriteEntry3b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
4845 Assert.IsNotNull (entry.Source, "#C15");
4846 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
4847 Assert.IsNull (entry.UserName, "#C17");
4848 }
4849 } finally {
4850 if (EventLog.Exists ("monologtemp"))
4851 EventLog.Delete ("monologtemp");
4852 }
4853 }
4854
4855 [Test]
4856 public void WriteEntry5_Message_Empty ()
4857 {
4858 if (EventLogImplType == NULL_IMPL)
4859 // test cannot pass with NULL implementation
4860 Assert.Ignore ("No EventLogImplType.");
4861
4862 if (EventLog.SourceExists ("monotempsource", "."))
4863 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4864
4865 if (EventLog.Exists ("monologtemp", "."))
4866 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4867
4868 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4869 try {
4870 EventLog.WriteEntry ("monotempsource", string.Empty, EventLogEntryType.Error);
4871
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.Error, 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.ToUpper(), entry.MachineName.ToUpper(), "#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");
4891 }
4892 } finally {
4893 if (EventLog.Exists ("monologtemp"))
4894 EventLog.Delete ("monologtemp");
4895 }
4896 }
4897
4898 [Test]
4899 public void WriteEntry5_Message_Null ()
4900 {
4901 if (EventLogImplType == NULL_IMPL)
4902 // test cannot pass with NULL implementation
4903 Assert.Ignore ("No EventLogImplType.");
4904
4905 if (EventLog.SourceExists ("monotempsource", "."))
4906 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4907
4908 if (EventLog.Exists ("monologtemp", "."))
4909 Assert.Ignore ("Event log 'monologtemp' should not exist.");
4910
4911 EventLog.CreateEventSource ("monotempsource", "monologtemp");
4912 try {
4913 EventLog.WriteEntry ("monotempsource", null, EventLogEntryType.FailureAudit);
4914
4915 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
4916 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4917 Assert.IsNotNull (entry, "#A1");
4918 Assert.IsNotNull (entry.Category, "#A2");
4919 Assert.AreEqual ("(0)", entry.Category, "#A3");
4920 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
4921 Assert.IsNotNull (entry.Data, "#A5");
4922 Assert.AreEqual (0, entry.Data.Length, "#A6");
4923 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#A7");
4924 Assert.AreEqual (0, entry.EventID, "#A8");
4925 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
4926 Assert.IsNotNull (entry.MachineName, "#A10");
4927 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#A11");
4928 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
4929 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
4930 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
4931 Assert.IsNotNull (entry.Source, "#A15");
4932 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
4933 Assert.IsNull (entry.UserName, "#A17");
4934 }
4935 } finally {
4936 if (EventLog.Exists ("monologtemp"))
4937 EventLog.Delete ("monologtemp");
4938 }
4939 }
4940
4941 [Test]
4942 public void WriteEntry5_Source_DoesNotExist ()
4943 {
4944 if (EventLogImplType == NULL_IMPL)
4945 // test cannot pass with NULL implementation
4946 Assert.Ignore ("No EventLogImplType.");
4947
4948 if (EventLog.SourceExists ("monotempsource", "."))
4949 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
4950
4951 bool applicationLogExists = EventLog.Exists ("Application");
4952 try {
4953 EventLog.WriteEntry ("monotempsource", "test", EventLogEntryType.SuccessAudit);
4954
4955 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
4956 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
4957 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
4958
4959 if (EventLogImplType == WIN32_IMPL)
4960 // win32 API does not return entries in order for
4961 // Application log
4962 return;
4963
4964 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
4965 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
4966 Assert.IsNotNull (entry, "#B1");
4967 Assert.IsNotNull (entry.Category, "#B2");
4968 Assert.AreEqual ("(0)", entry.Category, "#B3");
4969 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
4970 Assert.IsNotNull (entry.Data, "#B5");
4971 Assert.AreEqual (0, entry.Data.Length, "#B6");
4972 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
4973 Assert.AreEqual (0, entry.EventID, "#B8");
4974 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
4975 Assert.IsNotNull (entry.MachineName, "#B10");
4976 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
4977 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
4978 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
4979 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
4980 Assert.IsNotNull (entry.Source, "#B15");
4981 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
4982 Assert.IsNull (entry.UserName, "#B17");
4983 }
4984 } finally {
4985 if (!applicationLogExists) {
4986 if (EventLog.Exists ("Application"))
4987 EventLog.Delete ("Application");
4988 } else {
4989 if (EventLog.SourceExists ("monotempsource", "."))
4990 EventLog.DeleteEventSource ("monotempsource", ".");
4991 }
4992 }
4993 }
4994
4995 [Test]
4996 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
4997 public void WriteEntry5_Source_Empty ()
4998 {
4999 EventLog.WriteEntry (string.Empty, "test", EventLogEntryType.Warning);
5000 }
5001
5002 [Test]
5003 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
5004 public void WriteEntry5_Source_Null ()
5005 {
5006 EventLog.WriteEntry (null, "test", EventLogEntryType.Error);
5007 }
5008
5009 [Test]
5010 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
5011 public void WriteEntry5_Type_NotDefined ()
5012 {
5013 EventLog.WriteEntry ("monotempsource", "test", (EventLogEntryType) 666);
5014 }
5015
5016 [Test]
5017 public void WriteEntry6 ()
5018 {
5019 if (EventLogImplType == NULL_IMPL)
5020 // test cannot pass with NULL implementation
5021 Assert.Ignore ("No EventLogImplType.");
5022
5023 if (EventLog.SourceExists ("monotempsource", "."))
5024 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5025
5026 if (EventLog.Exists ("monologtemp", "."))
5027 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5028
5029 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5030 try {
5031 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5032 eventLog.WriteEntry ("WriteEntry6a", EventLogEntryType.Information, 56, 3);
5033
5034 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5035 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5036 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5037 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5038 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5039 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5040
5041 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5042 Assert.IsNotNull (entry, "#B1");
5043 Assert.IsNotNull (entry.Category, "#B2");
5044 Assert.AreEqual ("(3)", entry.Category, "#B3");
5045 Assert.AreEqual (3, entry.CategoryNumber, "#B4");
5046 Assert.IsNotNull (entry.Data, "#B5");
5047 Assert.AreEqual (0, entry.Data.Length, "#B6");
5048 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
5049 Assert.AreEqual (56, entry.EventID, "#B8");
5050 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5051 Assert.IsNotNull (entry.MachineName, "#B10");
5052 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
5053 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5054 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5055 Assert.AreEqual ("WriteEntry6a", entry.ReplacementStrings [0], "#B14");
5056 Assert.IsNotNull (entry.Source, "#B15");
5057 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5058 Assert.IsNull (entry.UserName, "#B17");
5059
5060 eventLog.WriteEntry ("WriteEntry6b" + Environment.NewLine + "ok",
5061 EventLogEntryType.Error, 0, 0);
5062
5063 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5064 Assert.IsNotNull (entry, "#C1");
5065 Assert.IsNotNull (entry.Category, "#C2");
5066 Assert.AreEqual ("(0)", entry.Category, "#C3");
5067 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
5068 Assert.IsNotNull (entry.Data, "#C5");
5069 Assert.AreEqual (0, entry.Data.Length, "#C6");
5070 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
5071 Assert.AreEqual (0, entry.EventID, "#C8");
5072 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
5073 Assert.IsNotNull (entry.MachineName, "#C10");
5074 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
5075 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
5076 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
5077 Assert.AreEqual ("WriteEntry6b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
5078 Assert.IsNotNull (entry.Source, "#C15");
5079 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
5080 Assert.IsNull (entry.UserName, "#C17");
5081
5082 eventLog.WriteEntry ("WriteEntry6c", EventLogEntryType.Error,
5083 ushort.MaxValue, short.MaxValue);
5084
5085 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5086 Assert.IsNotNull (entry, "#D1");
5087 Assert.IsNotNull (entry.Category, "#D2");
5088 Assert.AreEqual ("(32767)", entry.Category, "#D3");
5089 Assert.AreEqual (short.MaxValue, entry.CategoryNumber, "#D4");
5090 Assert.IsNotNull (entry.Data, "#D5");
5091 Assert.AreEqual (0, entry.Data.Length, "#D6");
5092 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
5093 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
5094 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
5095 Assert.IsNotNull (entry.MachineName, "#D10");
5096 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#D11");
5097 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
5098 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
5099 Assert.AreEqual ("WriteEntry6c", entry.ReplacementStrings [0], "#D14");
5100 Assert.IsNotNull (entry.Source, "#D15");
5101 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
5102 Assert.IsNull (entry.UserName, "#D17");
5103 }
5104 } finally {
5105 if (EventLog.Exists ("monologtemp"))
5106 EventLog.Delete ("monologtemp");
5107 }
5108 }
5109
5110 [Test]
5111 public void WriteEntry6_EventID_Invalid ()
5112 {
5113 if (EventLogImplType == NULL_IMPL)
5114 // test cannot pass with NULL implementation
5115 Assert.Ignore ("No EventLogImplType.");
5116
5117 if (EventLog.SourceExists ("monotempsource", "."))
5118 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5119
5120 if (EventLog.Exists ("monologtemp", "."))
5121 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5122
5123 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
5124
5125 try {
5126 eventLog.WriteEntry ("test", EventLogEntryType.Information, -1, 5);
5127 Assert.Fail ("#A1");
5128 } catch (ArgumentException ex) {
5129 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
5130 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5131 Assert.IsNotNull (ex.Message, "#A3");
5132 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
5133 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
5134 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
5135 Assert.IsNull (ex.InnerException, "#A7");
5136 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#A8");
5137 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
5138 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
5139 } finally {
5140 if (EventLog.Exists ("monologtemp"))
5141 EventLog.Delete ("monologtemp");
5142 }
5143
5144 try {
5145 eventLog.WriteEntry ("test", EventLogEntryType.Information, 65536, 5);
5146 Assert.Fail ("#B1");
5147 } catch (ArgumentException ex) {
5148 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
5149 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
5150 Assert.IsNotNull (ex.Message, "#B3");
5151 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
5152 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
5153 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
5154 Assert.IsNull (ex.InnerException, "#B7");
5155 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#B8");
5156 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
5157 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
5158 } finally {
5159 if (EventLog.Exists ("monologtemp"))
5160 EventLog.Delete ("monologtemp");
5161 }
5162 }
5163
5164 [Test]
5165 public void WriteEntry6_Log_Empty ()
5166 {
5167 if (EventLogImplType == NULL_IMPL)
5168 // test cannot pass with NULL implementation
5169 Assert.Ignore ("No EventLogImplType.");
5170
5171 if (EventLog.SourceExists ("monotempsource", "."))
5172 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5173
5174 bool applicationLogExists = EventLog.Exists ("Application", ".");
5175
5176 // specified source does not exist, so use Application log
5177 try {
5178 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
5179 eventLog.WriteEntry ("WriteEntry1_Log_Empty", EventLogEntryType.Error, 555, 5);
5180 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5181 Assert.AreEqual ("Application", eventLog.Log, "#A2");
5182 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5183 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
5184 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5185 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5186 }
5187 } finally {
5188 if (!applicationLogExists) {
5189 if (EventLog.Exists ("Application"))
5190 EventLog.Delete ("Application");
5191 } else {
5192 if (EventLog.SourceExists ("monotempsource", "."))
5193 EventLog.DeleteEventSource ("monotempsource", ".");
5194 }
5195 }
5196 }
5197
5198 [Test]
5199 public void WriteEntry6_Log_Mismatch ()
5200 {
5201 if (EventLogImplType == NULL_IMPL)
5202 // test cannot pass with NULL implementation
5203 Assert.Ignore ("No EventLogImplType.");
5204
5205 if (EventLog.SourceExists ("monotempsource", "."))
5206 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5207
5208 if (EventLog.Exists ("monologtemp", "."))
5209 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5210
5211 if (EventLog.Exists ("monologother", "."))
5212 Assert.Ignore ("Event log 'monologother' should not exist.");
5213
5214 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5215 try {
5216 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
5217 // valid message
5218 try {
5219 eventLog.WriteEntry ("WriteEntry6_Log_Mismatch1",
5220 EventLogEntryType.Error, 555, 5);
5221 Assert.Fail ("#A1");
5222 } catch (ArgumentException ex) {
5223 // The source 'monotempsource' is not registered in log
5224 // 'monologother' (it is registered in log 'monologtemp').
5225 // The Source and Log properties must be matched, or you may
5226 // set Log to the empty string, and it will automatically be
5227 // matched to the Source property
5228 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5229 Assert.IsNotNull (ex.Message, "#A3");
5230 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
5231 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
5232 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
5233 Assert.IsNull (ex.InnerException, "#A7");
5234 }
5235
5236 // invalid type
5237 try {
5238 eventLog.WriteEntry ("WriteEntry6_Log_Mismatch2",
5239 (EventLogEntryType) 666, 555, 5);
5240 Assert.Fail ("#B1");
5241 } catch (InvalidEnumArgumentException) {
5242 }
5243
5244 // invalid eventID
5245 try {
5246 eventLog.WriteEntry ("WriteEntry6_Log_Mismatch3",
5247 EventLogEntryType.Error, -1, 5);
5248 Assert.Fail ("#C1");
5249 } catch (ArgumentException ex) {
5250 // The source 'monotempsource' is not registered in log
5251 // 'monologother' (it is registered in log 'monologtemp').
5252 // The Source and Log properties must be matched, or you may
5253 // set Log to the empty string, and it will automatically be
5254 // matched to the Source property
5255 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
5256 Assert.IsNotNull (ex.Message, "#C3");
5257 Assert.IsFalse (ex.Message.IndexOf ("'monotempsource'") != -1, "#C4");
5258 Assert.IsFalse (ex.Message.IndexOf ("'monologother'") != -1, "#C5");
5259 Assert.IsFalse (ex.Message.IndexOf ("'monologtemp'") != -1, "#C6");
5260 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#C7");
5261 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#C8");
5262 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#C9");
5263 Assert.IsNull (ex.InnerException, "#C10");
5264 }
5265 }
5266 } finally {
5267 if (EventLog.Exists ("monologtemp"))
5268 EventLog.Delete ("monologtemp");
5269
5270 if (EventLog.Exists ("monologother"))
5271 EventLog.Delete ("monologother");
5272 }
5273 }
5274
5275 [Test]
5276 public void WriteEntry6_Message_Empty ()
5277 {
5278 if (EventLogImplType == NULL_IMPL)
5279 // test cannot pass with NULL implementation
5280 Assert.Ignore ("No EventLogImplType.");
5281
5282 if (EventLog.SourceExists ("monotempsource", "."))
5283 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5284
5285 if (EventLog.Exists ("monologtemp", "."))
5286 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5287
5288 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5289 try {
5290 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5291 eventLog.WriteEntry (string.Empty, EventLogEntryType.FailureAudit, 888, 6);
5292 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5293 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5294 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5295 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5296 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5297 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5298
5299 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5300 Assert.IsNotNull (entry, "#B1");
5301 Assert.IsNotNull (entry.Category, "#B2");
5302 Assert.AreEqual ("(6)", entry.Category, "#B3");
5303 Assert.AreEqual (6, entry.CategoryNumber, "#B4");
5304 Assert.IsNotNull (entry.Data, "#B5");
5305 Assert.AreEqual (0, entry.Data.Length, "#B6");
5306 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
5307 Assert.AreEqual (888, entry.EventID, "#B8");
5308 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5309 Assert.IsNotNull (entry.MachineName, "#B10");
5310 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
5311 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5312 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5313 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
5314 Assert.IsNotNull (entry.Source, "#B15");
5315 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5316 Assert.IsNull (entry.UserName, "#B17");
5317 }
5318 } finally {
5319 if (EventLog.Exists ("monologtemp"))
5320 EventLog.Delete ("monologtemp");
5321 }
5322 }
5323
5324 [Test]
5325 public void WriteEntry6_Message_Null ()
5326 {
5327 if (EventLogImplType == NULL_IMPL)
5328 // test cannot pass with NULL implementation
5329 Assert.Ignore ("No EventLogImplType.");
5330
5331 if (EventLog.SourceExists ("monotempsource", "."))
5332 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5333
5334 if (EventLog.Exists ("monologtemp", "."))
5335 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5336
5337 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5338 try {
5339 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5340 eventLog.WriteEntry (null, EventLogEntryType.SuccessAudit, 343, 8);
5341 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5342 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5343 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5344 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5345 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5346 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5347
5348 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5349 Assert.IsNotNull (entry, "#B1");
5350 Assert.IsNotNull (entry.Category, "#B2");
5351 Assert.AreEqual ("(8)", entry.Category, "#B3");
5352 Assert.AreEqual (8, entry.CategoryNumber, "#B4");
5353 Assert.IsNotNull (entry.Data, "#B5");
5354 Assert.AreEqual (0, entry.Data.Length, "#B6");
5355 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
5356 Assert.AreEqual (343, entry.EventID, "#B8");
5357 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5358 Assert.IsNotNull (entry.MachineName, "#B10");
5359 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
5360 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5361 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5362 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
5363 Assert.IsNotNull (entry.Source, "#B15");
5364 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5365 Assert.IsNull (entry.UserName, "#B17");
5366 }
5367 } finally {
5368 if (EventLog.Exists ("monologtemp"))
5369 EventLog.Delete ("monologtemp");
5370 }
5371 }
5372
5373 [Test]
5374 public void WriteEntry6_Source_DoesNotExist ()
5375 {
5376 if (EventLogImplType == NULL_IMPL)
5377 // test cannot pass with NULL implementation
5378 Assert.Ignore ("No EventLogImplType.");
5379
5380 if (EventLog.SourceExists ("monotempsource", "."))
5381 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5382
5383 if (EventLog.SourceExists ("monoothersource", "."))
5384 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
5385
5386 if (EventLog.Exists ("monologtemp", "."))
5387 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5388
5389 EventLog.CreateEventSource ("monoothersource", "monologtemp");
5390 try {
5391 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5392 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Warning, 2, 4);
5393 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5394 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5395 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5396 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5397 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5398 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5399
5400 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5401 Assert.IsNotNull (entry, "#B1");
5402 Assert.IsNotNull (entry.Category, "#B2");
5403 Assert.AreEqual ("(4)", entry.Category, "#B3");
5404 Assert.AreEqual (4, entry.CategoryNumber, "#B4");
5405 Assert.IsNotNull (entry.Data, "#B5");
5406 Assert.AreEqual (0, entry.Data.Length, "#B6");
5407 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
5408 Assert.AreEqual (2, entry.EventID, "#B8");
5409 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5410 Assert.IsNotNull (entry.MachineName, "#B10");
5411 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
5412 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5413 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5414 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
5415 Assert.IsNotNull (entry.Source, "#B15");
5416 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5417 Assert.IsNull (entry.UserName, "#B17");
5418 }
5419 } finally {
5420 if (EventLog.Exists ("monologtemp"))
5421 EventLog.Delete ("monologtemp");
5422 }
5423 }
5424
5425 [Test]
5426 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
5427 public void WriteEntry6_Source_Empty ()
5428 {
5429 EventLog eventLog = new EventLog ("monologtemp");
5430 eventLog.WriteEntry ("test", EventLogEntryType.Information, 56, 5);
5431 }
5432
5433 [Test]
5434 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
5435 public void WriteEntry6_Type_NotDefined ()
5436 {
5437 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
5438 eventLog.WriteEntry ("test", (EventLogEntryType) 666, 44, 8);
5439 }
5440
5441 [Test]
5442 public void WriteEntry7 ()
5443 {
5444 if (EventLogImplType == NULL_IMPL)
5445 // test cannot pass with NULL implementation
5446 Assert.Ignore ("No EventLogImplType.");
5447
5448 if (EventLog.SourceExists ("monotempsource", "."))
5449 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5450
5451 if (EventLog.Exists ("monologtemp", "."))
5452 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5453
5454 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5455 try {
5456 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5457 EventLog.WriteEntry ("monotempsource", "WriteEntry7a",
5458 EventLogEntryType.Information, 54);
5459
5460 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5461 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5462 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5463 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5464 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5465 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5466
5467 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5468 Assert.IsNotNull (entry, "#B1");
5469 Assert.IsNotNull (entry.Category, "#B2");
5470 Assert.AreEqual ("(0)", entry.Category, "#B3");
5471 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
5472 Assert.IsNotNull (entry.Data, "#B5");
5473 Assert.AreEqual (0, entry.Data.Length, "#B6");
5474 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
5475 Assert.AreEqual (54, entry.EventID, "#B8");
5476 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5477 Assert.IsNotNull (entry.MachineName, "#B10");
5478 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
5479 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5480 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5481 Assert.AreEqual ("WriteEntry7a", entry.ReplacementStrings [0], "#B14");
5482 Assert.IsNotNull (entry.Source, "#B15");
5483 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5484 Assert.IsNull (entry.UserName, "#B17");
5485
5486 EventLog.WriteEntry ("monotempsource", "WriteEntry7b"
5487 + Environment.NewLine + "ok", EventLogEntryType.Error, 0);
5488
5489 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5490 Assert.IsNotNull (entry, "#C1");
5491 Assert.IsNotNull (entry.Category, "#C2");
5492 Assert.AreEqual ("(0)", entry.Category, "#C3");
5493 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
5494 Assert.IsNotNull (entry.Data, "#C5");
5495 Assert.AreEqual (0, entry.Data.Length, "#C6");
5496 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
5497 Assert.AreEqual (0, entry.EventID, "#C8");
5498 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
5499 Assert.IsNotNull (entry.MachineName, "#C10");
5500 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
5501 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
5502 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
5503 Assert.AreEqual ("WriteEntry7b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
5504 Assert.IsNotNull (entry.Source, "#C15");
5505 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
5506 Assert.IsNull (entry.UserName, "#C17");
5507
5508 EventLog.WriteEntry ("monotempsource", "WriteEntry7c"
5509 + Environment.NewLine + "ok", EventLogEntryType.Error,
5510 ushort.MaxValue);
5511
5512 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5513 Assert.IsNotNull (entry, "#D1");
5514 Assert.IsNotNull (entry.Category, "#D2");
5515 Assert.AreEqual ("(0)", entry.Category, "#D3");
5516 Assert.AreEqual (0, entry.CategoryNumber, "#D4");
5517 Assert.IsNotNull (entry.Data, "#D5");
5518 Assert.AreEqual (0, entry.Data.Length, "#D6");
5519 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
5520 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
5521 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
5522 Assert.IsNotNull (entry.MachineName, "#D10");
5523 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#D11");
5524 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
5525 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
5526 Assert.AreEqual ("WriteEntry7c" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#D14");
5527 Assert.IsNotNull (entry.Source, "#D15");
5528 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
5529 Assert.IsNull (entry.UserName, "#D17");
5530 }
5531 } finally {
5532 if (EventLog.Exists ("monologtemp"))
5533 EventLog.Delete ("monologtemp");
5534 }
5535 }
5536
5537 [Test]
5538 public void WriteEntry7_EventID_Invalid ()
5539 {
5540 if (EventLogImplType == NULL_IMPL)
5541 // test cannot pass with NULL implementation
5542 Assert.Ignore ("No EventLogImplType.");
5543
5544 if (EventLog.SourceExists ("monotempsource", "."))
5545 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5546
5547 bool applicationLogExists = EventLog.Exists ("Application", ".");
5548 try {
5549 EventLog.WriteEntry ("monotempsource", "test",
5550 EventLogEntryType.Information, -1);
5551 Assert.Fail ("#A1");
5552 } catch (ArgumentException ex) {
5553 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
5554 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5555 Assert.IsNotNull (ex.Message, "#A3");
5556 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
5557 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
5558 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
5559 Assert.IsNull (ex.InnerException, "#A7");
5560 if (!applicationLogExists)
5561 Assert.IsFalse (EventLog.Exists ("Application"), "#A8");
5562 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
5563 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
5564 } finally {
5565 if (!applicationLogExists) {
5566 if (EventLog.Exists ("Application", "."))
5567 EventLog.Delete ("Application", ".");
5568 } else {
5569 if (EventLog.SourceExists ("monotempsource", "."))
5570 EventLog.DeleteEventSource ("monotempsource", ".");
5571 }
5572 }
5573
5574 try {
5575 EventLog.WriteEntry ("monotempsource", "test",
5576 EventLogEntryType.Information, 65536);
5577 Assert.Fail ("#B1");
5578 } catch (ArgumentException ex) {
5579 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
5580 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
5581 Assert.IsNotNull (ex.Message, "#B3");
5582 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
5583 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
5584 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
5585 Assert.IsNull (ex.InnerException, "#B7");
5586 if (!applicationLogExists)
5587 Assert.IsFalse (EventLog.Exists ("Application"), "#B8");
5588 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
5589 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
5590 } finally {
5591 if (!applicationLogExists) {
5592 if (EventLog.Exists ("Application", "."))
5593 EventLog.Delete ("Application", ".");
5594 } else {
5595 if (EventLog.SourceExists ("monotempsource", "."))
5596 EventLog.DeleteEventSource ("monotempsource", ".");
5597 }
5598 }
5599 }
5600
5601 [Test]
5602 public void WriteEntry7_Message_Empty ()
5603 {
5604 if (EventLogImplType == NULL_IMPL)
5605 // test cannot pass with NULL implementation
5606 Assert.Ignore ("No EventLogImplType.");
5607
5608 if (EventLog.SourceExists ("monotempsource", "."))
5609 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5610
5611 if (EventLog.Exists ("monologtemp", "."))
5612 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5613
5614 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5615 try {
5616 EventLog.WriteEntry ("monotempsource", string.Empty,
5617 EventLogEntryType.Error, 56);
5618
5619 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5620 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5621 Assert.IsNotNull (entry, "#A1");
5622 Assert.IsNotNull (entry.Category, "#A2");
5623 Assert.AreEqual ("(0)", entry.Category, "#A3");
5624 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
5625 Assert.IsNotNull (entry.Data, "#A5");
5626 Assert.AreEqual (0, entry.Data.Length, "#A6");
5627 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#A7");
5628 Assert.AreEqual (56, entry.EventID, "#A8");
5629 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
5630 Assert.IsNotNull (entry.MachineName, "#A10");
5631 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#A11");
5632 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
5633 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
5634 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
5635 Assert.IsNotNull (entry.Source, "#A15");
5636 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
5637 Assert.IsNull (entry.UserName, "#A17");
5638 }
5639 } finally {
5640 if (EventLog.Exists ("monologtemp"))
5641 EventLog.Delete ("monologtemp");
5642 }
5643 }
5644
5645 [Test]
5646 public void WriteEntry7_Message_Null ()
5647 {
5648 if (EventLogImplType == NULL_IMPL)
5649 // test cannot pass with NULL implementation
5650 Assert.Ignore ("No EventLogImplType.");
5651
5652 if (EventLog.SourceExists ("monotempsource", "."))
5653 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5654
5655 if (EventLog.Exists ("monologtemp", "."))
5656 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5657
5658 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5659 try {
5660 EventLog.WriteEntry ("monotempsource", null,
5661 EventLogEntryType.FailureAudit, 76);
5662
5663 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5664 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5665 Assert.IsNotNull (entry, "#A1");
5666 Assert.IsNotNull (entry.Category, "#A2");
5667 Assert.AreEqual ("(0)", entry.Category, "#A3");
5668 Assert.AreEqual (0, entry.CategoryNumber, "#A4");
5669 Assert.IsNotNull (entry.Data, "#A5");
5670 Assert.AreEqual (0, entry.Data.Length, "#A6");
5671 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#A7");
5672 Assert.AreEqual (76, entry.EventID, "#A8");
5673 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
5674 Assert.IsNotNull (entry.MachineName, "#A10");
5675 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#A11");
5676 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
5677 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
5678 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
5679 Assert.IsNotNull (entry.Source, "#A15");
5680 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
5681 Assert.IsNull (entry.UserName, "#A17");
5682 }
5683 } finally {
5684 if (EventLog.Exists ("monologtemp"))
5685 EventLog.Delete ("monologtemp");
5686 }
5687 }
5688
5689 [Test]
5690 public void WriteEntry7_Source_DoesNotExist ()
5691 {
5692 if (EventLogImplType == NULL_IMPL)
5693 // test cannot pass with NULL implementation
5694 Assert.Ignore ("No EventLogImplType.");
5695
5696 if (EventLog.SourceExists ("monotempsource", "."))
5697 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5698
5699 bool applicationLogExists = EventLog.Exists ("Application");
5700 try {
5701 EventLog.WriteEntry ("monotempsource", "test",
5702 EventLogEntryType.SuccessAudit, 89);
5703
5704 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
5705 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
5706 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
5707
5708 if (EventLogImplType == WIN32_IMPL)
5709 // win32 API does not return entries in order for
5710 // Application log
5711 return;
5712
5713 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
5714 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5715 Assert.IsNotNull (entry, "#B1");
5716 Assert.IsNotNull (entry.Category, "#B2");
5717 Assert.AreEqual ("(0)", entry.Category, "#B3");
5718 Assert.AreEqual (0, entry.CategoryNumber, "#B4");
5719 Assert.IsNotNull (entry.Data, "#B5");
5720 Assert.AreEqual (0, entry.Data.Length, "#B6");
5721 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
5722 Assert.AreEqual (89, entry.EventID, "#B8");
5723 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5724 Assert.IsNotNull (entry.MachineName, "#B10");
5725 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
5726 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5727 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5728 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
5729 Assert.IsNotNull (entry.Source, "#B15");
5730 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5731 Assert.IsNull (entry.UserName, "#B17");
5732 }
5733 } finally {
5734 if (!applicationLogExists) {
5735 if (EventLog.Exists ("Application"))
5736 EventLog.Delete ("Application");
5737 } else {
5738 if (EventLog.SourceExists ("monotempsource", "."))
5739 EventLog.DeleteEventSource ("monotempsource", ".");
5740 }
5741 }
5742 }
5743
5744 [Test]
5745 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
5746 public void WriteEntry7_Source_Empty ()
5747 {
5748 EventLog.WriteEntry (string.Empty, "test", EventLogEntryType.Warning, 5);
5749 }
5750
5751 [Test]
5752 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
5753 public void WriteEntry7_Source_Null ()
5754 {
5755 EventLog.WriteEntry (null, "test", EventLogEntryType.Error, 5);
5756 }
5757
5758 [Test]
5759 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
5760 public void WriteEntry7_Type_NotDefined ()
5761 {
5762 EventLog.WriteEntry ("monotempsource", "test", (EventLogEntryType) 666, 4);
5763 }
5764
5765 [Test]
5766 public void WriteEntry8 ()
5767 {
5768 if (EventLogImplType == NULL_IMPL)
5769 // test cannot pass with NULL implementation
5770 Assert.Ignore ("No EventLogImplType.");
5771
5772 if (EventLog.SourceExists ("monotempsource", "."))
5773 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5774
5775 if (EventLog.Exists ("monologtemp", "."))
5776 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5777
5778 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5779 try {
5780 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
5781 byte [] data = new byte [] { 56, 55, 23, 24 };
5782
5783 eventLog.WriteEntry ("WriteEntry8a", EventLogEntryType.Information, 56, 3, data);
5784
5785 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5786 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
5787 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5788 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
5789 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5790 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5791
5792 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
5793 Assert.IsNotNull (entry, "#B1");
5794 Assert.IsNotNull (entry.Category, "#B2");
5795 Assert.AreEqual ("(3)", entry.Category, "#B3");
5796 Assert.AreEqual (3, entry.CategoryNumber, "#B4");
5797 Assert.IsNotNull (entry.Data, "#B5");
5798 Assert.AreEqual (data, entry.Data, "#B6");
5799 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
5800 Assert.AreEqual (56, entry.EventID, "#B8");
5801 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
5802 Assert.IsNotNull (entry.MachineName, "#B10");
5803 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
5804 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
5805 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
5806 Assert.AreEqual ("WriteEntry8a", entry.ReplacementStrings [0], "#B14");
5807 Assert.IsNotNull (entry.Source, "#B15");
5808 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
5809 Assert.IsNull (entry.UserName, "#B17");
5810
5811 eventLog.WriteEntry ("WriteEntry8b" + Environment.NewLine + "ok",
5812 EventLogEntryType.Error, 0, 0, new byte [0]);
5813
5814 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5815 Assert.IsNotNull (entry, "#C1");
5816 Assert.IsNotNull (entry.Category, "#C2");
5817 Assert.AreEqual ("(0)", entry.Category, "#C3");
5818 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
5819 Assert.IsNotNull (entry.Data, "#C5");
5820 Assert.AreEqual (0, entry.Data.Length, "#C6");
5821 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
5822 Assert.AreEqual (0, entry.EventID, "#C8");
5823 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
5824 Assert.IsNotNull (entry.MachineName, "#C10");
5825 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
5826 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
5827 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
5828 Assert.AreEqual ("WriteEntry8b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
5829 Assert.IsNotNull (entry.Source, "#C15");
5830 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
5831 Assert.IsNull (entry.UserName, "#C17");
5832
5833 eventLog.WriteEntry ("WriteEntry8c", EventLogEntryType.Error,
5834 ushort.MaxValue, short.MaxValue, null);
5835
5836 entry = eventLog.Entries [eventLog.Entries.Count - 1];
5837 Assert.IsNotNull (entry, "#D1");
5838 Assert.IsNotNull (entry.Category, "#D2");
5839 Assert.AreEqual ("(32767)", entry.Category, "#D3");
5840 Assert.AreEqual (short.MaxValue, entry.CategoryNumber, "#D4");
5841 Assert.IsNotNull (entry.Data, "#D5");
5842 Assert.AreEqual (0, entry.Data.Length, "#D6");
5843 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
5844 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
5845 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
5846 Assert.IsNotNull (entry.MachineName, "#D10");
5847 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#D11");
5848 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
5849 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
5850 Assert.AreEqual ("WriteEntry8c", entry.ReplacementStrings [0], "#D14");
5851 Assert.IsNotNull (entry.Source, "#D15");
5852 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
5853 Assert.IsNull (entry.UserName, "#D17");
5854 }
5855 } finally {
5856 if (EventLog.Exists ("monologtemp"))
5857 EventLog.Delete ("monologtemp");
5858 }
5859 }
5860
5861 [Test]
5862 public void WriteEntry8_EventID_Invalid ()
5863 {
5864 if (EventLogImplType == NULL_IMPL)
5865 // test cannot pass with NULL implementation
5866 Assert.Ignore ("No EventLogImplType.");
5867
5868 if (EventLog.SourceExists ("monotempsource", "."))
5869 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5870
5871 if (EventLog.Exists ("monologtemp", "."))
5872 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5873
5874 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
5875
5876 try {
5877 eventLog.WriteEntry ("test", EventLogEntryType.Information, -1,
5878 5, new byte [0]);
5879 Assert.Fail ("#A1");
5880 } catch (ArgumentException ex) {
5881 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
5882 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5883 Assert.IsNotNull (ex.Message, "#A3");
5884 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
5885 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
5886 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
5887 Assert.IsNull (ex.InnerException, "#A7");
5888 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#A8");
5889 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
5890 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
5891 } finally {
5892 if (EventLog.Exists ("monologtemp"))
5893 EventLog.Delete ("monologtemp");
5894 }
5895
5896 try {
5897 eventLog.WriteEntry ("test", EventLogEntryType.Information, 65536,
5898 5, new byte [0]);
5899 Assert.Fail ("#B1");
5900 } catch (ArgumentException ex) {
5901 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
5902 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
5903 Assert.IsNotNull (ex.Message, "#B3");
5904 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
5905 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
5906 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
5907 Assert.IsNull (ex.InnerException, "#B7");
5908 Assert.IsFalse (EventLog.Exists ("monologtemp"), "#B8");
5909 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
5910 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
5911 } finally {
5912 if (EventLog.Exists ("monologtemp"))
5913 EventLog.Delete ("monologtemp");
5914 }
5915 }
5916
5917 [Test]
5918 public void WriteEntry8_Log_Empty ()
5919 {
5920 if (EventLogImplType == NULL_IMPL)
5921 // test cannot pass with NULL implementation
5922 Assert.Ignore ("No EventLogImplType.");
5923
5924 if (EventLog.SourceExists ("monotempsource", "."))
5925 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5926
5927 bool applicationLogExists = EventLog.Exists ("Application", ".");
5928
5929 // specified source does not exist, so use Application log
5930 try {
5931 using (EventLog eventLog = new EventLog (string.Empty, ".", "monotempsource")) {
5932 eventLog.WriteEntry ("WriteEntry1_Log_Empty", EventLogEntryType.Error, 555, 5, new byte [0]);
5933 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
5934 Assert.AreEqual ("Application", eventLog.Log, "#A2");
5935 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
5936 Assert.IsTrue (EventLog.Exists ("Application"), "#A4");
5937 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
5938 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
5939 }
5940 } finally {
5941 if (!applicationLogExists) {
5942 if (EventLog.Exists ("Application"))
5943 EventLog.Delete ("Application");
5944 } else {
5945 if (EventLog.SourceExists ("monotempsource", "."))
5946 EventLog.DeleteEventSource ("monotempsource", ".");
5947 }
5948 }
5949 }
5950
5951 [Test]
5952 public void WriteEntry8_Log_Mismatch ()
5953 {
5954 if (EventLogImplType == NULL_IMPL)
5955 // test cannot pass with NULL implementation
5956 Assert.Ignore ("No EventLogImplType.");
5957
5958 if (EventLog.SourceExists ("monotempsource", "."))
5959 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
5960
5961 if (EventLog.Exists ("monologtemp", "."))
5962 Assert.Ignore ("Event log 'monologtemp' should not exist.");
5963
5964 if (EventLog.Exists ("monologother", "."))
5965 Assert.Ignore ("Event log 'monologother' should not exist.");
5966
5967 EventLog.CreateEventSource ("monotempsource", "monologtemp");
5968 try {
5969 using (EventLog eventLog = new EventLog ("monologother", ".", "monotempsource")) {
5970 // valid message
5971 try {
5972 eventLog.WriteEntry ("WriteEntry8_Log_Mismatch1",
5973 EventLogEntryType.Error, 555, 5, new byte [0]);
5974 Assert.Fail ("#A1");
5975 } catch (ArgumentException ex) {
5976 // The source 'monotempsource' is not registered in log
5977 // 'monologother' (it is registered in log 'monologtemp').
5978 // The Source and Log properties must be matched, or you may
5979 // set Log to the empty string, and it will automatically be
5980 // matched to the Source property
5981 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
5982 Assert.IsNotNull (ex.Message, "#A3");
5983 Assert.IsTrue (ex.Message.IndexOf ("'monotempsource'") != -1, "#A4");
5984 Assert.IsTrue (ex.Message.IndexOf ("'monologother'") != -1, "#A5");
5985 Assert.IsTrue (ex.Message.IndexOf ("'monologtemp'") != -1, "#A6");
5986 Assert.IsNull (ex.InnerException, "#A7");
5987 }
5988
5989 // invalid type
5990 try {
5991 eventLog.WriteEntry ("WriteEntry8_Log_Mismatch2",
5992 (EventLogEntryType) 666, 555, 5, new byte [0]);
5993 Assert.Fail ("#B1");
5994 } catch (InvalidEnumArgumentException) {
5995 }
5996
5997 // invalid eventID
5998 try {
5999 eventLog.WriteEntry ("WriteEntry8_Log_Mismatch3",
6000 EventLogEntryType.Error, -1, 5, new byte [0]);
6001 Assert.Fail ("#C1");
6002 } catch (ArgumentException ex) {
6003 // The source 'monotempsource' is not registered in log
6004 // 'monologother' (it is registered in log 'monologtemp').
6005 // The Source and Log properties must be matched, or you may
6006 // set Log to the empty string, and it will automatically be
6007 // matched to the Source property
6008 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
6009 Assert.IsNotNull (ex.Message, "#C3");
6010 Assert.IsFalse (ex.Message.IndexOf ("'monotempsource'") != -1, "#C4");
6011 Assert.IsFalse (ex.Message.IndexOf ("'monologother'") != -1, "#C5");
6012 Assert.IsFalse (ex.Message.IndexOf ("'monologtemp'") != -1, "#C6");
6013 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#C7");
6014 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#C8");
6015 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#C9");
6016 Assert.IsNull (ex.InnerException, "#C10");
6017 }
6018 }
6019 } finally {
6020 if (EventLog.Exists ("monologtemp"))
6021 EventLog.Delete ("monologtemp");
6022
6023 if (EventLog.Exists ("monologother"))
6024 EventLog.Delete ("monologother");
6025 }
6026 }
6027
6028 [Test]
6029 public void WriteEntry8_Message_Empty ()
6030 {
6031 if (EventLogImplType == NULL_IMPL)
6032 // test cannot pass with NULL implementation
6033 Assert.Ignore ("No EventLogImplType.");
6034
6035 if (EventLog.SourceExists ("monotempsource", "."))
6036 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6037
6038 if (EventLog.Exists ("monologtemp", "."))
6039 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6040
6041 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6042 try {
6043 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6044 eventLog.WriteEntry (string.Empty, EventLogEntryType.FailureAudit, 888, 6, new byte [0]);
6045 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6046 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6047 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6048 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6049 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6050 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6051
6052 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6053 Assert.IsNotNull (entry, "#B1");
6054 Assert.IsNotNull (entry.Category, "#B2");
6055 Assert.AreEqual ("(6)", entry.Category, "#B3");
6056 Assert.AreEqual (6, entry.CategoryNumber, "#B4");
6057 Assert.IsNotNull (entry.Data, "#B5");
6058 Assert.AreEqual (0, entry.Data.Length, "#B6");
6059 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
6060 Assert.AreEqual (888, entry.EventID, "#B8");
6061 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6062 Assert.IsNotNull (entry.MachineName, "#B10");
6063 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
6064 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6065 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6066 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
6067 Assert.IsNotNull (entry.Source, "#B15");
6068 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6069 Assert.IsNull (entry.UserName, "#B17");
6070 }
6071 } finally {
6072 if (EventLog.Exists ("monologtemp"))
6073 EventLog.Delete ("monologtemp");
6074 }
6075 }
6076
6077 [Test]
6078 public void WriteEntry8_Message_Null ()
6079 {
6080 if (EventLogImplType == NULL_IMPL)
6081 // test cannot pass with NULL implementation
6082 Assert.Ignore ("No EventLogImplType.");
6083
6084 if (EventLog.SourceExists ("monotempsource", "."))
6085 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6086
6087 if (EventLog.Exists ("monologtemp", "."))
6088 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6089
6090 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6091 try {
6092 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6093 eventLog.WriteEntry (null, EventLogEntryType.SuccessAudit, 343, 8, new byte [0]);
6094 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6095 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6096 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6097 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6098 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6099 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6100
6101 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6102 Assert.IsNotNull (entry, "#B1");
6103 Assert.IsNotNull (entry.Category, "#B2");
6104 Assert.AreEqual ("(8)", entry.Category, "#B3");
6105 Assert.AreEqual (8, entry.CategoryNumber, "#B4");
6106 Assert.IsNotNull (entry.Data, "#B5");
6107 Assert.AreEqual (0, entry.Data.Length, "#B6");
6108 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
6109 Assert.AreEqual (343, entry.EventID, "#B8");
6110 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6111 Assert.IsNotNull (entry.MachineName, "#B10");
6112 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
6113 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6114 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6115 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
6116 Assert.IsNotNull (entry.Source, "#B15");
6117 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6118 Assert.IsNull (entry.UserName, "#B17");
6119 }
6120 } finally {
6121 if (EventLog.Exists ("monologtemp"))
6122 EventLog.Delete ("monologtemp");
6123 }
6124 }
6125
6126 [Test]
6127 public void WriteEntry8_Source_DoesNotExist ()
6128 {
6129 if (EventLogImplType == NULL_IMPL)
6130 // test cannot pass with NULL implementation
6131 Assert.Ignore ("No EventLogImplType.");
6132
6133 if (EventLog.SourceExists ("monotempsource", "."))
6134 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6135
6136 if (EventLog.SourceExists ("monoothersource", "."))
6137 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
6138
6139 if (EventLog.Exists ("monologtemp", "."))
6140 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6141
6142 EventLog.CreateEventSource ("monoothersource", "monologtemp");
6143 try {
6144 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6145 eventLog.WriteEntry ("WriteEntry1", EventLogEntryType.Warning, 2, 4, new byte [0]);
6146 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6147 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6148 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6149 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6150 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6151 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6152
6153 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6154 Assert.IsNotNull (entry, "#B1");
6155 Assert.IsNotNull (entry.Category, "#B2");
6156 Assert.AreEqual ("(4)", entry.Category, "#B3");
6157 Assert.AreEqual (4, entry.CategoryNumber, "#B4");
6158 Assert.IsNotNull (entry.Data, "#B5");
6159 Assert.AreEqual (0, entry.Data.Length, "#B6");
6160 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
6161 Assert.AreEqual (2, entry.EventID, "#B8");
6162 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6163 Assert.IsNotNull (entry.MachineName, "#B10");
6164 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
6165 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6166 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6167 Assert.AreEqual ("WriteEntry1", entry.ReplacementStrings [0], "#B14");
6168 Assert.IsNotNull (entry.Source, "#B15");
6169 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6170 Assert.IsNull (entry.UserName, "#B17");
6171 }
6172 } finally {
6173 if (EventLog.Exists ("monologtemp"))
6174 EventLog.Delete ("monologtemp");
6175 }
6176 }
6177
6178 [Test]
6179 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6180 public void WriteEntry8_Source_Empty ()
6181 {
6182 EventLog eventLog = new EventLog ("monologtemp");
6183 eventLog.WriteEntry ("test", EventLogEntryType.Information, 56, 5, new byte [0]);
6184 }
6185
6186 [Test]
6187 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
6188 public void WriteEntry8_Type_NotDefined ()
6189 {
6190 EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource");
6191 eventLog.WriteEntry ("test", (EventLogEntryType) 666, 44, 8, new byte [0]);
6192 }
6193
6194 [Test]
6195 public void WriteEntry9 ()
6196 {
6197 if (EventLogImplType == NULL_IMPL)
6198 // test cannot pass with NULL implementation
6199 Assert.Ignore ("No EventLogImplType.");
6200
6201 if (EventLog.SourceExists ("monotempsource", "."))
6202 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6203
6204 if (EventLog.Exists ("monologtemp", "."))
6205 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6206
6207 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6208 try {
6209 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6210 EventLog.WriteEntry ("monotempsource", "WriteEntry9a",
6211 EventLogEntryType.Information, 54, 5);
6212
6213 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6214 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6215 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6216 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6217 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6218 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6219
6220 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6221 Assert.IsNotNull (entry, "#B1");
6222 Assert.IsNotNull (entry.Category, "#B2");
6223 Assert.AreEqual ("(5)", entry.Category, "#B3");
6224 Assert.AreEqual (5, entry.CategoryNumber, "#B4");
6225 Assert.IsNotNull (entry.Data, "#B5");
6226 Assert.AreEqual (0, entry.Data.Length, "#B6");
6227 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
6228 Assert.AreEqual (54, entry.EventID, "#B8");
6229 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6230 Assert.IsNotNull (entry.MachineName, "#B10");
6231 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
6232 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6233 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6234 Assert.AreEqual ("WriteEntry9a", entry.ReplacementStrings [0], "#B14");
6235 Assert.IsNotNull (entry.Source, "#B15");
6236 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6237 Assert.IsNull (entry.UserName, "#B17");
6238
6239 EventLog.WriteEntry ("monotempsource", "WriteEntry9b"
6240 + Environment.NewLine + "ok", EventLogEntryType.Error,
6241 0, 0);
6242
6243 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6244 Assert.IsNotNull (entry, "#C1");
6245 Assert.IsNotNull (entry.Category, "#C2");
6246 Assert.AreEqual ("(0)", entry.Category, "#C3");
6247 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
6248 Assert.IsNotNull (entry.Data, "#C5");
6249 Assert.AreEqual (0, entry.Data.Length, "#C6");
6250 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
6251 Assert.AreEqual (0, entry.EventID, "#C8");
6252 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
6253 Assert.IsNotNull (entry.MachineName, "#C10");
6254 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
6255 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
6256 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
6257 Assert.AreEqual ("WriteEntry9b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
6258 Assert.IsNotNull (entry.Source, "#C15");
6259 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
6260 Assert.IsNull (entry.UserName, "#C17");
6261
6262 EventLog.WriteEntry ("monotempsource", "WriteEntry9c"
6263 + Environment.NewLine + "ok", EventLogEntryType.Error,
6264 ushort.MaxValue, short.MaxValue);
6265
6266 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6267 Assert.IsNotNull (entry, "#D1");
6268 Assert.IsNotNull (entry.Category, "#D2");
6269 Assert.AreEqual ("(32767)", entry.Category, "#D3");
6270 Assert.AreEqual (32767, entry.CategoryNumber, "#D4");
6271 Assert.IsNotNull (entry.Data, "#D5");
6272 Assert.AreEqual (0, entry.Data.Length, "#D6");
6273 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
6274 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
6275 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
6276 Assert.IsNotNull (entry.MachineName, "#D10");
6277 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#D11");
6278 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
6279 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
6280 Assert.AreEqual ("WriteEntry9c" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#D14");
6281 Assert.IsNotNull (entry.Source, "#D15");
6282 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
6283 Assert.IsNull (entry.UserName, "#D17");
6284 }
6285 } finally {
6286 if (EventLog.Exists ("monologtemp"))
6287 EventLog.Delete ("monologtemp");
6288 }
6289 }
6290
6291 [Test]
6292 public void WriteEntry9_EventID_Invalid ()
6293 {
6294 if (EventLogImplType == NULL_IMPL)
6295 // test cannot pass with NULL implementation
6296 Assert.Ignore ("No EventLogImplType.");
6297
6298 if (EventLog.SourceExists ("monotempsource", "."))
6299 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6300
6301 bool applicationLogExists = EventLog.Exists ("Application", ".");
6302 try {
6303 EventLog.WriteEntry ("monotempsource", "test",
6304 EventLogEntryType.Information, -1, 5);
6305 Assert.Fail ("#A1");
6306 } catch (ArgumentException ex) {
6307 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
6308 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
6309 Assert.IsNotNull (ex.Message, "#A3");
6310 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
6311 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
6312 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
6313 Assert.IsNull (ex.InnerException, "#A7");
6314 if (!applicationLogExists)
6315 Assert.IsFalse (EventLog.Exists ("Application"), "#A8");
6316 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
6317 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
6318 } finally {
6319 if (!applicationLogExists) {
6320 if (EventLog.Exists ("Application", "."))
6321 EventLog.Delete ("Application", ".");
6322 } else {
6323 if (EventLog.SourceExists ("monotempsource", "."))
6324 EventLog.DeleteEventSource ("monotempsource", ".");
6325 }
6326 }
6327
6328 try {
6329 EventLog.WriteEntry ("monotempsource", "test",
6330 EventLogEntryType.Information, 65536, 5);
6331 Assert.Fail ("#B1");
6332 } catch (ArgumentException ex) {
6333 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
6334 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
6335 Assert.IsNotNull (ex.Message, "#B3");
6336 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
6337 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
6338 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
6339 Assert.IsNull (ex.InnerException, "#B7");
6340 if (!applicationLogExists)
6341 Assert.IsFalse (EventLog.Exists ("Application"), "#B8");
6342 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
6343 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
6344 } finally {
6345 if (!applicationLogExists) {
6346 if (EventLog.Exists ("Application", "."))
6347 EventLog.Delete ("Application", ".");
6348 } else {
6349 if (EventLog.SourceExists ("monotempsource", "."))
6350 EventLog.DeleteEventSource ("monotempsource", ".");
6351 }
6352 }
6353 }
6354
6355 [Test]
6356 public void WriteEntry9_Message_Empty ()
6357 {
6358 if (EventLogImplType == NULL_IMPL)
6359 // test cannot pass with NULL implementation
6360 Assert.Ignore ("No EventLogImplType.");
6361
6362 if (EventLog.SourceExists ("monotempsource", "."))
6363 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6364
6365 if (EventLog.Exists ("monologtemp", "."))
6366 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6367
6368 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6369 try {
6370 EventLog.WriteEntry ("monotempsource", string.Empty,
6371 EventLogEntryType.Error, 56, 5);
6372
6373 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6374 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6375 Assert.IsNotNull (entry, "#A1");
6376 Assert.IsNotNull (entry.Category, "#A2");
6377 Assert.AreEqual ("(5)", entry.Category, "#A3");
6378 Assert.AreEqual (5, entry.CategoryNumber, "#A4");
6379 Assert.IsNotNull (entry.Data, "#A5");
6380 Assert.AreEqual (0, entry.Data.Length, "#A6");
6381 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#A7");
6382 Assert.AreEqual (56, entry.EventID, "#A8");
6383 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
6384 Assert.IsNotNull (entry.MachineName, "#A10");
6385 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#A11");
6386 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
6387 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
6388 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
6389 Assert.IsNotNull (entry.Source, "#A15");
6390 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
6391 Assert.IsNull (entry.UserName, "#A17");
6392 }
6393 } finally {
6394 if (EventLog.Exists ("monologtemp"))
6395 EventLog.Delete ("monologtemp");
6396 }
6397 }
6398
6399 [Test]
6400 public void WriteEntry9_Message_Null ()
6401 {
6402 if (EventLogImplType == NULL_IMPL)
6403 // test cannot pass with NULL implementation
6404 Assert.Ignore ("No EventLogImplType.");
6405
6406 if (EventLog.SourceExists ("monotempsource", "."))
6407 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6408
6409 if (EventLog.Exists ("monologtemp", "."))
6410 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6411
6412 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6413 try {
6414 EventLog.WriteEntry ("monotempsource", null,
6415 EventLogEntryType.FailureAudit, 76, 8);
6416
6417 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6418 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6419 Assert.IsNotNull (entry, "#A1");
6420 Assert.IsNotNull (entry.Category, "#A2");
6421 Assert.AreEqual ("(8)", entry.Category, "#A3");
6422 Assert.AreEqual (8, entry.CategoryNumber, "#A4");
6423 Assert.IsNotNull (entry.Data, "#A5");
6424 Assert.AreEqual (0, entry.Data.Length, "#A6");
6425 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#A7");
6426 Assert.AreEqual (76, entry.EventID, "#A8");
6427 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
6428 Assert.IsNotNull (entry.MachineName, "#A10");
6429 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#A11");
6430 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
6431 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
6432 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
6433 Assert.IsNotNull (entry.Source, "#A15");
6434 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
6435 Assert.IsNull (entry.UserName, "#A17");
6436 }
6437 } finally {
6438 if (EventLog.Exists ("monologtemp"))
6439 EventLog.Delete ("monologtemp");
6440 }
6441 }
6442
6443 [Test]
6444 public void WriteEntry9_Source_DoesNotExist ()
6445 {
6446 if (EventLogImplType == NULL_IMPL)
6447 // test cannot pass with NULL implementation
6448 Assert.Ignore ("No EventLogImplType.");
6449
6450 if (EventLog.SourceExists ("monotempsource", "."))
6451 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6452
6453 bool applicationLogExists = EventLog.Exists ("Application");
6454 try {
6455 EventLog.WriteEntry ("monotempsource", "test",
6456 EventLogEntryType.SuccessAudit, 89, 3);
6457
6458 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
6459 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
6460 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
6461
6462 if (EventLogImplType == WIN32_IMPL)
6463 // win32 API does not return entries in order for
6464 // Application log
6465 return;
6466
6467 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
6468 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6469 Assert.IsNotNull (entry, "#B1");
6470 Assert.IsNotNull (entry.Category, "#B2");
6471 Assert.AreEqual ("(3)", entry.Category, "#B3");
6472 Assert.AreEqual (3, entry.CategoryNumber, "#B4");
6473 Assert.IsNotNull (entry.Data, "#B5");
6474 Assert.AreEqual (0, entry.Data.Length, "#B6");
6475 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
6476 Assert.AreEqual (89, entry.EventID, "#B8");
6477 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6478 Assert.IsNotNull (entry.MachineName, "#B10");
6479 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
6480 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6481 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6482 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
6483 Assert.IsNotNull (entry.Source, "#B15");
6484 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6485 Assert.IsNull (entry.UserName, "#B17");
6486 }
6487 } finally {
6488 if (!applicationLogExists) {
6489 if (EventLog.Exists ("Application"))
6490 EventLog.Delete ("Application");
6491 } else {
6492 if (EventLog.SourceExists ("monotempsource", "."))
6493 EventLog.DeleteEventSource ("monotempsource", ".");
6494 }
6495 }
6496 }
6497
6498 [Test]
6499 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6500 public void WriteEntry9_Source_Empty ()
6501 {
6502 EventLog.WriteEntry (string.Empty, "test", EventLogEntryType.Warning,
6503 5, 4);
6504 }
6505
6506 [Test]
6507 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6508 public void WriteEntry9_Source_Null ()
6509 {
6510 EventLog.WriteEntry (null, "test", EventLogEntryType.Error, 5, 4);
6511 }
6512
6513 [Test]
6514 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
6515 public void WriteEntry9_Type_NotDefined ()
6516 {
6517 EventLog.WriteEntry ("monotempsource", "test", (EventLogEntryType) 666, 4, 3);
6518 }
6519
6520 [Test]
6521 public void WriteEntry10 ()
6522 {
6523 if (EventLogImplType == NULL_IMPL)
6524 // test cannot pass with NULL implementation
6525 Assert.Ignore ("No EventLogImplType.");
6526
6527 if (EventLog.SourceExists ("monotempsource", "."))
6528 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6529
6530 if (EventLog.Exists ("monologtemp", "."))
6531 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6532
6533 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6534 try {
6535 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6536 byte [] data = new byte [] { 56, 55, 23, 24 };
6537
6538 EventLog.WriteEntry ("monotempsource", "WriteEntry9a",
6539 EventLogEntryType.Information, 54, 5, data);
6540
6541 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6542 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6543 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6544 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6545 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6546 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6547
6548 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6549 Assert.IsNotNull (entry, "#B1");
6550 Assert.IsNotNull (entry.Category, "#B2");
6551 Assert.AreEqual ("(5)", entry.Category, "#B3");
6552 Assert.AreEqual (5, entry.CategoryNumber, "#B4");
6553 Assert.IsNotNull (entry.Data, "#B5");
6554 Assert.AreEqual (data, entry.Data, "#B6");
6555 Assert.AreEqual (EventLogEntryType.Information, entry.EntryType, "#B7");
6556 Assert.AreEqual (54, entry.EventID, "#B8");
6557 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6558 Assert.IsNotNull (entry.MachineName, "#B10");
6559 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
6560 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6561 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6562 Assert.AreEqual ("WriteEntry9a", entry.ReplacementStrings [0], "#B14");
6563 Assert.IsNotNull (entry.Source, "#B15");
6564 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6565 Assert.IsNull (entry.UserName, "#B17");
6566
6567 EventLog.WriteEntry ("monotempsource", "WriteEntry9b"
6568 + Environment.NewLine + "ok", EventLogEntryType.Error,
6569 0, 0, new byte [0]);
6570
6571 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6572 Assert.IsNotNull (entry, "#C1");
6573 Assert.IsNotNull (entry.Category, "#C2");
6574 Assert.AreEqual ("(0)", entry.Category, "#C3");
6575 Assert.AreEqual (0, entry.CategoryNumber, "#C4");
6576 Assert.IsNotNull (entry.Data, "#C5");
6577 Assert.AreEqual (0, entry.Data.Length, "#C6");
6578 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#C7");
6579 Assert.AreEqual (0, entry.EventID, "#C8");
6580 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
6581 Assert.IsNotNull (entry.MachineName, "#C10");
6582 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
6583 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
6584 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#C13");
6585 Assert.AreEqual ("WriteEntry9b" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#C14");
6586 Assert.IsNotNull (entry.Source, "#C15");
6587 Assert.AreEqual ("monotempsource", entry.Source, "#C16");
6588 Assert.IsNull (entry.UserName, "#C17");
6589
6590 EventLog.WriteEntry ("monotempsource", "WriteEntry9c"
6591 + Environment.NewLine + "ok", EventLogEntryType.Error,
6592 ushort.MaxValue, short.MaxValue, null);
6593
6594 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6595 Assert.IsNotNull (entry, "#D1");
6596 Assert.IsNotNull (entry.Category, "#D2");
6597 Assert.AreEqual ("(32767)", entry.Category, "#D3");
6598 Assert.AreEqual (32767, entry.CategoryNumber, "#D4");
6599 Assert.IsNotNull (entry.Data, "#D5");
6600 Assert.AreEqual (0, entry.Data.Length, "#D6");
6601 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#D7");
6602 Assert.AreEqual (ushort.MaxValue, entry.EventID, "#D8");
6603 Assert.AreEqual (entry.EventID, entry.InstanceId, "#D9");
6604 Assert.IsNotNull (entry.MachineName, "#D10");
6605 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#D11");
6606 Assert.IsNotNull (entry.ReplacementStrings, "#D12");
6607 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#D13");
6608 Assert.AreEqual ("WriteEntry9c" + Environment.NewLine + "ok", entry.ReplacementStrings [0], "#D14");
6609 Assert.IsNotNull (entry.Source, "#D15");
6610 Assert.AreEqual ("monotempsource", entry.Source, "#D16");
6611 Assert.IsNull (entry.UserName, "#D17");
6612 }
6613 } finally {
6614 if (EventLog.Exists ("monologtemp"))
6615 EventLog.Delete ("monologtemp");
6616 }
6617 }
6618
6619 [Test]
6620 public void WriteEntry10_EventID_Invalid ()
6621 {
6622 if (EventLogImplType == NULL_IMPL)
6623 // test cannot pass with NULL implementation
6624 Assert.Ignore ("No EventLogImplType.");
6625
6626 if (EventLog.SourceExists ("monotempsource", "."))
6627 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6628
6629 bool applicationLogExists = EventLog.Exists ("Application", ".");
6630 try {
6631 EventLog.WriteEntry ("monotempsource", "test",
6632 EventLogEntryType.Information, -1, 5, new byte[0]);
6633 Assert.Fail ("#A1");
6634 } catch (ArgumentException ex) {
6635 // Invalid eventID value '-1'. It must be in the range between '0' and '65535'.
6636 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
6637 Assert.IsNotNull (ex.Message, "#A3");
6638 Assert.IsTrue (ex.Message.IndexOf ("'-1'") != -1, "#A4");
6639 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#A5");
6640 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#A6");
6641 Assert.IsNull (ex.InnerException, "#A7");
6642 if (!applicationLogExists)
6643 Assert.IsFalse (EventLog.Exists ("Application"), "#A8");
6644 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#A9");
6645 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#A10");
6646 } finally {
6647 if (!applicationLogExists) {
6648 if (EventLog.Exists ("Application", "."))
6649 EventLog.Delete ("Application", ".");
6650 } else {
6651 if (EventLog.SourceExists ("monotempsource", "."))
6652 EventLog.DeleteEventSource ("monotempsource", ".");
6653 }
6654 }
6655
6656 try {
6657 EventLog.WriteEntry ("monotempsource", "test",
6658 EventLogEntryType.Information, 65536, 5, new byte[0]);
6659 Assert.Fail ("#B1");
6660 } catch (ArgumentException ex) {
6661 // Invalid eventID value '65536'. It must be in the range between '0' and '65535'.
6662 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
6663 Assert.IsNotNull (ex.Message, "#B3");
6664 Assert.IsTrue (ex.Message.IndexOf ("'65536'") != -1, "#B4");
6665 Assert.IsTrue (ex.Message.IndexOf ("'0'") != -1, "#B5");
6666 Assert.IsTrue (ex.Message.IndexOf ("'65535'") != -1, "#B6");
6667 Assert.IsNull (ex.InnerException, "#B7");
6668 if (!applicationLogExists)
6669 Assert.IsFalse (EventLog.Exists ("Application"), "#B8");
6670 Assert.IsFalse (EventLog.SourceExists ("monotempsource"), "#B9");
6671 Assert.AreEqual (string.Empty, EventLog.LogNameFromSourceName ("monotempsource", "."), "#B10");
6672 } finally {
6673 if (!applicationLogExists) {
6674 if (EventLog.Exists ("Application", "."))
6675 EventLog.Delete ("Application", ".");
6676 } else {
6677 if (EventLog.SourceExists ("monotempsource", "."))
6678 EventLog.DeleteEventSource ("monotempsource", ".");
6679 }
6680 }
6681 }
6682
6683 [Test]
6684 public void WriteEntry10_Message_Empty ()
6685 {
6686 if (EventLogImplType == NULL_IMPL)
6687 // test cannot pass with NULL implementation
6688 Assert.Ignore ("No EventLogImplType.");
6689
6690 if (EventLog.SourceExists ("monotempsource", "."))
6691 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6692
6693 if (EventLog.Exists ("monologtemp", "."))
6694 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6695
6696 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6697 try {
6698 EventLog.WriteEntry ("monotempsource", string.Empty,
6699 EventLogEntryType.Error, 56, 5, new byte [0]);
6700
6701 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6702 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6703 Assert.IsNotNull (entry, "#A1");
6704 Assert.IsNotNull (entry.Category, "#A2");
6705 Assert.AreEqual ("(5)", entry.Category, "#A3");
6706 Assert.AreEqual (5, entry.CategoryNumber, "#A4");
6707 Assert.IsNotNull (entry.Data, "#A5");
6708 Assert.AreEqual (0, entry.Data.Length, "#A6");
6709 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#A7");
6710 Assert.AreEqual (56, entry.EventID, "#A8");
6711 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
6712 Assert.IsNotNull (entry.MachineName, "#A10");
6713 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#A11");
6714 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
6715 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
6716 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
6717 Assert.IsNotNull (entry.Source, "#A15");
6718 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
6719 Assert.IsNull (entry.UserName, "#A17");
6720 }
6721 } finally {
6722 if (EventLog.Exists ("monologtemp"))
6723 EventLog.Delete ("monologtemp");
6724 }
6725 }
6726
6727 [Test]
6728 public void WriteEntry10_Message_Null ()
6729 {
6730 if (EventLogImplType == NULL_IMPL)
6731 // test cannot pass with NULL implementation
6732 Assert.Ignore ("No EventLogImplType.");
6733
6734 if (EventLog.SourceExists ("monotempsource", "."))
6735 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6736
6737 if (EventLog.Exists ("monologtemp", "."))
6738 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6739
6740 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6741 try {
6742 EventLog.WriteEntry ("monotempsource", null,
6743 EventLogEntryType.FailureAudit, 76, 8, new byte [0]);
6744
6745 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6746 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6747 Assert.IsNotNull (entry, "#A1");
6748 Assert.IsNotNull (entry.Category, "#A2");
6749 Assert.AreEqual ("(8)", entry.Category, "#A3");
6750 Assert.AreEqual (8, entry.CategoryNumber, "#A4");
6751 Assert.IsNotNull (entry.Data, "#A5");
6752 Assert.AreEqual (0, entry.Data.Length, "#A6");
6753 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#A7");
6754 Assert.AreEqual (76, entry.EventID, "#A8");
6755 Assert.AreEqual (entry.EventID, entry.InstanceId, "#A9");
6756 Assert.IsNotNull (entry.MachineName, "#A10");
6757 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#A11");
6758 Assert.IsNotNull (entry.ReplacementStrings, "#A12");
6759 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#A13");
6760 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#A14");
6761 Assert.IsNotNull (entry.Source, "#A15");
6762 Assert.AreEqual ("monotempsource", entry.Source, "#A16");
6763 Assert.IsNull (entry.UserName, "#A17");
6764 }
6765 } finally {
6766 if (EventLog.Exists ("monologtemp"))
6767 EventLog.Delete ("monologtemp");
6768 }
6769 }
6770
6771 [Test]
6772 public void WriteEntry10_Source_DoesNotExist ()
6773 {
6774 if (EventLogImplType == NULL_IMPL)
6775 // test cannot pass with NULL implementation
6776 Assert.Ignore ("No EventLogImplType.");
6777
6778 if (EventLog.SourceExists ("monotempsource", "."))
6779 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6780
6781 bool applicationLogExists = EventLog.Exists ("Application");
6782 try {
6783 EventLog.WriteEntry ("monotempsource", "test",
6784 EventLogEntryType.SuccessAudit, 89, 3, new byte [0]);
6785
6786 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
6787 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
6788 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
6789
6790 if (EventLogImplType == WIN32_IMPL)
6791 // win32 API does not return entries in order for
6792 // Application log
6793 return;
6794
6795 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
6796 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6797 Assert.IsNotNull (entry, "#B1");
6798 Assert.IsNotNull (entry.Category, "#B2");
6799 Assert.AreEqual ("(3)", entry.Category, "#B3");
6800 Assert.AreEqual (3, entry.CategoryNumber, "#B4");
6801 Assert.IsNotNull (entry.Data, "#B5");
6802 Assert.AreEqual (0, entry.Data.Length, "#B6");
6803 Assert.AreEqual (EventLogEntryType.SuccessAudit, entry.EntryType, "#B7");
6804 Assert.AreEqual (89, entry.EventID, "#B8");
6805 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6806 Assert.IsNotNull (entry.MachineName, "#B10");
6807 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
6808 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6809 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
6810 Assert.AreEqual ("test", entry.ReplacementStrings [0], "#B14");
6811 Assert.IsNotNull (entry.Source, "#B15");
6812 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
6813 Assert.IsNull (entry.UserName, "#B17");
6814 }
6815 } finally {
6816 if (!applicationLogExists) {
6817 if (EventLog.Exists ("Application"))
6818 EventLog.Delete ("Application");
6819 } else {
6820 if (EventLog.SourceExists ("monotempsource", "."))
6821 EventLog.DeleteEventSource ("monotempsource", ".");
6822 }
6823 }
6824 }
6825
6826 [Test]
6827 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6828 public void WriteEntry10_Source_Empty ()
6829 {
6830 EventLog.WriteEntry (string.Empty, "test", EventLogEntryType.Warning,
6831 5, 4, new byte [0]);
6832 }
6833
6834 [Test]
6835 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6836 public void WriteEntry10_Source_Null ()
6837 {
6838 EventLog.WriteEntry (null, "test", EventLogEntryType.Error, 5, 4,
6839 new byte [0]);
6840 }
6841
6842 [Test]
6843 [ExpectedException (typeof (InvalidEnumArgumentException))] // Enum argument value 666 is not valid for type. type should be a value from EventLogEntryType.
6844 public void WriteEntry10_Type_NotDefined ()
6845 {
6846 EventLog.WriteEntry ("monotempsource", "test", (EventLogEntryType) 666,
6847 4, 3, new byte [0]);
6848 }
6849
6850 [Test]
6851 public void WriteEvent1 ()
6852 {
6853 if (EventLog.SourceExists ("monotempsource", "."))
6854 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6855
6856 if (EventLog.Exists ("monologtemp", "."))
6857 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6858
6859 EventLog.CreateEventSource ("monotempsource", "monologtemp");
6860 try {
6861 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6862 EventInstance instance = new EventInstance (5, 666,
6863 EventLogEntryType.FailureAudit);
6864 eventLog.WriteEvent (instance, 5, "new" + Environment.NewLine + "line", true, null);
6865
6866 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6867 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6868 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6869 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6870 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6871 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
6872 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
6873
6874 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
6875 Assert.IsNotNull (entry, "#B1");
6876 Assert.IsNotNull (entry.Category, "#B2");
6877 Assert.AreEqual ("(666)", entry.Category, "#B3");
6878 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
6879 Assert.IsNotNull (entry.Data, "#B5");
6880 Assert.AreEqual (0, entry.Data.Length, "#B6");
6881 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
6882 Assert.AreEqual (5, entry.EventID, "#B8");
6883 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6884 Assert.IsNotNull (entry.MachineName, "#B10");
6885 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
6886 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6887 Assert.AreEqual (4, entry.ReplacementStrings.Length, "#B13");
6888 Assert.AreEqual ("5", entry.ReplacementStrings [0], "#B14");
6889 Assert.AreEqual ("new" + Environment.NewLine + "line", entry.ReplacementStrings [1], "#B15");
6890 Assert.AreEqual (true.ToString (), entry.ReplacementStrings [2], "#B16");
6891 Assert.AreEqual (string.Empty, entry.ReplacementStrings [3], "#B17");
6892 Assert.IsNotNull (entry.Source, "#B18");
6893 Assert.AreEqual ("monotempsource", entry.Source, "#B19");
6894 Assert.IsNull (entry.UserName, "#B20");
6895
6896 eventLog.WriteEvent (instance);
6897
6898 entry = eventLog.Entries [eventLog.Entries.Count - 1];
6899 Assert.IsNotNull (entry, "#C1");
6900 Assert.IsNotNull (entry.Category, "#C2");
6901 Assert.AreEqual ("(666)", entry.Category, "#C3");
6902 Assert.AreEqual (666, entry.CategoryNumber, "#C4");
6903 Assert.IsNotNull (entry.Data, "#C5");
6904 Assert.AreEqual (0, entry.Data.Length, "#C6");
6905 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#C7");
6906 Assert.AreEqual (5, entry.EventID, "#C8");
6907 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
6908 Assert.IsNotNull (entry.MachineName, "#C10");
6909 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
6910 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
6911 Assert.AreEqual (0, entry.ReplacementStrings.Length, "#C13");
6912 Assert.IsNotNull (entry.Source, "#C14");
6913 Assert.AreEqual ("monotempsource", entry.Source, "#C15");
6914 Assert.IsNull (entry.UserName, "#C16");
6915 }
6916 } finally {
6917 if (EventLog.Exists ("monologtemp"))
6918 EventLog.Delete ("monologtemp");
6919 }
6920 }
6921
6922 [Test]
6923 [ExpectedException (typeof (ArgumentNullException))]
6924 public void WriteEvent1_Instance_Null ()
6925 {
6926 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6927 eventLog.WriteEvent (null, "replace");
6928 }
6929 }
6930
6931 [Test]
6932 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
6933 public void WriteEvent1_Source_Empty ()
6934 {
6935 using (EventLog eventLog = new EventLog ("monologtemp")) {
6936 EventInstance instance = new EventInstance (5, 1,
6937 EventLogEntryType.Information);
6938 eventLog.WriteEvent (instance, "replace");
6939 }
6940 }
6941
6942 [Test]
6943 public void WriteEvent1_Source_DoesNotExist ()
6944 {
6945 if (EventLogImplType == NULL_IMPL)
6946 // test cannot pass with NULL implementation
6947 Assert.Ignore ("No EventLogImplType.");
6948
6949 if (EventLog.SourceExists ("monotempsource", "."))
6950 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
6951
6952 if (EventLog.SourceExists ("monoothersource", "."))
6953 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
6954
6955 if (EventLog.Exists ("monologtemp", "."))
6956 Assert.Ignore ("Event log 'monologtemp' should not exist.");
6957
6958 EventLog.CreateEventSource ("monoothersource", "monologtemp");
6959 try {
6960 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
6961 EventInstance instance = new EventInstance (5, 1,
6962 EventLogEntryType.Error);
6963 eventLog.WriteEvent (instance, "replace1", "replace2");
6964
6965 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
6966 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
6967 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
6968 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
6969 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
6970 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A6");
6971
6972 EventLogEntry entry = eventLog.Entries[eventLog.Entries.Count - 1];
6973 Assert.IsNotNull (entry, "#B1");
6974 Assert.IsNotNull (entry.Category, "#B2");
6975 Assert.AreEqual ("(1)", entry.Category, "#B3");
6976 Assert.AreEqual (1, entry.CategoryNumber, "#B4");
6977 Assert.IsNotNull (entry.Data, "#B5");
6978 Assert.AreEqual (0, entry.Data.Length, "#B6");
6979 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
6980 Assert.AreEqual (5, entry.EventID, "#B8");
6981 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
6982 Assert.IsNotNull (entry.MachineName, "#B10");
6983 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
6984 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
6985 Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
6986 Assert.AreEqual ("replace1", entry.ReplacementStrings[0], "#B14");
6987 Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
6988 Assert.IsNotNull (entry.Source, "#B16");
6989 Assert.AreEqual ("monotempsource", entry.Source, "#B17");
6990 Assert.IsNull (entry.UserName, "#B18");
6991 }
6992 } finally {
6993 if (EventLog.Exists ("monologtemp"))
6994 EventLog.Delete ("monologtemp");
6995 }
6996 }
6997
6998 [Test]
6999 public void WriteEvent1_Values_Null ()
7000 {
7001 if (EventLog.SourceExists ("monotempsource", "."))
7002 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7003
7004 if (EventLog.Exists ("monologtemp", "."))
7005 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7006
7007 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7008 try {
7009 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7010 EventInstance instance = new EventInstance (5, 666,
7011 EventLogEntryType.Warning);
7012 eventLog.WriteEvent (instance, (object) null);
7013
7014 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7015 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7016 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7017 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7018 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7019 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7020 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7021
7022 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7023 Assert.IsNotNull (entry, "#B1");
7024 Assert.IsNotNull (entry.Category, "#B2");
7025 Assert.AreEqual ("(666)", entry.Category, "#B3");
7026 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7027 Assert.IsNotNull (entry.Data, "#B5");
7028 Assert.AreEqual (0, entry.Data.Length, "#B6");
7029 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7030 Assert.AreEqual (5, entry.EventID, "#B8");
7031 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7032 Assert.IsNotNull (entry.MachineName, "#B10");
7033 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7034 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7035 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
7036 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
7037 Assert.IsNotNull (entry.Source, "#B15");
7038 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
7039 Assert.IsNull (entry.UserName, "#B17");
7040 }
7041 } finally {
7042 if (EventLog.Exists ("monologtemp"))
7043 EventLog.Delete ("monologtemp");
7044 }
7045 }
7046
7047 [Test]
7048 public void WriteEvent2 ()
7049 {
7050 if (EventLog.SourceExists ("monotempsource", "."))
7051 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7052
7053 if (EventLog.Exists ("monologtemp", "."))
7054 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7055
7056 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7057 try {
7058 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7059 byte [] data = new byte [] { 23, 54 };
7060 EventInstance instance = new EventInstance (5, 666,
7061 EventLogEntryType.FailureAudit);
7062 eventLog.WriteEvent (instance, data, 5, "new" + Environment.NewLine + "line", true, null);
7063
7064 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7065 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7066 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7067 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7068 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7069 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7070 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7071
7072 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7073 Assert.IsNotNull (entry, "#B1");
7074 Assert.IsNotNull (entry.Category, "#B2");
7075 Assert.AreEqual ("(666)", entry.Category, "#B3");
7076 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7077 Assert.IsNotNull (entry.Data, "#B5");
7078 Assert.AreEqual (data, entry.Data, "#B6");
7079 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
7080 Assert.AreEqual (5, entry.EventID, "#B8");
7081 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7082 Assert.IsNotNull (entry.MachineName, "#B10");
7083 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7084 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7085 Assert.AreEqual (4, entry.ReplacementStrings.Length, "#B13");
7086 Assert.AreEqual ("5", entry.ReplacementStrings [0], "#B14");
7087 Assert.AreEqual ("new" + Environment.NewLine + "line", entry.ReplacementStrings [1], "#B15");
7088 Assert.AreEqual (true.ToString (), entry.ReplacementStrings [2], "#B16");
7089 Assert.AreEqual (string.Empty, entry.ReplacementStrings [3], "#B17");
7090 Assert.IsNotNull (entry.Source, "#B18");
7091 Assert.AreEqual ("monotempsource", entry.Source, "#B19");
7092 Assert.IsNull (entry.UserName, "#B20");
7093
7094 eventLog.WriteEvent (instance, data);
7095
7096 entry = eventLog.Entries [eventLog.Entries.Count - 1];
7097 Assert.IsNotNull (entry, "#C1");
7098 Assert.IsNotNull (entry.Category, "#C2");
7099 Assert.AreEqual ("(666)", entry.Category, "#C3");
7100 Assert.AreEqual (666, entry.CategoryNumber, "#C4");
7101 Assert.IsNotNull (entry.Data, "#C5");
7102 Assert.AreEqual (data, entry.Data, "#C6");
7103 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#C7");
7104 Assert.AreEqual (5, entry.EventID, "#C8");
7105 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
7106 Assert.IsNotNull (entry.MachineName, "#C10");
7107 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
7108 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
7109 Assert.AreEqual (0, entry.ReplacementStrings.Length, "#C13");
7110 Assert.IsNotNull (entry.Source, "#C14");
7111 Assert.AreEqual ("monotempsource", entry.Source, "#C15");
7112 Assert.IsNull (entry.UserName, "#C16");
7113 }
7114 } finally {
7115 if (EventLog.Exists ("monologtemp"))
7116 EventLog.Delete ("monologtemp");
7117 }
7118 }
7119
7120 [Test]
7121 public void WriteEvent2_Data_Null ()
7122 {
7123 if (EventLog.SourceExists ("monotempsource", "."))
7124 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7125
7126 if (EventLog.Exists ("monologtemp", "."))
7127 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7128
7129 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7130 try {
7131 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7132 EventInstance instance = new EventInstance (5, 444,
7133 EventLogEntryType.Warning);
7134 eventLog.WriteEvent (instance, null, "replace1", null, "replace3");
7135
7136 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7137 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7138 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7139 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7140 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7141 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7142 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7143
7144 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7145 Assert.IsNotNull (entry, "#B1");
7146 Assert.IsNotNull (entry.Category, "#B2");
7147 Assert.AreEqual ("(444)", entry.Category, "#B3");
7148 Assert.AreEqual (444, entry.CategoryNumber, "#B4");
7149 Assert.IsNotNull (entry.Data, "#B5");
7150 Assert.AreEqual (0, entry.Data.Length, "#B6");
7151 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7152 Assert.AreEqual (5, entry.EventID, "#B8");
7153 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7154 Assert.IsNotNull (entry.MachineName, "#B10");
7155 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7156 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7157 Assert.AreEqual (3, entry.ReplacementStrings.Length, "#B13");
7158 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7159 Assert.AreEqual (string.Empty, entry.ReplacementStrings [1], "#B15");
7160 Assert.AreEqual ("replace3", entry.ReplacementStrings [2], "#B16");
7161 Assert.IsNotNull (entry.Source, "#B17");
7162 Assert.AreEqual ("monotempsource", entry.Source, "#B18");
7163 Assert.IsNull (entry.UserName, "#B19");
7164 }
7165 } finally {
7166 if (EventLog.Exists ("monologtemp"))
7167 EventLog.Delete ("monologtemp");
7168 }
7169 }
7170
7171
7172 [Test]
7173 [ExpectedException (typeof (ArgumentNullException))]
7174 public void WriteEvent2_Instance_Null ()
7175 {
7176 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7177 eventLog.WriteEvent (null, new byte [0], "replace");
7178 }
7179 }
7180
7181 [Test]
7182 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
7183 public void WriteEvent2_Source_Empty ()
7184 {
7185 using (EventLog eventLog = new EventLog ("monologtemp")) {
7186 EventInstance instance = new EventInstance (5, 1,
7187 EventLogEntryType.Information);
7188 eventLog.WriteEvent (instance, new byte [0], "replace");
7189 }
7190 }
7191
7192 [Test]
7193 public void WriteEvent2_Source_DoesNotExist ()
7194 {
7195 if (EventLogImplType == NULL_IMPL)
7196 // test cannot pass with NULL implementation
7197 Assert.Ignore ("No EventLogImplType.");
7198
7199 if (EventLog.SourceExists ("monotempsource", "."))
7200 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7201
7202 if (EventLog.SourceExists ("monoothersource", "."))
7203 Assert.Ignore ("Event log source 'monoothersource' should not exist.");
7204
7205 if (EventLog.Exists ("monologtemp", "."))
7206 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7207
7208 EventLog.CreateEventSource ("monoothersource", "monologtemp");
7209 try {
7210 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7211 byte [] data = new byte [] { 23, 54 };
7212 EventInstance instance = new EventInstance (5, 1,
7213 EventLogEntryType.Error);
7214 eventLog.WriteEvent (instance, data, "replace1", "replace2");
7215
7216 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7217 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7218 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7219 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7220 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7221 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7222 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7223
7224 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7225 Assert.IsNotNull (entry, "#B1");
7226 Assert.IsNotNull (entry.Category, "#B2");
7227 Assert.AreEqual ("(1)", entry.Category, "#B3");
7228 Assert.AreEqual (1, entry.CategoryNumber, "#B4");
7229 Assert.IsNotNull (entry.Data, "#B5");
7230 Assert.AreEqual (data, entry.Data, "#B6");
7231 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
7232 Assert.AreEqual (5, entry.EventID, "#B8");
7233 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7234 Assert.IsNotNull (entry.MachineName, "#B10");
7235 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7236 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7237 Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
7238 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7239 Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
7240 Assert.IsNotNull (entry.Source, "#B16");
7241 Assert.AreEqual ("monotempsource", entry.Source, "#B17");
7242 Assert.IsNull (entry.UserName, "#B18");
7243 }
7244 } finally {
7245 if (EventLog.Exists ("monologtemp"))
7246 EventLog.Delete ("monologtemp");
7247 }
7248 }
7249
7250 [Test]
7251 public void WriteEvent2_Values_Null ()
7252 {
7253 if (EventLog.SourceExists ("monotempsource", "."))
7254 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7255
7256 if (EventLog.Exists ("monologtemp", "."))
7257 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7258
7259 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7260 try {
7261 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7262 byte [] data = new byte [] { 23, 54 };
7263 EventInstance instance = new EventInstance (5, 556,
7264 EventLogEntryType.Warning);
7265 eventLog.WriteEvent (instance, data, (object) null);
7266
7267 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7268 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7269 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7270 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7271 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7272 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7273 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7274
7275 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7276 Assert.IsNotNull (entry, "#B1");
7277 Assert.IsNotNull (entry.Category, "#B2");
7278 Assert.AreEqual ("(556)", entry.Category, "#B3");
7279 Assert.AreEqual (556, entry.CategoryNumber, "#B4");
7280 Assert.IsNotNull (entry.Data, "#B5");
7281 Assert.AreEqual (data, entry.Data, "#B6");
7282 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7283 Assert.AreEqual (5, entry.EventID, "#B8");
7284 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7285 Assert.IsNotNull (entry.MachineName, "#B10");
7286 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7287 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7288 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
7289 Assert.IsNotNull (entry.Source, "#B14");
7290 Assert.AreEqual ("monotempsource", entry.Source, "#B15");
7291 Assert.IsNull (entry.UserName, "#B16");
7292 }
7293 } finally {
7294 if (EventLog.Exists ("monologtemp"))
7295 EventLog.Delete ("monologtemp");
7296 }
7297 }
7298
7299 [Test]
7300 public void WriteEvent3 ()
7301 {
7302 if (EventLog.SourceExists ("monotempsource", "."))
7303 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7304
7305 if (EventLog.Exists ("monologtemp", "."))
7306 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7307
7308 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7309 try {
7310 EventInstance instance = new EventInstance (5, 666,
7311 EventLogEntryType.FailureAudit);
7312 EventLog.WriteEvent ("monotempsource", instance, 5, "new"
7313 + Environment.NewLine + "line", true, null);
7314
7315 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7316 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7317 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7318 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7319 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7320 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7321 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7322 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7323
7324 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7325 Assert.IsNotNull (entry, "#B1");
7326 Assert.IsNotNull (entry.Category, "#B2");
7327 Assert.AreEqual ("(666)", entry.Category, "#B3");
7328 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7329 Assert.IsNotNull (entry.Data, "#B5");
7330 Assert.AreEqual (0, entry.Data.Length, "#B6");
7331 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
7332 Assert.AreEqual (5, entry.EventID, "#B8");
7333 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7334 Assert.IsNotNull (entry.MachineName, "#B10");
7335 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7336 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7337 Assert.AreEqual (4, entry.ReplacementStrings.Length, "#B13");
7338 Assert.AreEqual ("5", entry.ReplacementStrings [0], "#B14");
7339 Assert.AreEqual ("new" + Environment.NewLine + "line", entry.ReplacementStrings [1], "#B15");
7340 Assert.AreEqual (true.ToString (), entry.ReplacementStrings [2], "#B16");
7341 Assert.AreEqual (string.Empty, entry.ReplacementStrings [3], "#B17");
7342 Assert.IsNotNull (entry.Source, "#B18");
7343 Assert.AreEqual ("monotempsource", entry.Source, "#B19");
7344 Assert.IsNull (entry.UserName, "#B20");
7345
7346 EventLog.WriteEvent ("monotempsource", instance);
7347
7348 entry = eventLog.Entries [eventLog.Entries.Count - 1];
7349 Assert.IsNotNull (entry, "#C1");
7350 Assert.IsNotNull (entry.Category, "#C2");
7351 Assert.AreEqual ("(666)", entry.Category, "#C3");
7352 Assert.AreEqual (666, entry.CategoryNumber, "#C4");
7353 Assert.IsNotNull (entry.Data, "#C5");
7354 Assert.AreEqual (0, entry.Data.Length, "#C6");
7355 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#C7");
7356 Assert.AreEqual (5, entry.EventID, "#C8");
7357 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
7358 Assert.IsNotNull (entry.MachineName, "#C10");
7359 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
7360 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
7361 Assert.AreEqual (0, entry.ReplacementStrings.Length, "#C13");
7362 Assert.IsNotNull (entry.Source, "#C14");
7363 Assert.AreEqual ("monotempsource", entry.Source, "#C15");
7364 Assert.IsNull (entry.UserName, "#C16");
7365 }
7366 } finally {
7367 if (EventLog.Exists ("monologtemp"))
7368 EventLog.Delete ("monologtemp");
7369 }
7370 }
7371
7372 [Test]
7373 [ExpectedException (typeof (ArgumentNullException))]
7374 public void WriteEvent3_Instance_Null ()
7375 {
7376 EventLog.WriteEvent ("monotempsource", null);
7377 }
7378
7379 [Test]
7380 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
7381 public void WriteEvent3_Source_Empty ()
7382 {
7383 EventInstance instance = new EventInstance (5, 1,
7384 EventLogEntryType.Information);
7385 EventLog.WriteEvent (string.Empty, instance);
7386 }
7387
7388 [Test]
7389 public void WriteEvent3_Source_DoesNotExist ()
7390 {
7391 if (EventLogImplType == NULL_IMPL)
7392 // test cannot pass with NULL implementation
7393 Assert.Ignore ("No EventLogImplType.");
7394
7395 if (EventLog.SourceExists ("monotempsource", "."))
7396 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7397
7398 bool applicationLogExists = EventLog.Exists ("Application");
7399 try {
7400 EventInstance instance = new EventInstance (666, 1,
7401 EventLogEntryType.Error);
7402 EventLog.WriteEvent ("monotempsource", instance, "replace1", "replace2");
7403
7404 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
7405 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
7406 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
7407
7408 if (EventLogImplType == WIN32_IMPL)
7409 // win32 API does not return entries in order for
7410 // Application log
7411 return;
7412
7413 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
7414 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7415 Assert.IsNotNull (entry, "#B1");
7416 Assert.IsNotNull (entry.Category, "#B2");
7417 Assert.AreEqual ("(1)", entry.Category, "#B3");
7418 Assert.AreEqual (1, entry.CategoryNumber, "#B4");
7419 Assert.IsNotNull (entry.Data, "#B5");
7420 Assert.AreEqual (0, entry.Data.Length, "#B6");
7421 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
7422 Assert.AreEqual (666, entry.EventID, "#B8");
7423 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7424 Assert.IsNotNull (entry.MachineName, "#B10");
7425 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7426 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7427 Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
7428 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7429 Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
7430 Assert.IsNotNull (entry.Source, "#B16");
7431 Assert.AreEqual ("monotempsource", entry.Source, "#B17");
7432 Assert.IsNull (entry.UserName, "#B18");
7433 }
7434 } finally {
7435 if (!applicationLogExists) {
7436 if (EventLog.Exists ("Application"))
7437 EventLog.Delete ("Application");
7438 } else {
7439 if (EventLog.SourceExists ("monotempsource", "."))
7440 EventLog.DeleteEventSource ("monotempsource", ".");
7441 }
7442 }
7443 }
7444
7445 [Test]
7446 public void WriteEvent3_Values_Null ()
7447 {
7448 if (EventLog.SourceExists ("monotempsource", "."))
7449 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7450
7451 if (EventLog.Exists ("monologtemp", "."))
7452 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7453
7454 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7455 try {
7456 EventInstance instance = new EventInstance (5, 666,
7457 EventLogEntryType.Warning);
7458 EventLog.WriteEvent ("monotempsource", instance, (object) null);
7459
7460 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7461 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7462 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7463 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7464 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7465 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7466 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7467 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7468
7469 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7470 Assert.IsNotNull (entry, "#B1");
7471 Assert.IsNotNull (entry.Category, "#B2");
7472 Assert.AreEqual ("(666)", entry.Category, "#B3");
7473 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7474 Assert.IsNotNull (entry.Data, "#B5");
7475 Assert.AreEqual (0, entry.Data.Length, "#B6");
7476 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7477 Assert.AreEqual (5, entry.EventID, "#B8");
7478 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7479 Assert.IsNotNull (entry.MachineName, "#B10");
7480 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7481 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7482 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
7483 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
7484 Assert.IsNotNull (entry.Source, "#B15");
7485 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
7486 Assert.IsNull (entry.UserName, "#B17");
7487 }
7488 } finally {
7489 if (EventLog.Exists ("monologtemp"))
7490 EventLog.Delete ("monologtemp");
7491 }
7492 }
7493
7494 [Test]
7495 public void WriteEvent4 ()
7496 {
7497 if (EventLog.SourceExists ("monotempsource", "."))
7498 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7499
7500 if (EventLog.Exists ("monologtemp", "."))
7501 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7502
7503 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7504 try {
7505 byte [] data = new byte [] { 23, 54 };
7506 EventInstance instance = new EventInstance (5, 666,
7507 EventLogEntryType.FailureAudit);
7508 EventLog.WriteEvent ("monotempsource", instance, data, 5, "new"
7509 + Environment.NewLine + "line", true, null);
7510
7511 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7512 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7513 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7514 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7515 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7516 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7517 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7518 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7519
7520 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7521 Assert.IsNotNull (entry, "#B1");
7522 Assert.IsNotNull (entry.Category, "#B2");
7523 Assert.AreEqual ("(666)", entry.Category, "#B3");
7524 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7525 Assert.IsNotNull (entry.Data, "#B5");
7526 Assert.AreEqual (data, entry.Data, "#B6");
7527 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
7528 Assert.AreEqual (5, entry.EventID, "#B8");
7529 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7530 Assert.IsNotNull (entry.MachineName, "#B10");
7531 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7532 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7533 Assert.AreEqual (4, entry.ReplacementStrings.Length, "#B13");
7534 Assert.AreEqual ("5", entry.ReplacementStrings [0], "#B14");
7535 Assert.AreEqual ("new" + Environment.NewLine + "line", entry.ReplacementStrings [1], "#B15");
7536 Assert.AreEqual (true.ToString (), entry.ReplacementStrings [2], "#B16");
7537 Assert.AreEqual (string.Empty, entry.ReplacementStrings [3], "#B17");
7538 Assert.IsNotNull (entry.Source, "#B18");
7539 Assert.AreEqual ("monotempsource", entry.Source, "#B19");
7540 Assert.IsNull (entry.UserName, "#B20");
7541
7542 EventLog.WriteEvent ("monotempsource", instance, data);
7543
7544 entry = eventLog.Entries [eventLog.Entries.Count - 1];
7545 Assert.IsNotNull (entry, "#C1");
7546 Assert.IsNotNull (entry.Category, "#C2");
7547 Assert.AreEqual ("(666)", entry.Category, "#C3");
7548 Assert.AreEqual (666, entry.CategoryNumber, "#C4");
7549 Assert.IsNotNull (entry.Data, "#C5");
7550 Assert.AreEqual (data, entry.Data, "#C6");
7551 Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#C7");
7552 Assert.AreEqual (5, entry.EventID, "#C8");
7553 Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
7554 Assert.IsNotNull (entry.MachineName, "#C10");
7555 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#C11");
7556 Assert.IsNotNull (entry.ReplacementStrings, "#C12");
7557 Assert.AreEqual (0, entry.ReplacementStrings.Length, "#C13");
7558 Assert.IsNotNull (entry.Source, "#C14");
7559 Assert.AreEqual ("monotempsource", entry.Source, "#C15");
7560 Assert.IsNull (entry.UserName, "#C16");
7561 }
7562 } finally {
7563 if (EventLog.Exists ("monologtemp"))
7564 EventLog.Delete ("monologtemp");
7565 }
7566 }
7567
7568 [Test]
7569 public void WriteEvent4_Data_Null ()
7570 {
7571 if (EventLog.SourceExists ("monotempsource", "."))
7572 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7573
7574 if (EventLog.Exists ("monologtemp", "."))
7575 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7576
7577 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7578 try {
7579 EventInstance instance = new EventInstance (5, 444,
7580 EventLogEntryType.Warning);
7581 EventLog.WriteEvent ("monotempsource", instance, null, "replace1", null, "replace3");
7582
7583 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7584 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7585 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7586 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7587 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7588 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7589 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7590 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7591
7592 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7593 Assert.IsNotNull (entry, "#B1");
7594 Assert.IsNotNull (entry.Category, "#B2");
7595 Assert.AreEqual ("(444)", entry.Category, "#B3");
7596 Assert.AreEqual (444, entry.CategoryNumber, "#B4");
7597 Assert.IsNotNull (entry.Data, "#B5");
7598 Assert.AreEqual (0, entry.Data.Length, "#B6");
7599 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7600 Assert.AreEqual (5, entry.EventID, "#B8");
7601 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7602 Assert.IsNotNull (entry.MachineName, "#B10");
7603 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7604 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7605 Assert.AreEqual (3, entry.ReplacementStrings.Length, "#B13");
7606 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7607 Assert.AreEqual (string.Empty, entry.ReplacementStrings [1], "#B15");
7608 Assert.AreEqual ("replace3", entry.ReplacementStrings [2], "#B16");
7609 Assert.IsNotNull (entry.Source, "#B17");
7610 Assert.AreEqual ("monotempsource", entry.Source, "#B18");
7611 Assert.IsNull (entry.UserName, "#B19");
7612 }
7613 } finally {
7614 if (EventLog.Exists ("monologtemp"))
7615 EventLog.Delete ("monologtemp");
7616 }
7617 }
7618
7619 [Test]
7620 [ExpectedException (typeof (ArgumentNullException))]
7621 public void WriteEvent4_Instance_Null ()
7622 {
7623 EventLog.WriteEvent ("monotempsource", null, new byte [0]);
7624 }
7625
7626 [Test]
7627 [ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
7628 public void WriteEvent4_Source_Empty ()
7629 {
7630 EventInstance instance = new EventInstance (5, 1,
7631 EventLogEntryType.Information);
7632 EventLog.WriteEvent (string.Empty, instance, new byte [0]);
7633 }
7634
7635 [Test]
7636 public void WriteEvent4_Source_DoesNotExist ()
7637 {
7638 if (EventLogImplType == NULL_IMPL)
7639 // test cannot pass with NULL implementation
7640 Assert.Ignore ("No EventLogImplType.");
7641
7642 if (EventLog.SourceExists ("monotempsource", "."))
7643 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7644
7645 bool applicationLogExists = EventLog.Exists ("Application");
7646 try {
7647 byte [] data = new byte [] { 23, 54 };
7648 EventInstance instance = new EventInstance (666, 1,
7649 EventLogEntryType.Error);
7650 EventLog.WriteEvent ("monotempsource", instance, data, "replace1", "replace2");
7651
7652 Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
7653 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
7654 Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
7655
7656 if (EventLogImplType == WIN32_IMPL)
7657 // win32 API does not return entries in order for
7658 // Application log
7659 return;
7660
7661 using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
7662 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7663 Assert.IsNotNull (entry, "#B1");
7664 Assert.IsNotNull (entry.Category, "#B2");
7665 Assert.AreEqual ("(1)", entry.Category, "#B3");
7666 Assert.AreEqual (1, entry.CategoryNumber, "#B4");
7667 Assert.IsNotNull (entry.Data, "#B5");
7668 Assert.AreEqual (data, entry.Data, "#B6");
7669 Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
7670 Assert.AreEqual (666, entry.EventID, "#B8");
7671 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7672 Assert.IsNotNull (entry.MachineName, "#B10");
7673 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7674 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7675 Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
7676 Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
7677 Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
7678 Assert.IsNotNull (entry.Source, "#B16");
7679 Assert.AreEqual ("monotempsource", entry.Source, "#B17");
7680 Assert.IsNull (entry.UserName, "#B18");
7681 }
7682 } finally {
7683 if (!applicationLogExists) {
7684 if (EventLog.Exists ("Application"))
7685 EventLog.Delete ("Application");
7686 } else {
7687 if (EventLog.SourceExists ("monotempsource", "."))
7688 EventLog.DeleteEventSource ("monotempsource", ".");
7689 }
7690 }
7691 }
7692
7693 [Test]
7694 public void WriteEvent4_Values_Null ()
7695 {
7696 if (EventLog.SourceExists ("monotempsource", "."))
7697 Assert.Ignore ("Event log source 'monotempsource' should not exist.");
7698
7699 if (EventLog.Exists ("monologtemp", "."))
7700 Assert.Ignore ("Event log 'monologtemp' should not exist.");
7701
7702 EventLog.CreateEventSource ("monotempsource", "monologtemp");
7703 try {
7704 byte [] data = new byte [] { 23, 54 };
7705 EventInstance instance = new EventInstance (5, 666,
7706 EventLogEntryType.Warning);
7707 EventLog.WriteEvent ("monotempsource", instance, data, (object) null);
7708
7709 using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
7710 // MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
7711 Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
7712 Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
7713 Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
7714 Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
7715 Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
7716 Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
7717
7718 EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
7719 Assert.IsNotNull (entry, "#B1");
7720 Assert.IsNotNull (entry.Category, "#B2");
7721 Assert.AreEqual ("(666)", entry.Category, "#B3");
7722 Assert.AreEqual (666, entry.CategoryNumber, "#B4");
7723 Assert.IsNotNull (entry.Data, "#B5");
7724 Assert.AreEqual (data, entry.Data, "#B6");
7725 Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
7726 Assert.AreEqual (5, entry.EventID, "#B8");
7727 Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
7728 Assert.IsNotNull (entry.MachineName, "#B10");
7729 Assert.AreEqual (Environment.MachineName.ToUpper(), entry.MachineName.ToUpper(), "#B11");
7730 Assert.IsNotNull (entry.ReplacementStrings, "#B12");
7731 Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
7732 Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
7733 Assert.IsNotNull (entry.Source, "#B15");
7734 Assert.AreEqual ("monotempsource", entry.Source, "#B16");
7735 Assert.IsNull (entry.UserName, "#B17");
7736 }
7737 } finally {
7738 if (EventLog.Exists ("monologtemp"))
7739 EventLog.Delete ("monologtemp");
7740 }
7741 }
7742
7743 private static RegistryKey EventLogKey {
7744 get {
7745 return Registry.LocalMachine.OpenSubKey (@"SYSTEM\CurrentControlSet\Services\EventLog", true);
7746 }
7747 }
7748
7749 private static RegistryKey FindLogKeyByName (string logName)
7750 {
7751 RegistryKey eventLogKey = null;
7752 try {
7753 eventLogKey = EventLogKey;
7754 if (eventLogKey == null)
7755 Assert.Fail ("Event log key does not exist");
7756
7757 RegistryKey logKey = eventLogKey.OpenSubKey (logName, true);
7758 if (logKey != null)
7759 return logKey;
7760 return null;
7761 } finally {
7762 if (eventLogKey != null)
7763 eventLogKey.Close ();
7764 }
7765 }
7766
7767 private static RegistryKey FindSourceKeyByName (string source) {
7768 RegistryKey eventLogKey = null;
7769 try {
7770 eventLogKey = EventLogKey;
7771 if (eventLogKey == null)
7772 Assert.Fail ("Event log key does not exist");
7773
7774 string[] subKeys = eventLogKey.GetSubKeyNames ();
7775 for (int i = 0; i < subKeys.Length; i++) {
7776 using (RegistryKey logKey = eventLogKey.OpenSubKey (subKeys[i], true)) {
7777 if (logKey != null) {
7778 RegistryKey sourceKey = logKey.OpenSubKey (source, true);
7779 if (sourceKey != null)
7780 return sourceKey;
7781 }
7782 }
7783 }
7784 return null;
7785 } finally {
7786 if (eventLogKey != null)
7787 eventLogKey.Close ();
7788 }
7789 }
7790
7791 private static bool Win32EventLogEnabled {
7792 get {
7793 return (Environment.OSVersion.Platform == PlatformID.Win32NT);
7794 }
7795 }
7796
7797 // IMPORTANT: keep this in sync with System.Diagnostics.EventLog.EventLogImplType
7798 private static string EventLogImplType {
7799 get {
7800 string implType = Environment.GetEnvironmentVariable (EVENTLOG_TYPE_VAR);
7801 if (implType == null) {
7802 if (Win32EventLogEnabled)
7803 return WIN32_IMPL;
7804 implType = NULL_IMPL;
7805 } else {
7806 if (Win32EventLogEnabled && string.Compare (implType, WIN32_IMPL, true) == 0)
7807 implType = WIN32_IMPL;
7808 else if (string.Compare (implType, NULL_IMPL, true) == 0)
7809 implType = NULL_IMPL;
7810 else if (string.Compare (implType, 0, LOCAL_FILE_IMPL, 0, LOCAL_FILE_IMPL.Length, true) == 0)
7811 implType = LOCAL_FILE_IMPL;
7812 else
7813 throw new NotSupportedException (string.Format (
7814 CultureInfo.InvariantCulture, "Eventlog implementation"
7815 + " '{0}' is not supported.", implType));
7816 }
7817 return implType;
7818 }
7819 }
7820 }
7821 }
7822
7823 #endif
Mirror of the official Mono project git repository