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

   1 //
   2 // ReflectionPermissionTest.cs - NUnit Test Cases for ReflectionPermission
   3 //
   4 // Author:
   5 //      Sebastien Pouliot (spouliot@motus.com)
   6 //
   7 // (C) 2003 Motus Technologies Inc. (http://www.motus.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.Security;
  13 using System.Security.Permissions;
  14
  15 namespace MonoTests.System.Security.Permissions {
  16
  17         [TestFixture]
  18         public class ReflectionPermissionTest : Assertion {
  19
  20                 private static string className = "System.Security.Permissions.ReflectionPermission, ";
  21
  22                 [Test]
  23                 public void PermissionStateNone ()
  24                 {
  25                         ReflectionPermission p = new ReflectionPermission (PermissionState.None);
  26                         AssertNotNull ("ReflectionPermission(PermissionState.None)", p);
  27                         Assert ("IsUnrestricted", !p.IsUnrestricted ());
  28                         ReflectionPermission copy = (ReflectionPermission) p.Copy ();
  29                         AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
  30                         SecurityElement se = p.ToXml ();
  31                         Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className));
  32                         AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string));
  33                 }
  34
  35                 [Test]
  36                 public void PermissionStateUnrestricted ()
  37                 {
  38                         ReflectionPermission p = new ReflectionPermission (PermissionState.Unrestricted);
  39                         AssertNotNull ("ReflectionPermission(PermissionState.Unrestricted)", p);
  40                         Assert ("IsUnrestricted", p.IsUnrestricted ());
  41                         ReflectionPermission copy = (ReflectionPermission) p.Copy ();
  42                         AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
  43                         SecurityElement se = p.ToXml ();
  44                         AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
  45                 }
  46
  47                 [Test]
  48                 public void Derestricted ()
  49                 {
  50                         ReflectionPermission p = new ReflectionPermission (PermissionState.Unrestricted);
  51                         Assert ("IsUnrestricted", p.IsUnrestricted ());
  52                         p.Flags = ReflectionPermissionFlag.NoFlags;
  53                         Assert ("IsUnrestricted", !p.IsUnrestricted ());
  54                 }
  55
  56                 [Test]
  57                 public void NoFlags ()
  58                 {
  59                         ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
  60                         Assert ("IsUnrestricted", !p.IsUnrestricted ());
  61                         SecurityElement se = p.ToXml ();
  62                         AssertEquals ("ToXml-Flags=NoFlags", "NoFlags", (se.Attributes ["Flags"] as string));
  63                 }
  64
  65                 [Test]
  66                 public void TypeInformation ()
  67                 {
  68                         ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation);
  69                         Assert ("IsUnrestricted", !p.IsUnrestricted ());
  70                         SecurityElement se = p.ToXml ();
  71                         AssertEquals ("ToXml-Flags=TypeInformation", "TypeInformation", (se.Attributes ["Flags"] as string));
  72                 }
  73
  74                 [Test]
  75                 public void MemberAccess ()
  76                 {
  77                         ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
  78                         Assert ("IsUnrestricted", !p.IsUnrestricted ());
  79                         SecurityElement se = p.ToXml ();
  80                         AssertEquals ("ToXml-Flags=MemberAccess", "MemberAccess", (se.Attributes ["Flags"] as string));
  81                 }
  82
  83                 [Test]
  84                 public void ReflectionEmit ()
  85                 {
  86                         ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.ReflectionEmit);
  87                         Assert ("IsUnrestricted", !p.IsUnrestricted ());
  88                         SecurityElement se = p.ToXml ();
  89                         AssertEquals ("ToXml-Flags=ReflectionEmit", "ReflectionEmit", (se.Attributes ["Flags"] as string));
  90                 }
  91
  92                 [Test]
  93                 public void AllFlags ()
  94                 {
  95                         ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.AllFlags);
  96                         Assert ("IsUnrestricted", p.IsUnrestricted ());
  97                         SecurityElement se = p.ToXml ();
  98                         AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
  99                 }
 100
 101                 [Test]
 102                 public void Flags ()
 103                 {
 104                         ReflectionPermission p = new ReflectionPermission (PermissionState.None);
 105                         Assert ("Flags(default).IsUnrestricted", !p.IsUnrestricted ());
 106                         p.Flags = ReflectionPermissionFlag.NoFlags;
 107                         Assert ("Flags(NoFlags).IsUnrestricted", !p.IsUnrestricted ());
 108                         p.Flags = ReflectionPermissionFlag.TypeInformation;
 109                         Assert ("Flags(TypeInformation).IsUnrestricted", !p.IsUnrestricted ());
 110                         p.Flags = ReflectionPermissionFlag.MemberAccess;
 111                         Assert ("Flags(MemberAccess).IsUnrestricted", !p.IsUnrestricted ());
 112                         p.Flags = ReflectionPermissionFlag.ReflectionEmit;
 113                         Assert ("Flags(ReflectionEmit).IsUnrestricted", !p.IsUnrestricted ());
 114                         p.Flags = ReflectionPermissionFlag.AllFlags;
 115                         Assert ("Flags(AllFlags).IsUnrestricted", p.IsUnrestricted ());
 116                 }
 117
 118                 [Test]
 119                 [ExpectedException (typeof (ArgumentNullException))]
 120                 public void FromXmlNull ()
 121                 {
 122                         ReflectionPermission p = new ReflectionPermission (PermissionState.None);
 123                         p.FromXml (null);
 124                 }
 125
 126                 [Test]
 127                 [ExpectedException (typeof (ArgumentException))]
 128                 public void FromXmlInvalidPermission ()
 129                 {
 130                         ReflectionPermission p = new ReflectionPermission (PermissionState.None);
 131                         SecurityElement se = p.ToXml ();
 132                         // can't modify - so we create our own
 133                         SecurityElement se2 = new SecurityElement ("IInvalidPermission", se.Text);
 134                         se2.AddAttribute ("class", se.Attribute ("class"));
 135                         se2.AddAttribute ("version", se.Attribute ("version"));
 136                         p.FromXml (se2);
 137                 }
 138
 139                 [Test]
 140                 [ExpectedException (typeof (ArgumentException))]
 141                 public void FromXmlWrongVersion ()
 142                 {
 143                         ReflectionPermission p = new ReflectionPermission (PermissionState.None);
 144                         SecurityElement se = p.ToXml ();
 145                         // can't modify - so we create our own
 146                         SecurityElement se2 = new SecurityElement (se.Tag, se.Text);
 147                         se2.AddAttribute ("class", se.Attribute ("class"));
 148                         se2.AddAttribute ("version", "2");
 149                         p.FromXml (se2);
 150                 }
 151
 152                 [Test]
 153                 public void FromXml ()
 154                 {
 155                         ReflectionPermission p = new ReflectionPermission (PermissionState.None);
 156                         SecurityElement se = p.ToXml ();
 157                         AssertNotNull ("ToXml()", se);
 158
 159                         ReflectionPermission p2 = (ReflectionPermission) p.Copy ();
 160                         p2.FromXml (se);
 161                         AssertEquals ("FromXml-None", ReflectionPermissionFlag.NoFlags, p2.Flags);
 162
 163                         string className = (string) se.Attributes ["class"];
 164                         string version = (string) se.Attributes ["version"];
 165
 166                         SecurityElement se2 = new SecurityElement (se.Tag);
 167                         se2.AddAttribute ("class", className);
 168                         se2.AddAttribute ("version", version);
 169                         se2.AddAttribute ("Flags", "TypeInformation");
 170                         p2.FromXml (se2);
 171                         AssertEquals ("FromXml-TypeInformation", ReflectionPermissionFlag.TypeInformation, p2.Flags);
 172
 173                         se2 = new SecurityElement (se.Tag);
 174                         se2.AddAttribute ("class", className);
 175                         se2.AddAttribute ("version", version);
 176                         se2.AddAttribute ("Flags", "MemberAccess");
 177                         p2.FromXml (se2);
 178                         AssertEquals ("FromXml-MemberAccess", ReflectionPermissionFlag.MemberAccess, p2.Flags);
 179
 180                         se2 = new SecurityElement (se.Tag);
 181                         se2.AddAttribute ("class", className);
 182                         se2.AddAttribute ("version", version);
 183                         se2.AddAttribute ("Flags", "ReflectionEmit");
 184                         p2.FromXml (se2);
 185                         AssertEquals ("FromXml-ReflectionEmit", ReflectionPermissionFlag.ReflectionEmit, p2.Flags);
 186
 187                         se = p.ToXml ();
 188                         se.AddAttribute ("Unrestricted", "true");
 189                         p2.FromXml (se);
 190                         Assert ("FromXml-Unrestricted", p2.IsUnrestricted ());
 191                         AssertEquals ("FromXml-AllFlags", ReflectionPermissionFlag.AllFlags, p2.Flags);
 192                 }
 193
 194                 [Test]
 195                 public void UnionWithNull ()
 196                 {
 197                         ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
 198                         ReflectionPermission p2 = null;
 199                         ReflectionPermission p3 = (ReflectionPermission) p1.Union (p2);
 200                         AssertEquals ("P1 U null == P1", p1.ToXml ().ToString (), p3.ToXml ().ToString ());
 201                 }
 202
 203                 [Test]
 204                 public void UnionWithUnrestricted ()
 205                 {
 206                         ReflectionPermission p1 = new ReflectionPermission (PermissionState.Unrestricted);
 207                         ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
 208                         ReflectionPermission p3 = (ReflectionPermission) p1.Union (p2);
 209                         Assert ("Unrestricted U P2 == Unrestricted", p3.IsUnrestricted ());
 210                         p3 = (ReflectionPermission) p2.Union (p1);
 211                         Assert ("P2 U Unrestricted == Unrestricted", p3.IsUnrestricted ());
 212                 }
 213
 214                 [Test]
 215                 public void Union ()
 216                 {
 217                         ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation);
 218                         ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
 219                         ReflectionPermission p3 = (ReflectionPermission) p1.Union (p2);
 220                         AssertEquals (ReflectionPermissionFlag.MemberAccess | ReflectionPermissionFlag.TypeInformation, p3.Flags);
 221                         ReflectionPermission p4 = new ReflectionPermission (ReflectionPermissionFlag.ReflectionEmit);
 222                         ReflectionPermission p5 = (ReflectionPermission) p4.Union (p3);
 223                         Assert ("P3 U P4==Unrestricted", p5.IsUnrestricted ());
 224                 }
 225
 226                 [Test]
 227                 [ExpectedException (typeof (ArgumentException))]
 228                 public void UnionWithBadPermission ()
 229                 {
 230                         ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
 231                         EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted);
 232                         ReflectionPermission p3 = (ReflectionPermission) p1.Union (ep2);
 233                 }
 234
 235                 [Test]
 236                 public void IntersectWithNull ()
 237                 {
 238                         ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
 239                         ReflectionPermission p2 = null;
 240                         ReflectionPermission p3 = (ReflectionPermission) p1.Intersect (p2);
 241                         AssertNull ("P1 N null == null", p3);
 242                 }
 243
 244                 [Test]
 245                 public void IntersectWithUnrestricted ()
 246                 {
 247                         ReflectionPermission p1 = new ReflectionPermission (PermissionState.Unrestricted);
 248                         ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
 249                         ReflectionPermission p3 = (ReflectionPermission) p1.Intersect (p2);
 250                         Assert ("Unrestricted N P2 == P2", !p3.IsUnrestricted ());
 251                         AssertEquals ("Unrestricted N EP2 == EP2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
 252                         p3 = (ReflectionPermission) p2.Intersect (p1);
 253                         Assert ("P2 N Unrestricted == P2", !p3.IsUnrestricted ());
 254                         AssertEquals ("P2 N Unrestricted == P2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
 255
 256                         p2 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
 257                         p3 = (ReflectionPermission) p1.Intersect (p2);
 258                         AssertNull ("Unrestricted N None == null", p3);
 259                 }
 260
 261                 [Test]
 262                 public void Intersect ()
 263                 {
 264                         // no intersection
 265                         ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
 266                         ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation);
 267                         ReflectionPermission p3 = (ReflectionPermission) p1.Intersect (p2);
 268                         AssertNull ("EP1 N EP2 == null", p3);
 269                         // intersection in MemberAccess
 270                         ReflectionPermission p4 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess | ReflectionPermissionFlag.ReflectionEmit);
 271                         p3 = (ReflectionPermission) p4.Intersect (p1);
 272                         AssertEquals ("Intersect-MemberAccess", ReflectionPermissionFlag.MemberAccess, p3.Flags);
 273                         // intersection in TypeInformation
 274                         ReflectionPermission p5 = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation | ReflectionPermissionFlag.ReflectionEmit);
 275                         p3 = (ReflectionPermission) p5.Intersect (p2);
 276                         AssertEquals ("Intersect-TypeInformation", ReflectionPermissionFlag.TypeInformation, p3.Flags);
 277                         // intersection in AllFlags
 278                         ReflectionPermission p6 = new ReflectionPermission (ReflectionPermissionFlag.AllFlags);
 279                         ReflectionPermission p7 = new ReflectionPermission (ReflectionPermissionFlag.AllFlags);
 280                         p3 = (ReflectionPermission) p6.Intersect (p7);
 281                         AssertEquals ("Intersect-AllFlags", ReflectionPermissionFlag.AllFlags, p3.Flags);
 282                         Assert ("Intersect-AllFlags-Unrestricted", p3.IsUnrestricted ());
 283                 }
 284
 285                 [Test]
 286                 [ExpectedException (typeof (ArgumentException))]
 287                 public void IntersectWithBadPermission ()
 288                 {
 289                         ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
 290                         EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted);
 291                         ReflectionPermission p3 = (ReflectionPermission) p1.Intersect (ep2);
 292                 }
 293
 294                 [Test]
 295                 public void IsSubsetOfNull ()
 296                 {
 297                         ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
 298                         Assert ("NoFlags.IsSubsetOf(null)", p.IsSubsetOf (null));
 299                         p = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
 300                         Assert ("MemberAccess.IsSubsetOf(null)", !p.IsSubsetOf (null));
 301                 }
 302
 303                 [Test]
 304                 public void IsSubsetOfUnrestricted ()
 305                 {
 306                         ReflectionPermission p1 = new ReflectionPermission (PermissionState.Unrestricted);
 307                         ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
 308                         ReflectionPermission p3 = new ReflectionPermission (PermissionState.Unrestricted);
 309                         Assert ("Unrestricted.IsSubsetOf()", !p1.IsSubsetOf (p2));
 310                         Assert ("IsSubsetOf(Unrestricted)", p2.IsSubsetOf (p1));
 311                         Assert ("Unrestricted.IsSubsetOf(Unrestricted)", p1.IsSubsetOf (p3));
 312                 }
 313
 314                 [Test]
 315                 public void IsSubsetOf ()
 316                 {
 317                         ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
 318                         ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation);
 319                         ReflectionPermission p3 = new ReflectionPermission (ReflectionPermissionFlag.ReflectionEmit);
 320                         Assert ("MemberAccess.IsSubsetOf(TypeInformation)", !p1.IsSubsetOf (p2));
 321                         Assert ("MemberAccess.IsSubsetOf(ReflectionEmit)", !p1.IsSubsetOf (p3));
 322                         Assert ("TypeInformation.IsSubsetOf(MemberAccess)", !p2.IsSubsetOf (p1));
 323                         Assert ("TypeInformation.IsSubsetOf(ReflectionEmit)", !p2.IsSubsetOf (p3));
 324                         Assert ("ReflectionEmit.IsSubsetOf(MemberAccess)", !p3.IsSubsetOf (p1));
 325                         Assert ("ReflectionEmit.IsSubsetOf(TypeInformation)", !p3.IsSubsetOf (p2));
 326                         ReflectionPermission p4 = new ReflectionPermission (ReflectionPermissionFlag.AllFlags);
 327                         Assert ("MemberAccess.IsSubsetOf(AllFlags)", p1.IsSubsetOf (p4));
 328                         Assert ("TypeInformation.IsSubsetOf(AllFlags)", p2.IsSubsetOf (p4));
 329                         Assert ("ReflectionEmit.IsSubsetOf(AllFlags)", p3.IsSubsetOf (p4));
 330                         Assert ("AllFlags.IsSubsetOf(MemberAccess)", !p4.IsSubsetOf (p1));
 331                         Assert ("AllFlags.IsSubsetOf(TypeInformation)", !p4.IsSubsetOf (p2));
 332                         Assert ("AllFlags.IsSubsetOf(ReflectionEmit)", !p4.IsSubsetOf (p3));
 333                 }
 334
 335                 [Test]
 336                 [ExpectedException (typeof (ArgumentException))]
 337                 public void IsSubsetOfBadPermission ()
 338                 {
 339                         ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
 340                         EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted);
 341                         Assert ("IsSubsetOf(EnvironmentPermission)", p1.IsSubsetOf (ep2));
 342                 }
 343         }
 344 }