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

   1 //
   2 // SecurityPermissionAttributeTest.cs -
   3 //      NUnit Test Cases for SecurityPermissionAttribute
   4 //
   5 // Author:
   6 //      Sebastien Pouliot  <sebastien@ximian.com>
   7 //
   8 // (C) 2003 Motus Technologies Inc. (http://www.motus.com)
   9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 using NUnit.Framework;
  32 using System;
  33 using System.Security;
  34 using System.Security.Permissions;
  35
  36 namespace MonoTests.System.Security.Permissions {
  37
  38         [TestFixture]
  39 #if MOBILE
  40         [Ignore]
  41 #endif
  42         public class SecurityPermissionAttributeTest {
  43
  44                 [Test]
  45                 public void Default ()
  46                 {
  47                         SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
  48                         Assert.IsFalse (a.Assertion, "Assertion");
  49                         Assert.IsFalse (a.BindingRedirects, "BindingRedirects");
  50                         Assert.IsFalse (a.ControlAppDomain, "ControlAppDomain");
  51                         Assert.IsFalse (a.ControlDomainPolicy, "ControlDomainPolicy");
  52                         Assert.IsFalse (a.ControlEvidence, "ControlEvidence");
  53                         Assert.IsFalse (a.ControlPolicy, "ControlPolicy");
  54                         Assert.IsFalse (a.ControlPrincipal, "ControlPrincipal");
  55                         Assert.IsFalse (a.ControlThread, "ControlThread");
  56                         Assert.IsFalse (a.Execution, "Execution");
  57                         Assert.IsFalse (a.Infrastructure, "Infrastructure");
  58                         Assert.IsFalse (a.RemotingConfiguration, "RemotingConfiguration");
  59                         Assert.IsFalse (a.SerializationFormatter, "SerializationFormatter");
  60                         Assert.IsFalse (a.SkipVerification, "SkipVerification");
  61                         Assert.IsFalse (a.UnmanagedCode, "UnmanagedCode");
  62
  63                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags");
  64                         Assert.AreEqual (a.ToString (), a.TypeId.ToString (), "TypeId");
  65                         Assert.IsFalse (a.Unrestricted, "Unrestricted");
  66
  67                         SecurityPermission perm = (SecurityPermission) a.CreatePermission ();
  68                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, perm.Flags, "CreatePermission.Flags");
  69                 }
  70
  71                 [Test]
  72                 public void Action ()
  73                 {
  74                         SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
  75                         Assert.AreEqual (SecurityAction.Assert, a.Action, "Action=Assert");
  76                         a.Action = SecurityAction.Demand;
  77                         Assert.AreEqual (SecurityAction.Demand, a.Action, "Action=Demand");
  78                         a.Action = SecurityAction.Deny;
  79                         Assert.AreEqual (SecurityAction.Deny, a.Action, "Action=Deny");
  80                         a.Action = SecurityAction.InheritanceDemand;
  81                         Assert.AreEqual (SecurityAction.InheritanceDemand, a.Action, "Action=InheritanceDemand");
  82                         a.Action = SecurityAction.LinkDemand;
  83                         Assert.AreEqual (SecurityAction.LinkDemand, a.Action, "Action=LinkDemand");
  84                         a.Action = SecurityAction.PermitOnly;
  85                         Assert.AreEqual (SecurityAction.PermitOnly, a.Action, "Action=PermitOnly");
  86                         a.Action = SecurityAction.RequestMinimum;
  87                         Assert.AreEqual (SecurityAction.RequestMinimum, a.Action, "Action=RequestMinimum");
  88                         a.Action = SecurityAction.RequestOptional;
  89                         Assert.AreEqual (SecurityAction.RequestOptional, a.Action, "Action=RequestOptional");
  90                         a.Action = SecurityAction.RequestRefuse;
  91                         Assert.AreEqual (SecurityAction.RequestRefuse, a.Action, "Action=RequestRefuse");
  92                 }
  93
  94                 [Test]
  95                 public void Action_Invalid ()
  96                 {
  97                         SecurityPermissionAttribute a = new SecurityPermissionAttribute ((SecurityAction)Int32.MinValue);
  98                         // no validation in attribute
  99                 }
 100
 101                 private SecurityPermissionAttribute Empty ()
 102                 {
 103                         SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
 104                         a.Assertion = false;
 105                         a.BindingRedirects = false;
 106                         a.ControlAppDomain = false;
 107                         a.ControlDomainPolicy = false;
 108                         a.ControlEvidence = false;
 109                         a.ControlPolicy = false;
 110                         a.ControlPrincipal = false;
 111                         a.ControlThread = false;
 112                         a.Execution = false;
 113                         a.Infrastructure = false;
 114                         a.RemotingConfiguration = false;
 115                         a.SerializationFormatter = false;
 116                         a.SkipVerification = false;
 117                         a.UnmanagedCode = false;
 118                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags");
 119                         return a;
 120                 }
 121
 122                 [Test]
 123                 public void Assertion ()
 124                 {
 125                         SecurityPermissionAttribute a = Empty ();
 126                         a.Assertion = true;
 127                         Assert.AreEqual (SecurityPermissionFlag.Assertion, a.Flags, "Flags=Assertion");
 128                         a.Assertion = false;
 129                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 130                 }
 131                 [Test]
 132                 public void BindingRedirects ()
 133                 {
 134                         SecurityPermissionAttribute a = Empty ();
 135                         a.BindingRedirects = true;
 136                         Assert.AreEqual (SecurityPermissionFlag.BindingRedirects, a.Flags, "Flags=BindingRedirects");
 137                         a.BindingRedirects = false;
 138                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 139                 }
 140                 [Test]
 141                 public void ControlAppDomain ()
 142                 {
 143                         SecurityPermissionAttribute a = Empty ();
 144                         a.ControlAppDomain = true;
 145                         Assert.AreEqual (SecurityPermissionFlag.ControlAppDomain, a.Flags, "Flags=ControlAppDomain");
 146                         a.ControlAppDomain = false;
 147                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 148                 }
 149
 150                 [Test]
 151                 public void ControlDomainPolicy ()
 152                 {
 153                         SecurityPermissionAttribute a = Empty ();
 154                         a.ControlDomainPolicy = true;
 155                         Assert.AreEqual (SecurityPermissionFlag.ControlDomainPolicy, a.Flags, "Flags=ControlDomainPolicy");
 156                         a.ControlDomainPolicy = false;
 157                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 158                 }
 159
 160                 [Test]
 161                 public void ControlEvidence ()
 162                 {
 163                         SecurityPermissionAttribute a = Empty ();
 164                         a.ControlEvidence = true;
 165                         Assert.AreEqual (SecurityPermissionFlag.ControlEvidence, a.Flags, "Flags=ControlEvidence");
 166                         a.ControlEvidence = false;
 167                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 168                 }
 169
 170                 [Test]
 171                 public void ControlPolicy ()
 172                 {
 173                         SecurityPermissionAttribute a = Empty ();
 174                         a.ControlPolicy = true;
 175                         Assert.AreEqual (SecurityPermissionFlag.ControlPolicy, a.Flags, "Flags=ControlPolicy");
 176                         a.ControlPolicy = false;
 177                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 178                 }
 179
 180                 [Test]
 181                 public void ControlPrincipal ()
 182                 {
 183                         SecurityPermissionAttribute a = Empty ();
 184                         a.ControlPrincipal = true;
 185                         Assert.AreEqual (SecurityPermissionFlag.ControlPrincipal, a.Flags, "Flags=ControlPrincipal");
 186                         a.ControlPrincipal = false;
 187                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 188                 }
 189
 190                 [Test]
 191                 public void ControlThread ()
 192                 {
 193                         SecurityPermissionAttribute a = Empty ();
 194                         a.ControlThread = true;
 195                         Assert.AreEqual (SecurityPermissionFlag.ControlThread, a.Flags, "Flags=ControlThread");
 196                         a.ControlThread = false;
 197                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 198                 }
 199
 200                 [Test]
 201                 public void Execution ()
 202                 {
 203                         SecurityPermissionAttribute a = Empty ();
 204                         a.Execution = true;
 205                         Assert.AreEqual (SecurityPermissionFlag.Execution, a.Flags, "Flags=Execution");
 206                         a.Execution = false;
 207                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 208                 }
 209
 210                 [Test]
 211                 public void Infrastructure ()
 212                 {
 213                         SecurityPermissionAttribute a = Empty ();
 214                         a.Infrastructure = true;
 215                         Assert.AreEqual (SecurityPermissionFlag.Infrastructure, a.Flags, "Flags=Infrastructure");
 216                         a.Infrastructure = false;
 217                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 218                 }
 219
 220                 [Test]
 221                 public void RemotingConfiguration ()
 222                 {
 223                         SecurityPermissionAttribute a = Empty ();
 224                         a.RemotingConfiguration = true;
 225                         Assert.AreEqual (SecurityPermissionFlag.RemotingConfiguration, a.Flags, "Flags=RemotingConfiguration");
 226                         a.RemotingConfiguration = false;
 227                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 228                 }
 229
 230                 [Test]
 231                 public void SerializationFormatter ()
 232                 {
 233                         SecurityPermissionAttribute a = Empty ();
 234                         a.SerializationFormatter = true;
 235                         Assert.AreEqual (SecurityPermissionFlag.SerializationFormatter, a.Flags, "Flags=SerializationFormatter");
 236                         a.SerializationFormatter = false;
 237                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 238                 }
 239
 240                 [Test]
 241                 public void SkipVerification ()
 242                 {
 243                         SecurityPermissionAttribute a = Empty ();
 244                         a.SkipVerification = true;
 245                         Assert.AreEqual (SecurityPermissionFlag.SkipVerification, a.Flags, "Flags=SkipVerification");
 246                         a.SkipVerification = false;
 247                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 248                 }
 249
 250                 [Test]
 251                 public void UnmanagedCode ()
 252                 {
 253                         SecurityPermissionAttribute a = Empty ();
 254                         a.UnmanagedCode = true;
 255                         Assert.AreEqual (SecurityPermissionFlag.UnmanagedCode, a.Flags, "Flags=UnmanagedCode");
 256                         a.UnmanagedCode = false;
 257                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags=NoFlags");
 258                 }
 259
 260                 [Test]
 261                 public void Unrestricted ()
 262                 {
 263                         SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
 264                         a.Unrestricted = true;
 265                         Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Unrestricted");
 266
 267                         SecurityPermission perm = (SecurityPermission) a.CreatePermission ();
 268                         Assert.AreEqual (SecurityPermissionFlag.AllFlags, perm.Flags, "CreatePermission.Flags");
 269                 }
 270
 271                 [Test]
 272                 public void Flags ()
 273                 {
 274                         SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
 275                         a.Flags = SecurityPermissionFlag.Assertion;
 276                         Assert.IsTrue (a.Assertion, "Assertion");
 277                         a.Flags |= SecurityPermissionFlag.BindingRedirects;
 278                         Assert.IsTrue (a.BindingRedirects, "BindingRedirects");
 279                         a.Flags |= SecurityPermissionFlag.ControlAppDomain;
 280                         Assert.IsTrue (a.ControlAppDomain, "ControlAppDomain");
 281                         a.Flags |= SecurityPermissionFlag.ControlDomainPolicy;
 282                         Assert.IsTrue (a.ControlDomainPolicy, "ControlDomainPolicy");
 283                         a.Flags |= SecurityPermissionFlag.ControlEvidence;
 284                         Assert.IsTrue (a.ControlEvidence, "ControlEvidence");
 285                         a.Flags |= SecurityPermissionFlag.ControlPolicy;
 286                         Assert.IsTrue (a.ControlPolicy, "ControlPolicy");
 287                         a.Flags |= SecurityPermissionFlag.ControlPrincipal;
 288                         Assert.IsTrue (a.ControlPrincipal, "ControlPrincipal");
 289                         a.Flags |= SecurityPermissionFlag.ControlThread;
 290                         Assert.IsTrue (a.ControlThread, "ControlThread");
 291                         a.Flags |= SecurityPermissionFlag.Execution;
 292                         Assert.IsTrue (a.Execution, "Execution");
 293                         a.Flags |= SecurityPermissionFlag.Infrastructure;
 294                         Assert.IsTrue (a.Infrastructure, "Infrastructure");
 295                         a.Flags |= SecurityPermissionFlag.RemotingConfiguration;
 296                         Assert.IsTrue (a.RemotingConfiguration, "RemotingConfiguration");
 297                         a.Flags |= SecurityPermissionFlag.SerializationFormatter;
 298                         Assert.IsTrue (a.SerializationFormatter, "SerializationFormatter");
 299                         a.Flags |= SecurityPermissionFlag.SkipVerification;
 300                         Assert.IsTrue (a.SkipVerification, "SkipVerification");
 301                         a.Flags |= SecurityPermissionFlag.UnmanagedCode;
 302
 303                         Assert.IsTrue (a.UnmanagedCode, "UnmanagedCode");
 304                         Assert.IsFalse (a.Unrestricted, "Unrestricted");
 305
 306                         a.Flags &= ~SecurityPermissionFlag.Assertion;
 307                         Assert.IsFalse (a.Assertion, "Assertion-False");
 308                         a.Flags &= ~SecurityPermissionFlag.BindingRedirects;
 309                         Assert.IsFalse (a.BindingRedirects, "BindingRedirects-False");
 310                         a.Flags &= ~SecurityPermissionFlag.ControlAppDomain;
 311                         Assert.IsFalse (a.ControlAppDomain, "ControlAppDomain-False");
 312                         a.Flags &= ~SecurityPermissionFlag.ControlDomainPolicy;
 313                         Assert.IsFalse (a.ControlDomainPolicy, "ControlDomainPolicy-False");
 314                         a.Flags &= ~SecurityPermissionFlag.ControlEvidence;
 315                         Assert.IsFalse (a.ControlEvidence, "ControlEvidence-False");
 316                         a.Flags &= ~SecurityPermissionFlag.ControlPolicy;
 317                         Assert.IsFalse (a.ControlPolicy, "ControlPolicy-False");
 318                         a.Flags &= ~SecurityPermissionFlag.ControlPrincipal;
 319                         Assert.IsFalse (a.ControlPrincipal, "ControlPrincipal-False");
 320                         a.Flags &= ~SecurityPermissionFlag.ControlThread;
 321                         Assert.IsFalse (a.ControlThread, "ControlThread-False");
 322                         a.Flags &= ~SecurityPermissionFlag.Execution;
 323                         Assert.IsFalse (a.Execution, "Execution-False");
 324                         a.Flags &= ~SecurityPermissionFlag.Infrastructure;
 325                         Assert.IsFalse (a.Infrastructure, "Infrastructure-False");
 326                         a.Flags &= ~SecurityPermissionFlag.RemotingConfiguration;
 327                         Assert.IsFalse (a.RemotingConfiguration, "RemotingConfiguration-False");
 328                         a.Flags &= ~SecurityPermissionFlag.SerializationFormatter;
 329                         Assert.IsFalse (a.SerializationFormatter, "SerializationFormatter-False");
 330                         a.Flags &= ~SecurityPermissionFlag.SkipVerification;
 331                         Assert.IsFalse (a.SkipVerification, "SkipVerification-False");
 332                         a.Flags &= ~SecurityPermissionFlag.UnmanagedCode;
 333                 }
 334
 335                 [Test]
 336                 public void Attributes ()
 337                 {
 338                         Type t = typeof (SecurityPermissionAttribute);
 339                         Assert.IsTrue (t.IsSerializable, "IsSerializable");
 340
 341                         object[] attrs = t.GetCustomAttributes (typeof (AttributeUsageAttribute), false);
 342                         Assert.AreEqual (1, attrs.Length, "AttributeUsage");
 343                         AttributeUsageAttribute aua = (AttributeUsageAttribute)attrs [0];
 344                         Assert.IsTrue (aua.AllowMultiple, "AllowMultiple");
 345                         Assert.IsFalse (aua.Inherited, "Inherited");
 346                         AttributeTargets at = (AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method);
 347                         Assert.AreEqual (at, aua.ValidOn, "ValidOn");
 348                 }
 349         }
 350 }