2004-09-10 Sebastien Pouliot <sebastien@ximian.com>

	* MessageQueuePermissionAttributeTest.cs: New. Unit tests for Message
	QueuePermissionAttribute.

svn path=/trunk/mcs/; revision=33705

diff --git a/mcs/class/System.Messaging/Test/System.Messaging/ChangeLog b/mcs/class/System.Messaging/Test/System.Messaging/ChangeLog
new file mode 100644 (file)
index 0000000..eef1776
--- /dev/null
+++ b/mcs/class/System.Messaging/Test/System.Messaging/ChangeLog
@@ -0,0 +1,4 @@
+2004-09-10  Sebastien Pouliot  <sebastien@ximian.com>
+
+       * MessageQueuePermissionAttributeTest.cs: New. Unit tests for Message
+       QueuePermissionAttribute.

diff --git a/mcs/class/System.Messaging/Test/System.Messaging/MessageQueuePermissionAttributeTest.cs b/mcs/class/System.Messaging/Test/System.Messaging/MessageQueuePermissionAttributeTest.cs
new file mode 100755 (executable)
index 0000000..b95bb68
--- /dev/null
+++ b/mcs/class/System.Messaging/Test/System.Messaging/MessageQueuePermissionAttributeTest.cs
@@ -0,0 +1,273 @@
+//\r
+// MessageQueuePermissionAttributeTest.cs -\r
+//     NUnit Test Cases for MessageQueuePermissionAttribute\r
+//\r
+// Author:\r
+//     Sebastien Pouliot  <sebastien@ximian.com>\r
+//\r
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)\r
+//\r
+// Permission is hereby granted, free of charge, to any person obtaining\r
+// a copy of this software and associated documentation files (the\r
+// "Software"), to deal in the Software without restriction, including\r
+// without limitation the rights to use, copy, modify, merge, publish,\r
+// distribute, sublicense, and/or sell copies of the Software, and to\r
+// permit persons to whom the Software is furnished to do so, subject to\r
+// the following conditions:\r
+// \r
+// The above copyright notice and this permission notice shall be\r
+// included in all copies or substantial portions of the Software.\r
+// \r
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+//\r
+\r
+using NUnit.Framework;\r
+using System;\r
+using System.Messaging;\r
+using System.Security;\r
+using System.Security.Permissions;\r
+\r
+namespace MonoTests.System.Messaging {\r
+\r
+       [TestFixture]\r
+       public class MessageQueuePermissionAttributeTest {\r
+\r
+               [Test]\r
+               public void Default ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       Assert.AreEqual (a.ToString (), a.TypeId.ToString (), "TypeId");\r
+                       Assert.IsFalse (a.Unrestricted, "Unrestricted");\r
+                       Assert.IsNull (a.Category, "Category");\r
+                       Assert.IsNull (a.Label, "Label");\r
+                       Assert.IsNull (a.MachineName, "MachineName");\r
+                       Assert.IsNull (a.Path, "Path");\r
+                       Assert.AreEqual (MessageQueuePermissionAccess.None, a.PermissionAccess, "PermissionAccess");\r
+\r
+                       a.MachineName = "localhost";\r
+                       MessageQueuePermission sp = (MessageQueuePermission)a.CreatePermission ();\r
+                       Assert.IsFalse (sp.IsUnrestricted (), "IsUnrestricted");\r
+               }\r
+\r
+               [Test]\r
+               public void Action ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       Assert.AreEqual (SecurityAction.Assert, a.Action, "Action=Assert");\r
+                       a.Action = SecurityAction.Demand;\r
+                       Assert.AreEqual (SecurityAction.Demand, a.Action, "Action=Demand");\r
+                       a.Action = SecurityAction.Deny;\r
+                       Assert.AreEqual (SecurityAction.Deny, a.Action, "Action=Deny");\r
+                       a.Action = SecurityAction.InheritanceDemand;\r
+                       Assert.AreEqual (SecurityAction.InheritanceDemand, a.Action, "Action=InheritanceDemand");\r
+                       a.Action = SecurityAction.LinkDemand;\r
+                       Assert.AreEqual (SecurityAction.LinkDemand, a.Action, "Action=LinkDemand");\r
+                       a.Action = SecurityAction.PermitOnly;\r
+                       Assert.AreEqual (SecurityAction.PermitOnly, a.Action, "Action=PermitOnly");\r
+                       a.Action = SecurityAction.RequestMinimum;\r
+                       Assert.AreEqual (SecurityAction.RequestMinimum, a.Action, "Action=RequestMinimum");\r
+                       a.Action = SecurityAction.RequestOptional;\r
+                       Assert.AreEqual (SecurityAction.RequestOptional, a.Action, "Action=RequestOptional");\r
+                       a.Action = SecurityAction.RequestRefuse;\r
+                       Assert.AreEqual (SecurityAction.RequestRefuse, a.Action, "Action=RequestRefuse");\r
+#if NET_2_0\r
+                       a.Action = SecurityAction.DemandChoice;\r
+                       Assert.AreEqual (SecurityAction.DemandChoice, a.Action, "Action=DemandChoice");\r
+                       a.Action = SecurityAction.InheritanceDemandChoice;\r
+                       Assert.AreEqual (SecurityAction.InheritanceDemandChoice, a.Action, "Action=InheritanceDemandChoice");\r
+                       a.Action = SecurityAction.LinkDemandChoice;\r
+                       Assert.AreEqual (SecurityAction.LinkDemandChoice, a.Action, "Action=LinkDemandChoice");\r
+#endif\r
+               }\r
+\r
+               [Test]\r
+               public void Action_Invalid ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute ((SecurityAction)Int32.MinValue);\r
+                       // no validation in attribute\r
+               }\r
+\r
+               [Test]\r
+               public void Unrestricted ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.MachineName = "localhost";\r
+                       a.Unrestricted = true;\r
+                       MessageQueuePermission mqp = (MessageQueuePermission)a.CreatePermission ();\r
+                       Assert.IsTrue (mqp.IsUnrestricted (), "IsUnrestricted");\r
+\r
+                       a.Unrestricted = false;\r
+                       mqp = (MessageQueuePermission)a.CreatePermission ();\r
+                       Assert.IsFalse (mqp.IsUnrestricted (), "!IsUnrestricted");\r
+               }\r
+\r
+               [Test]\r
+               [ExpectedException (typeof (InvalidOperationException))]\r
+               public void Category_Null ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.Category = null;\r
+               }\r
+\r
+               [Test]\r
+               public void Category ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.Category = "Mono";\r
+                       Assert.AreEqual ("Mono", a.Category, "Category-1");\r
+                       a.Category = String.Empty;\r
+                       Assert.AreEqual (String.Empty, a.Category, "Category-2");\r
+               }\r
+\r
+               [Test]\r
+               [ExpectedException (typeof (InvalidOperationException))]\r
+               public void Label_Null ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.Label = null;\r
+               }\r
+\r
+               [Test]\r
+               public void Label ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.Label = "Mono";\r
+                       Assert.AreEqual ("Mono", a.Label, "Label-1");\r
+                       a.Label = String.Empty;\r
+                       Assert.AreEqual (String.Empty, a.Label, "Label-2");\r
+               }\r
+\r
+               [Test]\r
+               [ExpectedException (typeof (InvalidOperationException))]\r
+               public void MachineName_Null ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.MachineName = null;\r
+               }\r
+\r
+               [Test]\r
+               [ExpectedException (typeof (ArgumentException))]\r
+               public void MachineName_Invalid ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.MachineName = String.Empty;\r
+               }\r
+\r
+               [Test]\r
+               public void MachineName ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.MachineName = "Mono";\r
+                       Assert.AreEqual ("Mono", a.MachineName, "MachineName-1");\r
+\r
+                       for (int i = 0; i < 256; i++) {\r
+                               try{\r
+                                       a.MachineName = Convert.ToChar (i).ToString ();\r
+                                       Assert.AreEqual (i, (int)a.MachineName [0], i.ToString ());\r
+                               }\r
+                               catch {\r
+                                       switch (i) {\r
+                                               case 9:\r
+                                               case 10:\r
+                                               case 11:\r
+                                               case 12:\r
+                                               case 13:\r
+                                               case 32:\r
+                                               case 92:\r
+                                               case 160:\r
+                                                       // known invalid chars\r
+                                                       break;\r
+                                               default:\r
+                                                       Assert.Fail (i.ToString ());\r
+                                                       break;\r
+                                       }\r
+                               }\r
+                       }\r
+                       // all first 256 characters seems to be valid\r
+                       // is there other rules ?\r
+               }\r
+\r
+               [Test]\r
+               [ExpectedException (typeof (InvalidOperationException))]\r
+               public void Path_Null ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.Path = null;\r
+               }\r
+\r
+               [Test]\r
+               [ExpectedException (typeof (ArgumentException))]\r
+               public void Path_Invalid ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.Path = "Mono";\r
+               }\r
+\r
+               [Test]\r
+               public void Path ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.Path = "\\Mono";\r
+                       Assert.AreEqual ("\\Mono", a.Path, "Path-1");\r
+                       a.Path = "\\";\r
+                       Assert.AreEqual ("\\", a.Path, "Path-2");\r
+                       a.Path = String.Empty;\r
+                       Assert.AreEqual (String.Empty, a.Path, "Path-3");\r
+               }\r
+\r
+               [Test]\r
+               public void PermissionAccess_Invalid ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.PermissionAccess = (MessageQueuePermissionAccess) Int32.MinValue;\r
+                       Assert.AreEqual (Int32.MinValue, (int)a.PermissionAccess);\r
+               }\r
+\r
+               [Test]\r
+               public void PermissionAccess ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.PermissionAccess = MessageQueuePermissionAccess.None;\r
+                       Assert.AreEqual (MessageQueuePermissionAccess.None, a.PermissionAccess, "None");\r
+                       a.PermissionAccess = MessageQueuePermissionAccess.Browse;\r
+                       Assert.AreEqual (MessageQueuePermissionAccess.Browse, a.PermissionAccess, "Browse");\r
+                       a.PermissionAccess = MessageQueuePermissionAccess.Send;\r
+                       Assert.AreEqual (MessageQueuePermissionAccess.Send, a.PermissionAccess, "Send");\r
+                       a.PermissionAccess = MessageQueuePermissionAccess.Peek;\r
+                       Assert.AreEqual (MessageQueuePermissionAccess.Peek, a.PermissionAccess, "Peek");\r
+                       a.PermissionAccess = MessageQueuePermissionAccess.Receive;\r
+                       Assert.AreEqual (MessageQueuePermissionAccess.Receive, a.PermissionAccess, "Receive");\r
+                       a.PermissionAccess = MessageQueuePermissionAccess.Administer;\r
+                       Assert.AreEqual (MessageQueuePermissionAccess.Administer, a.PermissionAccess, "Administer");\r
+               }\r
+\r
+               [Test]\r
+               [ExpectedException (typeof (ArgumentNullException))]\r
+               public void CreatePermission_WithoutMachineName ()\r
+               {\r
+                       MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute (SecurityAction.Assert);\r
+                       a.CreatePermission ();\r
+               }\r
+\r
+               [Test]\r
+               public void Attributes ()\r
+               {\r
+                       Type t = typeof (MessageQueuePermissionAttribute);\r
+                       Assert.IsTrue (t.IsSerializable, "IsSerializable");\r
+\r
+                       object [] attrs = t.GetCustomAttributes (typeof (AttributeUsageAttribute), false);\r
+                       Assert.AreEqual (1, attrs.Length, "AttributeUsage");\r
+                       AttributeUsageAttribute aua = (AttributeUsageAttribute)attrs [0];\r
+                       Assert.IsTrue (aua.AllowMultiple, "AllowMultiple");\r
+                       Assert.IsFalse (aua.Inherited, "Inherited");\r
+                       AttributeTargets at = (AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Event);\r
+                       Assert.AreEqual (at, aua.ValidOn, "ValidOn");\r
+               }\r
+       }\r
+}\r