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

   1 //
   2 // PerformanceCounterPermissionTest.cs -
   3 //      NUnit Test Cases for PerformanceCounterPermission
   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 PerformanceCounterPermissionTest {
  42
  43                 static PerformanceCounterPermissionAccess[] AllAccess = {
  44                         PerformanceCounterPermissionAccess.None,
  45                         PerformanceCounterPermissionAccess.Browse,
  46                         PerformanceCounterPermissionAccess.Read,
  47                         PerformanceCounterPermissionAccess.Write,
  48                         PerformanceCounterPermissionAccess.Instrument,
  49                         PerformanceCounterPermissionAccess.Administer,
  50                 };
  51
  52                 [Test]
  53                 public void PermissionState_None ()
  54                 {
  55                         PermissionState ps = PermissionState.None;
  56                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (ps);
  57                         Assert.AreEqual (0, pcp.PermissionEntries.Count, "PermissionEntries");
  58                         Assert.IsFalse (pcp.IsUnrestricted (), "IsUnrestricted");
  59
  60                         SecurityElement se = pcp.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                         PerformanceCounterPermission copy = (PerformanceCounterPermission)pcp.Copy ();
  66                         Assert.IsFalse (Object.ReferenceEquals (pcp, copy), "ReferenceEquals");
  67                         Assert.AreEqual (pcp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");
  68                         Assert.AreEqual (pcp.IsUnrestricted (), copy.IsUnrestricted (), "IsUnrestricted ()");
  69                 }
  70
  71                 [Test]
  72                 public void PermissionState_Unrestricted ()
  73                 {
  74                         PermissionState ps = PermissionState.Unrestricted;
  75                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (ps);
  76                         Assert.AreEqual (0, pcp.PermissionEntries.Count, "PermissionEntries");
  77                         Assert.IsTrue (pcp.IsUnrestricted (), "IsUnrestricted");
  78
  79                         SecurityElement se = pcp.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                         PerformanceCounterPermission copy = (PerformanceCounterPermission)pcp.Copy ();
  85                         Assert.IsFalse (Object.ReferenceEquals (pcp, copy), "ReferenceEquals");
  86                         Assert.AreEqual (pcp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");
  87                         Assert.AreEqual (pcp.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                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (ps);
  96                         Assert.IsFalse (pcp.IsUnrestricted (), "IsUnrestricted");
  97                 }
  98
  99                 [Test]
 100                 [ExpectedException (typeof (ArgumentNullException))]
 101                 public void Constructor_PermissionEntries_Null ()
 102                 {
 103                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (null);
 104                 }
 105
 106                 [Test]
 107                 [ExpectedException (typeof (ArgumentNullException))]
 108                 public void Constructor_MachineName_Null ()
 109                 {
 110                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PerformanceCounterPermissionAccess.None, null, String.Empty);
 111                 }
 112
 113                 [Test]
 114                 [ExpectedException (typeof (ArgumentNullException))]
 115                 public void Constructor_CategoryName_Null ()
 116                 {
 117                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PerformanceCounterPermissionAccess.None, "localhost", null);
 118                 }
 119
 120                 [Test]
 121                 [ExpectedException (typeof (ArgumentException))]
 122                 public void PerformanceCounterPermissionAccesss_Bad ()
 123                 {
 124                         PerformanceCounterPermissionAccess pcpa = (PerformanceCounterPermissionAccess)Int32.MinValue;
 125                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (pcpa, "localhost", String.Empty);
 126                         Assert.AreEqual (1, pcp.PermissionEntries.Count, "Count");
 127                         Assert.AreEqual ((PerformanceCounterPermissionAccess)Int32.MinValue, pcp.PermissionEntries [0].PermissionAccess, "PermissionAccess");
 128                 }
 129
 130                 [Test]
 131                 public void PermissionEntries ()
 132                 {
 133                         PerformanceCounterPermissionAccess pcpa = PerformanceCounterPermissionAccess.None;
 134                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (pcpa, "localhost", String.Empty);
 135                         PerformanceCounterPermissionEntryCollection pcpec = pcp.PermissionEntries;
 136                         Assert.AreEqual (1, pcpec.Count, "Count==1");
 137
 138                         PerformanceCounterPermissionEntry pcpe = new PerformanceCounterPermissionEntry (PerformanceCounterPermissionAccess.Browse, "*", String.Empty);
 139                         pcp.PermissionEntries.Add (pcpe);
 140                         Assert.AreEqual (2, pcpec.Count, "Count==2");
 141
 142                         // remove (same instance)
 143                         pcp.PermissionEntries.Remove (pcpe);
 144                         Assert.AreEqual (1, pcpec.Count, "Count==1 (b)");
 145
 146                         // remove different instance (doesn't work)
 147                         pcpe = new PerformanceCounterPermissionEntry (PerformanceCounterPermissionAccess.None, "localhost", String.Empty);
 148                         Assert.AreEqual (1, pcpec.Count, "Count==1");
 149                 }
 150
 151                 [Test]
 152                 public void Copy ()
 153                 {
 154                         foreach (PerformanceCounterPermissionAccess pcpa in AllAccess) {
 155                                 PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 156                                 PerformanceCounterPermissionEntry pcpe = new PerformanceCounterPermissionEntry (pcpa, pcpa.ToString (), String.Empty);
 157                                 pcp.PermissionEntries.Add (pcpe);
 158                                 PerformanceCounterPermission copy = (PerformanceCounterPermission)pcp.Copy ();
 159                                 Assert.AreEqual (1, copy.PermissionEntries.Count, "Count==1");
 160                                 Assert.AreEqual (pcpa, pcp.PermissionEntries [0].PermissionAccess, pcpa.ToString ());
 161                         }
 162                 }
 163
 164                 [Test]
 165                 public void Intersect_Null ()
 166                 {
 167                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 168                         // No intersection with null
 169                         Assert.IsNull (pcp.Intersect (null), "None N null");
 170                 }
 171
 172                 [Test]
 173                 public void Intersect_None ()
 174                 {
 175                         PerformanceCounterPermission pcp1 = new PerformanceCounterPermission (PermissionState.None);
 176                         PerformanceCounterPermission pcp2 = new PerformanceCounterPermission (PermissionState.None);
 177                         // 1. None N None
 178                         PerformanceCounterPermission result = (PerformanceCounterPermission)pcp1.Intersect (pcp2);
 179                         Assert.IsNull (result, "Empty N Empty");
 180                         // 2. None N Entry
 181                         pcp2.PermissionEntries.Add (new PerformanceCounterPermissionEntry (PerformanceCounterPermissionAccess.None, "localhost", String.Empty));
 182                         result = (PerformanceCounterPermission)pcp1.Intersect (pcp2);
 183                         Assert.IsNull (result, "Empty N Entry");
 184                         // 3. Entry N None
 185                         result = (PerformanceCounterPermission)pcp2.Intersect (pcp1);
 186                         Assert.IsNull (result, "Entry N Empty");
 187                 }
 188
 189                 [Test]
 190                 public void Intersect_Unrestricted ()
 191                 {
 192                         // Intersection with unrestricted == Copy
 193                         // a. source (this) is unrestricted
 194                         PerformanceCounterPermission pcp1 = new PerformanceCounterPermission (PermissionState.Unrestricted);
 195                         PerformanceCounterPermission pcp2 = new PerformanceCounterPermission (PermissionState.None);
 196
 197                         // 1. Unrestricted N None
 198                         PerformanceCounterPermission result = (PerformanceCounterPermission)pcp1.Intersect (pcp2);
 199                         Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N None).IsUnrestricted");
 200                         Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N None).Count");
 201
 202                         // 2. None N Unrestricted
 203                         result = (PerformanceCounterPermission)pcp2.Intersect (pcp1);
 204                         Assert.IsFalse (result.IsUnrestricted (), "(None N Unrestricted).IsUnrestricted");
 205                         Assert.AreEqual (0, result.PermissionEntries.Count, "(None N Unrestricted).Count");
 206
 207                         // 3. Unrestricted N Unrestricted
 208                         result = (PerformanceCounterPermission)pcp1.Intersect (pcp1);
 209                         Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");
 210                         Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
 211
 212                         // 4. Unrestricted N Entry
 213                         pcp2.PermissionEntries.Add (new PerformanceCounterPermissionEntry (PerformanceCounterPermissionAccess.None, "localhost", String.Empty));
 214                         result = (PerformanceCounterPermission)pcp1.Intersect (pcp2);
 215                         Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N Entry).IsUnrestricted");
 216                         Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Entry).Count");
 217
 218                         // 5. Entry N Unrestricted
 219                         result = (PerformanceCounterPermission)pcp2.Intersect (pcp1);
 220                         Assert.IsFalse (result.IsUnrestricted (), "(Entry N Unrestricted).IsUnrestricted");
 221                         Assert.AreEqual (1, result.PermissionEntries.Count, "(Entry N Unrestricted).Count");
 222
 223                         // 6. Unrestricted N Unrestricted
 224                         pcp1.PermissionEntries.Add (new PerformanceCounterPermissionEntry (PerformanceCounterPermissionAccess.None, "localhost", String.Empty));
 225                         result = (PerformanceCounterPermission)pcp1.Intersect (pcp1);
 226                         Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");
 227                         Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
 228                 }
 229
 230                 [Test]
 231                 [ExpectedException (typeof (ArgumentException))]
 232                 public void Intersect_BadPermission ()
 233                 {
 234                         PerformanceCounterPermission pcp1 = new PerformanceCounterPermission (PermissionState.Unrestricted);
 235                         pcp1.Intersect (new SecurityPermission (SecurityPermissionFlag.Assertion));
 236                 }
 237
 238                 [Test]
 239                 public void IsSubset_Null ()
 240                 {
 241                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 242                         Assert.IsTrue (pcp.IsSubsetOf (null), "null");
 243                 }
 244
 245                 [Test]
 246                 public void IsSubset_None ()
 247                 {
 248                         // IsSubset with none
 249                         // a. source (this) is none -> target is never a subset
 250                         // b. destination (target) is none -> target is always a subset
 251                         PerformanceCounterPermission pcp1 = new PerformanceCounterPermission (PermissionState.None);
 252                         foreach (PerformanceCounterPermissionAccess pcpa in AllAccess) {
 253                                 PerformanceCounterPermission pcp2 = new PerformanceCounterPermission (PermissionState.None);
 254                                 pcp2.PermissionEntries.Add (new PerformanceCounterPermissionEntry (pcpa, pcpa.ToString (), String.Empty));
 255                                 Assert.IsTrue (pcp1.IsSubsetOf (pcp2), "target " + pcpa.ToString ());
 256                                 Assert.IsFalse (pcp2.IsSubsetOf (pcp1), "source " + pcpa.ToString ());
 257                         }
 258                 }
 259
 260                 [Test]
 261                 public void IsSubset_Self ()
 262                 {
 263                         foreach (PerformanceCounterPermissionAccess pcpa in AllAccess) {
 264                                 PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 265                                 pcp.PermissionEntries.Add (new PerformanceCounterPermissionEntry (pcpa, pcpa.ToString (), String.Empty));
 266                                 Assert.IsTrue (pcp.IsSubsetOf (pcp), pcpa.ToString ());
 267                         }
 268                 }
 269
 270                 [Test]
 271                 public void IsSubset_Unrestricted ()
 272                 {
 273                         // IsSubset with unrestricted
 274                         // a. source (this) is unrestricted -> target is never a subset
 275                         // b. destination (target) is unrestricted -> source is always a subset
 276                         PerformanceCounterPermission pcp1 = new PerformanceCounterPermission (PermissionState.Unrestricted);
 277                         foreach (PerformanceCounterPermissionAccess pcpa in AllAccess) {
 278                                 PerformanceCounterPermission pcp2 = new PerformanceCounterPermission (PermissionState.None);
 279                                 pcp2.PermissionEntries.Add (new PerformanceCounterPermissionEntry (pcpa, pcpa.ToString (), String.Empty));
 280                                 Assert.IsFalse (pcp1.IsSubsetOf (pcp2), "target " + pcpa.ToString ());
 281                                 Assert.IsTrue (pcp2.IsSubsetOf (pcp1), "source " + pcpa.ToString ());
 282                         }
 283                         Assert.IsTrue (pcp1.IsSubsetOf (pcp1), "Unrestricted.IsSubsetOf(Unrestricted)");
 284                 }
 285
 286                 [Test]
 287 // "special" behavior inherited from ResourceBasePermission
 288 //              [ExpectedException (typeof (ArgumentException))]
 289                 public void IsSubsetOf_BadPermission ()
 290                 {
 291                         PerformanceCounterPermission pcp1 = new PerformanceCounterPermission (PermissionState.Unrestricted);
 292                         Assert.IsFalse (pcp1.IsSubsetOf (new SecurityPermission (SecurityPermissionFlag.Assertion)));
 293                 }
 294
 295                 [Test]
 296                 public void Union_Null ()
 297                 {
 298                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 299                         pcp.PermissionEntries.Add (new PerformanceCounterPermissionEntry (PerformanceCounterPermissionAccess.None, "localhost", String.Empty));
 300                         // Union with null is a simple copy
 301                         PerformanceCounterPermission union = (PerformanceCounterPermission)pcp.Union (null);
 302                         Assert.IsNotNull (pcp.PermissionEntries.Count, "Count");
 303                 }
 304
 305                 [Test]
 306                 public void Union_None ()
 307                 {
 308                         PerformanceCounterPermission pcp1 = new PerformanceCounterPermission (PermissionState.None);
 309                         foreach (PerformanceCounterPermissionAccess pcpa in AllAccess) {
 310                                 PerformanceCounterPermission pcp2 = new PerformanceCounterPermission (PermissionState.None);
 311                                 pcp2.PermissionEntries.Add (new PerformanceCounterPermissionEntry (pcpa, pcpa.ToString (), String.Empty));
 312                                 PerformanceCounterPermission union = (PerformanceCounterPermission)pcp1.Union (pcp2);
 313                                 Assert.IsFalse (union.IsUnrestricted (), "target.IsUnrestricted " + pcpa.ToString ());
 314                                 Assert.AreEqual (1, union.PermissionEntries.Count, "target.Count " + pcpa.ToString ());
 315
 316                                 union = (PerformanceCounterPermission)pcp2.Union (pcp1);
 317                                 Assert.IsFalse (union.IsUnrestricted (), "source.IsUnrestricted " + pcpa.ToString ());
 318                                 Assert.AreEqual (1, union.PermissionEntries.Count, "source.Count " + pcpa.ToString ());
 319                         }
 320                 }
 321
 322                 [Test]
 323                 public void Union_Self ()
 324                 {
 325                         foreach (PerformanceCounterPermissionAccess pcpa in AllAccess) {
 326                                 PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 327                                 pcp.PermissionEntries.Add (new PerformanceCounterPermissionEntry (pcpa, pcpa.ToString (), String.Empty));
 328                                 PerformanceCounterPermission union = (PerformanceCounterPermission)pcp.Union (pcp);
 329                                 Assert.IsFalse (union.IsUnrestricted (), "IsUnrestricted " + pcpa.ToString ());
 330                                 Assert.AreEqual (1, union.PermissionEntries.Count, "Count " + pcpa.ToString ());
 331                         }
 332                 }
 333
 334                 [Test]
 335                 public void Union_Unrestricted ()
 336                 {
 337                         // Union with unrestricted is unrestricted
 338                         PerformanceCounterPermission pcp1 = new PerformanceCounterPermission (PermissionState.Unrestricted);
 339                         foreach (PerformanceCounterPermissionAccess pcpa in AllAccess) {
 340                                 PerformanceCounterPermission pcp2 = new PerformanceCounterPermission (PermissionState.None);
 341                                 pcp2.PermissionEntries.Add (new PerformanceCounterPermissionEntry (pcpa, pcpa.ToString (), String.Empty));
 342                                 PerformanceCounterPermission union = (PerformanceCounterPermission)pcp1.Union (pcp2);
 343                                 Assert.IsTrue (union.IsUnrestricted (), "target.IsUnrestricted " + pcpa.ToString ());
 344                                 Assert.AreEqual (0, union.PermissionEntries.Count, "target.Count " + pcpa.ToString ());
 345
 346                                 union = (PerformanceCounterPermission)pcp2.Union (pcp1);
 347                                 Assert.IsTrue (union.IsUnrestricted (), "source.IsUnrestricted " + pcpa.ToString ());
 348                                 Assert.AreEqual (0, union.PermissionEntries.Count, "source.Count " + pcpa.ToString ());
 349                         }
 350                 }
 351
 352                 [Test]
 353                 [ExpectedException (typeof (ArgumentException))]
 354                 public void Union_BadPermission ()
 355                 {
 356                         PerformanceCounterPermission pcp1 = new PerformanceCounterPermission (PermissionState.Unrestricted);
 357                         pcp1.Union (new SecurityPermission (SecurityPermissionFlag.Assertion));
 358                 }
 359
 360                 [Test]
 361                 [ExpectedException (typeof (ArgumentNullException))]
 362                 public void FromXml_Null ()
 363                 {
 364                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 365                         pcp.FromXml (null);
 366                 }
 367
 368                 [Test]
 369                 [ExpectedException (typeof (ArgumentException))]
 370                 public void FromXml_WrongTag ()
 371                 {
 372                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 373                         SecurityElement se = pcp.ToXml ();
 374                         se.Tag = "IMono";
 375                         pcp.FromXml (se);
 376                         // note: normally IPermission classes (in corlib) DO care about the
 377                         // IPermission tag
 378                 }
 379
 380                 [Test]
 381                 [ExpectedException (typeof (ArgumentException))]
 382                 public void FromXml_WrongTagCase ()
 383                 {
 384                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 385                         SecurityElement se = pcp.ToXml ();
 386                         se.Tag = "IPERMISSION"; // instead of IPermission
 387                         pcp.FromXml (se);
 388                         // note: normally IPermission classes (in corlib) DO care about the
 389                         // IPermission tag
 390                 }
 391
 392                 [Test]
 393                 public void FromXml_WrongClass ()
 394                 {
 395                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 396                         SecurityElement se = pcp.ToXml ();
 397
 398                         SecurityElement w = new SecurityElement (se.Tag);
 399                         w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
 400                         w.AddAttribute ("version", se.Attribute ("version"));
 401                         pcp.FromXml (w);
 402                         // doesn't care of the class name at that stage
 403                         // anyway the class has already be created so...
 404                 }
 405
 406                 [Test]
 407                 public void FromXml_NoClass ()
 408                 {
 409                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 410                         SecurityElement se = pcp.ToXml ();
 411
 412                         SecurityElement w = new SecurityElement (se.Tag);
 413                         w.AddAttribute ("version", se.Attribute ("version"));
 414                         pcp.FromXml (w);
 415                         // doesn't even care of the class attribute presence
 416                 }
 417
 418                 [Test]
 419                 [ExpectedException (typeof (ArgumentException))]
 420                 public void FromXml_WrongVersion ()
 421                 {
 422                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 423                         SecurityElement se = pcp.ToXml ();
 424                         se.Attributes.Remove ("version");
 425                         se.Attributes.Add ("version", "2");
 426                         pcp.FromXml (se);
 427                 }
 428
 429                 [Test]
 430                 public void FromXml_NoVersion ()
 431                 {
 432                         PerformanceCounterPermission pcp = new PerformanceCounterPermission (PermissionState.None);
 433                         SecurityElement se = pcp.ToXml ();
 434
 435                         SecurityElement w = new SecurityElement (se.Tag);
 436                         w.AddAttribute ("class", se.Attribute ("class"));
 437                         pcp.FromXml (w);
 438                 }
 439         }
 440 }
 441
 442 #endif