Author: spouliot
Date: 2006-10-31 15:35:01 -0500 (Tue, 31 Oct 2006)
New Revision: 67188

Added:
   trunk/mcs/class/System/Test/System.Net.Mail/ChangeLog
   trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionAttributeTest.cs
   trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionTest.cs
Log:
2006-10-31  Sebastien Pouliot  <[EMAIL PROTECTED]>

        * SmtpPermissionAttributeTest.cs: New. Unit tests for 
        SmtpPermissionAttribute.
        * SmtpPermissionTest.cs: New. Unit tests for SmtpPermission.


Added: trunk/mcs/class/System/Test/System.Net.Mail/ChangeLog
===================================================================
--- trunk/mcs/class/System/Test/System.Net.Mail/ChangeLog       2006-10-31 
20:34:35 UTC (rev 67187)
+++ trunk/mcs/class/System/Test/System.Net.Mail/ChangeLog       2006-10-31 
20:35:01 UTC (rev 67188)
@@ -0,0 +1,5 @@
+2006-10-31  Sebastien Pouliot  <[EMAIL PROTECTED]>
+
+       * SmtpPermissionAttributeTest.cs: New. Unit tests for 
+       SmtpPermissionAttribute.
+       * SmtpPermissionTest.cs: New. Unit tests for SmtpPermission.

