mcs/class/corlib/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 #if NET_2_0
  81                         a.Action = SecurityAction.DemandChoice;
  82                         Assert.AreEqual (SecurityAction.DemandChoice, a.Action, "Action=DemandChoice");
  83                         a.Action = SecurityAction.InheritanceDemandChoice;
  84                         Assert.AreEqual (SecurityAction.InheritanceDemandChoice, a.Action, "Action=InheritanceDemandChoice");
  85                         a.Action = SecurityAction.LinkDemandChoice;
  86                         Assert.AreEqual (SecurityAction.LinkDemandChoice, a.Action, "Action=LinkDemandChoice");
  87 #endif
  88                 }
  89
  90                 [Test]
  91                 public void Action_Invalid ()
  92                 {
  93                         DataProtectionPermissionAttribute a = new DataProtectionPermissionAttribute ((SecurityAction)Int32.MinValue);
  94                         // no validation in attribute
  95                 }
  96
  97                 private DataProtectionPermissionAttribute Empty ()
  98                 {
  99                         DataProtectionPermissionAttribute a = new DataProtectionPermissionAttribute (SecurityAction.Assert);
 100                         a.ProtectData = false;
 101                         a.UnprotectData = false;
 102                         a.ProtectMemory = false;
 103                         a.UnprotectMemory = false;
 104                         Assert.AreEqual (DataProtectionPermissionFlags.NoFlags, a.Flags, "Flags");
 105                         return a;
 106                 }
 107
 108                 [Test]
 109                 public void ProtectData ()
 110                 {
 111                         DataProtectionPermissionAttribute a = Empty ();
 112                         a.ProtectData = true;
 113                         Assert.AreEqual (DataProtectionPermissionFlags.ProtectData, a.Flags, "Flags=ProtectData");
 114                 }
 115
 116                 [Test]
 117                 public void UnprotectData ()
 118                 {
 119                         DataProtectionPermissionAttribute a = Empty ();
 120                         a.UnprotectData = true;
 121                         Assert.AreEqual (DataProtectionPermissionFlags.UnprotectData, a.Flags, "Flags=UnprotectData");
 122                 }
 123
 124                 [Test]
 125                 public void ProtectMemory ()
 126                 {
 127                         DataProtectionPermissionAttribute a = Empty ();
 128                         a.ProtectMemory = true;
 129                         Assert.AreEqual (DataProtectionPermissionFlags.ProtectMemory, a.Flags, "Flags=ProtectMemory");
 130                 }
 131
 132                 [Test]
 133                 public void UnprotectMemory ()
 134                 {
 135                         DataProtectionPermissionAttribute a = Empty ();
 136                         a.UnprotectMemory = true;
 137                         Assert.AreEqual (DataProtectionPermissionFlags.UnprotectMemory, a.Flags, "Flags=UnprotectMemory");
 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");
 166                 }
 167
 168                 [Test]
 169                 [ExpectedException (typeof (ArgumentException))]
 170                 public void Flags_Invalid ()
 171                 {
 172                         DataProtectionPermissionAttribute a = Empty ();
 173                         a.Flags = ((DataProtectionPermissionFlags)Int32.MinValue);
 174                 }
 175
 176                 [Test]
 177                 public void Attributes ()
 178                 {
 179                         Type t = typeof (DataProtectionPermissionAttribute);
 180                         Assert.IsTrue (t.IsSerializable, "IsSerializable");
 181
 182                         object [] attrs = t.GetCustomAttributes (typeof (AttributeUsageAttribute), false);
 183                         Assert.AreEqual (1, attrs.Length, "AttributeUsage");
 184                         AttributeUsageAttribute aua = (AttributeUsageAttribute)attrs [0];
 185                         Assert.IsTrue (aua.AllowMultiple, "AllowMultiple");
 186                         Assert.IsFalse (aua.Inherited, "Inherited");
 187                         AttributeTargets at = (AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method);
 188                         Assert.AreEqual (at, aua.ValidOn, "ValidOn");
 189                 }
 190         }
 191 }
 192
 193 #endif