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

   1 //
   2 // UIPermissionTest.cs - NUnit Test Cases for UIPermission
   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 UIPermissionTest {
  38
  39                 [Test]
  40                 public void PermissionStateNone ()
  41                 {
  42                         UIPermission uip = new UIPermission (PermissionState.None);
  43                         Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Clipboard");
  44                         Assert.AreEqual (UIPermissionWindow.NoWindows, uip.Window, "Window");
  45                         Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
  46
  47                         SecurityElement se = uip.ToXml ();
  48                         Assert.IsNull (se.Attribute ("Unrestricted"), "Xml-Unrestricted");
  49
  50                         UIPermission copy = (UIPermission)uip.Copy ();
  51                         Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Copy-Clipboard");
  52                         Assert.AreEqual (UIPermissionWindow.NoWindows, uip.Window, "Copy-Window");
  53                         Assert.IsFalse (uip.IsUnrestricted (), "Copy-IsUnrestricted");
  54                 }
  55
  56                 [Test]
  57                 public void PermissionStateUnrestricted ()
  58                 {
  59                         UIPermission uip = new UIPermission (PermissionState.Unrestricted);
  60                         Assert.AreEqual (UIPermissionClipboard.AllClipboard, uip.Clipboard, "Clipboard");
  61                         Assert.AreEqual (UIPermissionWindow.AllWindows, uip.Window, "Window");
  62                         Assert.IsTrue (uip.IsUnrestricted (), "IsUnrestricted");
  63
  64                         SecurityElement se = uip.ToXml ();
  65                         Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "Xml-Unrestricted");
  66
  67                         UIPermission copy = (UIPermission)uip.Copy ();
  68                         Assert.AreEqual (UIPermissionClipboard.AllClipboard, uip.Clipboard, "Copy-Clipboard");
  69                         Assert.AreEqual (UIPermissionWindow.AllWindows, uip.Window, "Copy-Window");
  70                         Assert.IsTrue (uip.IsUnrestricted (), "Copy-IsUnrestricted");
  71                 }
  72
  73                 [Test]
  74                 [ExpectedException (typeof (ArgumentException))]
  75                 public void PermissionStateInvalid ()
  76                 {
  77                         UIPermission uip = new UIPermission ((PermissionState)2);
  78                 }
  79
  80                 [Test]
  81                 public void UIPermission_Clipboard_All ()
  82                 {
  83                         UIPermission uip = new UIPermission (UIPermissionClipboard.AllClipboard);
  84                         Assert.AreEqual (UIPermissionClipboard.AllClipboard, uip.Clipboard, "Clipboard");
  85                         Assert.AreEqual (UIPermissionWindow.NoWindows, uip.Window, "Window");
  86                         Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
  87                 }
  88
  89                 [Test]
  90                 public void UIPermission_Clipboard_Own ()
  91                 {
  92                         UIPermission uip = new UIPermission (UIPermissionClipboard.OwnClipboard);
  93                         Assert.AreEqual (UIPermissionClipboard.OwnClipboard, uip.Clipboard, "Clipboard");
  94                         Assert.AreEqual (UIPermissionWindow.NoWindows, uip.Window, "Window");
  95                         Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
  96                 }
  97
  98                 [Test]
  99                 public void UIPermission_Clipboard_No ()
 100                 {
 101                         UIPermission uip = new UIPermission (UIPermissionClipboard.NoClipboard);
 102                         Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Clipboard");
 103                         Assert.AreEqual (UIPermissionWindow.NoWindows, uip.Window, "Window");
 104                         Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
 105                 }
 106
 107                 [Test]
 108                 [ExpectedException (typeof (ArgumentException))]
 109                 public void UIPermission_Clipboard_Bad ()
 110                 {
 111                         UIPermission uip = new UIPermission ((UIPermissionClipboard)128);
 112                 }
 113
 114                 [Test]
 115                 public void UIPermission_Windows_All ()
 116                 {
 117                         UIPermission uip = new UIPermission (UIPermissionWindow.AllWindows);
 118                         Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Clipboard");
 119                         Assert.AreEqual (UIPermissionWindow.AllWindows, uip.Window, "Window");
 120                         Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
 121                 }
 122
 123                 [Test]
 124                 public void UIPermission_Windows_SafeSubWindows ()
 125                 {
 126                         UIPermission uip = new UIPermission (UIPermissionWindow.SafeSubWindows);
 127                         Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Clipboard");
 128                         Assert.AreEqual (UIPermissionWindow.SafeSubWindows, uip.Window, "Window");
 129                         Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
 130                 }
 131
 132                 [Test]
 133                 public void UIPermission_Windows_SafeTopLevelWindows ()
 134                 {
 135                         UIPermission uip = new UIPermission (UIPermissionWindow.SafeTopLevelWindows);
 136                         Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Clipboard");
 137                         Assert.AreEqual (UIPermissionWindow.SafeTopLevelWindows, uip.Window, "Window");
 138                         Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
 139                 }
 140
 141                 [Test]
 142                 public void UIPermission_Windows_No ()
 143                 {
 144                         UIPermission uip = new UIPermission (UIPermissionWindow.NoWindows);
 145                         Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Clipboard");
 146                         Assert.AreEqual (UIPermissionWindow.NoWindows, uip.Window, "Window");
 147                         Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
 148                 }
 149
 150                 [Test]
 151                 [ExpectedException (typeof (ArgumentException))]
 152                 public void UIPermission_Windows_Bad ()
 153                 {
 154                         UIPermission uip = new UIPermission ((UIPermissionWindow)128);
 155                 }
 156
 157                 [Test]
 158                 [ExpectedException (typeof (ArgumentException))]
 159                 public void Clipboard_Bad ()
 160                 {
 161                         UIPermission uip = new UIPermission (PermissionState.None);
 162                         uip.Clipboard = (UIPermissionClipboard) 128;
 163                 }
 164
 165                 [Test]
 166                 [ExpectedException (typeof (ArgumentException))]
 167                 public void Window_Bad ()
 168                 {
 169                         UIPermission uip = new UIPermission (PermissionState.None);
 170                         uip.Window = (UIPermissionWindow) 128;
 171                 }
 172
 173                 [Test]
 174                 public void Unrestricted ()
 175                 {
 176                         UIPermission uip = new UIPermission (PermissionState.None);
 177                         SecurityElement se = uip.ToXml ();
 178                         // attribute value is not case-sensitive
 179                         se.AddAttribute ("Unrestricted", "TRUE");
 180                         uip.FromXml (se);
 181                         Assert.IsTrue (uip.IsUnrestricted (), "IsUnrestricted-TRUE");
 182
 183                         uip = new UIPermission (PermissionState.None);
 184                         // attribute name is not case-sensitive either!!!
 185                         se.AddAttribute ("UNRESTRICTED", "TRUE");
 186                         uip.FromXml (se);
 187                         Assert.IsTrue (uip.IsUnrestricted (), "IsUnrestricted-UPPER");
 188                 }
 189
 190                 private void Compare (UIPermission uip1, UIPermission uip2, string prefix)
 191                 {
 192                         Assert.AreEqual (uip1.Clipboard, uip2.Clipboard, prefix + ".Clipboard");
 193                         Assert.AreEqual (uip1.Window, uip2.Window, prefix + ".Window");
 194                         Assert.AreEqual (uip1.IsUnrestricted (), uip2.IsUnrestricted (), prefix + ".IsUnrestricted ()");
 195                 }
 196
 197                 [Test]
 198                 public void Intersect ()
 199                 {
 200                         UIPermission clip_all = new UIPermission (UIPermissionClipboard.AllClipboard);
 201                         UIPermission clip_own = new UIPermission (UIPermissionClipboard.OwnClipboard);
 202                         UIPermission intersect = (UIPermission)clip_all.Intersect (clip_own);
 203                         Compare (clip_own, intersect, "clip_all N clip_own");
 204                         Assert.IsFalse (Object.ReferenceEquals (clip_own, intersect), "!ReferenceEquals1");
 205                         Assert.IsTrue (intersect.IsSubsetOf (clip_all), "intersect.IsSubsetOf (clip_all)");
 206                         Assert.IsTrue (intersect.IsSubsetOf (clip_own), "intersect.IsSubsetOf (clip_own)");
 207
 208                         UIPermission win_all = new UIPermission (UIPermissionWindow.AllWindows);
 209                         UIPermission win_safe = new UIPermission (UIPermissionWindow.SafeSubWindows);
 210                         intersect = (UIPermission) win_all.Intersect (win_safe);
 211                         Compare (win_safe, intersect, "win_all N win_safe");
 212                         Assert.IsFalse (Object.ReferenceEquals (win_safe, intersect), "!ReferenceEquals2");
 213                         Assert.IsTrue (intersect.IsSubsetOf (win_all), "intersect.IsSubsetOf (win_all)");
 214                         Assert.IsTrue (intersect.IsSubsetOf (win_safe), "intersect.IsSubsetOf (win_safe)");
 215
 216                         intersect = (UIPermission)win_all.Intersect (clip_all);
 217                         Assert.IsNull (intersect, "win_all N clip_all");
 218
 219                         intersect = (UIPermission)win_all.Intersect (null);
 220                         Assert.IsNull (intersect, "win_all N null");
 221
 222                         intersect = (UIPermission)clip_all.Intersect (null);
 223                         Assert.IsNull (intersect, "clip_all N null");
 224
 225                         UIPermission empty = new UIPermission (PermissionState.None);
 226                         intersect = (UIPermission)clip_all.Intersect (empty);
 227                         Assert.IsNull (intersect, "clip_all N null");
 228
 229                         UIPermission unrestricted = new UIPermission (PermissionState.Unrestricted);
 230                         intersect = (UIPermission)clip_all.Intersect (unrestricted);
 231                         Compare (clip_all, intersect, "clip_all N unrestricted");
 232                         Assert.IsFalse (Object.ReferenceEquals (clip_all, intersect), "!ReferenceEquals4");
 233                         Assert.IsTrue (intersect.IsSubsetOf (clip_all), "intersect.IsSubsetOf (clip_all)");
 234                         Assert.IsTrue (intersect.IsSubsetOf (unrestricted), "intersect.IsSubsetOf (unrestricted)");
 235                 }
 236
 237                 [Test]
 238                 [ExpectedException (typeof (ArgumentException))]
 239                 public void Intersect_DifferentPermissions ()
 240                 {
 241                         UIPermission a = new UIPermission (PermissionState.None);
 242                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 243                         a.Intersect (b);
 244                 }
 245
 246                 [Test]
 247                 public void IsSubsetOf ()
 248                 {
 249                         UIPermission unrestricted = new UIPermission (PermissionState.Unrestricted);
 250                         UIPermission empty = new UIPermission (PermissionState.None);
 251
 252                         Assert.IsFalse (unrestricted.IsSubsetOf (empty), "unrestricted.IsSubsetOf (empty)");
 253                         Assert.IsTrue (empty.IsSubsetOf (unrestricted), "empty.IsSubsetOf (unrestricted)");
 254                         Assert.IsTrue (empty.IsSubsetOf (null), "empty.IsSubsetOf (null)");
 255                         Assert.IsFalse (unrestricted.IsSubsetOf (null), "unrestricted.IsSubsetOf (null)");
 256                 }
 257
 258                 [Test]
 259                 [ExpectedException (typeof (ArgumentException))]
 260                 public void IsSubsetOf_DifferentPermissions ()
 261                 {
 262                         UIPermission a = new UIPermission (PermissionState.None);
 263                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 264                         a.IsSubsetOf (b);
 265                 }
 266
 267                 [Test]
 268                 public void Union ()
 269                 {
 270                         UIPermission none = new UIPermission (PermissionState.None);
 271                         UIPermission union = (UIPermission)none.Union (null);
 272                         Compare (none, union, "none U null");
 273                         Assert.IsFalse (Object.ReferenceEquals (none, union), "!ReferenceEquals1");
 274                         Assert.IsTrue (none.IsSubsetOf (union), "none.IsSubsetOf (union)");
 275
 276                         union = (UIPermission)none.Union (new UIPermission (PermissionState.None));
 277                         Assert.IsNull (union, "none U none");
 278                         Assert.IsTrue (none.IsSubsetOf (null), "none.IsSubsetOf (null)");
 279
 280                         UIPermission unrestricted = new UIPermission (PermissionState.Unrestricted);
 281                         union = (UIPermission)none.Union (unrestricted);
 282                         Compare (unrestricted, union, "none U unrestricted");
 283                         Assert.IsTrue (union.IsUnrestricted (), "IsUnrestricted-1");
 284                         Assert.IsFalse (Object.ReferenceEquals (unrestricted, union), "!ReferenceEquals2");
 285                         Assert.IsTrue (none.IsSubsetOf (union), "none.IsSubsetOf (union)");
 286                         Assert.IsTrue (unrestricted.IsSubsetOf (union), "unrestricted.IsSubsetOf (union)");
 287
 288                         union = (UIPermission)unrestricted.Union (unrestricted);
 289                         Compare (unrestricted, union, "unrestricted U unrestricted");
 290                         Assert.IsTrue (union.IsUnrestricted (), "IsUnrestricted-2");
 291                         Assert.IsFalse (Object.ReferenceEquals (unrestricted, union), "!ReferenceEquals3");
 292                         Assert.IsTrue (unrestricted.IsSubsetOf (union), "unrestricted.IsSubsetOf (union)");
 293
 294                         UIPermission clip_all = new UIPermission (UIPermissionClipboard.AllClipboard);
 295                         UIPermission win_all = new UIPermission (UIPermissionWindow.AllWindows);
 296                         union = (UIPermission)clip_all.Union (win_all);
 297                         Compare (unrestricted, union, "clip_all U win_all");
 298                         Assert.IsTrue (union.IsUnrestricted (), "IsUnrestricted-3");
 299                         Assert.IsTrue (clip_all.IsSubsetOf (union), "clip_all.IsSubsetOf (union)");
 300                         Assert.IsTrue (win_all.IsSubsetOf (union), "win_all.IsSubsetOf (union)");
 301                 }
 302
 303                 [Test]
 304                 [ExpectedException (typeof (ArgumentException))]
 305                 public void Union_DifferentPermissions ()
 306                 {
 307                         UIPermission a = new UIPermission (PermissionState.None);
 308                         SecurityPermission b = new SecurityPermission (PermissionState.None);
 309                         a.Union (b);
 310                 }
 311
 312                 [Test]
 313                 [ExpectedException (typeof (ArgumentNullException))]
 314                 public void FromXml_Null ()
 315                 {
 316                         UIPermission uip = new UIPermission (PermissionState.None);
 317                         uip.FromXml (null);
 318                 }
 319
 320                 [Test]
 321                 [ExpectedException (typeof (ArgumentException))]
 322                 public void FromXml_WrongTag ()
 323                 {
 324                         UIPermission uip = new UIPermission (PermissionState.None);
 325                         SecurityElement se = uip.ToXml ();
 326                         se.Tag = "IMono"; // instead of IPermission
 327                         uip.FromXml (se);
 328                 }
 329
 330                 [Test]
 331                 [ExpectedException (typeof (ArgumentException))]
 332                 public void FromXml_WrongTagCase ()
 333                 {
 334                         UIPermission uip = new UIPermission (PermissionState.None);
 335                         SecurityElement se = uip.ToXml ();
 336                         se.Tag = "IPERMISSION"; // instead of IPermission
 337                         uip.FromXml (se);
 338                 }
 339
 340                 [Test]
 341                 public void FromXml_WrongClass ()
 342                 {
 343                         UIPermission uip = new UIPermission (PermissionState.None);
 344                         SecurityElement se = uip.ToXml ();
 345
 346                         SecurityElement w = new SecurityElement (se.Tag);
 347                         w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
 348                         w.AddAttribute ("version", se.Attribute ("version"));
 349                         uip.FromXml (w);
 350                         // doesn't care of the class name at that stage
 351                         // anyway the class has already be created so...
 352                 }
 353
 354                 [Test]
 355                 public void FromXml_NoClass ()
 356                 {
 357                         UIPermission uip = new UIPermission (PermissionState.None);
 358                         SecurityElement se = uip.ToXml ();
 359
 360                         SecurityElement w = new SecurityElement (se.Tag);
 361                         w.AddAttribute ("version", se.Attribute ("version"));
 362                         uip.FromXml (w);
 363                         // doesn't even care of the class attribute presence
 364                 }
 365
 366                 [Test]
 367                 [ExpectedException (typeof (ArgumentException))]
 368                 public void FromXml_WrongVersion ()
 369                 {
 370                         UIPermission uip = new UIPermission (PermissionState.None);
 371                         SecurityElement se = uip.ToXml ();
 372
 373                         SecurityElement w = new SecurityElement (se.Tag);
 374                         w.AddAttribute ("class", se.Attribute ("class"));
 375                         w.AddAttribute ("version", "2");
 376                         uip.FromXml (w);
 377                 }
 378
 379                 [Test]
 380                 public void FromXml_NoVersion ()
 381                 {
 382                         UIPermission uip = new UIPermission (PermissionState.None);
 383                         SecurityElement se = uip.ToXml ();
 384
 385                         SecurityElement w = new SecurityElement (se.Tag);
 386                         w.AddAttribute ("class", se.Attribute ("class"));
 387                         uip.FromXml (w);
 388                 }
 389         }
 390 }