Added: 
trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionAttributeTest.cs
===================================================================
--- trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionAttributeTest.cs  
2006-10-31 20:34:35 UTC (rev 67187)
+++ trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionAttributeTest.cs  
2006-10-31 20:35:01 UTC (rev 67188)
@@ -0,0 +1,162 @@
+//
+// SmtpPermissionAttributeTest.cs -
+//     NUnit Test Cases for SmtpPermissionAttribute
+//
+// Author:
+//     Sebastien Pouliot  <[EMAIL PROTECTED]>
+//
+// Copyright (C) 2006 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.Net.Mail;
+using System.Security;
+using System.Security.Permissions;
+
+namespace MonoTests.System.Net.Mail {
+
+       [TestFixture]
+       public class SmtpPermissionAttributeTest {
+
+               [Test]
+               public void Default ()
+               {
+                       SmtpPermissionAttribute a = new SmtpPermissionAttribute 
(SecurityAction.Assert);
+                       Assert.AreEqual (a.ToString (), a.TypeId.ToString (), 
"TypeId");
+                       Assert.IsFalse (a.Unrestricted, "Unrestricted");
+                       Assert.IsNull (a.Access, "Access");
+
+                       SmtpPermission perm = (SmtpPermission) 
a.CreatePermission ();
+                       Assert.IsFalse (a.Unrestricted, "Unrestricted");
+               }
+
+               private void Access (SmtpPermissionAttribute a, string s)
+               {
+                       a.Access = s;
+                       Assert.AreEqual (s, a.Access, s);
+               }
+
+               [Test]
+               public void Access ()
+               {
+                       SmtpPermissionAttribute a = new SmtpPermissionAttribute 
(SecurityAction.Assert);
+                       Assert.IsNull (a.Access, "Null-default");
+
+                       Access (a, String.Empty);
+
+                       Access (a, "None");
+                       Access (a, "none");
+                       Access (a, "NONE");
+                       Access (a, "nOnE");
+
+                       Access (a, "Connect");
+                       Access (a, "connect");
+                       Access (a, "CONNECT");
+                       Access (a, "cOnNeCt");
+
+                       a.Access = null;
+                       Assert.IsNull (a.Access, "Null");
+               }
+
+               [Test]
+               public void Access_Invalid ()
+               {
+                       SmtpPermissionAttribute a = new SmtpPermissionAttribute 
(SecurityAction.Assert);
+                       a.Access = "invalid";
+                       Assert.AreEqual ("invalid", a.Access, "invalid");
+                       // no validation in attribute
+               }
+
+               [Test]
+               public void Action ()
+               {
+                       SmtpPermissionAttribute a = new SmtpPermissionAttribute 
(SecurityAction.Assert);
+                       Assert.AreEqual (SecurityAction.Assert, a.Action, 
"Action=Assert");
+                       a.Action = SecurityAction.Demand;
+                       Assert.AreEqual (SecurityAction.Demand, a.Action, 
"Action=Demand");
+                       a.Action = SecurityAction.Deny;
+                       Assert.AreEqual (SecurityAction.Deny, a.Action, 
"Action=Deny");
+                       a.Action = SecurityAction.InheritanceDemand;
+                       Assert.AreEqual (SecurityAction.InheritanceDemand, 
a.Action, "Action=InheritanceDemand");
+                       a.Action = SecurityAction.LinkDemand;
+                       Assert.AreEqual (SecurityAction.LinkDemand, a.Action, 
"Action=LinkDemand");
+                       a.Action = SecurityAction.PermitOnly;
+                       Assert.AreEqual (SecurityAction.PermitOnly, a.Action, 
"Action=PermitOnly");
+                       a.Action = SecurityAction.RequestMinimum;
+                       Assert.AreEqual (SecurityAction.RequestMinimum, 
a.Action, "Action=RequestMinimum");
+                       a.Action = SecurityAction.RequestOptional;
+                       Assert.AreEqual (SecurityAction.RequestOptional, 
a.Action, "Action=RequestOptional");
+                       a.Action = SecurityAction.RequestRefuse;
+                       Assert.AreEqual (SecurityAction.RequestRefuse, 
a.Action, "Action=RequestRefuse");
+               }
+
+               [Test]
+               public void Action_Invalid ()
+               {
+                       SmtpPermissionAttribute a = new SmtpPermissionAttribute 
((SecurityAction) Int32.MinValue);
+                       // no validation in attribute
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void CreatePermission_Invalid ()
+               {
+                       SmtpPermissionAttribute a = new SmtpPermissionAttribute 
(SecurityAction.Assert);
+                       a.Access = String.Empty;
+                       Assert.AreEqual (0, a.Access.Length, "Empty");
+                       Assert.IsNotNull (a.CreatePermission (), 
"Empty-Permission");
+               }
+
+               [Test]
+               public void Unrestricted ()
+               {
+                       SmtpPermissionAttribute a = new SmtpPermissionAttribute 
(SecurityAction.Assert);
+                       a.Unrestricted = true;
+                       SmtpPermission dp = (SmtpPermission) a.CreatePermission 
();
+                       Assert.IsTrue (dp.IsUnrestricted (), "IsUnrestricted");
+
+                       a.Unrestricted = false;
+                       dp = (SmtpPermission) a.CreatePermission ();
+                       Assert.IsFalse (dp.IsUnrestricted (), 
"!IsUnrestricted");
+               }
+
+               [Test]
+               public void Attributes ()
+               {
+                       Type t = typeof (SmtpPermissionAttribute);
+                       Assert.IsTrue (t.IsSerializable, "IsSerializable");
+
+                       object[] attrs = t.GetCustomAttributes (typeof 
(AttributeUsageAttribute), false);
+                       Assert.AreEqual (1, attrs.Length, "AttributeUsage");
+                       AttributeUsageAttribute aua = (AttributeUsageAttribute) 
attrs[0];
+                       Assert.IsTrue (aua.AllowMultiple, "AllowMultiple");
+                       Assert.IsFalse (aua.Inherited, "Inherited");
+                       AttributeTargets at = (AttributeTargets.Assembly | 
AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor 
| AttributeTargets.Method);
+                       Assert.AreEqual (at, aua.ValidOn, "ValidOn");
+               }
+       }
+}
+
+#endif


Property changes on: 
trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionAttributeTest.cs
___________________________________________________________________
Name: svn:executable
   + *

Added: trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionTest.cs
===================================================================
--- trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionTest.cs   
2006-10-31 20:34:35 UTC (rev 67187)
+++ trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionTest.cs   
2006-10-31 20:35:01 UTC (rev 67188)
@@ -0,0 +1,525 @@
+//
+// SmtpPermissionTest.cs - NUnit Test Cases for SmtpPermission
+//
+// Author:
+//     Sebastien Pouliot  <[EMAIL PROTECTED]>
+//
+// Copyright (C) 2006 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.Net.Mail;
+using System.Security;
+using System.Security.Permissions;
+
+namespace MonoTests.System.Net.Mail {
+
+       [TestFixture]
+       public class SmtpPermissionTest {
+
+               [Test]
+               public void PermissionState_None ()
+               {
+                       PermissionState ps = PermissionState.None;
+                       SmtpPermission sp = new SmtpPermission (ps);
+                       Assert.IsFalse (sp.IsUnrestricted (), "IsUnrestricted");
+                       Assert.AreEqual (SmtpAccess.None, sp.Access, "Access");
+
+                       SecurityElement se = sp.ToXml ();
+                       // only class and version are present
+                       Assert.AreEqual (2, se.Attributes.Count, 
"Xml-Attributes#");
+                       Assert.IsNull (se.Children, "Xml-Children");
+
+                       SmtpPermission copy = (SmtpPermission) sp.Copy ();
+                       Assert.IsFalse (Object.ReferenceEquals (sp, copy), 
"ReferenceEquals");
+                       Assert.AreEqual (sp.IsUnrestricted (), 
copy.IsUnrestricted (), "IsUnrestricted ()");
+                       Assert.AreEqual (sp.Access, copy.Access, "copy.Access");
+               }
+
+               [Test]
+               public void PermissionState_Unrestricted ()
+               {
+                       PermissionState ps = PermissionState.Unrestricted;
+                       SmtpPermission sp = new SmtpPermission (ps);
+                       Assert.IsTrue (sp.IsUnrestricted (), "IsUnrestricted");
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
sp.Access, "Access");
+
+                       SecurityElement se = sp.ToXml ();
+                       Assert.AreEqual ("true", se.Attribute ("Unrestricted"), 
"Xml-Unrestricted");
+                       Assert.AreEqual (3, se.Attributes.Count, 
"Xml-Attributes#");
+                       Assert.IsNull (se.Children, "Xml-Children");
+
+                       SmtpPermission copy = (SmtpPermission) sp.Copy ();
+                       Assert.IsFalse (Object.ReferenceEquals (sp, copy), 
"ReferenceEquals");
+                       Assert.AreEqual (sp.IsUnrestricted (), 
copy.IsUnrestricted (), "IsUnrestricted ()");
+                       Assert.AreEqual (sp.Access, copy.Access, "copy.Access");
+               }
+
+               [Test]
+               public void PermissionState_Bad ()
+               {
+                       PermissionState ps = (PermissionState) Int32.MinValue;
+                       SmtpPermission sp = new SmtpPermission (ps);
+                       // no ArgumentException here
+                       Assert.IsFalse (sp.IsUnrestricted ());
+                       Assert.AreEqual (SmtpAccess.None, sp.Access, "Access");
+               }
+
+               [Test]
+               public void Ctor_Boolean_True ()
+               {
+                       SmtpPermission sp = new SmtpPermission (true);
+                       Assert.IsTrue (sp.IsUnrestricted (), "IsUnrestricted");
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
sp.Access, "Access");
+
+                       SecurityElement se = sp.ToXml ();
+                       Assert.AreEqual ("true", se.Attribute ("Unrestricted"), 
"Xml-Unrestricted");
+                       Assert.AreEqual (3, se.Attributes.Count, 
"Xml-Attributes#");
+                       Assert.IsNull (se.Children, "Xml-Children");
+               }
+
+               [Test]
+               public void Ctor_Boolean_False ()
+               {
+                       SmtpPermission sp = new SmtpPermission (false);
+                       Assert.IsFalse (sp.IsUnrestricted (), "IsUnrestricted");
+                       Assert.AreEqual (SmtpAccess.None, sp.Access, "Access");
+
+                       SecurityElement se = sp.ToXml ();
+                       // only class and version are present
+                       Assert.AreEqual (2, se.Attributes.Count, 
"Xml-Attributes#");
+                       Assert.IsNull (se.Children, "Xml-Children");
+               }
+
+               [Test]
+               public void Ctor_SmtpAccess_None ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(SmtpAccess.None);
+                       Assert.IsFalse (sp.IsUnrestricted (), "IsUnrestricted");
+                       Assert.AreEqual (SmtpAccess.None, sp.Access, "Access");
+
+                       SecurityElement se = sp.ToXml ();
+                       // only class and version are present
+                       Assert.AreEqual (2, se.Attributes.Count, 
"Xml-Attributes#");
+                       Assert.IsNull (se.Children, "Xml-Children");
+               }
+
+               [Test]
+               public void Ctor_SmtpAccess_Connect ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(SmtpAccess.Connect);
+                       Assert.IsFalse (sp.IsUnrestricted (), "IsUnrestricted");
+                       Assert.AreEqual (SmtpAccess.Connect, sp.Access, 
"Access");
+
+                       SecurityElement se = sp.ToXml ();
+                       // only class and version are present
+                       Assert.AreEqual (3, se.Attributes.Count, 
"Xml-Attributes#");
+                       Assert.AreEqual ("Connect", se.Attribute ("Access"), 
"Xml-Access");
+                       Assert.IsNull (se.Children, "Xml-Children");
+               }
+
+               [Test]
+               public void Ctor_SmtpAccess_ConnectToUnrestrictedPort ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(SmtpAccess.ConnectToUnrestrictedPort);
+                       Assert.IsFalse (sp.IsUnrestricted (), "IsUnrestricted");
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
sp.Access, "Access");
+
+                       SecurityElement se = sp.ToXml ();
+                       // only class and version are present
+                       Assert.AreEqual (3, se.Attributes.Count, 
"Xml-Attributes#");
+                       Assert.AreEqual ("ConnectToUnrestrictedPort", 
se.Attribute ("Access"), "Xml-Access");
+                       Assert.IsNull (se.Children, "Xml-Children");
+               }
+
+               [Test]
+               public void Ctor_SmtpAccess_Invalid ()
+               {
+                       SmtpAccess sa = (SmtpAccess)Int32.MinValue;
+                       SmtpPermission sp = new SmtpPermission (sa);
+                       // no exception
+                       Assert.IsFalse (sp.IsUnrestricted (), "IsUnrestricted");
+                       Assert.AreEqual (sa, sp.Access, "Access");
+
+                       // invalid access doesn't get serialized to XML
+                       SecurityElement se = sp.ToXml ();
+                       Assert.AreEqual (2, se.Attributes.Count, 
"Xml-Attributes#");
+                       Assert.IsNull (se.Children, "Xml-Children");
+
+                       // but it doesn't roundtrip
+                       SmtpPermission copy = (SmtpPermission) sp.Copy ();
+                       Assert.AreEqual (sp.Access, copy.Access, "copy.Access");
+               }
+
+               [Test]
+               public void AddPermission ()
+               {
+                       SmtpPermission sp = new SmtpPermission (false);
+                       Assert.AreEqual (SmtpAccess.None, sp.Access, 
"Access-default");
+                       sp.AddPermission (SmtpAccess.Connect);
+                       Assert.AreEqual (SmtpAccess.Connect, sp.Access, 
"Connect");
+                       sp.AddPermission (SmtpAccess.ConnectToUnrestrictedPort);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
sp.Access, "ConnectToUnrestrictedPort");
+               }
+
+               [Test]
+               public void AddPermission_Unrestricted ()
+               {
+                       SmtpPermission sp = new SmtpPermission (true);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
sp.Access, "Access-default");
+                       sp.AddPermission (SmtpAccess.None);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
sp.Access, "ConnectToUnrestrictedPort");
+               }
+
+               [Test]
+               public void AddPermission_Invalid ()
+               {
+                       SmtpAccess sa = (SmtpAccess) Int32.MinValue;
+                       SmtpPermission sp = new SmtpPermission (false);
+                       sp.AddPermission (sa);
+                       Assert.AreEqual (SmtpAccess.None, sp.Access, "None");
+               }
+
+               [Test]
+               public void Intersect ()
+               {
+                       SmtpPermission spn = new SmtpPermission 
(PermissionState.None);
+                       Assert.IsNull (spn.Intersect (null), "None N null");
+                       SmtpPermission inter = (SmtpPermission) spn.Intersect 
(spn);
+                       Assert.AreEqual (SmtpAccess.None, inter.Access, "None N 
None");
+
+                       SmtpPermission spu = new SmtpPermission 
(PermissionState.Unrestricted);
+                       Assert.IsNull (spu.Intersect (null), "Unrestricted N 
null");
+
+                       SmtpPermission result = (SmtpPermission) spu.Intersect 
(spu);
+                       Assert.IsTrue (result.IsUnrestricted (), "Unrestricted 
N Unrestricted");
+
+                       inter = (SmtpPermission) spn.Intersect (spu);
+                       Assert.AreEqual (SmtpAccess.None, inter.Access, "None N 
Unrestricted");
+
+                       inter = (SmtpPermission) spu.Intersect (spn);
+                       Assert.AreEqual (SmtpAccess.None, inter.Access, 
"Unrestricted N None");
+               }
+
+               [Test]
+               public void Intersect_SmtpAccess ()
+               {
+                       SmtpPermission spn = new SmtpPermission (false);
+                       SmtpPermission spu = new SmtpPermission (true);
+                       SmtpPermission spctup = new SmtpPermission 
(SmtpAccess.ConnectToUnrestrictedPort);
+                       SmtpPermission spconnect = new SmtpPermission 
(SmtpAccess.Connect);
+                       SmtpPermission spnone = new SmtpPermission 
(SmtpAccess.None);
+
+                       SmtpPermission intersect = (SmtpPermission) 
spn.Intersect (spctup);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"None N ConnectToUnrestrictedPort");
+                       intersect = (SmtpPermission) spn.Intersect (spconnect);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"None N Connect");
+                       intersect = (SmtpPermission) spn.Intersect (spnone);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"None N SmtpAccess.None");
+
+                       intersect = (SmtpPermission) spu.Intersect (spctup);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
intersect.Access, "Unrestricted N ConnectToUnrestrictedPort");
+                       intersect = (SmtpPermission) spu.Intersect (spconnect);
+                       Assert.AreEqual (SmtpAccess.Connect, intersect.Access, 
"Unrestricted N Connect");
+                       intersect = (SmtpPermission) spu.Intersect (spnone);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"Unrestricted N SmtpAccess.None");
+
+                       intersect = (SmtpPermission) spctup.Intersect (spctup);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
intersect.Access, "ConnectToUnrestrictedPort N ConnectToUnrestrictedPort");
+                       intersect = (SmtpPermission) spctup.Intersect 
(spconnect);
+                       Assert.AreEqual (SmtpAccess.Connect, intersect.Access, 
"ConnectToUnrestrictedPort N Connect");
+                       intersect = (SmtpPermission) spctup.Intersect (spnone);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"ConnectToUnrestrictedPort N SmtpAccess.None");
+                       intersect = (SmtpPermission) spctup.Intersect (spn);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"ConnectToUnrestrictedPort N None");
+                       intersect = (SmtpPermission) spctup.Intersect (spu);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
intersect.Access, "ConnectToUnrestrictedPort N Unrestricted");
+
+                       intersect = (SmtpPermission) spconnect.Intersect 
(spctup);
+                       Assert.AreEqual (SmtpAccess.Connect, intersect.Access, 
"Connect N ConnectToUnrestrictedPort");
+                       intersect = (SmtpPermission) spconnect.Intersect 
(spconnect);
+                       Assert.AreEqual (SmtpAccess.Connect, intersect.Access, 
"Connect N Connect");
+                       intersect = (SmtpPermission) spconnect.Intersect 
(spnone);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"Connect N SmtpAccess.None");
+                       intersect = (SmtpPermission) spconnect.Intersect (spn);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"Connect N None");
+                       intersect = (SmtpPermission) spconnect.Intersect (spu);
+                       Assert.AreEqual (SmtpAccess.Connect, intersect.Access, 
"Connect N Unrestricted");
+
+                       intersect = (SmtpPermission) spnone.Intersect (spctup);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"SmtpAccess.None N ConnectToUnrestrictedPort");
+                       intersect = (SmtpPermission) spnone.Intersect 
(spconnect);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"SmtpAccess.None N Connect");
+                       intersect = (SmtpPermission) spnone.Intersect (spnone);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"SmtpAccess.None N SmtpAccess.None");
+                       intersect = (SmtpPermission) spnone.Intersect (spn);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"SmtpAccess.None N None");
+                       intersect = (SmtpPermission) spnone.Intersect (spu);
+                       Assert.AreEqual (SmtpAccess.None, intersect.Access, 
"SmtpAccess.None N Unrestricted");
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void Intersect_BadPermission ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       sp.Intersect (new SecurityPermission 
(PermissionState.Unrestricted));
+               }
+
+               [Test]
+               public void IsSubset ()
+               {
+                       SmtpPermission spn = new SmtpPermission 
(PermissionState.None);
+                       SmtpPermission spu = new SmtpPermission 
(PermissionState.Unrestricted);
+
+                       Assert.IsTrue (spn.IsSubsetOf (null), "None IsSubsetOf 
null");
+                       Assert.IsFalse (spu.IsSubsetOf (null), "Unrestricted 
IsSubsetOf null");
+
+                       Assert.IsTrue (spn.IsSubsetOf (spn), "None IsSubsetOf 
None");
+                       Assert.IsTrue (spu.IsSubsetOf (spu), "Unrestricted 
IsSubsetOf Unrestricted");
+
+                       Assert.IsTrue (spn.IsSubsetOf (spu), "None IsSubsetOf 
Unrestricted");
+                       Assert.IsFalse (spu.IsSubsetOf (spn), "Unrestricted 
IsSubsetOf None");
+               }
+
+               [Test]
+               public void IsSubset_SmtpAccess ()
+               {
+                       SmtpPermission spn = new SmtpPermission (false);
+                       SmtpPermission spu = new SmtpPermission (true);
+                       SmtpPermission spctup = new SmtpPermission 
(SmtpAccess.ConnectToUnrestrictedPort);
+                       SmtpPermission spconnect = new SmtpPermission 
(SmtpAccess.Connect);
+                       SmtpPermission spnone = new SmtpPermission 
(SmtpAccess.None);
+
+                       Assert.IsTrue (spn.IsSubsetOf (spctup), "None 
IsSubsetOf ConnectToUnrestrictedPort");
+                       Assert.IsTrue (spn.IsSubsetOf (spconnect), "None 
IsSubsetOf Connect");
+                       Assert.IsTrue (spn.IsSubsetOf (spnone), "None 
IsSubsetOf SmtpAccess.None");
+
+                       Assert.IsFalse (spu.IsSubsetOf (spctup), "Unrestricted 
IsSubsetOf ConnectToUnrestrictedPort");
+                       Assert.IsFalse (spu.IsSubsetOf (spconnect), 
"Unrestricted IsSubsetOf Connect");
+                       Assert.IsFalse (spu.IsSubsetOf (spnone), "Unrestricted 
IsSubsetOf SmtpAccess.None");
+
+                       Assert.IsTrue (spctup.IsSubsetOf (spctup), 
"ConnectToUnrestrictedPort IsSubsetOf ConnectToUnrestrictedPort");
+                       Assert.IsFalse (spctup.IsSubsetOf (spconnect), 
"ConnectToUnrestrictedPort IsSubsetOf Connect");
+                       Assert.IsFalse (spctup.IsSubsetOf (spnone), 
"ConnectToUnrestrictedPort IsSubsetOf SmtpAccess.None");
+                       Assert.IsFalse (spctup.IsSubsetOf (spn), 
"ConnectToUnrestrictedPort IsSubsetOf None");
+                       Assert.IsTrue (spctup.IsSubsetOf (spu), 
"ConnectToUnrestrictedPort IsSubsetOf Unrestricted");
+
+                       Assert.IsTrue (spconnect.IsSubsetOf (spctup), "Connect 
IsSubsetOf ConnectToUnrestrictedPort");
+                       Assert.IsTrue (spconnect.IsSubsetOf (spconnect), 
"Connect IsSubsetOf Connect");
+                       Assert.IsFalse (spconnect.IsSubsetOf (spnone), "Connect 
IsSubsetOf SmtpAccess.None");
+                       Assert.IsFalse (spconnect.IsSubsetOf (spn), "Connect 
IsSubsetOf None");
+                       Assert.IsTrue (spconnect.IsSubsetOf (spu), "Connect 
IsSubsetOf Unrestricted");
+
+                       Assert.IsTrue (spnone.IsSubsetOf (spctup), 
"SmtpAccess.None IsSubsetOf ConnectToUnrestrictedPort");
+                       Assert.IsTrue (spnone.IsSubsetOf (spconnect), 
"SmtpAccess.None IsSubsetOf Connect");
+                       Assert.IsTrue (spnone.IsSubsetOf (spnone), 
"SmtpAccess.None IsSubsetOf SmtpAccess.None");
+                       Assert.IsTrue (spnone.IsSubsetOf (spn), 
"SmtpAccess.None IsSubsetOf None");
+                       Assert.IsTrue (spnone.IsSubsetOf (spu), 
"SmtpAccess.None IsSubsetOf Unrestricted");
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void IsSubset_BadPermission ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       sp.IsSubsetOf (new SecurityPermission 
(PermissionState.Unrestricted));
+               }
+
+               [Test]
+               public void Union ()
+               {
+                       SmtpPermission spn = new SmtpPermission 
(PermissionState.None);
+                       SmtpPermission spu = new SmtpPermission 
(PermissionState.Unrestricted);
+
+                       SmtpPermission result = (SmtpPermission) spn.Union 
(null);
+                       Assert.IsFalse (result.IsUnrestricted (), "None U 
null");
+
+                       result = (SmtpPermission) spu.Union (null);
+                       Assert.IsTrue (result.IsUnrestricted (), "Unrestricted 
U null");
+
+                       result = (SmtpPermission) spn.Union (spn);
+                       Assert.IsFalse (result.IsUnrestricted (), "None U 
None");
+
+                       result = (SmtpPermission) spu.Union (spu);
+                       Assert.IsTrue (result.IsUnrestricted (), "Unrestricted 
U Unrestricted");
+
+                       result = (SmtpPermission) spn.Union (spu);
+                       Assert.IsTrue (result.IsUnrestricted (), "None U 
Unrestricted");
+
+                       result = (SmtpPermission) spu.Union (spn);
+                       Assert.IsTrue (result.IsUnrestricted (), "Unrestricted 
U None");
+               }
+
+               [Test]
+               public void Union_SmtpAccess ()
+               {
+                       SmtpPermission spn = new SmtpPermission (false);
+                       SmtpPermission spu = new SmtpPermission (true);
+                       SmtpPermission spctup = new SmtpPermission 
(SmtpAccess.ConnectToUnrestrictedPort);
+                       SmtpPermission spconnect = new SmtpPermission 
(SmtpAccess.Connect);
+                       SmtpPermission spnone = new SmtpPermission 
(SmtpAccess.None);
+
+                       SmtpPermission union = (SmtpPermission) spn.Union 
(spctup);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "None U ConnectToUnrestrictedPort");
+                       union = (SmtpPermission) spn.Union (spconnect);
+                       Assert.AreEqual (SmtpAccess.Connect, union.Access, 
"None U Connect");
+                       union = (SmtpPermission) spn.Union (spnone);
+                       Assert.AreEqual (SmtpAccess.None, union.Access, "None U 
SmtpAccess.None");
+
+                       union = (SmtpPermission) spu.Union (spctup);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "Unrestricted U ConnectToUnrestrictedPort");
+                       union = (SmtpPermission) spu.Union (spconnect);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "Unrestricted U Connect");
+                       union = (SmtpPermission) spu.Union (spnone);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "Unrestricted U SmtpAccess.None");
+
+                       union = (SmtpPermission) spctup.Union (spctup);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "ConnectToUnrestrictedPort U ConnectToUnrestrictedPort");
+                       union = (SmtpPermission) spctup.Union (spconnect);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "ConnectToUnrestrictedPort U Connect");
+                       union = (SmtpPermission) spctup.Union (spnone);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "ConnectToUnrestrictedPort U SmtpAccess.None");
+                       union = (SmtpPermission) spctup.Union (spn);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "ConnectToUnrestrictedPort U None");
+                       union = (SmtpPermission) spctup.Union (spu);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "ConnectToUnrestrictedPort U Unrestricted");
+
+                       union = (SmtpPermission) spconnect.Union (spctup);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "Connect U ConnectToUnrestrictedPort");
+                       union = (SmtpPermission) spconnect.Union (spconnect);
+                       Assert.AreEqual (SmtpAccess.Connect, union.Access, 
"Connect U Connect");
+                       union = (SmtpPermission) spconnect.Union (spnone);
+                       Assert.AreEqual (SmtpAccess.Connect, union.Access, 
"Connect U SmtpAccess.None");
+                       union = (SmtpPermission) spconnect.Union (spn);
+                       Assert.AreEqual (SmtpAccess.Connect, union.Access, 
"Connect U None");
+                       union = (SmtpPermission) spconnect.Union (spu);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "Connect U Unrestricted");
+
+                       union = (SmtpPermission) spnone.Union (spctup);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "SmtpAccess.None U ConnectToUnrestrictedPort");
+                       union = (SmtpPermission) spnone.Union (spconnect);
+                       Assert.AreEqual (SmtpAccess.Connect, union.Access, 
"SmtpAccess.None U Connect");
+                       union = (SmtpPermission) spnone.Union (spnone);
+                       Assert.AreEqual (SmtpAccess.None, union.Access, 
"SmtpAccess.None U SmtpAccess.None");
+                       union = (SmtpPermission) spnone.Union (spn);
+                       Assert.AreEqual (SmtpAccess.None, union.Access, 
"SmtpAccess.None U None");
+                       union = (SmtpPermission) spnone.Union (spu);
+                       Assert.AreEqual (SmtpAccess.ConnectToUnrestrictedPort, 
union.Access, "SmtpAccess.None U Unrestricted");
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void Union_BadPermission ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       sp.Union (new SecurityPermission 
(PermissionState.Unrestricted));
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentNullException))]
+               public void FromXml_Null ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       sp.FromXml (null);
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void FromXml_WrongTag ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       SecurityElement se = sp.ToXml ();
+                       se.Tag = "IMono";
+                       sp.FromXml (se);
+                       // note: normally IPermission classes (in corlib) DO 
care about the
+                       // IPermission tag
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void FromXml_WrongTagCase ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       SecurityElement se = sp.ToXml ();
+                       se.Tag = "IPERMISSION"; // instead of IPermission
+                       sp.FromXml (se);
+                       // note: normally IPermission classes (in corlib) DO 
care about the
+                       // IPermission tag
+               }
+
+               [Test]
+               public void FromXml_WrongClass ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       SecurityElement se = sp.ToXml ();
+
+                       SecurityElement w = new SecurityElement (se.Tag);
+                       w.AddAttribute ("class", "Wrong" + se.Attribute 
("class"));
+                       w.AddAttribute ("version", se.Attribute ("version"));
+                       sp.FromXml (w);
+                       // doesn't care of the class name at that stage
+                       // anyway the class has already be created so...
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void FromXml_NoClass ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       SecurityElement se = sp.ToXml ();
+
+                       SecurityElement w = new SecurityElement (se.Tag);
+                       w.AddAttribute ("version", se.Attribute ("version"));
+                       sp.FromXml (w);
+                       // note: normally IPermission classes (in corlib) DO 
NOT care about
+                       // attribute "class" name presence in the XML
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void FromXml_WrongVersion ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       SecurityElement se = sp.ToXml ();
+                       se.Attributes.Remove ("version");
+                       se.Attributes.Add ("version", "2");
+                       sp.FromXml (se);
+               }
+
+               [Test]
+               public void FromXml_NoVersion ()
+               {
+                       SmtpPermission sp = new SmtpPermission 
(PermissionState.None);
+                       SecurityElement se = sp.ToXml ();
+
+                       SecurityElement w = new SecurityElement (se.Tag);
+                       w.AddAttribute ("class", se.Attribute ("class"));
+                       sp.FromXml (w);
+               }
+       }
+}
+
+#endif


Property changes on: 
trunk/mcs/class/System/Test/System.Net.Mail/SmtpPermissionTest.cs
___________________________________________________________________
Name: svn:executable
   + *

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to