mcs/class/System.Security/Test/System.Security.Permissions/DataProtectionPermissionAttributeTest.cs

   1 //
   2 // DataProtectionPermissionAttributeTest.cs -
   3 //      NUnit Test Cases for DataProtectionPermissionAttributeTest
   4 //
   5 // Author:
   6 //      Sebastien Pouliot  <sebastien@ximian.com>
   7 //
   8 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 #if NET_2_0
  31
  32 using NUnit.Framework;
  33 using System;
  34 using System.Security;
  35 using System.Security.Permissions;
  36
  37 namespace MonoTests.System.Security.Permissions {
  38
  39         [TestFixture]
  40         public class DataProtectionPermissionAttributeTest {
  41
  42                 [Test]
  43                 public void Default ()
  44                 {
  45                         DataProtectionPermissionAttribute a = new DataProtectionPermissionAttribute (SecurityAction.Assert);
  46                         Assert.IsFalse (a.ProtectData, "ProtectData");
  47                         Assert.IsFalse (a.UnprotectData, "UnprotectData");
  48                         Assert.IsFalse (a.ProtectMemory, "ProtectMemory");
  49                         Assert.IsFalse (a.UnprotectMemory, "UnprotectMemory");
  50                         Assert.IsFalse (a.Unrestricted, "Unrestricted");
  51
  52                         Assert.AreEqual (DataProtectionPermissionFlags.NoFlags, a.Flags, "Flags");
  53                         Assert.AreEqual (a.ToString (), a.TypeId.ToString (), "TypeId");
  54
  55                         DataProtectionPermission perm = (DataProtectionPermission)a.CreatePermission ();
  56                         Assert.AreEqual (DataProtectionPermissionFlags.NoFlags, perm.Flags, "CreatePermission.Flags");
  57                 }
  58
  59                 [Test]
  60                 public void Action ()
  61                 {
  62                         DataProtectionPermissionAttribute a = new DataProtectionPermissionAttribute (SecurityAction.Assert);
  63                         Assert.AreEqual (SecurityAction.Assert, a.Action, "Action=Assert");
  64                         a.Action = SecurityAction.Demand;
  65                         Assert.AreEqual (SecurityAction.Demand, a.Action, "Action=Demand");
  66                         a.Action = SecurityAction.Deny;
  67                         Assert.AreEqual (SecurityAction.Deny, a.Action, "Action=Deny");
  68                         a.Action = SecurityAction.InheritanceDemand;
  69                         Assert.AreEqual (SecurityAction.InheritanceDemand, a.Action, "Action=InheritanceDemand");
  70                         a.Action = SecurityAction.LinkDemand;
  71                         Assert.AreEqual (SecurityAction.LinkDemand, a.Action, "Action=LinkDemand");
  72                         a.Action = SecurityAction.PermitOnly;
  73                         Assert.AreEqual (SecurityAction.PermitOnly, a.Action, "Action=PermitOnly");
  74                         a.Action = SecurityAction.RequestMinimum;
  75                         Assert.AreEqual (SecurityAction.RequestMinimum, a.Action, "Action=RequestMinimum");
  76                         a.Action = SecurityAction.RequestOptional;
  77                         Assert.AreEqual (SecurityAction.RequestOptional, a.Action, "Action=RequestOptional");
  78                         a.Action = SecurityAction.RequestRefuse;
  79                         Assert.AreEqual (SecurityAction.RequestRefuse, a.Action, "Action=RequestRefuse");
  80                 }
  81
  82                 [Test]
  83                 public void Action_Invalid ()
  84                 {
  85                         DataProtectionPermissionAttribute a = new DataProtectionPermissionAttribute ((SecurityAction)Int32.MinValue);
  86                         // no validation in attribute
  87                 }
  88
  89                 private DataProtectionPermissionAttribute Empty ()
  90                 {
  91                         DataProtectionPermissionAttribute a = new DataProtectionPermissionAttribute (SecurityAction.Assert);
  92                         a.ProtectData = false;
  93                         a.UnprotectData = false;
  94                         a.ProtectMemory = false;
  95                         a.UnprotectMemory = false;
  96                         Assert.AreEqual (DataProtectionPermissionFlags.NoFlags, a.Flags, "Flags");
  97                         return a;
  98                 }
  99
 100                 [Test]
 101                 public void ProtectData ()
 102                 {
 103                         DataProtectionPermissionAttribute a = Empty ();
 104                         a.ProtectData = true;
 105                         Assert.AreEqual (DataProtectionPermissionFlags.ProtectData, a.Flags, "Flags=ProtectData");
 106                         a.ProtectData = false;
 107                         Assert.AreEqual (DataProtectionPermissionFlags.NoFlags, a.Flags, "Flags=NoFlags");
 108                 }
 109
 110                 [Test]
 111                 public void UnprotectData ()
 112                 {
 113                         DataProtectionPermissionAttribute a = Empty ();
 114                         a.UnprotectData = true;
 115                         Assert.AreEqual (DataProtectionPermissionFlags.UnprotectData, a.Flags, "Flags=UnprotectData");
 116                         a.UnprotectData = false;
 117                         Assert.AreEqual (DataProtectionPermissionFlags.NoFlags, a.Flags, "Flags=NoFlags");
 118                 }
 119
 120                 [Test]
 121                 public void ProtectMemory ()
 122                 {
 123                         DataProtectionPermissionAttribute a = Empty ();
 124                         a.ProtectMemory = true;
 125                         Assert.AreEqual (DataProtectionPermissionFlags.ProtectMemory, a.Flags, "Flags=ProtectMemory");
 126                         a.ProtectMemory = false;
 127                         Assert.AreEqual (DataProtectionPermissionFlags.NoFlags, a.Flags, "Flags=NoFlags");
 128                 }
 129
 130                 [Test]
 131                 public void UnprotectMemory ()
 132                 {
 133                         DataProtectionPermissionAttribute a = Empty ();
 134                         a.UnprotectMemory = true;
 135                         Assert.AreEqual (DataProtectionPermissionFlags.UnprotectMemory, a.Flags, "Flags=UnprotectMemory");
 136                         a.UnprotectMemory = false;
 137                         Assert.AreEqual (DataProtectionPermissionFlags.NoFlags, a.Flags, "Flags=NoFlags");
 138                 }
 139
 140                 [Test]
 141                 public void Unrestricted ()
 142                 {
 143                         DataProtectionPermissionAttribute a = Empty ();
 144                         a.Unrestricted = true;
 145                         Assert.AreEqual (DataProtectionPermissionFlags.NoFlags, a.Flags, "Unrestricted");
 146
 147                         DataProtectionPermission perm = (DataProtectionPermission)a.CreatePermission ();
 148                         Assert.AreEqual (DataProtectionPermissionFlags.AllFlags, perm.Flags, "CreatePermission.Flags");
 149                 }
 150
 151                 [Test]
 152                 public void Flags ()
 153                 {
 154                         DataProtectionPermissionAttribute a = Empty ();
 155                         a.Flags = DataProtectionPermissionFlags.ProtectData;
 156                         Assert.IsTrue (a.ProtectData, "ProtectData");
 157                         a.Flags |= DataProtectionPermissionFlags.ProtectMemory;
 158                         Assert.IsTrue (a.ProtectMemory, "ProtectMemory");
 159                         a.Flags |= DataProtectionPermissionFlags.UnprotectData;
 160                         Assert.IsTrue (a.UnprotectData, "UnprotectData");
 161                         a.Flags |= DataProtectionPermissionFlags.UnprotectMemory;
 162                         Assert.IsTrue (a.UnprotectMemory, "UnprotectMemory");
 163
 164                         Assert.IsFalse (a.Unrestricted, "Unrestricted");
 165                         Assert.AreEqual (DataProtectionPermissionFlags.AllFlags, a.Flags, "Flags=AllFlags");
 166
 167                         a.Flags &= ~DataProtectionPermissionFlags.ProtectData;
 168                         Assert.IsFalse (a.ProtectData, "ProtectData");
 169                         a.Flags &= ~DataProtectionPermissionFlags.ProtectMemory;
 170                         Assert.IsFalse (a.ProtectMemory, "ProtectMemory");
 171                         a.Flags &= ~DataProtectionPermissionFlags.UnprotectData;
 172                         Assert.IsFalse (a.UnprotectData, "UnprotectData");
 173                         a.Flags &= ~DataProtectionPermissionFlags.UnprotectMemory;
 174                 }
 175
 176                 [Test]
 177                 [ExpectedException (typeof (ArgumentException))]
 178                 public void Flags_Invalid ()
 179                 {
 180                         DataProtectionPermissionAttribute a = Empty ();
 181                         a.Flags = ((DataProtectionPermissionFlags)Int32.MinValue);
 182                 }
 183
 184                 [Test]
 185                 public void Attributes ()
 186                 {
 187                         Type t = typeof (DataProtectionPermissionAttribute);
 188                         Assert.IsTrue (t.IsSerializable, "IsSerializable");
 189
 190                         object [] attrs = t.GetCustomAttributes (typeof (AttributeUsageAttribute), false);
 191                         Assert.AreEqual (1, attrs.Length, "AttributeUsage");
 192                         AttributeUsageAttribute aua = (AttributeUsageAttribute)attrs [0];
 193                         Assert.IsTrue (aua.AllowMultiple, "AllowMultiple");
 194                         Assert.IsFalse (aua.Inherited, "Inherited");
 195                         AttributeTargets at = (AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method);
 196                         Assert.AreEqual (at, aua.ValidOn, "ValidOn");
 197                 }
 198         }
 199 }
 200
 201 #endif