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

   1 //
   2 // ZoneIdentityPermissionTest.cs - NUnit Test Cases for ZoneIdentityPermission
   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 namespace MonoTests.System.Security.Permissions {
  35
  36         [TestFixture]
  37         public class ZoneIdentityPermissionTest {
  38
  39                 [Test]
  40                 public void PermissionStateNone ()
  41                 {
  42                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.None);
  43                         Assert.AreEqual (SecurityZone.NoZone, zip.SecurityZone);
  44                 }
  45 #if NET_2_0
  46                 [Test]
  47                 [Category ("NotWorking")]
  48                 public void PermissionStateUnrestricted ()
  49                 {
  50                         // In 2.0 Unrestricted are permitted for identity permissions
  51                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.Unrestricted);
  52                         Assert.AreEqual (SecurityZone.NoZone, zip.SecurityZone);
  53                         SecurityElement se = zip.ToXml ();
  54                         Assert.AreEqual (5, se.Children.Count, "Count");
  55                         // and they aren't equals to None
  56                         Assert.IsFalse (zip.Equals (new ZoneIdentityPermission (PermissionState.None)));
  57                 }
  58 #else
  59                 [Test]
  60                 [ExpectedException (typeof (ArgumentException))]
  61                 public void PermissionStateUnrestricted ()
  62                 {
  63                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.Unrestricted);
  64                 }
  65 #endif
  66                 [Test]
  67                 [ExpectedException (typeof (ArgumentException))]
  68                 public void PermissionStateInvalid ()
  69                 {
  70                         ZoneIdentityPermission zip = new ZoneIdentityPermission ((PermissionState)2);
  71                 }
  72
  73                 private bool Same (ZoneIdentityPermission zip1, ZoneIdentityPermission zip2)
  74                 {
  75 #if NET_2_0
  76                         return zip1.Equals (zip2);
  77 #else
  78                         return (zip1.SecurityZone == zip2.SecurityZone);
  79 #endif
  80                 }
  81
  82                 private ZoneIdentityPermission BasicTestZone (SecurityZone zone, bool special)
  83                 {
  84                         ZoneIdentityPermission zip = new ZoneIdentityPermission (zone);
  85                         Assert.AreEqual (zone, zip.SecurityZone, "SecurityZone");
  86
  87                         ZoneIdentityPermission copy = (ZoneIdentityPermission) zip.Copy ();
  88                         Assert.IsTrue (Same (zip, copy), "Equals-Copy");
  89                         Assert.IsTrue (zip.IsSubsetOf (copy), "IsSubset-1");
  90                         Assert.IsTrue (copy.IsSubsetOf (zip), "IsSubset-2");
  91                         if (special) {
  92                                 Assert.IsFalse (zip.IsSubsetOf (null), "IsSubset-Null");
  93                         }
  94
  95                         IPermission intersect = zip.Intersect (copy);
  96                         if (special) {
  97                                 Assert.IsTrue (intersect.IsSubsetOf (zip), "IsSubset-3");
  98                                 Assert.IsFalse (Object.ReferenceEquals (zip, intersect), "!ReferenceEquals1");
  99                                 Assert.IsTrue (intersect.IsSubsetOf (copy), "IsSubset-4");
 100                                 Assert.IsFalse (Object.ReferenceEquals (copy, intersect), "!ReferenceEquals2");
 101                         }
 102
 103                         Assert.IsNull (zip.Intersect (null), "Intersect with null");
 104
 105                         intersect = zip.Intersect (new ZoneIdentityPermission (PermissionState.None));
 106                         Assert.IsNull (intersect, "Intersect with PS.None");
 107
 108                         // note: can't be tested with PermissionState.Unrestricted
 109
 110                         // XML roundtrip
 111                         SecurityElement se = zip.ToXml ();
 112                         copy.FromXml (se);
 113                         Assert.IsTrue (Same (zip, copy), "Equals-Xml");
 114
 115                         return zip;
 116                 }
 117
 118                 [Test]
 119                 public void SecurityZone_Internet ()
 120                 {
 121                         BasicTestZone (SecurityZone.Internet, true);
 122                 }
 123
 124                 [Test]
 125                 public void SecurityZone_Intranet ()
 126                 {
 127                         BasicTestZone (SecurityZone.Intranet, true);
 128                 }
 129
 130                 [Test]
 131                 public void SecurityZone_MyComputer ()
 132                 {
 133                         BasicTestZone (SecurityZone.MyComputer, true);
 134                 }
 135
 136                 [Test]
 137                 public void SecurityZone_NoZone ()
 138                 {
 139                         ZoneIdentityPermission zip = BasicTestZone (SecurityZone.NoZone, false);
 140                         Assert.IsNull (zip.ToXml ().Attribute ("Zone"), "Zone Attribute");
 141                         Assert.IsTrue (zip.IsSubsetOf (null), "IsSubset-Null");
 142                         IPermission intersect = zip.Intersect (zip);
 143                         Assert.IsNull (intersect, "Intersect with No Zone");
 144                         // NoZone is special as it is a subset of all zones
 145                         ZoneIdentityPermission ss = new ZoneIdentityPermission (SecurityZone.Internet);
 146                         Assert.IsTrue (zip.IsSubsetOf (ss), "IsSubset-Internet");
 147                         ss.SecurityZone = SecurityZone.Intranet;
 148                         Assert.IsTrue (zip.IsSubsetOf (ss), "IsSubset-Intranet");
 149                         ss.SecurityZone = SecurityZone.MyComputer;
 150                         Assert.IsTrue (zip.IsSubsetOf (ss), "IsSubset-MyComputer");
 151                         ss.SecurityZone = SecurityZone.NoZone;
 152                         Assert.IsTrue (zip.IsSubsetOf (ss), "IsSubset-NoZone");
 153                         ss.SecurityZone = SecurityZone.Trusted;
 154                         Assert.IsTrue (zip.IsSubsetOf (ss), "IsSubset-Trusted");
 155                         ss.SecurityZone = SecurityZone.Untrusted;
 156                         Assert.IsTrue (zip.IsSubsetOf (ss), "IsSubset-Untrusted");
 157                 }
 158
 159                 [Test]
 160                 public void SecurityZone_Trusted ()
 161                 {
 162                         BasicTestZone (SecurityZone.Trusted, true);
 163                 }
 164
 165                 [Test]
 166                 public void SecurityZone_Untrusted ()
 167                 {
 168                         BasicTestZone (SecurityZone.Untrusted, true);
 169                 }
 170
 171                 [Test]
 172                 [ExpectedException (typeof (ArgumentException))]
 173                 public void SecurityZone_Invalid ()
 174                 {
 175                         ZoneIdentityPermission zip = new ZoneIdentityPermission ((SecurityZone)128);
 176                 }
 177
 178                 [Test]
 179                 [ExpectedException (typeof (ArgumentException))]
 180                 public void Intersect_DifferentPermissions ()
 181                 {
 182                         ZoneIdentityPermission a = new ZoneIdentityPermission (SecurityZone.Trusted);
 183                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 184                         a.Intersect (b);
 185                 }
 186
 187                 [Test]
 188                 [ExpectedException (typeof (ArgumentException))]
 189                 public void IsSubsetOf_DifferentPermissions ()
 190                 {
 191                         ZoneIdentityPermission a = new ZoneIdentityPermission (SecurityZone.Trusted);
 192                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 193                         a.IsSubsetOf (b);
 194                 }
 195
 196                 [Test]
 197                 public void Union ()
 198                 {
 199                         ZoneIdentityPermission a = new ZoneIdentityPermission (SecurityZone.Trusted);
 200
 201                         ZoneIdentityPermission z = (ZoneIdentityPermission) a.Union (null);
 202                         Assert.IsTrue (Same (a, z), "Trusted+null");
 203                         Assert.IsFalse (Object.ReferenceEquals (a, z), "!ReferenceEquals1");
 204
 205                         z = (ZoneIdentityPermission) a.Union (new ZoneIdentityPermission (PermissionState.None));
 206                         Assert.IsTrue (Same (a, z), "Trusted+PS.None");
 207                         Assert.IsFalse (Object.ReferenceEquals (a, z), "!ReferenceEquals2");
 208
 209                         // note: can't be tested with PermissionState.Unrestricted
 210
 211                         ZoneIdentityPermission n = new ZoneIdentityPermission (SecurityZone.NoZone);
 212                         z = (ZoneIdentityPermission) a.Union (n);
 213                         Assert.IsTrue (Same (a, z), "Trusted+NoZone");
 214                         Assert.IsFalse (Object.ReferenceEquals (a, z), "!ReferenceEquals3");
 215
 216                         z = (ZoneIdentityPermission) n.Union (a);
 217                         Assert.IsTrue (Same (a, z), "NoZone+Trusted");
 218                         Assert.IsFalse (Object.ReferenceEquals (a, z), "!ReferenceEquals4");
 219                 }
 220 #if NET_2_0
 221                 [Category ("NotWorking")]
 222 #endif
 223                 [Test]
 224                 public void Union_DifferentIdentities ()
 225                 {
 226                         ZoneIdentityPermission a = new ZoneIdentityPermission (SecurityZone.Trusted);
 227                         ZoneIdentityPermission b = new ZoneIdentityPermission (SecurityZone.Untrusted);
 228                         IPermission result = a.Union (b);
 229 #if NET_2_0
 230                         Assert.IsNotNull (result, "Union");
 231                         // new XML format is used to contain more than one site
 232                         SecurityElement se = result.ToXml ();
 233                         Assert.AreEqual (2, se.Children.Count, "Childs");
 234                         Assert.AreEqual (a.SecurityZone.ToString (), (se.Children [0] as SecurityElement).Attribute ("Zone"), "Zone#1");
 235                         Assert.AreEqual (b.SecurityZone.ToString (), (se.Children [1] as SecurityElement).Attribute ("Zone"), "Zone#2");
 236                         // strangely it is still versioned as 'version="1"'.
 237                         Assert.AreEqual ("1", se.Attribute ("version"), "Version");
 238 #else
 239                         Assert.IsNull (result);
 240 #endif
 241                 }
 242
 243                 [Test]
 244                 [ExpectedException (typeof (ArgumentException))]
 245                 public void Union_DifferentPermissions ()
 246                 {
 247                         ZoneIdentityPermission a = new ZoneIdentityPermission (SecurityZone.Trusted);
 248                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 249                         a.Union (b);
 250                 }
 251
 252                 [Test]
 253                 [ExpectedException (typeof (ArgumentNullException))]
 254                 public void FromXml_Null ()
 255                 {
 256                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.None);
 257                         zip.FromXml (null);
 258                 }
 259
 260                 [Test]
 261                 [ExpectedException (typeof (ArgumentException))]
 262                 public void FromXml_WrongTag ()
 263                 {
 264                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.None);
 265                         SecurityElement se = zip.ToXml ();
 266                         se.Tag = "IMono"; // instead of IPermission
 267                         zip.FromXml (se);
 268                 }
 269
 270                 [Test]
 271                 [ExpectedException (typeof (ArgumentException))]
 272                 public void FromXml_WrongTagCase ()
 273                 {
 274                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.None);
 275                         SecurityElement se = zip.ToXml ();
 276                         se.Tag = "IPERMISSION"; // instead of IPermission
 277                         zip.FromXml (se);
 278                 }
 279
 280                 [Test]
 281                 public void FromXml_WrongClass ()
 282                 {
 283                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.None);
 284                         SecurityElement se = zip.ToXml ();
 285
 286                         SecurityElement w = new SecurityElement (se.Tag);
 287                         w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
 288                         w.AddAttribute ("version", se.Attribute ("version"));
 289                         zip.FromXml (w);
 290                         // doesn't care of the class name at that stage
 291                         // anyway the class has already be created so...
 292                 }
 293
 294                 [Test]
 295                 public void FromXml_NoClass ()
 296                 {
 297                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.None);
 298                         SecurityElement se = zip.ToXml ();
 299
 300                         SecurityElement w = new SecurityElement (se.Tag);
 301                         w.AddAttribute ("version", se.Attribute ("version"));
 302                         zip.FromXml (w);
 303                         // doesn't even care of the class attribute presence
 304                 }
 305
 306                 [Test]
 307                 [ExpectedException (typeof (ArgumentException))]
 308                 public void FromXml_WrongVersion ()
 309                 {
 310                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.None);
 311                         SecurityElement se = zip.ToXml ();
 312
 313                         SecurityElement w = new SecurityElement (se.Tag);
 314                         w.AddAttribute ("class", se.Attribute ("class"));
 315                         w.AddAttribute ("version", "2");
 316                         zip.FromXml (w);
 317                 }
 318
 319                 [Test]
 320                 public void FromXml_NoVersion ()
 321                 {
 322                         ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.None);
 323                         SecurityElement se = zip.ToXml ();
 324
 325                         SecurityElement w = new SecurityElement (se.Tag);
 326                         w.AddAttribute ("class", se.Attribute ("class"));
 327                         zip.FromXml (w);
 328                 }
 329         }
 330 }