Author: spouliot
Date: 2005-04-28 09:27:13 -0400 (Thu, 28 Apr 2005)
New Revision: 43720
Added:
trunk/mcs/class/corlib/Test/System.Security/SecurityContextCas.cs
trunk/mcs/class/corlib/Test/System.Security/SecurityContextTest.cs
trunk/mcs/class/corlib/Test/System.Security/SecurityCriticalAttributeTest.cs
trunk/mcs/class/corlib/Test/System.Security/SecurityTransparentAttributeTest.cs
Modified:
trunk/mcs/class/corlib/Test/System.Security/ChangeLog
Log:
2005-03-28 Sebastien Pouliot <[EMAIL PROTECTED]>
* SecurityContextCas.cs: New. CAS unit tests for SecurityContext.
* SecurityContextTest.cs: New. Unit tests for SecurityContext.
* SecurityCriticalAttributeTest.cs: New. Unit tests for
SecurityCriticalAttribute.
* SecurityTransparentAttributeTest.cs: New. Unit tests for
SecurityTransparentAttribute.
Modified: trunk/mcs/class/corlib/Test/System.Security/ChangeLog
===================================================================
--- trunk/mcs/class/corlib/Test/System.Security/ChangeLog 2005-04-28
13:24:04 UTC (rev 43719)
+++ trunk/mcs/class/corlib/Test/System.Security/ChangeLog 2005-04-28
13:27:13 UTC (rev 43720)
@@ -1,3 +1,12 @@
+2005-03-28 Sebastien Pouliot <[EMAIL PROTECTED]>
+
+ * SecurityContextCas.cs: New. CAS unit tests for SecurityContext.
+ * SecurityContextTest.cs: New. Unit tests for SecurityContext.
+ * SecurityCriticalAttributeTest.cs: New. Unit tests for
+ SecurityCriticalAttribute.
+ * SecurityTransparentAttributeTest.cs: New. Unit tests for
+ SecurityTransparentAttribute.
+
2005-04-25 Sebastien Pouliot <[EMAIL PROTECTED]>
* HostSecurityManagerTest.cs: Renamed HostSecurityManagerFlags to
Added: trunk/mcs/class/corlib/Test/System.Security/SecurityContextCas.cs
===================================================================
--- trunk/mcs/class/corlib/Test/System.Security/SecurityContextCas.cs
2005-04-28 13:24:04 UTC (rev 43719)
+++ trunk/mcs/class/corlib/Test/System.Security/SecurityContextCas.cs
2005-04-28 13:27:13 UTC (rev 43720)
@@ -0,0 +1,172 @@
+//
+// SecurityContextCas.cs - CAS Unit Tests for SecurityContext
+//
+// Author:
+// Sebastien Pouliot ([EMAIL PROTECTED])
+//
+// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+#if NET_2_0
+
+using System;
+using System.Security;
+using System.Security.Permissions;
+using System.Threading;
+
+using NUnit.Framework;
+
+namespace MonoCasTests.System.Threading {
+
+ [TestFixture]
+ [Category ("CAS")]
+ public class SecurityContextCas {
+
+ static bool success;
+
+ static void Callback (object o)
+ {
+ new SecurityPermission
(SecurityPermissionFlag.UnmanagedCode).Demand ();
+ success = (bool)o;
+ }
+
+ [SetUp]
+ public void SetUp ()
+ {
+ if (!SecurityManager.SecurityEnabled)
+ Assert.Ignore ("SecurityManager isn't enabled");
+
+ success = false;
+ }
+
+ [TearDown]
+ public void TearDown ()
+ {
+ if (SecurityContext.IsFlowSuppressed () ||
SecurityContext.IsWindowsIdentityFlowSuppressed ())
+ SecurityContext.RestoreFlow ();
+ }
+
+ private void Thread_Run_Empty ()
+ {
+ Assert.IsFalse (success, "pre-check");
+ SecurityContext.Run (SecurityContext.Capture (), new
ContextCallback (Callback), true);
+ Assert.IsTrue (success, "post-check");
+ }
+
+ [Test]
+ public void Run_Empty ()
+ {
+ Thread t = new Thread (new ThreadStart
(Thread_Run_Empty));
+ t.Start ();
+ t.Join ();
+ }
+
+ [SecurityPermission (SecurityAction.Deny, UnmanagedCode = true)]
+ private SecurityContext GetSecurityContextUnmanaged ()
+ {
+ return SecurityContext.Capture ();
+ // the Deny disappears with this stack frame but we got
a capture of it
+ }
+
+ private void Thread_Run_UnmanagedCode ()
+ {
+ bool result = false;
+ Assert.IsFalse (success, "pre-check");
+ try {
+ SecurityContext sc =
GetSecurityContextUnmanaged ();
+ // run with the captured security stack (i.e.
deny unmanaged)
+ SecurityContext.Run (sc, new ContextCallback
(Callback), true);
+ }
+ catch (SecurityException) {
+ result = true;
+ }
+ finally {
+ Assert.IsFalse (success, "post-check");
+ Assert.IsTrue (result, "Result");
+ }
+ }
+
+ [Test]
+ public void Run_UnmanagedCode ()
+ {
+ Thread t = new Thread (new ThreadStart
(Thread_Run_UnmanagedCode));
+ t.Start ();
+ t.Join ();
+ }
+
+ private void
Thread_Run_UnmanagedCode_SuppressFlow_BeforeCapture ()
+ {
+ bool result = false;
+ Assert.IsFalse (success, "pre-check");
+ AsyncFlowControl afc = SecurityContext.SuppressFlow ();
+ try {
+ SecurityContext sc =
GetSecurityContextUnmanaged ();
+ SecurityContext.Run (sc, new ContextCallback
(Callback), true);
+ }
+ catch (InvalidOperationException) {
+ result = true;
+ }
+ finally {
+ Assert.IsFalse (success, "post-check");
+ afc.Undo ();
+ Assert.IsTrue (result, "Result");
+ }
+ }
+
+ [Test]
+ public void Run_UnmanagedCode_SuppressFlow_BeforeCapture ()
+ {
+ Thread t = new Thread (new ThreadStart
(Thread_Run_UnmanagedCode_SuppressFlow_BeforeCapture));
+ t.Start ();
+ t.Join ();
+ }
+
+ private void Thread_Run_UnmanagedCode_SuppressFlow_AfterCapture
()
+ {
+ bool result = false;
+ Assert.IsFalse (success, "pre-check");
+ SecurityContext sc = GetSecurityContextUnmanaged ();
+ AsyncFlowControl afc = SecurityContext.SuppressFlow ();
+ try {
+ SecurityContext.Run (sc, new ContextCallback
(Callback), true);
+ }
+ catch (SecurityException) {
+ result = true;
+ }
+ finally {
+ Assert.IsFalse (success, "post-check");
+ afc.Undo ();
+ Assert.IsTrue (result, "Result");
+ }
+ }
+
+ [Test]
+ public void Run_UnmanagedCode_SuppressFlow_AfterCapture ()
+ {
+ Thread t = new Thread (new ThreadStart
(Thread_Run_UnmanagedCode_SuppressFlow_AfterCapture));
+ t.Start ();
+ t.Join ();
+ }
+ }
+}
+
+#endif
Added: trunk/mcs/class/corlib/Test/System.Security/SecurityContextTest.cs
===================================================================
--- trunk/mcs/class/corlib/Test/System.Security/SecurityContextTest.cs
2005-04-28 13:24:04 UTC (rev 43719)
+++ trunk/mcs/class/corlib/Test/System.Security/SecurityContextTest.cs
2005-04-28 13:27:13 UTC (rev 43720)
@@ -0,0 +1,290 @@
+//
+// SecurityContextTest.cs - NUnit tests for SecurityContext
+//
+// Author:
+// Sebastien Pouliot <[EMAIL PROTECTED]>
+//
+// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+#if NET_2_0
+
+using System;
+using System.Security;
+using System.Security.Principal;
+using System.Threading;
+
+using NUnit.Framework;
+
+namespace MonoTests.System.Security {
+
+ [TestFixture]
+ public class SecurityContextTest {
+
+ static bool success;
+
+ static void Callback (object o)
+ {
+ success = (bool) o;
+ }
+
+ [SetUp]
+ public void SetUp ()
+ {
+ success = false;
+ }
+
+ [TearDown]
+ public void TearDown ()
+ {
+ if (SecurityContext.IsFlowSuppressed () ||
SecurityContext.IsWindowsIdentityFlowSuppressed ())
+ SecurityContext.RestoreFlow ();
+ }
+
+ [Test]
+ public void Capture ()
+ {
+ SecurityContext sc = SecurityContext.Capture ();
+ Assert.IsNotNull (sc, "Capture");
+
+ AsyncFlowControl afc = SecurityContext.SuppressFlow ();
+ Assert.IsTrue (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-1");
+ try {
+ sc = SecurityContext.Capture ();
+ Assert.IsNull (sc, "Capture with SuppressFlow");
+ }
+ finally {
+ afc.Undo ();
+ }
+
+ afc = SecurityContext.SuppressFlowWindowsIdentity ();
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-1");
+ try {
+ sc = SecurityContext.Capture ();
+ Assert.IsNotNull (sc, "Capture with
SuppressFlowWindowsIdentity");
+ }
+ finally {
+ afc.Undo ();
+ }
+ }
+
+ [Test]
+ public void Copy ()
+ {
+ SecurityContext sc = SecurityContext.Capture ();
+ Assert.IsNotNull (sc, "Capture");
+
+ SecurityContext copy = sc.CreateCopy ();
+ Assert.IsNotNull (copy, "Copy of Capture");
+
+ Assert.IsFalse (sc.Equals (copy));
+ Assert.IsFalse (copy.Equals (sc));
+ Assert.IsFalse (Object.ReferenceEquals (sc, copy));
+
+ SecurityContext copy2nd = copy.CreateCopy ();
+ Assert.IsNotNull (copy2nd, "2nd level copy of Capture");
+ }
+
+ [Test]
+ public void IsFlowSuppressed ()
+ {
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-1");
+
+ AsyncFlowControl afc =
SecurityContext.SuppressFlowWindowsIdentity ();
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-2");
+ afc.Undo ();
+
+ afc = SecurityContext.SuppressFlow ();
+ Assert.IsTrue (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-3");
+ afc.Undo ();
+
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-4");
+ }
+
+ [Test]
+ public void IsWindowsIdentityFlowSuppressed ()
+ {
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-1");
+
+ AsyncFlowControl afc = SecurityContext.SuppressFlow ();
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-2");
+ afc.Undo ();
+
+ afc = SecurityContext.SuppressFlowWindowsIdentity ();
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-3");
+ afc.Undo ();
+
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-4");
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void RestoreFlow_None ()
+ {
+ SecurityContext.RestoreFlow ();
+ }
+
+ [Test]
+ public void RestoreFlow_SuppressFlow ()
+ {
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-1");
+ SecurityContext.SuppressFlow ();
+ Assert.IsTrue (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-2");
+ SecurityContext.RestoreFlow ();
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-3");
+ }
+
+ [Test]
+ public void RestoreFlow_SuppressFlowWindowsIdentity ()
+ {
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-1");
+ SecurityContext.SuppressFlowWindowsIdentity ();
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-2");
+ SecurityContext.RestoreFlow ();
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-3");
+ }
+
+ [Test]
+ public void Run ()
+ {
+ Assert.IsFalse (success, "pre-check");
+ SecurityContext.Run (SecurityContext.Capture (), new
ContextCallback (Callback), true);
+ Assert.IsTrue (success, "post-check");
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void Run_SuppressFlow ()
+ {
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed ());
+ AsyncFlowControl afc = SecurityContext.SuppressFlow ();
+ Assert.IsTrue (SecurityContext.IsFlowSuppressed ());
+ try {
+ SecurityContext.Run (SecurityContext.Capture
(), new ContextCallback (Callback), "Hello world.");
+ }
+ finally {
+ afc.Undo ();
+ }
+ }
+
+ [Test]
+ public void SuppressFlow ()
+ {
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-1");
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-1");
+
+ AsyncFlowControl afc = SecurityContext.SuppressFlow ();
+ Assert.IsTrue (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-3");
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-3");
+ afc.Undo ();
+
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-4");
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-4");
+ }
+
+ [Test]
+ public void SuppressFlowWindowsIdentity ()
+ {
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-1");
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-1");
+
+ AsyncFlowControl afc =
SecurityContext.SuppressFlowWindowsIdentity ();
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-2");
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-2");
+ afc.Undo ();
+
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-4");
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-4");
+ }
+
+ [Test]
+ public void SuppressFlow_Both ()
+ {
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-1");
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-1");
+
+ AsyncFlowControl afc =
SecurityContext.SuppressFlowWindowsIdentity ();
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-2");
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-2");
+
+ AsyncFlowControl afc2 = SecurityContext.SuppressFlow ();
+ Assert.IsTrue (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-2");
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-2");
+ afc2.Undo ();
+
+ // note: afc2 Undo return to the original (not the
previous) state
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-2");
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-2");
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void SuppressFlow_Both_Undo ()
+ {
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-1");
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-1");
+
+ AsyncFlowControl afc =
SecurityContext.SuppressFlowWindowsIdentity ();
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-2");
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-2");
+
+ AsyncFlowControl afc2 = SecurityContext.SuppressFlow ();
+ Assert.IsTrue (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-2");
+ Assert.IsTrue
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-2");
+ afc2.Undo ();
+
+ // note: afc2 Undo return to the original (not the
previous) state
+ Assert.IsFalse (SecurityContext.IsFlowSuppressed (),
"IsFlowSuppressed-2");
+ Assert.IsFalse
(SecurityContext.IsWindowsIdentityFlowSuppressed (),
"IsWindowsIdentityFlowSuppressed-2");
+
+ // we can't use the first AsyncFlowControl
+ afc.Undo ();
+ }
+
+ // effects of ExecutionContext on SecurityContext
+
+ [Test]
+ public void ExecutionContext_SuppressFlow ()
+ {
+ Assert.IsFalse (ExecutionContext.IsFlowSuppressed (),
"IsFlowSuppressed-1");
+ AsyncFlowControl afc = ExecutionContext.SuppressFlow ();
+ try {
+ Assert.IsTrue
(ExecutionContext.IsFlowSuppressed (), "IsFlowSuppressed-2");
+ Assert.IsFalse
(SecurityContext.IsFlowSuppressed (), "IsFlowSuppressed-3");
+ Assert.IsNotNull (SecurityContext.Capture (),
"Capture");
+ }
+ finally {
+ afc.Undo ();
+ }
+ }
+
+ [Test]
+ public void WindowsIdentity_ ()
+ {
+ Thread.CurrentPrincipal = new WindowsPrincipal
(WindowsIdentity.GetCurrent ());
+ SecurityContext sc = SecurityContext.Capture ();
+ Assert.IsNotNull (sc, "Capture");
+ }
+ }
+}
+
+#endif
\ No newline at end of file
Added:
trunk/mcs/class/corlib/Test/System.Security/SecurityCriticalAttributeTest.cs
===================================================================
---
trunk/mcs/class/corlib/Test/System.Security/SecurityCriticalAttributeTest.cs
2005-04-28 13:24:04 UTC (rev 43719)
+++
trunk/mcs/class/corlib/Test/System.Security/SecurityCriticalAttributeTest.cs
2005-04-28 13:27:13 UTC (rev 43720)
@@ -0,0 +1,87 @@
+//
+// SecurityCriticalAttributeTest.cs -
+// NUnit Test Cases for SecurityCriticalAttribute
+//
+// Author:
+// Sebastien Pouliot <[EMAIL PROTECTED]>
+//
+// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+#if NET_2_0
+
+using NUnit.Framework;
+using System;
+using System.Security;
+
+namespace MonoTests.System.Security {
+
+ [TestFixture]
+ public class SecurityCriticalAttributeTest {
+
+ [Test]
+ public void Constructor_Default ()
+ {
+ SecurityCriticalAttribute sca = new
SecurityCriticalAttribute ();
+ Assert.AreEqual (SecurityCriticalScope.Explicit,
sca.Scope);
+ }
+
+ [Test]
+ public void Constructor_Scope_Everything ()
+ {
+ SecurityCriticalAttribute sca = new
SecurityCriticalAttribute (SecurityCriticalScope.Everything);
+ Assert.AreEqual (SecurityCriticalScope.Everything,
sca.Scope);
+ }
+
+ [Test]
+ public void Constructor_Scope_Explicit ()
+ {
+ SecurityCriticalAttribute sca = new
SecurityCriticalAttribute (SecurityCriticalScope.Explicit);
+ Assert.AreEqual (SecurityCriticalScope.Explicit,
sca.Scope);
+ }
+
+ [Test]
+ public void Constructor_Scope_Bad ()
+ {
+ SecurityCriticalScope scs =
(SecurityCriticalScope)UInt32.MinValue;
+ SecurityCriticalAttribute sca = new
SecurityCriticalAttribute (scs);
+ Assert.AreEqual (SecurityCriticalScope.Explicit,
sca.Scope);
+ }
+
+ [Test]
+ public void Attributes ()
+ {
+ Type t = typeof (SecurityCriticalAttribute);
+ Assert.IsFalse (t.IsSerializable, "IsSerializable");
+
+ object [] attrs = t.GetCustomAttributes (typeof
(AttributeUsageAttribute), false);
+ Assert.AreEqual (1, attrs.Length, "AttributeUsage");
+ AttributeUsageAttribute aua =
(AttributeUsageAttribute)attrs [0];
+ Assert.IsFalse (aua.AllowMultiple, "AllowMultiple");
+ Assert.IsFalse (aua.Inherited, "Inherited");
+ AttributeTargets at = (AttributeTargets.Assembly |
AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct |
AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method
| AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event |
AttributeTargets.Interface | AttributeTargets.Delegate);
+ Assert.AreEqual (at, aua.ValidOn, "ValidOn");
+ }
+ }
+}
+
+#endif
Added:
trunk/mcs/class/corlib/Test/System.Security/SecurityTransparentAttributeTest.cs
===================================================================
---
trunk/mcs/class/corlib/Test/System.Security/SecurityTransparentAttributeTest.cs
2005-04-28 13:24:04 UTC (rev 43719)
+++
trunk/mcs/class/corlib/Test/System.Security/SecurityTransparentAttributeTest.cs
2005-04-28 13:27:13 UTC (rev 43720)
@@ -0,0 +1,57 @@
+//
+// SecurityTransparentAttributeTest.cs -
+// NUnit Test Cases for SecurityTransparentAttribute
+//
+// Author:
+// Sebastien Pouliot <[EMAIL PROTECTED]>
+//
+// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+#if NET_2_0
+
+using NUnit.Framework;
+using System;
+using System.Security;
+
+namespace MonoTests.System.Security {
+
+ [TestFixture]
+ public class SecurityTransparentAttributeTest {
+
+ [Test]
+ public void Attributes ()
+ {
+ Type t = typeof (SecurityTransparentAttribute);
+ Assert.IsFalse (t.IsSerializable, "IsSerializable");
+
+ object [] attrs = t.GetCustomAttributes (typeof
(AttributeUsageAttribute), false);
+ Assert.AreEqual (1, attrs.Length, "AttributeUsage");
+ AttributeUsageAttribute aua =
(AttributeUsageAttribute)attrs [0];
+ Assert.IsFalse (aua.AllowMultiple, "AllowMultiple");
+ Assert.IsFalse (aua.Inherited, "Inherited");
+ Assert.AreEqual (AttributeTargets.Assembly,
aua.ValidOn, "ValidOn");
+ }
+ }
+}
+
+#endif
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches
