Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/System.ServiceProcess/Test/System.ServiceProcess/ChangeLog

@@ -0,0 +1,34 @@
+2006-10-07  Gert Driesen  <drieseng@users.sourceforge.net>
+
+	* ServiceControllerTest.cs: Modifying ServiceService, DisplayName
+	or MachineName does not cause cache to be cleared. Categorized as
+	"By Design" by MS.
+
+2006-09-14  Gert Driesen  <drieseng@users.sourceforge.net>
+
+	* ServiceControllerPermissionTest.cs: Set eol-style to native. Fixed
+	warning and improved Union_Null test.
+	* ServiceControllerPermissionAttributeTest.cs: Set eol-style to native.
+	Fixed warning.
+	* ServiceControllerTest.cs: Added unit tests for win32 implementation
+	of ServiceController.
+
+2005-09-22  Sebastien Pouliot  <sebastien@ximian.com>
+
+	* ServiceControllerPermissionAttributeTest.cs: Removed *Choice 
+	security actions.
+
+2005-05-31  Sebastien Pouliot  <sebastien@ximian.com>
+
+	* ServiceControllerPermissionAttributeTest.cs: Character #133 isn't
+	valid in machine names for 2.0. An empt service name is acceptable 
+	before 2.0.
+	* ServiceControllerPermissionTest.cs: 2.0 has better parameters
+	checking (since FDBK15131 was fixed).
+
+2004-09-11  Sebastien Pouliot  <sebastien@ximian.com>
+
+	* ServiceControllerPermissionAttributeTest.cs: New. Unit tests for
+	ServiceControllerPermissionAttribute class.
+	* ServiceControllerPermissionTest.cs: New. Unit tests for Service
+	ControllerPermission class.

mcs/class/System.ServiceProcess/Test/System.ServiceProcess/ServiceBaseTest.cs

@@ -0,0 +1,118 @@
+//
+// ServiceBaseTest.cs -
+//	NUnit Test Cases for ServiceBase
+//
+// Author:
+//	Andres G. Aragoneses  (andres@7digital.com)
+//
+// Copyright (C) 2013 7digital Media, Ltd (http://www.7digital.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.
+//
+
+using System.ServiceProcess;
+using NUnit.Framework;
+
+namespace Test
+{
+	[TestFixture]
+	public class ServiceBaseTest
+	{
+		const int SOME_ERROR_CODE = 1;
+
+		public partial class ServiceFoo : ServiceBase
+		{
+			public ServiceFoo ()
+			{
+				InitializeComponent ();
+			}
+
+			protected override void OnStart (string[] args)
+			{
+			}
+
+			protected override void OnStop ()
+			{
+				ExitCode = SOME_ERROR_CODE;
+			}
+
+			public void StartHook ()
+			{
+				OnStart (new string [] { });
+			}
+		}
+
+		[Test]
+		public void StopCallsOnStop ()
+		{
+			var s = new ServiceFoo ();
+			Assert.AreEqual (0, s.ExitCode);
+			s.Stop ();
+			Assert.AreEqual (SOME_ERROR_CODE, s.ExitCode);
+		}
+
+		[Test]
+		public void ExitCodeIsNotResetByBaseClassServiceBaseBetweenRuns ()
+		{
+			var s = new ServiceFoo ();
+			Assert.AreEqual (0, s.ExitCode);
+			s.Stop ();
+			Assert.AreEqual (SOME_ERROR_CODE, s.ExitCode);
+			s.StartHook ();
+			Assert.AreEqual (SOME_ERROR_CODE, s.ExitCode);
+		}
+
+		partial class ServiceFoo
+		{
+			/// <summary>
+			/// Required designer variable.
+			/// </summary>
+			private System.ComponentModel.IContainer components = null;
+
+			/// <summary>
+			/// Clean up any resources being used.
+			/// </summary>
+			/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+			protected override void Dispose(bool disposing)
+			{
+				if (disposing && (components != null))
+				{
+					components.Dispose();
+				}
+				base.Dispose(disposing);
+			}
+
+			#region Component Designer generated code
+
+			/// <summary>
+			/// Required method for Designer support - do not modify
+			/// the contents of this method with the code editor.
+			/// </summary>
+			private void InitializeComponent()
+			{
+				components = new System.ComponentModel.Container();
+				this.ServiceName = "ServiceFoo";
+			}
+
+			#endregion
+		}
+	}
+}
+

mcs/class/System.ServiceProcess/Test/System.ServiceProcess/ServiceControllerPermissionAttributeTest.cs

@@ -0,0 +1,226 @@
+//
+// ServiceControllerPermissionAttributeTest.cs -
+//	NUnit Test Cases for ServiceControllerPermissionAttribute
+//
+// Author:
+//	Sebastien Pouliot  <sebastien@ximian.com>
+//
+// Copyright (C) 2004-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.
+//
+
+using NUnit.Framework;
+using System;
+using System.Security;
+using System.Security.Permissions;
+using System.ServiceProcess;
+
+namespace MonoTests.System.ServiceProcess {
+
+	[TestFixture]
+	public class ServiceControllerPermissionAttributeTest {
+
+		[Test]
+		public void Default ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			Assert.AreEqual (a.ToString (), a.TypeId.ToString (), "TypeId");
+			Assert.IsFalse (a.Unrestricted, "Unrestricted");
+			Assert.AreEqual (".", a.MachineName, "MachineName");
+			Assert.AreEqual (ServiceControllerPermissionAccess.Browse, a.PermissionAccess, "PermissionAccess");
+
+			ServiceControllerPermission sp = (ServiceControllerPermission)a.CreatePermission ();
+			Assert.IsFalse (sp.IsUnrestricted (), "IsUnrestricted");
+		}
+
+		[Test]
+		public void Action ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (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 ()
+		{
+			new ServiceControllerPermissionAttribute ((SecurityAction)Int32.MinValue);
+			// no validation in attribute
+		}
+
+		[Test]
+		public void Unrestricted ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			a.Unrestricted = true;
+			ServiceControllerPermission wp = (ServiceControllerPermission)a.CreatePermission ();
+			Assert.IsTrue (wp.IsUnrestricted (), "IsUnrestricted");
+
+			a.Unrestricted = false;
+			wp = (ServiceControllerPermission)a.CreatePermission ();
+			Assert.IsFalse (wp.IsUnrestricted (), "!IsUnrestricted");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void MachineName_Null ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			a.MachineName = null;
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void MachineName_Empty ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			a.MachineName = String.Empty;
+		}
+
+		[Test]
+		public void MachineName ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			for (int i = 0; i < 256; i++) {
+				try {
+					a.MachineName = Convert.ToChar (i).ToString ();
+					Assert.AreEqual (i, (int)a.MachineName [0], i.ToString ());
+				}
+				catch {
+					switch (i) {
+						case 9:
+						case 10:
+						case 11:
+						case 12:
+						case 13:
+						case 32:
+						case 92:
+#if NET_2_0
+						case 133:
+#endif
+						case 160:
+							// known invalid chars
+							break;
+						default:
+							Assert.Fail (i.ToString ());
+							break;
+					}
+				}
+			}
+			// all first 256 characters seems to be valid
+			// is there other rules ?
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentNullException))]
+		public void ServiceName_Null ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			a.ServiceName = null;
+		}
+
+		[Test]
+#if NET_2_0
+		[ExpectedException (typeof (ArgumentException))]
+#endif
+		public void ServiceName_Empty ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			a.ServiceName = String.Empty;
+		}
+
+		[Test]
+		public void ServiceName ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			for (int i = 0; i < 256; i++) {
+				try {
+					a.ServiceName = Convert.ToChar (i).ToString ();
+					Assert.AreEqual (i, (int)a.ServiceName [0], i.ToString ());
+				}
+				catch {
+					switch (i) {
+						case 47:
+						case 92:
+							// known invalid chars
+							break;
+						default:
+							Assert.Fail (i.ToString ());
+							break;
+					}
+				}
+			}
+			// all first 256 characters seems to be valid
+			// is there other rules ?
+		}
+
+		[Test]
+		public void PermissionAccess ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			a.PermissionAccess = ServiceControllerPermissionAccess.None;
+			Assert.AreEqual (ServiceControllerPermissionAccess.None, a.PermissionAccess, "None");
+			a.PermissionAccess = ServiceControllerPermissionAccess.Browse;
+			Assert.AreEqual (ServiceControllerPermissionAccess.Browse, a.PermissionAccess, "Browse");
+			a.PermissionAccess = ServiceControllerPermissionAccess.Control;
+			Assert.AreEqual (ServiceControllerPermissionAccess.Control, a.PermissionAccess, "Control");
+		}
+
+		[Test]
+		public void PermissionAccess_Invalid ()
+		{
+			ServiceControllerPermissionAttribute a = new ServiceControllerPermissionAttribute (SecurityAction.Assert);
+			a.PermissionAccess = (ServiceControllerPermissionAccess)Int32.MinValue;
+			Assert.AreEqual ((ServiceControllerPermissionAccess)Int32.MinValue, a.PermissionAccess, "None");
+			// no exception thrown
+		}
+
+		[Test]
+		public void Attributes ()
+		{
+			Type t = typeof (ServiceControllerPermissionAttribute);
+			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 | AttributeTargets.Event);
+			Assert.AreEqual (at, aua.ValidOn, "ValidOn");
+		}
+	}
+}

mcs/class/System.ServiceProcess/Test/System.ServiceProcess/ServiceControllerPermissionTest.cs

@@ -0,0 +1,428 @@
+//
+// ServiceControllerPermissionTest.cs -
+//	NUnit Test Cases for ServiceControllerPermission
+//
+// Author:
+//	Sebastien Pouliot  <sebastien@ximian.com>
+//
+// Copyright (C) 2004-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.
+//
+
+using NUnit.Framework;
+using System;
+using System.Security;
+using System.Security.Permissions;
+using System.ServiceProcess;
+
+namespace MonoTests.System.ServiceProcess {
+
+	[TestFixture]
+	public class ServiceControllerPermissionTest {
+
+		static ServiceControllerPermissionAccess [] AllAccess = {
+			ServiceControllerPermissionAccess.None,
+			ServiceControllerPermissionAccess.Browse,
+			ServiceControllerPermissionAccess.Control,
+		};
+
+		[Test]
+		public void PermissionState_None ()
+		{
+			PermissionState ps = PermissionState.None;
+			ServiceControllerPermission scp = new ServiceControllerPermission (ps);
+			Assert.AreEqual (0, scp.PermissionEntries.Count, "PermissionEntries");
+			Assert.IsFalse (scp.IsUnrestricted (), "IsUnrestricted");
+
+			SecurityElement se = scp.ToXml ();
+			// only class and version are present
+			Assert.AreEqual (2, se.Attributes.Count, "Xml-Attributes");
+			Assert.IsNull (se.Children, "Xml-Children");
+
+			ServiceControllerPermission copy = (ServiceControllerPermission)scp.Copy ();
+			Assert.IsFalse (Object.ReferenceEquals (scp, copy), "ReferenceEquals");
+			Assert.AreEqual (scp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");
+			Assert.AreEqual (scp.IsUnrestricted (), copy.IsUnrestricted (), "IsUnrestricted ()");
+		}
+
+		[Test]
+		public void PermissionState_Unrestricted ()
+		{
+			PermissionState ps = PermissionState.Unrestricted;
+			ServiceControllerPermission scp = new ServiceControllerPermission (ps);
+			Assert.AreEqual (0, scp.PermissionEntries.Count, "PermissionEntries");
+			Assert.IsTrue (scp.IsUnrestricted (), "IsUnrestricted");
+
+			SecurityElement se = scp.ToXml ();
+			// only class and version are present
+			Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "Xml-Unrestricted");
+			Assert.IsNull (se.Children, "Xml-Children");
+
+			ServiceControllerPermission copy = (ServiceControllerPermission)scp.Copy ();
+			Assert.IsFalse (Object.ReferenceEquals (scp, copy), "ReferenceEquals");
+			Assert.AreEqual (scp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");
+			Assert.AreEqual (scp.IsUnrestricted (), copy.IsUnrestricted (), "copy-IsUnrestricted ()");
+		}
+
+		[Test]
+#if NET_2_0
+		[ExpectedException (typeof (ArgumentException))]
+#endif
+		public void PermissionState_Bad ()
+		{
+			PermissionState ps = (PermissionState)77;
+			ServiceControllerPermission scp = new ServiceControllerPermission (ps);
+			Assert.IsFalse (scp.IsUnrestricted (), "IsUnrestricted");
+		}
+
+		[Test]
+		public void ServiceControllerPermissionAccesss_Bad ()
+		{
+			ServiceControllerPermissionAccess scpa = (ServiceControllerPermissionAccess)Int32.MinValue;
+			ServiceControllerPermission scp = new ServiceControllerPermission (scpa, "localhost", "http");
+			Assert.AreEqual (1, scp.PermissionEntries.Count, "Count");
+			Assert.AreEqual ((ServiceControllerPermissionAccess)Int32.MinValue, scp.PermissionEntries [0].PermissionAccess, "PermissionAccess");
+		}
+
+		[Test]
+		public void PermissionEntries ()
+		{
+			ServiceControllerPermissionAccess scpa = ServiceControllerPermissionAccess.None;
+			ServiceControllerPermission scp = new ServiceControllerPermission (scpa, "localhost", "http");
+			ServiceControllerPermissionEntryCollection scpec = scp.PermissionEntries;
+			Assert.AreEqual (1, scpec.Count, "Count==1");
+
+			ServiceControllerPermissionEntry scpe = new ServiceControllerPermissionEntry (ServiceControllerPermissionAccess.Browse, "*", "ftp");
+			scp.PermissionEntries.Add (scpe);
+			Assert.AreEqual (2, scpec.Count, "Count==2");
+
+			// remove (same instance)
+			scp.PermissionEntries.Remove (scpe);
+			Assert.AreEqual (1, scpec.Count, "Count==1 (b)");
+
+			// remove different instance (doesn't work)
+			scpe = new ServiceControllerPermissionEntry (ServiceControllerPermissionAccess.None, "localhost", "http");
+			Assert.AreEqual (1, scpec.Count, "Count==1");
+		}
+
+		[Test]
+		public void Copy ()
+		{
+			foreach (ServiceControllerPermissionAccess scpa in AllAccess) {
+				ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+				ServiceControllerPermissionEntry scpe = new ServiceControllerPermissionEntry (scpa, "localhost", scpa.ToString ());
+				scp.PermissionEntries.Add (scpe);
+				ServiceControllerPermission copy = (ServiceControllerPermission)scp.Copy ();
+				Assert.AreEqual (1, copy.PermissionEntries.Count, "Count==1");
+				Assert.AreEqual (scpa, scp.PermissionEntries [0].PermissionAccess, scpa.ToString ());
+			}
+		}
+
+		[Test]
+		public void Intersect_Null ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+			// No intersection with null
+			Assert.IsNull (scp.Intersect (null), "None N null");
+		}
+
+		[Test]
+		public void Intersect_None ()
+		{
+			ServiceControllerPermission scp1 = new ServiceControllerPermission (PermissionState.None);
+			ServiceControllerPermission scp2 = new ServiceControllerPermission (PermissionState.None);
+			// 1. None N None
+			ServiceControllerPermission result = (ServiceControllerPermission)scp1.Intersect (scp2);
+			Assert.IsNull (result, "Empty N Empty");
+			// 2. None N Entry
+			scp2.PermissionEntries.Add (new ServiceControllerPermissionEntry (ServiceControllerPermissionAccess.None, "localhost", "http"));
+			result = (ServiceControllerPermission)scp1.Intersect (scp2);
+			Assert.IsNull (result, "Empty N Entry");
+			// 3. Entry N None
+			result = (ServiceControllerPermission)scp2.Intersect (scp1);
+			Assert.IsNull (result, "Entry N Empty");
+		}
+
+		[Test]
+		public void Intersect_Unrestricted ()
+		{
+			// Intersection with unrestricted == Copy
+			// a. source (this) is unrestricted
+			ServiceControllerPermission scp1 = new ServiceControllerPermission (PermissionState.Unrestricted);
+			ServiceControllerPermission scp2 = new ServiceControllerPermission (PermissionState.None);
+
+			// 1. Unrestricted N None
+			ServiceControllerPermission result = (ServiceControllerPermission)scp1.Intersect (scp2);
+			Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N None).IsUnrestricted");
+			Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N None).Count");
+
+			// 2. None N Unrestricted
+			result = (ServiceControllerPermission)scp2.Intersect (scp1);
+			Assert.IsFalse (result.IsUnrestricted (), "(None N Unrestricted).IsUnrestricted");
+			Assert.AreEqual (0, result.PermissionEntries.Count, "(None N Unrestricted).Count");
+
+			// 3. Unrestricted N Unrestricted
+			result = (ServiceControllerPermission)scp1.Intersect (scp1);
+			Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");
+			Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
+
+			// 4. Unrestricted N Entry
+			scp2.PermissionEntries.Add (new ServiceControllerPermissionEntry (ServiceControllerPermissionAccess.None, "localhost", "http"));
+			result = (ServiceControllerPermission)scp1.Intersect (scp2);
+			Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N Entry).IsUnrestricted");
+			Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Entry).Count");
+
+			// 5. Entry N Unrestricted
+			result = (ServiceControllerPermission)scp2.Intersect (scp1);
+			Assert.IsFalse (result.IsUnrestricted (), "(Entry N Unrestricted).IsUnrestricted");
+			Assert.AreEqual (1, result.PermissionEntries.Count, "(Entry N Unrestricted).Count");
+
+			// 6. Unrestricted N Unrestricted
+			scp1.PermissionEntries.Add (new ServiceControllerPermissionEntry (ServiceControllerPermissionAccess.None, "localhost", "http"));
+			result = (ServiceControllerPermission)scp1.Intersect (scp1);
+			Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");
+			Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Intersect_BadPermission ()
+		{
+			ServiceControllerPermission scp1 = new ServiceControllerPermission (PermissionState.Unrestricted);
+			scp1.Intersect (new SecurityPermission (SecurityPermissionFlag.Assertion));
+		}
+
+		[Test]
+		public void IsSubset_Null ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+#if NET_2_0
+			Assert.IsTrue (scp.IsSubsetOf (null), "null");
+#else
+			Assert.IsFalse (scp.IsSubsetOf (null), "null");
+#endif
+		}
+
+		[Test]
+		public void IsSubset_None ()
+		{
+			// IsSubset with none
+			// a. source (this) is none -> target is never a subset
+			// b. destination (target) is none -> target is always a subset
+			ServiceControllerPermission scp1 = new ServiceControllerPermission (PermissionState.None);
+			foreach (ServiceControllerPermissionAccess scpa in AllAccess) {
+				ServiceControllerPermission scp2 = new ServiceControllerPermission (PermissionState.None);
+				scp2.PermissionEntries.Add (new ServiceControllerPermissionEntry (scpa, "localhost", scpa.ToString ()));
+				Assert.IsTrue (scp1.IsSubsetOf (scp2), "target " + scpa.ToString ());
+				Assert.IsFalse (scp2.IsSubsetOf (scp1), "source " + scpa.ToString ());
+			}
+		}
+
+		[Test]
+		public void IsSubset_Self ()
+		{
+			foreach (ServiceControllerPermissionAccess scpa in AllAccess) {
+				ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+				scp.PermissionEntries.Add (new ServiceControllerPermissionEntry (scpa, "localhost", scpa.ToString ()));
+				Assert.IsTrue (scp.IsSubsetOf (scp), scpa.ToString ());
+			}
+		}
+
+		[Test]
+		public void IsSubset_Unrestricted ()
+		{
+			// IsSubset with unrestricted
+			// a. source (this) is unrestricted -> target is never a subset
+			// b. destination (target) is unrestricted -> source is always a subset
+			ServiceControllerPermission scp1 = new ServiceControllerPermission (PermissionState.Unrestricted);
+			foreach (ServiceControllerPermissionAccess scpa in AllAccess) {
+				ServiceControllerPermission scp2 = new ServiceControllerPermission (PermissionState.None);
+				scp2.PermissionEntries.Add (new ServiceControllerPermissionEntry (scpa, "localhost", scpa.ToString ()));
+				Assert.IsFalse (scp1.IsSubsetOf (scp2), "target " + scpa.ToString ());
+				Assert.IsTrue (scp2.IsSubsetOf (scp1), "source " + scpa.ToString ());
+			}
+			Assert.IsTrue (scp1.IsSubsetOf (scp1), "Unrestricted.IsSubsetOf(Unrestricted)");
+		}
+
+		[Test]
+// "special" behavior inherited from ResourceBasePermission
+//		[ExpectedException (typeof (ArgumentException))]
+		public void IsSubsetOf_BadPermission ()
+		{
+			ServiceControllerPermission scp1 = new ServiceControllerPermission (PermissionState.Unrestricted);
+			Assert.IsFalse (scp1.IsSubsetOf (new SecurityPermission (SecurityPermissionFlag.Assertion)));
+		}
+
+		[Test]
+		public void Union_Null ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+			scp.PermissionEntries.Add (new ServiceControllerPermissionEntry (ServiceControllerPermissionAccess.None, "localhost", "http"));
+			// Union with null is a simple copy
+			ServiceControllerPermission union = (ServiceControllerPermission)scp.Union (null);
+			Assert.AreEqual (1, union.PermissionEntries.Count, "Count");
+		}
+
+		[Test]
+		public void Union_None ()
+		{
+			ServiceControllerPermission scp1 = new ServiceControllerPermission (PermissionState.None);
+			foreach (ServiceControllerPermissionAccess scpa in AllAccess) {
+				ServiceControllerPermission scp2 = new ServiceControllerPermission (PermissionState.None);
+				scp2.PermissionEntries.Add (new ServiceControllerPermissionEntry (scpa, "localhost", scpa.ToString ()));
+				ServiceControllerPermission union = (ServiceControllerPermission)scp1.Union (scp2);
+				Assert.IsFalse (union.IsUnrestricted (), "target.IsUnrestricted " + scpa.ToString ());
+				Assert.AreEqual (1, union.PermissionEntries.Count, "target.Count " + scpa.ToString ());
+
+				union = (ServiceControllerPermission)scp2.Union (scp1);
+				Assert.IsFalse (union.IsUnrestricted (), "source.IsUnrestricted " + scpa.ToString ());
+				Assert.AreEqual (1, union.PermissionEntries.Count, "source.Count " + scpa.ToString ());
+			}
+		}
+
+		[Test]
+		public void Union_Self ()
+		{
+			foreach (ServiceControllerPermissionAccess scpa in AllAccess) {
+				ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+				scp.PermissionEntries.Add (new ServiceControllerPermissionEntry (scpa, "localhost", scpa.ToString ()));
+				ServiceControllerPermission union = (ServiceControllerPermission)scp.Union (scp);
+				Assert.IsFalse (union.IsUnrestricted (), "IsUnrestricted " + scpa.ToString ());
+				Assert.AreEqual (1, union.PermissionEntries.Count, "Count " + scpa.ToString ());
+			}
+		}
+
+		[Test]
+		public void Union_Unrestricted ()
+		{
+			// Union with unrestricted is unrestricted
+			ServiceControllerPermission scp1 = new ServiceControllerPermission (PermissionState.Unrestricted);
+			foreach (ServiceControllerPermissionAccess scpa in AllAccess) {
+				ServiceControllerPermission scp2 = new ServiceControllerPermission (PermissionState.None);
+				scp2.PermissionEntries.Add (new ServiceControllerPermissionEntry (scpa, "localhost", scpa.ToString ()));
+				ServiceControllerPermission union = (ServiceControllerPermission)scp1.Union (scp2);
+				Assert.IsTrue (union.IsUnrestricted (), "target.IsUnrestricted " + scpa.ToString ());
+				Assert.AreEqual (0, union.PermissionEntries.Count, "target.Count " + scpa.ToString ());
+
+				union = (ServiceControllerPermission)scp2.Union (scp1);
+				Assert.IsTrue (union.IsUnrestricted (), "source.IsUnrestricted " + scpa.ToString ());
+				Assert.AreEqual (0, union.PermissionEntries.Count, "source.Count " + scpa.ToString ());
+			}
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void Union_BadPermission ()
+		{
+			ServiceControllerPermission scp1 = new ServiceControllerPermission (PermissionState.Unrestricted);
+			scp1.Union (new SecurityPermission (SecurityPermissionFlag.Assertion));
+		}
+
+		[Test]
+#if NET_2_0
+		[ExpectedException (typeof (ArgumentNullException))]
+#else
+		// Problem inherited from ResourcePermissionBase
+		[ExpectedException (typeof (NullReferenceException))]
+#endif
+		public void FromXml_Null ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+			scp.FromXml (null);
+		}
+
+		[Test]
+#if NET_2_0
+		[ExpectedException (typeof (ArgumentException))]
+#endif
+		public void FromXml_WrongTag ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+			SecurityElement se = scp.ToXml ();
+			se.Tag = "IMono";
+			scp.FromXml (se);
+			// note: normally IPermission classes (in corlib) DO care about the
+			// IPermission tag
+		}
+
+		[Test]
+#if NET_2_0
+		[ExpectedException (typeof (ArgumentException))]
+#endif
+		public void FromXml_WrongTagCase ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+			SecurityElement se = scp.ToXml ();
+			se.Tag = "IPERMISSION"; // instead of IPermission
+			scp.FromXml (se);
+			// note: normally IPermission classes (in corlib) DO care about the
+			// IPermission tag
+		}
+
+		[Test]
+		public void FromXml_WrongClass ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+			SecurityElement se = scp.ToXml ();
+
+			SecurityElement w = new SecurityElement (se.Tag);
+			w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
+			w.AddAttribute ("version", se.Attribute ("version"));
+			scp.FromXml (w);
+			// doesn't care of the class name at that stage
+			// anyway the class has already be created so...
+		}
+
+		[Test]
+		public void FromXml_NoClass ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+			SecurityElement se = scp.ToXml ();
+
+			SecurityElement w = new SecurityElement (se.Tag);
+			w.AddAttribute ("version", se.Attribute ("version"));
+			scp.FromXml (w);
+			// doesn't even care of the class attribute presence
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentException))]
+		public void FromXml_WrongVersion ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+			SecurityElement se = scp.ToXml ();
+			se.Attributes.Remove ("version");
+			se.Attributes.Add ("version", "2");
+			scp.FromXml (se);
+		}
+
+		[Test]
+		public void FromXml_NoVersion ()
+		{
+			ServiceControllerPermission scp = new ServiceControllerPermission (PermissionState.None);
+			SecurityElement se = scp.ToXml ();
+
+			SecurityElement w = new SecurityElement (se.Tag);
+			w.AddAttribute ("class", se.Attribute ("class"));
+			scp.FromXml (w);
+		}
+	}
+}

mcs/class/System.ServiceProcess/Test/System.ServiceProcess/ServiceControllerTest.cs.REMOVED.git-id

@@ -0,0 +1 @@
+8f5b8f6000b50c1927c8e79c4b36e834fa09ca5b