mcs/class/System/Test/System.Diagnostics/EventLogTest.cs

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