ServiceControllerTest.cs

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

https://github.com/iainlane/mono
C# | 1437 lines | 1087 code | 213 blank | 137 comment | 112 complexity | 0fa93accaf189410736ebf37b58e4bc2 MD5 | raw file

//
// ServiceControllerTest.cs -
//	NUnit Test Cases for ServiceController
//
// Author:
//	Gert Driesen  (drieseng@users.sourceforge.net)
//
// 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.
//
// TODO:
// - Status
// - Start

using System;
using System.ComponentModel;
using System.ServiceProcess;
using TimeoutException = System.ServiceProcess.TimeoutException;

using NUnit.Framework;

namespace MonoTests.System.ServiceProcess
{
	[TestFixture]
	public class ServiceControllerTest
	{
		[Test]
		public void Constructor1 ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ();

			try {
				bool value = sc.CanPauseAndContinue;
				Assert.Fail ("#A1: " + value.ToString ());
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
				Assert.IsNotNull (ex.Message, "#A3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#A4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#A5");
				Assert.IsNull (ex.ParamName, "#A6");
				Assert.IsNull (ex.InnerException, "#A7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
				Assert.IsNotNull (ex.Message, "#A3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#A4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#A5");
				Assert.IsNotNull (ex.InnerException, "#A6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#A7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#A8");
				Assert.IsNotNull (win32Error.Message, "#A9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#A10");
				Assert.IsNull (win32Error.InnerException, "#A11");
			}
#endif

			try {
				bool value = sc.CanShutdown;
				Assert.Fail ("#B1: " + value.ToString ());
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
				Assert.IsNotNull (ex.Message, "#B3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#B4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#B5");
				Assert.IsNull (ex.ParamName, "#B6");
				Assert.IsNull (ex.InnerException, "#B7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
				Assert.IsNotNull (ex.Message, "#B3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#B4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
				Assert.IsNotNull (ex.InnerException, "#B6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
				Assert.IsNotNull (win32Error.Message, "#B9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#B10");
				Assert.IsNull (win32Error.InnerException, "#B11");
			}
#endif

			try {
				bool value = sc.CanStop;
				Assert.Fail ("#C1: " + value.ToString ());
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
				Assert.IsNotNull (ex.Message, "#C3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#C4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#C5");
				Assert.IsNull (ex.ParamName, "#C6");
				Assert.IsNull (ex.InnerException, "#C7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
				Assert.IsNotNull (ex.Message, "#C3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#C4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#C5");
				Assert.IsNotNull (ex.InnerException, "#C6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#C7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#C8");
				Assert.IsNotNull (win32Error.Message, "#C9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#C10");
				Assert.IsNull (win32Error.InnerException, "#C11");
			}
#endif

			// closing the ServiceController does not result in exception
			sc.Close ();

			try {
				sc.Continue ();
				Assert.Fail ("#D1");
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
				Assert.IsNotNull (ex.Message, "#D3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#D4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#D5");
				Assert.IsNull (ex.ParamName, "#D6");
				Assert.IsNull (ex.InnerException, "#D7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
				Assert.IsNotNull (ex.Message, "#D3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#D4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#D5");
				Assert.IsNotNull (ex.InnerException, "#D6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#D7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#D8");
				Assert.IsNotNull (win32Error.Message, "#D9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#D10");
				Assert.IsNull (win32Error.InnerException, "#D11");
			}
#endif

			try {
				Assert.Fail ("#E1: " + sc.DependentServices.Length);
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
				Assert.IsNotNull (ex.Message, "#E3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#E4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#E5");
				Assert.IsNull (ex.ParamName, "#E6");
				Assert.IsNull (ex.InnerException, "#E7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
				Assert.IsNotNull (ex.Message, "#E3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#E4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#E5");
				Assert.IsNotNull (ex.InnerException, "#E6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#E7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#E8");
				Assert.IsNotNull (win32Error.Message, "#E9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#E10");
				Assert.IsNull (win32Error.InnerException, "#E11");
			}
#endif

			Assert.IsNotNull (sc.DisplayName, "#F1");
			Assert.AreEqual (string.Empty, sc.DisplayName, "#F2");

			try {
				sc.ExecuteCommand (0);
				Assert.Fail ("#G1");
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#G2");
				Assert.IsNotNull (ex.Message, "#G3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#G4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#G5");
				Assert.IsNull (ex.ParamName, "#G6");
				Assert.IsNull (ex.InnerException, "#G7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
				Assert.IsNotNull (ex.Message, "#G3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#G4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#G5");
				Assert.IsNotNull (ex.InnerException, "#G6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#G7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#G8");
				Assert.IsNotNull (win32Error.Message, "#G9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#G10");
				Assert.IsNull (win32Error.InnerException, "#G11");
			}
#endif

			Assert.IsNotNull (sc.MachineName, "#H1");
			Assert.AreEqual (".", sc.MachineName, "#H2");


			try {
				sc.Pause ();
				Assert.Fail ("#I1");
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
				Assert.IsNotNull (ex.Message, "#I3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#I4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#I5");
				Assert.IsNull (ex.ParamName, "#I6");
				Assert.IsNull (ex.InnerException, "#I7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#I2");
				Assert.IsNotNull (ex.Message, "#I3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#I4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#I5");
				Assert.IsNotNull (ex.InnerException, "#I6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#I7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#I8");
				Assert.IsNotNull (win32Error.Message, "#I9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#I10");
				Assert.IsNull (win32Error.InnerException, "#I11");
			}
#endif
		}

		[Test]
		public void Constructor2 ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("lanmanworkstation");

			Assert.IsTrue (sc.CanPauseAndContinue, "#A1");
			Assert.IsTrue (sc.CanShutdown, "#B1");
			Assert.IsTrue (sc.CanStop, "#C1");

			sc.Close ();
			sc.Continue ();

			ServiceController [] dependentServices = sc.DependentServices;
			Assert.IsNotNull (dependentServices, "#D1");
			Assert.IsTrue (dependentServices.Length > 1, "#D2");

			Assert.IsNotNull (sc.DisplayName, "#E1");
			Assert.AreEqual ("Workstation", sc.DisplayName, "#E2");

			Assert.IsNotNull (sc.MachineName, "#F1");
			Assert.AreEqual (".", sc.MachineName, "#F2");

			sc.Refresh ();

			Assert.IsNotNull (sc.ServiceName, "#G1");
			Assert.AreEqual ("lanmanworkstation", sc.ServiceName, "#G2");

			ServiceController [] servicesDependedOn = sc.ServicesDependedOn;
			Assert.IsNotNull (servicesDependedOn, "#H1");
			Assert.AreEqual (0, servicesDependedOn.Length, "#H2");

			Assert.AreEqual (ServiceType.Win32ShareProcess, sc.ServiceType, "#I1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#J1");
		}

		[Test]
		public void Constructor2_Name_Empty ()
		{
			try {
				new ServiceController (string.Empty);
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// Invalid value  for parameter name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("name") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
				Assert.IsNull (ex.InnerException, "#7");
			}
		}

		[Test]
		public void Constructor2_Name_DisplayName ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("workstation");

			Assert.IsTrue (sc.CanPauseAndContinue, "#A1");
			Assert.IsTrue (sc.CanShutdown, "#B1");
			Assert.IsTrue (sc.CanStop, "#C1");
		}

		[Test]
		public void Constructor2_Name_Null ()
		{
			try {
				new ServiceController (null);
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// Invalid value  for parameter name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("name") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
				Assert.IsNull (ex.InnerException, "#7");
			}
		}

		[Test]
		public void Constructor2_Name_ServiceName ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("lanmanworkstation");

			Assert.IsTrue (sc.CanPauseAndContinue, "#A1");
			Assert.IsTrue (sc.CanShutdown, "#B1");
			Assert.IsTrue (sc.CanStop, "#C1");
		}

		[Test]
		public void Constructor3 ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("lanmanworkstation",
				Environment.MachineName);

			Assert.IsTrue (sc.CanPauseAndContinue, "#A1");
			Assert.IsTrue (sc.CanShutdown, "#B1");
			Assert.IsTrue (sc.CanStop, "#C1");

			sc.Close ();
			sc.Continue ();

			ServiceController [] dependentServices = sc.DependentServices;
			Assert.IsNotNull (dependentServices, "#D1");
			Assert.IsTrue (dependentServices.Length > 1, "#D2");

			Assert.IsNotNull (sc.DisplayName, "#E1");
			Assert.AreEqual ("Workstation", sc.DisplayName, "#E2");

			Assert.IsNotNull (sc.MachineName, "#F1");
			Assert.AreEqual (Environment.MachineName, sc.MachineName, "#F2");

			sc.Refresh ();

			Assert.IsNotNull (sc.ServiceName, "#G1");
			Assert.AreEqual ("lanmanworkstation", sc.ServiceName, "#G2");

			ServiceController [] servicesDependedOn = sc.ServicesDependedOn;
			Assert.IsNotNull (servicesDependedOn, "#H1");
			Assert.AreEqual (0, servicesDependedOn.Length, "#H2");

			Assert.AreEqual (ServiceType.Win32ShareProcess, sc.ServiceType, "#I1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#J1");
		}

		[Test]
		public void Constructor3_MachineName_Empty ()
		{
			try {
				new ServiceController ("alerter", string.Empty);
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// MachineName value  is invalid
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
				Assert.IsNull (ex.InnerException, "#7");
			}
		}

		[Test]
		public void Constructor3_MachineName_Null ()
		{
			try {
				new ServiceController ("alerter", null);
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// MachineName value  is invalid
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
				Assert.IsNull (ex.InnerException, "#7");
			}
		}

		[Test]
		public void Constructor3_Name_Empty ()
		{
			try {
				new ServiceController (string.Empty, ".");
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// Invalid value  for parameter name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("name") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
				Assert.IsNull (ex.InnerException, "#7");
			}
		}

		[Test]
		public void Constructor3_Name_Null ()
		{
			try {
				new ServiceController (null, ".");
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// Invalid value  for parameter name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("name") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
				Assert.IsNull (ex.InnerException, "#7");
			}
		}

		[Test]
		public void CanPauseAndContinue ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule", ".");
			Assert.IsTrue (sc.CanPauseAndContinue, "#1");
			sc.ServiceName = "SamSs";
			Assert.IsFalse (sc.CanPauseAndContinue, "#2");
			sc.DisplayName = "Workstation";
			Assert.IsTrue (sc.CanPauseAndContinue, "#3");
			sc.MachineName = "doesnotexist";
			try {
				bool value = sc.CanPauseAndContinue;
				Assert.Fail ("#4: " + value.ToString ());
			} catch (InvalidOperationException ex) {
				// Cannot open Service Control Manager on computer 'doesnotexist'.
				// This operation might require other priviliges
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#5");
				Assert.IsNotNull (ex.Message, "#6");
				Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#7");
				Assert.IsNotNull (ex.InnerException, "#8");

				// The RPC server is unavailable
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#9");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#10");
				Assert.IsNotNull (win32Error.Message, "#11");
				Assert.AreEqual (1722, win32Error.NativeErrorCode, "#12");
				Assert.IsNull (win32Error.InnerException, "#13");
			}
		}

		[Test]
		public void CanPauseAndContinue_Machine_DoesNotExist ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule",
				"doesnotexist");
			try {
				bool canPauseAndContinue = sc.CanPauseAndContinue;
				Assert.Fail ("#1: " + canPauseAndContinue);
			} catch (InvalidOperationException ex) {
				// Cannot open Service Control Manager on computer 'doesnotexist'.
				// This operation might require other priviliges
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
				Assert.IsNotNull (ex.InnerException, "#5");

				// The RPC server is unavailable
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
				Assert.IsNotNull (win32Error.Message, "#8");
				Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
				Assert.IsNull (win32Error.InnerException, "#10");
			}
		}

