mcs/class/corlib/Test/System.Security.Permissions/SecurityPermissionTest.cs

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