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

   1 //
   2 // EventLogPermissionTest.cs -
   3 //      NUnit Test Cases for EventLogPermission
   4 //
   5 // Author:
   6 //      Sebastien Pouliot  <sebastien@ximian.com>
   7 //
   8 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 #if !MOBILE
  31
  32 using NUnit.Framework;
  33 using System;
  34 using System.Diagnostics;
  35 using System.Security;
  36 using System.Security.Permissions;
  37
  38 namespace MonoTests.System.Diagnostics {
  39
  40         [TestFixture]
  41         public class EventLogPermissionTest {
  42
  43                 static EventLogPermissionAccess[] AllAccess = {
  44                         EventLogPermissionAccess.None,
  45                         EventLogPermissionAccess.Browse,
  46                         EventLogPermissionAccess.Instrument,
  47                         EventLogPermissionAccess.Audit,
  48                         EventLogPermissionAccess.Write,
  49                         EventLogPermissionAccess.Administer,
  50                 };
  51
  52                 [Test]
  53                 public void PermissionState_None ()
  54                 {
  55                         PermissionState ps = PermissionState.None;
  56                         EventLogPermission elp = new EventLogPermission (ps);
  57                         Assert.AreEqual (0, elp.PermissionEntries.Count, "PermissionEntries");
  58                         Assert.IsFalse (elp.IsUnrestricted (), "IsUnrestricted");
  59
  60                         SecurityElement se = elp.ToXml ();
  61                         // only class and version are present
  62                         Assert.AreEqual (2, se.Attributes.Count, "Xml-Attributes");
  63                         Assert.IsNull (se.Children, "Xml-Children");
  64
  65                         EventLogPermission copy = (EventLogPermission)elp.Copy ();
  66                         Assert.IsFalse (Object.ReferenceEquals (elp, copy), "ReferenceEquals");
  67                         Assert.AreEqual (elp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");
  68                         Assert.AreEqual (elp.IsUnrestricted (), copy.IsUnrestricted (), "IsUnrestricted ()");
  69                 }
  70
  71                 [Test]
  72                 public void PermissionState_Unrestricted ()
  73                 {
  74                         PermissionState ps = PermissionState.Unrestricted;
  75                         EventLogPermission elp = new EventLogPermission (ps);
  76                         Assert.AreEqual (0, elp.PermissionEntries.Count, "PermissionEntries");
  77                         Assert.IsTrue (elp.IsUnrestricted (), "IsUnrestricted");
  78
  79                         SecurityElement se = elp.ToXml ();
  80                         // only class and version are present
  81                         Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "Xml-Unrestricted");
  82                         Assert.IsNull (se.Children, "Xml-Children");
  83
  84                         EventLogPermission copy = (EventLogPermission)elp.Copy ();
  85                         Assert.IsFalse (Object.ReferenceEquals (elp, copy), "ReferenceEquals");
  86                         Assert.AreEqual (elp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");
  87                         Assert.AreEqual (elp.IsUnrestricted (), copy.IsUnrestricted (), "copy-IsUnrestricted ()");
  88                 }
  89
  90                 [Test]
  91                 [ExpectedException (typeof (ArgumentException))]
  92                 public void PermissionState_Bad ()
  93                 {
  94                         PermissionState ps = (PermissionState)77;
  95                         EventLogPermission elp = new EventLogPermission (ps);
  96                         Assert.IsFalse (elp.IsUnrestricted (), "IsUnrestricted");
  97                 }
  98
  99                 [Test]
 100                 [ExpectedException (typeof (ArgumentNullException))]
 101                 public void Constructor_PermissionEntries_Null ()
 102                 {
 103                         EventLogPermission elp = new EventLogPermission (null);
 104                 }
 105
 106                 [Test]
 107                 [ExpectedException (typeof (ArgumentException))]
 108                 public void Constructor_MachineName_Null ()
 109                 {
 110                         EventLogPermission elp = new EventLogPermission (EventLogPermissionAccess.None, null);
 111                 }
 112
 113                 [Test]
 114                 public void EventLogPermissionAccesss_Bad ()
 115                 {
 116                         EventLogPermissionAccess elpa = (EventLogPermissionAccess)Int32.MinValue;
 117                         EventLogPermission elp = new EventLogPermission (elpa, "localhost");
 118                         Assert.AreEqual (1, elp.PermissionEntries.Count, "Count");
 119                         Assert.AreEqual ((EventLogPermissionAccess)Int32.MinValue, elp.PermissionEntries [0].PermissionAccess, "PermissionAccess");
 120                 }
 121
 122                 [Test]
 123                 public void PermissionEntries ()
 124                 {
 125                         EventLogPermissionAccess elpa = EventLogPermissionAccess.None;
 126                         EventLogPermission elp = new EventLogPermission (elpa, "localhost");
 127                         EventLogPermissionEntryCollection elpec = elp.PermissionEntries;
 128                         Assert.AreEqual (1, elpec.Count, "Count==1");
 129
 130                         EventLogPermissionEntry elpe = new EventLogPermissionEntry (EventLogPermissionAccess.Browse, "*");
 131                         elp.PermissionEntries.Add (elpe);
 132                         Assert.AreEqual (2, elpec.Count, "Count==2");
 133
 134                         // remove (same instance)
 135                         elp.PermissionEntries.Remove (elpe);
 136                         Assert.AreEqual (1, elpec.Count, "Count==1 (b)");
 137
 138                         // remove different instance (doesn't work)
 139                         elpe = new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost");
 140                         Assert.AreEqual (1, elpec.Count, "Count==1");
 141                 }
 142
 143                 [Test]
 144                 public void Copy ()
 145                 {
 146                         foreach (EventLogPermissionAccess elpa in AllAccess) {
 147                                 EventLogPermission elp = new EventLogPermission (PermissionState.None);
 148                                 EventLogPermissionEntry elpe = new EventLogPermissionEntry (elpa, elpa.ToString ());
 149                                 elp.PermissionEntries.Add (elpe);
 150                                 EventLogPermission copy = (EventLogPermission)elp.Copy ();
 151                                 Assert.AreEqual (1, copy.PermissionEntries.Count, "Count==1");
 152                                 Assert.AreEqual (elpa, elp.PermissionEntries [0].PermissionAccess, elpa.ToString ());
 153                         }
 154                 }
 155
 156                 [Test]
 157                 public void Intersect_Null ()
 158                 {
 159                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 160                         // No intersection with null
 161                         Assert.IsNull (elp.Intersect (null), "None N null");
 162                 }
 163
 164                 [Test]
 165                 public void Intersect_None ()
 166                 {
 167                         EventLogPermission elp1 = new EventLogPermission (PermissionState.None);
 168                         EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
 169                         // 1. None N None
 170                         EventLogPermission result = (EventLogPermission)elp1.Intersect (elp2);
 171                         Assert.IsNull (result, "Empty N Empty");
 172                         // 2. None N Entry
 173                         elp2.PermissionEntries.Add (new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost"));
 174                         result = (EventLogPermission)elp1.Intersect (elp2);
 175                         Assert.IsNull (result, "Empty N Entry");
 176                         // 3. Entry N None
 177                         result = (EventLogPermission)elp2.Intersect (elp1);
 178                         Assert.IsNull (result, "Entry N Empty");
 179                 }
 180
 181                 [Test]
 182                 public void Intersect_Unrestricted ()
 183                 {
 184                         // Intersection with unrestricted == Copy
 185                         // a. source (this) is unrestricted
 186                         EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
 187                         EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
 188
 189                         // 1. Unrestricted N None
 190                         EventLogPermission result = (EventLogPermission)elp1.Intersect (elp2);
 191                         Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N None).IsUnrestricted");
 192                         Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N None).Count");
 193
 194                         // 2. None N Unrestricted
 195                         result = (EventLogPermission)elp2.Intersect (elp1);
 196                         Assert.IsFalse (result.IsUnrestricted (), "(None N Unrestricted).IsUnrestricted");
 197                         Assert.AreEqual (0, result.PermissionEntries.Count, "(None N Unrestricted).Count");
 198
 199                         // 3. Unrestricted N Unrestricted
 200                         result = (EventLogPermission)elp1.Intersect (elp1);
 201                         Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");
 202                         Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
 203
 204                         // 4. Unrestricted N Entry
 205                         elp2.PermissionEntries.Add (new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost"));
 206                         result = (EventLogPermission)elp1.Intersect (elp2);
 207                         Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N Entry).IsUnrestricted");
 208                         Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Entry).Count");
 209
 210                         // 5. Entry N Unrestricted
 211                         result = (EventLogPermission)elp2.Intersect (elp1);
 212                         Assert.IsFalse (result.IsUnrestricted (), "(Entry N Unrestricted).IsUnrestricted");
 213                         Assert.AreEqual (1, result.PermissionEntries.Count, "(Entry N Unrestricted).Count");
 214
 215                         // 6. Unrestricted N Unrestricted
 216                         elp1.PermissionEntries.Add (new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost"));
 217                         result = (EventLogPermission)elp1.Intersect (elp1);
 218                         Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");
 219                         Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
 220                 }
 221
 222                 [Test]
 223                 [ExpectedException (typeof (ArgumentException))]
 224                 public void Intersect_BadPermission ()
 225                 {
 226                         EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
 227                         elp1.Intersect (new SecurityPermission (SecurityPermissionFlag.Assertion));
 228                 }
 229
 230                 [Test]
 231                 public void IsSubset_Null ()
 232                 {
 233                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 234                         Assert.IsTrue (elp.IsSubsetOf (null), "null");
 235                 }
 236
 237                 [Test]
 238                 public void IsSubset_None ()
 239                 {
 240                         // IsSubset with none
 241                         // a. source (this) is none -> target is never a subset
 242                         // b. destination (target) is none -> target is always a subset
 243                         EventLogPermission elp1 = new EventLogPermission (PermissionState.None);
 244                         foreach (EventLogPermissionAccess elpa in AllAccess) {
 245                                 EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
 246                                 elp2.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
 247                                 Assert.IsTrue (elp1.IsSubsetOf (elp2), "target " + elpa.ToString ());
 248                                 Assert.IsFalse (elp2.IsSubsetOf (elp1), "source " + elpa.ToString ());
 249                         }
 250                 }
 251
 252                 [Test]
 253                 public void IsSubset_Self ()
 254                 {
 255                         foreach (EventLogPermissionAccess elpa in AllAccess) {
 256                                 EventLogPermission elp = new EventLogPermission (PermissionState.None);
 257                                 elp.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
 258                                 Assert.IsTrue (elp.IsSubsetOf (elp), elpa.ToString ());
 259                         }
 260                 }
 261
 262                 [Test]
 263                 public void IsSubset_Unrestricted ()
 264                 {
 265                         // IsSubset with unrestricted
 266                         // a. source (this) is unrestricted -> target is never a subset
 267                         // b. destination (target) is unrestricted -> source is always a subset
 268                         EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
 269                         foreach (EventLogPermissionAccess elpa in AllAccess) {
 270                                 EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
 271                                 elp2.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
 272                                 Assert.IsFalse (elp1.IsSubsetOf (elp2), "target " + elpa.ToString ());
 273                                 Assert.IsTrue (elp2.IsSubsetOf (elp1), "source " + elpa.ToString ());
 274                         }
 275                         Assert.IsTrue (elp1.IsSubsetOf (elp1), "Unrestricted.IsSubsetOf(Unrestricted)");
 276                 }
 277
 278                 [Test]
 279 // "special" behavior inherited from ResourceBasePermission
 280 //              [ExpectedException (typeof (ArgumentException))]
 281                 public void IsSubsetOf_BadPermission ()
 282                 {
 283                         EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
 284                         Assert.IsFalse (elp1.IsSubsetOf (new SecurityPermission (SecurityPermissionFlag.Assertion)));
 285                 }
 286
 287                 [Test]
 288                 public void Union_Null ()
 289                 {
 290                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 291                         elp.PermissionEntries.Add (new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost"));
 292                         // Union with null is a simple copy
 293                         EventLogPermission union = (EventLogPermission)elp.Union (null);
 294                         Assert.IsNotNull (elp.PermissionEntries.Count, "Count");
 295                 }
 296
 297                 [Test]
 298                 public void Union_None ()
 299                 {
 300                         EventLogPermission elp1 = new EventLogPermission (PermissionState.None);
 301                         foreach (EventLogPermissionAccess elpa in AllAccess) {
 302                                 EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
 303                                 elp2.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
 304                                 EventLogPermission union = (EventLogPermission)elp1.Union (elp2);
 305                                 Assert.IsFalse (union.IsUnrestricted (), "target.IsUnrestricted " + elpa.ToString ());
 306                                 Assert.AreEqual (1, union.PermissionEntries.Count, "target.Count " + elpa.ToString ());
 307
 308                                 union = (EventLogPermission)elp2.Union (elp1);
 309                                 Assert.IsFalse (union.IsUnrestricted (), "source.IsUnrestricted " + elpa.ToString ());
 310                                 Assert.AreEqual (1, union.PermissionEntries.Count, "source.Count " + elpa.ToString ());
 311                         }
 312                 }
 313
 314                 [Test]
 315                 public void Union_Self ()
 316                 {
 317                         foreach (EventLogPermissionAccess elpa in AllAccess)
 318                         {
 319                                 EventLogPermission elp = new EventLogPermission (PermissionState.None);
 320                                 elp.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
 321                                 EventLogPermission union = (EventLogPermission)elp.Union (elp);
 322                                 Assert.IsFalse (union.IsUnrestricted (), "IsUnrestricted " + elpa.ToString ());
 323                                 Assert.AreEqual (1, union.PermissionEntries.Count, "Count " + elpa.ToString ());
 324                         }
 325                 }
 326
 327                 [Test]
 328                 public void Union_Unrestricted ()
 329                 {
 330                         // Union with unrestricted is unrestricted
 331                         EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
 332                         foreach (EventLogPermissionAccess elpa in AllAccess) {
 333                                 EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
 334                                 elp2.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
 335                                 EventLogPermission union = (EventLogPermission)elp1.Union (elp2);
 336                                 Assert.IsTrue (union.IsUnrestricted (), "target.IsUnrestricted " + elpa.ToString ());
 337                                 Assert.AreEqual (0, union.PermissionEntries.Count, "target.Count " + elpa.ToString ());
 338
 339                                 union = (EventLogPermission)elp2.Union (elp1);
 340                                 Assert.IsTrue (union.IsUnrestricted (), "source.IsUnrestricted " + elpa.ToString ());
 341                                 Assert.AreEqual (0, union.PermissionEntries.Count, "source.Count " + elpa.ToString ());
 342                         }
 343                 }
 344
 345                 [Test]
 346                 [ExpectedException (typeof (ArgumentException))]
 347                 public void Union_BadPermission ()
 348                 {
 349                         EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
 350                         elp1.Union (new SecurityPermission (SecurityPermissionFlag.Assertion));
 351                 }
 352
 353                 [Test]
 354                 [ExpectedException (typeof (ArgumentNullException))]
 355                 public void FromXml_Null ()
 356                 {
 357                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 358                         elp.FromXml (null);
 359                 }
 360
 361                 [Test]
 362                 [ExpectedException (typeof (ArgumentException))]
 363                 public void FromXml_WrongTag ()
 364                 {
 365                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 366                         SecurityElement se = elp.ToXml ();
 367                         se.Tag = "IMono";
 368                         elp.FromXml (se);
 369                         // note: normally IPermission classes (in corlib) DO care about the
 370                         // IPermission tag
 371                 }
 372
 373                 [Test]
 374                 [ExpectedException (typeof (ArgumentException))]
 375                 public void FromXml_WrongTagCase ()
 376                 {
 377                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 378                         SecurityElement se = elp.ToXml ();
 379                         se.Tag = "IPERMISSION"; // instead of IPermission
 380                         elp.FromXml (se);
 381                         // note: normally IPermission classes (in corlib) DO care about the
 382                         // IPermission tag
 383                 }
 384
 385                 [Test]
 386                 public void FromXml_WrongClass ()
 387                 {
 388                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 389                         SecurityElement se = elp.ToXml ();
 390
 391                         SecurityElement w = new SecurityElement (se.Tag);
 392                         w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
 393                         w.AddAttribute ("version", se.Attribute ("version"));
 394                         elp.FromXml (w);
 395                         // doesn't care of the class name at that stage
 396                         // anyway the class has already be created so...
 397                 }
 398
 399                 [Test]
 400                 public void FromXml_NoClass ()
 401                 {
 402                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 403                         SecurityElement se = elp.ToXml ();
 404
 405                         SecurityElement w = new SecurityElement (se.Tag);
 406                         w.AddAttribute ("version", se.Attribute ("version"));
 407                         elp.FromXml (w);
 408                         // doesn't even care of the class attribute presence
 409                 }
 410
 411                 [Test]
 412                 [ExpectedException (typeof (ArgumentException))]
 413                 public void FromXml_WrongVersion ()
 414                 {
 415                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 416                         SecurityElement se = elp.ToXml ();
 417                         se.Attributes.Remove ("version");
 418                         se.Attributes.Add ("version", "2");
 419                         elp.FromXml (se);
 420                 }
 421
 422                 [Test]
 423                 public void FromXml_NoVersion ()
 424                 {
 425                         EventLogPermission elp = new EventLogPermission (PermissionState.None);
 426                         SecurityElement se = elp.ToXml ();
 427
 428                         SecurityElement w = new SecurityElement (se.Tag);
 429                         w.AddAttribute ("class", se.Attribute ("class"));
 430                         elp.FromXml (w);
 431                 }
 432         }
 433 }
 434
 435 #endif