		[Test]
		public void CanPauseAndContinue_Service_Disabled ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("NetDDE", ".");
			Assert.IsFalse (sc1.CanPauseAndContinue);
		}

		[Test]
		public void CanPauseAndContinue_Service_DoesNotExist ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("doesnotexist", ".");
			try {
				bool canPauseAndContinue = sc.CanPauseAndContinue;
				Assert.Fail ("#1: " + canPauseAndContinue);
			} catch (InvalidOperationException ex) {
				// Cannot open doesnotexist service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
				Assert.IsNotNull (ex.InnerException, "#6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
				Assert.IsNotNull (win32Error.Message, "#9");
				Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
				Assert.IsNull (win32Error.InnerException, "#11");
			}
		}

		[Test]
		public void CanPauseAndContinue_Service_OperationNotValid ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("SamSs", ".");
			Assert.IsFalse (sc1.CanPauseAndContinue);
		}

		[Test]
		public void CanPauseAndContinue_Service_Running ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule", ".");
			Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#1");
			Assert.IsTrue (sc.CanPauseAndContinue, "#2");
		}

		[Test]
		public void CanPauseAndContinue_Service_Paused ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("Schedule", ".");
			ServiceController sc2 = new ServiceController ("Schedule", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			Assert.IsTrue (sc1.CanPauseAndContinue, "#B1");
			Assert.IsTrue (sc2.CanPauseAndContinue, "#B2");

			sc1.Pause ();

			try {
				Assert.IsTrue (sc1.CanPauseAndContinue, "#C1");
				Assert.IsTrue (sc2.CanPauseAndContinue, "#C2");

				sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));

				Assert.IsTrue (sc1.CanPauseAndContinue, "#D1");
				Assert.IsTrue (sc2.CanPauseAndContinue, "#D2");
			} finally {
				EnsureServiceIsRunning (sc1);
				sc2.Refresh ();
			}

			Assert.IsTrue (sc1.CanPauseAndContinue, "#E1");
			Assert.IsTrue (sc2.CanPauseAndContinue, "#E2");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
		}

		[Test]
		public void CanPauseAndContinue_Service_Stopped ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("Schedule", ".");
			ServiceController sc2 = new ServiceController ("Schedule", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			Assert.IsTrue (sc1.CanPauseAndContinue, "#B1");
			Assert.IsTrue (sc2.CanPauseAndContinue, "#B2");

			sc1.Stop ();

			try {
				Assert.IsTrue (sc1.CanPauseAndContinue, "#C1");
				Assert.IsTrue (sc2.CanPauseAndContinue, "#C2");

				sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));

				Assert.IsFalse (sc1.CanPauseAndContinue, "#D1");
				Assert.IsTrue (sc2.CanPauseAndContinue, "#D2");
			} finally {
				EnsureServiceIsRunning (sc1);
				sc2.Refresh ();
			}

			Assert.IsTrue (sc1.CanPauseAndContinue, "#E1");
			Assert.IsTrue (sc2.CanPauseAndContinue, "#E2");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
		}

		[Test]
		public void CanPauseAndContinue_ServiceName_Empty ()
		{
#if ONLY_1_1
			if (RunningOnUnix)
				return;
#endif

			ServiceController sc = new ServiceController ();
			try {
				bool canPauseAndContinue = sc.CanPauseAndContinue;
				Assert.Fail ("#1: " + canPauseAndContinue);
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
				Assert.IsNull (ex.InnerException, "#7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
				Assert.IsNotNull (ex.InnerException, "#6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
				Assert.IsNotNull (win32Error.Message, "#9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#10");
				Assert.IsNull (win32Error.InnerException, "#11");
			}
#endif
		}

		[Test]
		public void CanShutdown ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule", ".");
			Assert.IsTrue (sc.CanShutdown, "#1");
			sc.ServiceName = "SamSs";
			Assert.IsFalse (sc.CanShutdown, "#2");
			sc.DisplayName = "Workstation";
			Assert.IsTrue (sc.CanShutdown, "#3");
			sc.MachineName = "doesnotexist";
			try {
				bool value = sc.CanShutdown;
				Assert.Fail ("#4: " + value.ToString ());
			} catch (InvalidOperationException ex) {
				// Cannot open Service Control Manager on computer 'doesnotexist'.
				// This operation might require other priviliges
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#5");
				Assert.IsNotNull (ex.Message, "#6");
				Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#7");
				Assert.IsNotNull (ex.InnerException, "#8");

				// The RPC server is unavailable
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#9");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#10");
				Assert.IsNotNull (win32Error.Message, "#11");
				Assert.AreEqual (1722, win32Error.NativeErrorCode, "#12");
				Assert.IsNull (win32Error.InnerException, "#13");
			}
		}

		[Test]
		public void CanShutdown_Machine_DoesNotExist ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule",
				"doesnotexist");
			try {
				bool canShutdown = sc.CanShutdown;
				Assert.Fail ("#1: " + canShutdown);
			} catch (InvalidOperationException ex) {
				// Cannot open Service Control Manager on computer 'doesnotexist'.
				// This operation might require other priviliges
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
				Assert.IsNotNull (ex.InnerException, "#5");

				// The RPC server is unavailable
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
				Assert.IsNotNull (win32Error.Message, "#8");
				Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
				Assert.IsNull (win32Error.InnerException, "#10");
			}
		}

		[Test]
		public void CanShutdown_Service_Disabled ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("NetDDE", ".");
			Assert.IsFalse (sc1.CanShutdown);
		}

		[Test]
		public void CanShutdown_Service_DoesNotExist ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("doesnotexist", ".");
			try {
				bool value = sc.CanShutdown;
				Assert.Fail ("#1: " + value.ToString ());
			} catch (InvalidOperationException ex) {
				// Cannot open doesnotexist service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
				Assert.IsNotNull (ex.InnerException, "#6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
				Assert.IsNotNull (win32Error.Message, "#9");
				Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
				Assert.IsNull (win32Error.InnerException, "#11");
			}
		}

		[Test]
		public void CanShutdown_Service_OperationNotValid ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("SamSs", ".");
			Assert.IsFalse (sc1.CanShutdown);
		}

		[Test]
		public void CanShutdown_Service_Running ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule", ".");
			Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#1");
			Assert.IsTrue (sc.CanShutdown, "#2");
		}

		[Test]
		public void CanShutdown_Service_Paused ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("Schedule", ".");
			ServiceController sc2 = new ServiceController ("Schedule", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			Assert.IsTrue (sc1.CanShutdown, "#B1");
			Assert.IsTrue (sc2.CanShutdown, "#B2");

			sc1.Pause ();

			try {
				Assert.IsTrue (sc1.CanShutdown, "#C1");
				Assert.IsTrue (sc2.CanShutdown, "#C2");

				sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));

				Assert.IsTrue (sc1.CanShutdown, "#D1");
				Assert.IsTrue (sc2.CanShutdown, "#D2");
			} finally {
				EnsureServiceIsRunning (sc1);
				sc2.Refresh ();
			}

			Assert.IsTrue (sc1.CanShutdown, "#E1");
			Assert.IsTrue (sc2.CanShutdown, "#E2");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
		}

		[Test]
		public void CanShutdown_Service_Stopped ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("Schedule", ".");
			ServiceController sc2 = new ServiceController ("Schedule", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			Assert.IsTrue (sc1.CanShutdown, "#B1");
			Assert.IsTrue (sc2.CanShutdown, "#B2");

			sc1.Stop ();

			try {
				Assert.IsTrue (sc1.CanShutdown, "#C1");
				Assert.IsTrue (sc2.CanShutdown, "#C2");

				sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));

				Assert.IsFalse (sc1.CanShutdown, "#D1");
				Assert.IsTrue (sc2.CanShutdown, "#D2");
			} finally {
				EnsureServiceIsRunning (sc1);
				sc2.Refresh ();
			}

			Assert.IsTrue (sc1.CanShutdown, "#E1");
			Assert.IsTrue (sc2.CanShutdown, "#E2");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
		}

		[Test]
		public void CanShutdown_ServiceName_Empty ()
		{
#if ONLY_1_1
			if (RunningOnUnix)
				return;
#endif

			ServiceController sc = new ServiceController ();
			try {
				bool canShutdown = sc.CanShutdown;
				Assert.Fail ("#1: " + canShutdown);
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
				Assert.IsNull (ex.InnerException, "#7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
				Assert.IsNotNull (ex.InnerException, "#6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
				Assert.IsNotNull (win32Error.Message, "#9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#10");
				Assert.IsNull (win32Error.InnerException, "#11");
			}
#endif
		}

		[Test]
		public void CanStop ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule", ".");
			Assert.IsTrue (sc.CanStop, "#1");
			sc.ServiceName = "SamSs";
			Assert.IsFalse (sc.CanStop, "#2");
			sc.DisplayName = "Workstation";
			Assert.IsTrue (sc.CanStop, "#3");
			sc.MachineName = "doesnotexist";
			try {
				bool value = sc.CanStop;
				Assert.Fail ("#4: " + value.ToString ());
			} catch (InvalidOperationException ex) {
				// Cannot open Service Control Manager on computer 'doesnotexist'.
				// This operation might require other priviliges
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#5");
				Assert.IsNotNull (ex.Message, "#6");
				Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#7");
				Assert.IsNotNull (ex.InnerException, "#8");

				// The RPC server is unavailable
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#9");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#10");
				Assert.IsNotNull (win32Error.Message, "#11");
				Assert.AreEqual (1722, win32Error.NativeErrorCode, "#12");
				Assert.IsNull (win32Error.InnerException, "#13");
			}
		}

		[Test]
		public void CanStop_Machine_DoesNotExist ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule",
				"doesnotexist");
			try {
				bool canStop = sc.CanStop;
				Assert.Fail ("#1: " + canStop);
			} catch (InvalidOperationException ex) {
				// Cannot open Service Control Manager on computer 'doesnotexist'.
				// This operation might require other priviliges
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
				Assert.IsNotNull (ex.InnerException, "#5");

				// The RPC server is unavailable
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
				Assert.IsNotNull (win32Error.Message, "#8");
				Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
				Assert.IsNull (win32Error.InnerException, "#10");
			}
		}

		[Test]
		public void CanStop_Service_Disabled ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("NetDDE", ".");
			Assert.IsFalse (sc1.CanStop);
		}

		[Test]
		public void CanStop_Service_DoesNotExist ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("doesnotexist", ".");
			try {
				bool canStop = sc.CanStop;
				Assert.Fail ("#1: " + canStop);
			} catch (InvalidOperationException ex) {
				// Cannot open doesnotexist service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
				Assert.IsNotNull (ex.InnerException, "#6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
				Assert.IsNotNull (win32Error.Message, "#9");
				Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
				Assert.IsNull (win32Error.InnerException, "#11");
			}
		}

		[Test]
		public void CanStop_Service_OperationNotValid ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("SamSs", ".");
			Assert.IsFalse (sc1.CanStop);
		}

		[Test]
		public void CanStop_Service_Running ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule", ".");
			Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#1");
			Assert.IsTrue (sc.CanStop, "#2");
		}

		[Test]
		public void CanStop_Service_Paused ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("Schedule", ".");
			ServiceController sc2 = new ServiceController ("Schedule", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			Assert.IsTrue (sc1.CanStop, "#B1");
			Assert.IsTrue (sc2.CanStop, "#B2");

			sc1.Pause ();

			try {
				Assert.IsTrue (sc1.CanStop, "#C1");
				Assert.IsTrue (sc2.CanStop, "#C2");

				sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));

				Assert.IsTrue (sc1.CanStop, "#D1");
				Assert.IsTrue (sc2.CanStop, "#D2");
			} finally {
				EnsureServiceIsRunning (sc1);
				sc2.Refresh ();
			}

			Assert.IsTrue (sc1.CanStop, "#E1");
			Assert.IsTrue (sc2.CanStop, "#E2");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
		}

		[Test]
		public void CanStop_Service_Stopped ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("Schedule", ".");
			ServiceController sc2 = new ServiceController ("Schedule", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			Assert.IsTrue (sc1.CanStop, "#B1");
			Assert.IsTrue (sc2.CanStop, "#B2");

			sc1.Stop ();

			try {
				Assert.IsTrue (sc1.CanStop, "#C1");
				Assert.IsTrue (sc2.CanStop, "#C2");

				sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));

				Assert.IsFalse (sc1.CanStop, "#D1");
				Assert.IsTrue (sc2.CanStop, "#D2");
			} finally {
				EnsureServiceIsRunning (sc1);
				sc2.Refresh ();
			}

			Assert.IsTrue (sc1.CanShutdown, "#E1");
			Assert.IsTrue (sc2.CanShutdown, "#E2");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
		}

		[Test]
		public void CanStop_ServiceName_Empty ()
		{
#if ONLY_1_1
			if (RunningOnUnix)
				return;
#endif

			ServiceController sc = new ServiceController ();
			try {
				bool canStop = sc.CanStop;
				Assert.Fail ("#1: " + canStop);
#if NET_2_0
			} catch (ArgumentException ex) {
				// Service name  contains invalid characters, is empty or is
				// too long (max length = 80)
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
				Assert.IsNull (ex.InnerException, "#7");
			}
#else
			} catch (InvalidOperationException ex) {
				// Cannot open  service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
				Assert.IsNotNull (ex.InnerException, "#6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
				Assert.IsNotNull (win32Error.Message, "#9");
				Assert.AreEqual (123, win32Error.NativeErrorCode, "#10");
				Assert.IsNull (win32Error.InnerException, "#11");
			}
#endif
		}

		[Test]
		public void Continue ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("Schedule", ".");
			ServiceController sc2 = new ServiceController ("Schedule", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			sc1.Pause ();

			try {
				Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
				Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");

				sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));

				Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#C1");
				Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");

				sc1.Continue ();

				Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#D1");
				Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");

				sc1.WaitForStatus (ServiceControllerStatus.Running, new TimeSpan (0, 0, 5));

				Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#E1");
				Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#E2");
			} finally {
				EnsureServiceIsRunning (sc1);
				sc2.Refresh ();
			}
		}

		[Test]
		public void Continue_Machine_DoesNotExist ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("Schedule",
				"doesnotexist");
			try {
				sc.Continue ();
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Cannot open Service Control Manager on computer 'doesnotexist'.
				// This operation might require other priviliges
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
				Assert.IsNotNull (ex.InnerException, "#5");

				// The RPC server is unavailable
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
				Assert.IsNotNull (win32Error.Message, "#8");
				Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
				Assert.IsNull (win32Error.InnerException, "#10");
			}
		}

		[Test]
		public void Continue_Service_Disabled ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("NetDDE", ".");
			ServiceController sc2 = new ServiceController ("NetDDE", ".");

			Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#A2");

			try {
				sc1.Continue ();
				Assert.Fail ("#B1");
			} catch (InvalidOperationException ex) {
				// Cannot resume NetDDE service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
				Assert.IsNotNull (ex.Message, "#B3");
				Assert.IsTrue (ex.Message.IndexOf ("NetDDE") != -1, "#B4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
				Assert.IsNotNull (ex.InnerException, "#B6");

				// The service has not been started
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
				Assert.IsNotNull (win32Error.Message, "#B9");
				Assert.AreEqual (1062, win32Error.NativeErrorCode, "#B10");
				Assert.IsNull (win32Error.InnerException, "#B11");
			}

			Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
			Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#C2");
		}

		[Test]
		public void Continue_Service_DoesNotExist ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc = new ServiceController ("doesnotexist", ".");
			try {
				sc.Continue ();
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Cannot open doesnotexist service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
				Assert.IsNotNull (ex.InnerException, "#6");

				// The filename, directory name, or volume label is incorrect
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
				Assert.IsNotNull (win32Error.Message, "#9");
				Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
				Assert.IsNull (win32Error.InnerException, "#11");
			}
		}

		[Test]
		public void Continue_Service_OperationNotValid ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("SamSs", ".");
			ServiceController sc2 = new ServiceController ("SamSs", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			try {
				sc1.Continue ();
				Assert.Fail ("#B1");
			} catch (InvalidOperationException ex) {
				// Cannot resume SamSs service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
				Assert.IsNotNull (ex.Message, "#B3");
				Assert.IsTrue (ex.Message.IndexOf ("SamSs") != -1, "#B4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
				Assert.IsNotNull (ex.InnerException, "#B6");

				// The requested control is not valid for this service
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
				Assert.IsNotNull (win32Error.Message, "#B9");
				Assert.AreEqual (1052, win32Error.NativeErrorCode, "#B10");
				Assert.IsNull (win32Error.InnerException, "#B11");
			}

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#C1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
		}

		[Test]
		public void Continue_Service_Running ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("Schedule", ".");
			ServiceController sc2 = new ServiceController ("Schedule", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			sc1.Continue ();

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
		}

		[Test]
		public void Continue_Service_Stopped ()
		{
			if (RunningOnUnix)
				return;

			ServiceController sc1 = new ServiceController ("Schedule", ".");
			ServiceController sc2 = new ServiceController ("Schedule", ".");

			Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
			Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");

			sc1.Stop ();

			try {
				Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
				Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");

				sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));

				Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
				Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");

				sc1.Continue ();
				Assert.Fail ("#D1");
			} catch (InvalidOperationException ex) {
				// Cannot resume Schedule service on computer '.'
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
				Assert.IsNotNull (ex.Message, "#D3");
				Assert.IsTrue (ex.Message.IndexOf ("Schedule") != -1, "#D4");
				Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#D5");
				Assert.IsNotNull (ex.InnerException, "#D6");

				// The service has not been started
				Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#D7");
				Win32Exception win32Error = (Win32Exception) ex.InnerException;
				//Assert.AreEqual (-2147467259, win32E