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