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