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

   1 //
   2 // ServiceControllerTest.cs -
   3 //      NUnit Test Cases for ServiceController
   4 //
   5 // Author:
   6 //      Gert Driesen  (drieseng@users.sourceforge.net)
   7 //
   8 // Copyright (C) 2006 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29 // TODO:
  30 // - Status
  31 // - Start
  32
  33 using System;
  34 using System.Collections.Generic;
  35 using System.ComponentModel;
  36 using System.ServiceProcess;
  37 using TimeoutException = System.ServiceProcess.TimeoutException;
  38
  39 using NUnit.Framework;
  40
  41 namespace MonoTests.System.ServiceProcess
  42 {
  43         [TestFixture]
  44         public class ServiceControllerTest
  45         {
  46                 class ServiceInfo
  47                 {
  48                         public string ServiceName;
  49                         public string DisplayName;
  50                         public ServiceType ServiceType = ServiceType.Win32ShareProcess;
  51                         public string[] Dependents = new string[] {};
  52                         public string[] DependedOn = new string[] {};
  53                 }
  54
  55                 // NOTE: information about these services is current as of Windows 10 / Server 2016,
  56                 // it may be different and cause test failures on other Windows versions
  57
  58                 static ServiceInfo DISK_DRIVER_SERVICE = new ServiceInfo { ServiceName = "disk", DisplayName = "Disk Driver", ServiceType = ServiceType.KernelDriver };
  59                 static ServiceInfo ROUTING_AND_REMOTE_ACCESS_SERVICE = new ServiceInfo { ServiceName = "RemoteAccess", DisplayName = "Routing and Remote Access", DependedOn = new [] { "bfe", "http", "rasman", "rpcss" } };
  60                 static ServiceInfo SECONDARY_LOGON_SERVICE = new ServiceInfo { ServiceName = "seclogon", DisplayName = "Secondary Logon", Dependents = new [] { "te.service" } };
  61                 static ServiceInfo SECURITY_ACCOUNTS_MANAGER_SERVICE = new ServiceInfo { ServiceName = "SamSs", DisplayName = "Security Accounts Manager", Dependents = new [] { "browser", "ktmrm", "lanmanserver", "msdtc" }, DependedOn = new [] { "rpcss" } };
  62                 static ServiceInfo COMPLUS_EVENTSYSTEM_SERVICE = new ServiceInfo { ServiceName = "EventSystem", DisplayName = "COM+ Event System", ServiceType = ServiceType.Win32ShareProcess, Dependents = new [] { "comsysapp", "sens" }, DependedOn = new [] { "rpcss" } };
  63                 static ServiceInfo WINDOWS_IMAGE_ACQUISITION_SERVICE = new ServiceInfo { ServiceName = "stisvc", DisplayName = "Windows Image Acquisition (WIA)", ServiceType = ServiceType.Win32OwnProcess, DependedOn = new [] { "rpcss" } };
  64                 static ServiceInfo WINDOWS_SEARCH_SERVICE = new ServiceInfo { ServiceName = "WSearch", DisplayName = "Windows Search", ServiceType = ServiceType.Win32OwnProcess, Dependents = new [] { "wmpnetworksvc", "workfolderssvc" }, DependedOn = new [] { "rpcss" } };
  65                 static ServiceInfo WINDOWS_TIME_SERVICE = new ServiceInfo { ServiceName = "W32Time", DisplayName = "Windows Time" };
  66                 static ServiceInfo WINDOWS_UPDATE_SERVICE = new ServiceInfo { ServiceName = "wuauserv", DisplayName = "Windows Update", DependedOn = new [] { "rpcss" } };
  67                 static ServiceInfo WORKSTATION_SERVICE = new ServiceInfo { ServiceName = "LanmanWorkstation", DisplayName = "Workstation", Dependents = new [] { "browser", "netlogon", "sessionenv" }, DependedOn = new [] { "bowser", "mrxsmb20", "nsi" } };
  68
  69                 // A service which is expected to be disabled by default on all supported Windows versions.
  70                 static ServiceInfo DISABLED_SERVICE = ROUTING_AND_REMOTE_ACCESS_SERVICE;
  71                 // A service which is running by default and can be stopped/paused by the current user when running with admin rights.
  72                 static ServiceInfo CONTROLLABLE_SERVICE = WINDOWS_IMAGE_ACQUISITION_SERVICE;
  73                 // A service which cannot be stopped/paused.
  74                 static ServiceInfo UNCONTROLLABLE_SERVICE = SECURITY_ACCOUNTS_MANAGER_SERVICE;
  75                 // A service with ServiceType == KernelDriver
  76                 static ServiceInfo KERNEL_SERVICE = DISK_DRIVER_SERVICE;
  77                 // A service with ServiceType == Win32ShareProcess.
  78                 static ServiceInfo SHARE_PROCESS_SERVICE = WORKSTATION_SERVICE;
  79
  80                 static ServiceInfo SERVICE_1_WITH_DEPENDENTS_AND_DEPENDED_ON = SECURITY_ACCOUNTS_MANAGER_SERVICE;
  81                 static ServiceInfo SERVICE_2_WITH_DEPENDENTS_AND_DEPENDED_ON = COMPLUS_EVENTSYSTEM_SERVICE;
  82                 static ServiceInfo SERVICE_3_WITH_DEPENDENTS_AND_DEPENDED_ON = WORKSTATION_SERVICE;
  83
  84                 static ServiceInfo SERVICE_WITH_MANY_DEPENDENTS = WORKSTATION_SERVICE;
  85                 static ServiceInfo SERVICE_WITH_ONE_DEPENDENT = SECONDARY_LOGON_SERVICE;
  86                 static ServiceInfo SERVICE_WITH_NO_DEPENDENTS = WINDOWS_TIME_SERVICE;
  87
  88                 static ServiceInfo SERVICE_WITH_MANY_DEPENDED_ON = WORKSTATION_SERVICE;
  89                 static ServiceInfo SERVICE_WITH_ONE_DEPENDED_ON = WINDOWS_UPDATE_SERVICE;
  90                 static ServiceInfo SERVICE_WITH_NO_DEPENDED_ON = WINDOWS_TIME_SERVICE;
  91
  92                 [TestFixtureSetUp]
  93                 public void FixtureSetUp ()
  94                 {
  95                         try {
  96                                 EnsureServiceIsRunning (new ServiceController (CONTROLLABLE_SERVICE.ServiceName));
  97                         } catch {
  98                                 Assert.Ignore ($"Failed to start the service '{CONTROLLABLE_SERVICE.DisplayName}'. Ensure you are running the tests with admin privileges.");
  99                         }
 100                 }
 101
 102                 [Test]
 103                 public void Constructor1 ()
 104                 {
 105                         if (RunningOnUnix)
 106                                 Assert.Ignore ("Running on Unix.");
 107
 108                         ServiceController sc = new ServiceController ();
 109
 110                         try {
 111                                 bool value = sc.CanPauseAndContinue;
 112                                 Assert.Fail ("#A1: " + value.ToString ());
 113                         } catch (ArgumentException ex) {
 114                                 // Service name  contains invalid characters, is empty or is
 115                                 // too long (max length = 80)
 116                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 117                                 Assert.IsNotNull (ex.Message, "#A3");
 118                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#A4");
 119                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#A5");
 120                                 Assert.IsNull (ex.ParamName, "#A6");
 121                                 Assert.IsNull (ex.InnerException, "#A7");
 122                         }
 123
 124                         try {
 125                                 bool value = sc.CanShutdown;
 126                                 Assert.Fail ("#B1: " + value.ToString ());
 127                         } catch (ArgumentException ex) {
 128                                 // Service name  contains invalid characters, is empty or is
 129                                 // too long (max length = 80)
 130                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 131                                 Assert.IsNotNull (ex.Message, "#B3");
 132                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#B4");
 133                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#B5");
 134                                 Assert.IsNull (ex.ParamName, "#B6");
 135                                 Assert.IsNull (ex.InnerException, "#B7");
 136                         }
 137
 138                         try {
 139                                 bool value = sc.CanStop;
 140                                 Assert.Fail ("#C1: " + value.ToString ());
 141                         } catch (ArgumentException ex) {
 142                                 // Service name  contains invalid characters, is empty or is
 143                                 // too long (max length = 80)
 144                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 145                                 Assert.IsNotNull (ex.Message, "#C3");
 146                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#C4");
 147                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#C5");
 148                                 Assert.IsNull (ex.ParamName, "#C6");
 149                                 Assert.IsNull (ex.InnerException, "#C7");
 150                         }
 151
 152                         // closing the ServiceController does not result in exception
 153                         sc.Close ();
 154
 155                         try {
 156                                 sc.Continue ();
 157                                 Assert.Fail ("#D1");
 158                         } catch (ArgumentException ex) {
 159                                 // Service name  contains invalid characters, is empty or is
 160                                 // too long (max length = 80)
 161                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 162                                 Assert.IsNotNull (ex.Message, "#D3");
 163                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#D4");
 164                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#D5");
 165                                 Assert.IsNull (ex.ParamName, "#D6");
 166                                 Assert.IsNull (ex.InnerException, "#D7");
 167                         }
 168
 169                         try {
 170                                 Assert.Fail ("#E1: " + sc.DependentServices.Length);
 171                         } catch (ArgumentException ex) {
 172                                 // Service name  contains invalid characters, is empty or is
 173                                 // too long (max length = 80)
 174                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
 175                                 Assert.IsNotNull (ex.Message, "#E3");
 176                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#E4");
 177                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#E5");
 178                                 Assert.IsNull (ex.ParamName, "#E6");
 179                                 Assert.IsNull (ex.InnerException, "#E7");
 180                         }
 181
 182                         Assert.IsNotNull (sc.DisplayName, "#F1");
 183                         Assert.AreEqual (string.Empty, sc.DisplayName, "#F2");
 184
 185                         try {
 186                                 sc.ExecuteCommand (0);
 187                                 Assert.Fail ("#G1");
 188                         } catch (ArgumentException ex) {
 189                                 // Service name  contains invalid characters, is empty or is
 190                                 // too long (max length = 80)
 191                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#G2");
 192                                 Assert.IsNotNull (ex.Message, "#G3");
 193                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#G4");
 194                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#G5");
 195                                 Assert.IsNull (ex.ParamName, "#G6");
 196                                 Assert.IsNull (ex.InnerException, "#G7");
 197                         }
 198
 199                         Assert.IsNotNull (sc.MachineName, "#H1");
 200                         Assert.AreEqual (".", sc.MachineName, "#H2");
 201
 202
 203                         try {
 204                                 sc.Pause ();
 205                                 Assert.Fail ("#I1");
 206                         } catch (ArgumentException ex) {
 207                                 // Service name  contains invalid characters, is empty or is
 208                                 // too long (max length = 80)
 209                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#I2");
 210                                 Assert.IsNotNull (ex.Message, "#I3");
 211                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#I4");
 212                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#I5");
 213                                 Assert.IsNull (ex.ParamName, "#I6");
 214                                 Assert.IsNull (ex.InnerException, "#I7");
 215                         }
 216                 }
 217
 218                 [Test]
 219                 public void Constructor2 ()
 220                 {
 221                         if (RunningOnUnix)
 222                                 Assert.Ignore ("Running on Unix.");
 223
 224                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName);
 225
 226                         Assert.IsTrue (sc.CanPauseAndContinue, "#A1");
 227                         Assert.IsTrue (sc.CanShutdown, "#B1");
 228                         Assert.IsTrue (sc.CanStop, "#C1");
 229
 230                         sc.Close ();
 231                         sc.Continue ();
 232
 233                         ServiceController [] dependentServices = sc.DependentServices;
 234                         Assert.IsNotNull (dependentServices, "#D1");
 235                         Assert.AreEqual (CONTROLLABLE_SERVICE.Dependents, ServiceNames (dependentServices), "#D2");
 236
 237                         Assert.IsNotNull (sc.DisplayName, "#E1");
 238                         Assert.AreEqual (CONTROLLABLE_SERVICE.DisplayName, sc.DisplayName, "#E2");
 239
 240                         Assert.IsNotNull (sc.MachineName, "#F1");
 241                         Assert.AreEqual (".", sc.MachineName, "#F2");
 242
 243                         sc.Refresh ();
 244
 245                         Assert.IsNotNull (sc.ServiceName, "#G1");
 246                         Assert.AreEqual (CONTROLLABLE_SERVICE.ServiceName, sc.ServiceName, "#G2");
 247
 248                         ServiceController [] servicesDependedOn = sc.ServicesDependedOn;
 249                         Assert.IsNotNull (servicesDependedOn, "#H1");
 250                         Assert.AreEqual (CONTROLLABLE_SERVICE.DependedOn, ServiceNames (servicesDependedOn), "#H2");
 251
 252                         Assert.AreEqual (CONTROLLABLE_SERVICE.ServiceType, sc.ServiceType, "#I1");
 253                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#J1");
 254                 }
 255
 256                 [Test]
 257                 public void Constructor2_Name_Empty ()
 258                 {
 259                         try {
 260                                 new ServiceController (string.Empty);
 261                                 Assert.Fail ("#1");
 262                         } catch (ArgumentException ex) {
 263                                 // Invalid value  for parameter name
 264                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 265                                 Assert.IsNotNull (ex.Message, "#3");
 266                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
 267                                 Assert.IsTrue (ex.Message.IndexOf ("name") != -1, "#5");
 268                                 Assert.IsNull (ex.ParamName, "#6");
 269                                 Assert.IsNull (ex.InnerException, "#7");
 270                         }
 271                 }
 272
 273                 [Test]
 274                 public void Constructor2_Name_DisplayName ()
 275                 {
 276                         if (RunningOnUnix)
 277                                 Assert.Ignore ("Running on Unix.");
 278
 279                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.DisplayName);
 280
 281                         Assert.IsTrue (sc.CanPauseAndContinue, "#A1");
 282                         Assert.IsTrue (sc.CanShutdown, "#B1");
 283                         Assert.IsTrue (sc.CanStop, "#C1");
 284                 }
 285
 286                 [Test]
 287                 public void Constructor2_Name_Null ()
 288                 {
 289                         try {
 290                                 new ServiceController (null);
 291                                 Assert.Fail ("#1");
 292                         } catch (ArgumentException ex) {
 293                                 // Invalid value  for parameter name
 294                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 295                                 Assert.IsNotNull (ex.Message, "#3");
 296                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
 297                                 Assert.IsTrue (ex.Message.IndexOf ("name") != -1, "#5");
 298                                 Assert.IsNull (ex.ParamName, "#6");
 299                                 Assert.IsNull (ex.InnerException, "#7");
 300                         }
 301                 }
 302
 303                 [Test]
 304                 public void Constructor2_Name_ServiceName ()
 305                 {
 306                         if (RunningOnUnix)
 307                                 Assert.Ignore ("Running on Unix.");
 308
 309                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName);
 310
 311                         Assert.IsTrue (sc.CanPauseAndContinue, "#A1");
 312                         Assert.IsTrue (sc.CanShutdown, "#B1");
 313                         Assert.IsTrue (sc.CanStop, "#C1");
 314                 }
 315
 316                 [Test]
 317                 public void Constructor3 ()
 318                 {
 319                         if (RunningOnUnix)
 320                                 Assert.Ignore ("Running on Unix.");
 321
 322                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
 323                                 Environment.MachineName);
 324
 325                         Assert.IsTrue (sc.CanPauseAndContinue, "#A1");
 326                         Assert.IsTrue (sc.CanShutdown, "#B1");
 327                         Assert.IsTrue (sc.CanStop, "#C1");
 328
 329                         sc.Close ();
 330                         sc.Continue ();
 331
 332                         ServiceController [] dependentServices = sc.DependentServices;
 333                         Assert.IsNotNull (dependentServices, "#D1");
 334                         Assert.AreEqual (CONTROLLABLE_SERVICE.Dependents, ServiceNames (dependentServices), "#D2");
 335
 336                         Assert.IsNotNull (sc.DisplayName, "#E1");
 337                         Assert.AreEqual (CONTROLLABLE_SERVICE.DisplayName, sc.DisplayName, "#E2");
 338
 339                         Assert.IsNotNull (sc.MachineName, "#F1");
 340                         Assert.AreEqual (Environment.MachineName, sc.MachineName, "#F2");
 341
 342                         sc.Refresh ();
 343
 344                         Assert.IsNotNull (sc.ServiceName, "#G1");
 345                         Assert.AreEqual (CONTROLLABLE_SERVICE.ServiceName, sc.ServiceName, "#G2");
 346
 347                         ServiceController [] servicesDependedOn = sc.ServicesDependedOn;
 348                         Assert.IsNotNull (servicesDependedOn, "#H1");
 349                         Assert.AreEqual (CONTROLLABLE_SERVICE.DependedOn, ServiceNames (servicesDependedOn), "#H2");
 350
 351                         Assert.AreEqual (CONTROLLABLE_SERVICE.ServiceType, sc.ServiceType, "#I1");
 352                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#J1");
 353                 }
 354
 355                 [Test]
 356                 public void Constructor3_MachineName_Empty ()
 357                 {
 358                         try {
 359                                 new ServiceController (CONTROLLABLE_SERVICE.ServiceName, string.Empty);
 360                                 Assert.Fail ("#1");
 361                         } catch (ArgumentException ex) {
 362                                 // MachineName value  is invalid
 363                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 364                                 Assert.IsNotNull (ex.Message, "#3");
 365                                 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
 366                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
 367                                 Assert.IsNull (ex.ParamName, "#6");
 368                                 Assert.IsNull (ex.InnerException, "#7");
 369                         }
 370                 }
 371
 372                 [Test]
 373                 public void Constructor3_MachineName_Null ()
 374                 {
 375                         try {
 376                                 new ServiceController (CONTROLLABLE_SERVICE.ServiceName, null);
 377                                 Assert.Fail ("#1");
 378                         } catch (ArgumentException ex) {
 379                                 // MachineName value  is invalid
 380                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 381                                 Assert.IsNotNull (ex.Message, "#3");
 382                                 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
 383                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
 384                                 Assert.IsNull (ex.ParamName, "#6");
 385                                 Assert.IsNull (ex.InnerException, "#7");
 386                         }
 387                 }
 388
 389                 [Test]
 390                 public void Constructor3_Name_Empty ()
 391                 {
 392                         try {
 393                                 new ServiceController (string.Empty, ".");
 394                                 Assert.Fail ("#1");
 395                         } catch (ArgumentException ex) {
 396                                 // Invalid value  for parameter name
 397                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 398                                 Assert.IsNotNull (ex.Message, "#3");
 399                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
 400                                 Assert.IsTrue (ex.Message.IndexOf ("name") != -1, "#5");
 401                                 Assert.IsNull (ex.ParamName, "#6");
 402                                 Assert.IsNull (ex.InnerException, "#7");
 403                         }
 404                 }
 405
 406                 [Test]
 407                 public void Constructor3_Name_Null ()
 408                 {
 409                         try {
 410                                 new ServiceController (null, ".");
 411                                 Assert.Fail ("#1");
 412                         } catch (ArgumentException ex) {
 413                                 // Invalid value  for parameter name
 414                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 415                                 Assert.IsNotNull (ex.Message, "#3");
 416                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
 417                                 Assert.IsTrue (ex.Message.IndexOf ("name") != -1, "#5");
 418                                 Assert.IsNull (ex.ParamName, "#6");
 419                                 Assert.IsNull (ex.InnerException, "#7");
 420                         }
 421                 }
 422
 423                 [Test]
 424                 public void CanPauseAndContinue ()
 425                 {
 426                         if (RunningOnUnix)
 427                                 Assert.Ignore ("Running on Unix.");
 428
 429                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 430                         Assert.IsTrue (sc.CanPauseAndContinue, "#1");
 431                         sc.ServiceName = UNCONTROLLABLE_SERVICE.ServiceName;
 432                         Assert.IsFalse (sc.CanPauseAndContinue, "#2");
 433                         sc.DisplayName = CONTROLLABLE_SERVICE.DisplayName;
 434                         Assert.IsTrue (sc.CanPauseAndContinue, "#3");
 435                         sc.MachineName = "doesnotexist";
 436                         try {
 437                                 bool value = sc.CanPauseAndContinue;
 438                                 Assert.Fail ("#4: " + value.ToString ());
 439                         } catch (InvalidOperationException ex) {
 440                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
 441                                 // This operation might require other priviliges
 442                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#5");
 443                                 Assert.IsNotNull (ex.Message, "#6");
 444                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#7");
 445                                 Assert.IsNotNull (ex.InnerException, "#8");
 446
 447                                 // The RPC server is unavailable
 448                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#9");
 449                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
 450                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#10");
 451                                 Assert.IsNotNull (win32Error.Message, "#11");
 452                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#12");
 453                                 Assert.IsNull (win32Error.InnerException, "#13");
 454                         }
 455                 }
 456
 457                 [Test]
 458                 public void CanPauseAndContinue_Machine_DoesNotExist ()
 459                 {
 460                         if (RunningOnUnix)
 461                                 Assert.Ignore ("Running on Unix.");
 462
 463                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
 464                                 "doesnotexist");
 465                         try {
 466                                 bool canPauseAndContinue = sc.CanPauseAndContinue;
 467                                 Assert.Fail ("#1: " + canPauseAndContinue);
 468                         } catch (InvalidOperationException ex) {
 469                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
 470                                 // This operation might require other priviliges
 471                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 472                                 Assert.IsNotNull (ex.Message, "#3");
 473                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
 474                                 Assert.IsNotNull (ex.InnerException, "#5");
 475
 476                                 // The RPC server is unavailable
 477                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
 478                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
 479                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
 480                                 Assert.IsNotNull (win32Error.Message, "#8");
 481                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
 482                                 Assert.IsNull (win32Error.InnerException, "#10");
 483                         }
 484                 }
 485
 486                 [Test]
 487                 public void CanPauseAndContinue_Service_Disabled ()
 488                 {
 489                         if (RunningOnUnix)
 490                                 Assert.Ignore ("Running on Unix.");
 491
 492                         ServiceController sc1 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
 493                         Assert.IsFalse (sc1.CanPauseAndContinue);
 494                 }
 495
 496                 [Test]
 497                 public void CanPauseAndContinue_Service_DoesNotExist ()
 498                 {
 499                         if (RunningOnUnix)
 500                                 Assert.Ignore ("Running on Unix.");
 501
 502                         ServiceController sc = new ServiceController ("doesnotexist", ".");
 503                         try {
 504                                 bool canPauseAndContinue = sc.CanPauseAndContinue;
 505                                 Assert.Fail ("#1: " + canPauseAndContinue);
 506                         } catch (InvalidOperationException ex) {
 507                                 // Cannot open doesnotexist service on computer '.'
 508                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 509                                 Assert.IsNotNull (ex.Message, "#3");
 510                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
 511                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
 512                                 Assert.IsNotNull (ex.InnerException, "#6");
 513
 514                                 // The filename, directory name, or volume label is incorrect
 515                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
 516                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
 517                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
 518                                 Assert.IsNotNull (win32Error.Message, "#9");
 519                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
 520                                 Assert.IsNull (win32Error.InnerException, "#11");
 521                         }
 522                 }
 523
 524                 [Test]
 525                 public void CanPauseAndContinue_Service_OperationNotValid ()
 526                 {
 527                         if (RunningOnUnix)
 528                                 Assert.Ignore ("Running on Unix.");
 529
 530                         ServiceController sc1 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
 531                         Assert.IsFalse (sc1.CanPauseAndContinue);
 532                 }
 533
 534                 [Test]
 535                 public void CanPauseAndContinue_Service_Running ()
 536                 {
 537                         if (RunningOnUnix)
 538                                 Assert.Ignore ("Running on Unix.");
 539
 540                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 541                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#1");
 542                         Assert.IsTrue (sc.CanPauseAndContinue, "#2");
 543                 }
 544
 545                 [Test]
 546                 public void CanPauseAndContinue_Service_Paused ()
 547                 {
 548                         if (RunningOnUnix)
 549                                 Assert.Ignore ("Running on Unix.");
 550
 551                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 552                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 553
 554                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
 555                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
 556
 557                         Assert.IsTrue (sc1.CanPauseAndContinue, "#B1");
 558                         Assert.IsTrue (sc2.CanPauseAndContinue, "#B2");
 559
 560                         sc1.Pause ();
 561
 562                         try {
 563                                 Assert.IsTrue (sc1.CanPauseAndContinue, "#C1");
 564                                 Assert.IsTrue (sc2.CanPauseAndContinue, "#C2");
 565
 566                                 sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
 567
 568                                 Assert.IsTrue (sc1.CanPauseAndContinue, "#D1");
 569                                 Assert.IsTrue (sc2.CanPauseAndContinue, "#D2");
 570                         } finally {
 571                                 EnsureServiceIsRunning (sc1);
 572                                 sc2.Refresh ();
 573                         }
 574
 575                         Assert.IsTrue (sc1.CanPauseAndContinue, "#E1");
 576                         Assert.IsTrue (sc2.CanPauseAndContinue, "#E2");
 577
 578                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
 579                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
 580                 }
 581
 582                 [Test]
 583                 public void CanPauseAndContinue_Service_Stopped ()
 584                 {
 585                         if (RunningOnUnix)
 586                                 Assert.Ignore ("Running on Unix.");
 587
 588                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 589                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 590
 591                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
 592                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
 593
 594                         Assert.IsTrue (sc1.CanPauseAndContinue, "#B1");
 595                         Assert.IsTrue (sc2.CanPauseAndContinue, "#B2");
 596
 597                         sc1.Stop ();
 598
 599                         try {
 600                                 Assert.IsTrue (sc1.CanPauseAndContinue, "#C1");
 601                                 Assert.IsTrue (sc2.CanPauseAndContinue, "#C2");
 602
 603                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
 604
 605                                 Assert.IsFalse (sc1.CanPauseAndContinue, "#D1");
 606                                 Assert.IsTrue (sc2.CanPauseAndContinue, "#D2");
 607                         } finally {
 608                                 EnsureServiceIsRunning (sc1);
 609                                 sc2.Refresh ();
 610                         }
 611
 612                         Assert.IsTrue (sc1.CanPauseAndContinue, "#E1");
 613                         Assert.IsTrue (sc2.CanPauseAndContinue, "#E2");
 614
 615                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
 616                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
 617                 }
 618
 619                 [Test]
 620                 public void CanPauseAndContinue_ServiceName_Empty ()
 621                 {
 622                         ServiceController sc = new ServiceController ();
 623                         try {
 624                                 bool canPauseAndContinue = sc.CanPauseAndContinue;
 625                                 Assert.Fail ("#1: " + canPauseAndContinue);
 626                         } catch (ArgumentException ex) {
 627                                 // Service name  contains invalid characters, is empty or is
 628                                 // too long (max length = 80)
 629                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 630                                 Assert.IsNotNull (ex.Message, "#3");
 631                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
 632                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
 633                                 Assert.IsNull (ex.ParamName, "#6");
 634                                 Assert.IsNull (ex.InnerException, "#7");
 635                         }
 636                 }
 637
 638                 [Test]
 639                 public void CanShutdown ()
 640                 {
 641                         if (RunningOnUnix)
 642                                 Assert.Ignore ("Running on Unix.");
 643
 644                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 645                         Assert.IsTrue (sc.CanShutdown, "#1");
 646                         sc.ServiceName = UNCONTROLLABLE_SERVICE.ServiceName;
 647                         Assert.IsFalse (sc.CanShutdown, "#2");
 648                         sc.DisplayName = CONTROLLABLE_SERVICE.DisplayName;
 649                         Assert.IsTrue (sc.CanShutdown, "#3");
 650                         sc.MachineName = "doesnotexist";
 651                         try {
 652                                 bool value = sc.CanShutdown;
 653                                 Assert.Fail ("#4: " + value.ToString ());
 654                         } catch (InvalidOperationException ex) {
 655                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
 656                                 // This operation might require other priviliges
 657                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#5");
 658                                 Assert.IsNotNull (ex.Message, "#6");
 659                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#7");
 660                                 Assert.IsNotNull (ex.InnerException, "#8");
 661
 662                                 // The RPC server is unavailable
 663                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#9");
 664                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
 665                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#10");
 666                                 Assert.IsNotNull (win32Error.Message, "#11");
 667                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#12");
 668                                 Assert.IsNull (win32Error.InnerException, "#13");
 669                         }
 670                 }
 671
 672                 [Test]
 673                 public void CanShutdown_Machine_DoesNotExist ()
 674                 {
 675                         if (RunningOnUnix)
 676                                 Assert.Ignore ("Running on Unix.");
 677
 678                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
 679                                 "doesnotexist");
 680                         try {
 681                                 bool canShutdown = sc.CanShutdown;
 682                                 Assert.Fail ("#1: " + canShutdown);
 683                         } catch (InvalidOperationException ex) {
 684                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
 685                                 // This operation might require other priviliges
 686                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 687                                 Assert.IsNotNull (ex.Message, "#3");
 688                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
 689                                 Assert.IsNotNull (ex.InnerException, "#5");
 690
 691                                 // The RPC server is unavailable
 692                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
 693                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
 694                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
 695                                 Assert.IsNotNull (win32Error.Message, "#8");
 696                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
 697                                 Assert.IsNull (win32Error.InnerException, "#10");
 698                         }
 699                 }
 700
 701                 [Test]
 702                 public void CanShutdown_Service_Disabled ()
 703                 {
 704                         if (RunningOnUnix)
 705                                 Assert.Ignore ("Running on Unix.");
 706
 707                         ServiceController sc1 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
 708                         Assert.IsFalse (sc1.CanShutdown);
 709                 }
 710
 711                 [Test]
 712                 public void CanShutdown_Service_DoesNotExist ()
 713                 {
 714                         if (RunningOnUnix)
 715                                 Assert.Ignore ("Running on Unix.");
 716
 717                         ServiceController sc = new ServiceController ("doesnotexist", ".");
 718                         try {
 719                                 bool value = sc.CanShutdown;
 720                                 Assert.Fail ("#1: " + value.ToString ());
 721                         } catch (InvalidOperationException ex) {
 722                                 // Cannot open doesnotexist service on computer '.'
 723                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 724                                 Assert.IsNotNull (ex.Message, "#3");
 725                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
 726                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
 727                                 Assert.IsNotNull (ex.InnerException, "#6");
 728
 729                                 // The filename, directory name, or volume label is incorrect
 730                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
 731                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
 732                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
 733                                 Assert.IsNotNull (win32Error.Message, "#9");
 734                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
 735                                 Assert.IsNull (win32Error.InnerException, "#11");
 736                         }
 737                 }
 738
 739                 [Test]
 740                 public void CanShutdown_Service_OperationNotValid ()
 741                 {
 742                         if (RunningOnUnix)
 743                                 Assert.Ignore ("Running on Unix.");
 744
 745                         ServiceController sc1 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
 746                         Assert.IsFalse (sc1.CanShutdown);
 747                 }
 748
 749                 [Test]
 750                 public void CanShutdown_Service_Running ()
 751                 {
 752                         if (RunningOnUnix)
 753                                 Assert.Ignore ("Running on Unix.");
 754
 755                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 756                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#1");
 757                         Assert.IsTrue (sc.CanShutdown, "#2");
 758                 }
 759
 760                 [Test]
 761                 public void CanShutdown_Service_Paused ()
 762                 {
 763                         if (RunningOnUnix)
 764                                 Assert.Ignore ("Running on Unix.");
 765
 766                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 767                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 768
 769                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
 770                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
 771
 772                         Assert.IsTrue (sc1.CanShutdown, "#B1");
 773                         Assert.IsTrue (sc2.CanShutdown, "#B2");
 774
 775                         sc1.Pause ();
 776
 777                         try {
 778                                 Assert.IsTrue (sc1.CanShutdown, "#C1");
 779                                 Assert.IsTrue (sc2.CanShutdown, "#C2");
 780
 781                                 sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
 782
 783                                 Assert.IsTrue (sc1.CanShutdown, "#D1");
 784                                 Assert.IsTrue (sc2.CanShutdown, "#D2");
 785                         } finally {
 786                                 EnsureServiceIsRunning (sc1);
 787                                 sc2.Refresh ();
 788                         }
 789
 790                         Assert.IsTrue (sc1.CanShutdown, "#E1");
 791                         Assert.IsTrue (sc2.CanShutdown, "#E2");
 792
 793                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
 794                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
 795                 }
 796
 797                 [Test]
 798                 public void CanShutdown_Service_Stopped ()
 799                 {
 800                         if (RunningOnUnix)
 801                                 Assert.Ignore ("Running on Unix.");
 802
 803                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 804                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 805
 806                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
 807                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
 808
 809                         Assert.IsTrue (sc1.CanShutdown, "#B1");
 810                         Assert.IsTrue (sc2.CanShutdown, "#B2");
 811
 812                         sc1.Stop ();
 813
 814                         try {
 815                                 Assert.IsTrue (sc1.CanShutdown, "#C1");
 816                                 Assert.IsTrue (sc2.CanShutdown, "#C2");
 817
 818                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
 819
 820                                 Assert.IsFalse (sc1.CanShutdown, "#D1");
 821                                 Assert.IsTrue (sc2.CanShutdown, "#D2");
 822                         } finally {
 823                                 EnsureServiceIsRunning (sc1);
 824                                 sc2.Refresh ();
 825                         }
 826
 827                         Assert.IsTrue (sc1.CanShutdown, "#E1");
 828                         Assert.IsTrue (sc2.CanShutdown, "#E2");
 829
 830                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
 831                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
 832                 }
 833
 834                 [Test]
 835                 public void CanShutdown_ServiceName_Empty ()
 836                 {
 837                         ServiceController sc = new ServiceController ();
 838                         try {
 839                                 bool canShutdown = sc.CanShutdown;
 840                                 Assert.Fail ("#1: " + canShutdown);
 841                         } catch (ArgumentException ex) {
 842                                 // Service name  contains invalid characters, is empty or is
 843                                 // too long (max length = 80)
 844                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 845                                 Assert.IsNotNull (ex.Message, "#3");
 846                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
 847                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
 848                                 Assert.IsNull (ex.ParamName, "#6");
 849                                 Assert.IsNull (ex.InnerException, "#7");
 850                         }
 851                 }
 852
 853                 [Test]
 854                 public void CanStop ()
 855                 {
 856                         if (RunningOnUnix)
 857                                 Assert.Ignore ("Running on Unix.");
 858
 859                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 860                         Assert.IsTrue (sc.CanStop, "#1");
 861                         sc.ServiceName = UNCONTROLLABLE_SERVICE.ServiceName;
 862                         Assert.IsFalse (sc.CanStop, "#2");
 863                         sc.DisplayName = CONTROLLABLE_SERVICE.DisplayName;
 864                         Assert.IsTrue (sc.CanStop, "#3");
 865                         sc.MachineName = "doesnotexist";
 866                         try {
 867                                 bool value = sc.CanStop;
 868                                 Assert.Fail ("#4: " + value.ToString ());
 869                         } catch (InvalidOperationException ex) {
 870                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
 871                                 // This operation might require other priviliges
 872                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#5");
 873                                 Assert.IsNotNull (ex.Message, "#6");
 874                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#7");
 875                                 Assert.IsNotNull (ex.InnerException, "#8");
 876
 877                                 // The RPC server is unavailable
 878                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#9");
 879                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
 880                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#10");
 881                                 Assert.IsNotNull (win32Error.Message, "#11");
 882                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#12");
 883                                 Assert.IsNull (win32Error.InnerException, "#13");
 884                         }
 885                 }
 886
 887                 [Test]
 888                 public void CanStop_Machine_DoesNotExist ()
 889                 {
 890                         if (RunningOnUnix)
 891                                 Assert.Ignore ("Running on Unix.");
 892
 893                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
 894                                 "doesnotexist");
 895                         try {
 896                                 bool canStop = sc.CanStop;
 897                                 Assert.Fail ("#1: " + canStop);
 898                         } catch (InvalidOperationException ex) {
 899                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
 900                                 // This operation might require other priviliges
 901                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 902                                 Assert.IsNotNull (ex.Message, "#3");
 903                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
 904                                 Assert.IsNotNull (ex.InnerException, "#5");
 905
 906                                 // The RPC server is unavailable
 907                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
 908                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
 909                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
 910                                 Assert.IsNotNull (win32Error.Message, "#8");
 911                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
 912                                 Assert.IsNull (win32Error.InnerException, "#10");
 913                         }
 914                 }
 915
 916                 [Test]
 917                 public void CanStop_Service_Disabled ()
 918                 {
 919                         if (RunningOnUnix)
 920                                 Assert.Ignore ("Running on Unix.");
 921
 922                         ServiceController sc1 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
 923                         Assert.IsFalse (sc1.CanStop);
 924                 }
 925
 926                 [Test]
 927                 public void CanStop_Service_DoesNotExist ()
 928                 {
 929                         if (RunningOnUnix)
 930                                 Assert.Ignore ("Running on Unix.");
 931
 932                         ServiceController sc = new ServiceController ("doesnotexist", ".");
 933                         try {
 934                                 bool canStop = sc.CanStop;
 935                                 Assert.Fail ("#1: " + canStop);
 936                         } catch (InvalidOperationException ex) {
 937                                 // Cannot open doesnotexist service on computer '.'
 938                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 939                                 Assert.IsNotNull (ex.Message, "#3");
 940                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
 941                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
 942                                 Assert.IsNotNull (ex.InnerException, "#6");
 943
 944                                 // The filename, directory name, or volume label is incorrect
 945                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
 946                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
 947                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
 948                                 Assert.IsNotNull (win32Error.Message, "#9");
 949                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
 950                                 Assert.IsNull (win32Error.InnerException, "#11");
 951                         }
 952                 }
 953
 954                 [Test]
 955                 public void CanStop_Service_OperationNotValid ()
 956                 {
 957                         if (RunningOnUnix)
 958                                 Assert.Ignore ("Running on Unix.");
 959
 960                         ServiceController sc1 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
 961                         Assert.IsFalse (sc1.CanStop);
 962                 }
 963
 964                 [Test]
 965                 public void CanStop_Service_Running ()
 966                 {
 967                         if (RunningOnUnix)
 968                                 Assert.Ignore ("Running on Unix.");
 969
 970                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 971                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#1");
 972                         Assert.IsTrue (sc.CanStop, "#2");
 973                 }
 974
 975                 [Test]
 976                 public void CanStop_Service_Paused ()
 977                 {
 978                         if (RunningOnUnix)
 979                                 Assert.Ignore ("Running on Unix.");
 980
 981                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 982                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
 983
 984                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
 985                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
 986
 987                         Assert.IsTrue (sc1.CanStop, "#B1");
 988                         Assert.IsTrue (sc2.CanStop, "#B2");
 989
 990                         sc1.Pause ();
 991
 992                         try {
 993                                 Assert.IsTrue (sc1.CanStop, "#C1");
 994                                 Assert.IsTrue (sc2.CanStop, "#C2");
 995
 996                                 sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
 997
 998                                 Assert.IsTrue (sc1.CanStop, "#D1");
 999                                 Assert.IsTrue (sc2.CanStop, "#D2");
1000                         } finally {
1001                                 EnsureServiceIsRunning (sc1);
1002                                 sc2.Refresh ();
1003                         }
1004
1005                         Assert.IsTrue (sc1.CanStop, "#E1");
1006                         Assert.IsTrue (sc2.CanStop, "#E2");
1007
1008                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
1009                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
1010                 }
1011
1012                 [Test]
1013                 public void CanStop_Service_Stopped ()
1014                 {
1015                         if (RunningOnUnix)
1016                                 Assert.Ignore ("Running on Unix.");
1017
1018                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
1019                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
1020
1021                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
1022                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
1023
1024                         Assert.IsTrue (sc1.CanStop, "#B1");
1025                         Assert.IsTrue (sc2.CanStop, "#B2");
1026
1027                         sc1.Stop ();
1028
1029                         try {
1030                                 Assert.IsTrue (sc1.CanStop, "#C1");
1031                                 Assert.IsTrue (sc2.CanStop, "#C2");
1032
1033                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
1034
1035                                 Assert.IsFalse (sc1.CanStop, "#D1");
1036                                 Assert.IsTrue (sc2.CanStop, "#D2");
1037                         } finally {
1038                                 EnsureServiceIsRunning (sc1);
1039                                 sc2.Refresh ();
1040                         }
1041
1042                         Assert.IsTrue (sc1.CanShutdown, "#E1");
1043                         Assert.IsTrue (sc2.CanShutdown, "#E2");
1044
1045                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
1046                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
1047                 }
1048
1049                 [Test]
1050                 public void CanStop_ServiceName_Empty ()
1051                 {
1052                         ServiceController sc = new ServiceController ();
1053                         try {
1054                                 bool canStop = sc.CanStop;
1055                                 Assert.Fail ("#1: " + canStop);
1056                         } catch (ArgumentException ex) {
1057                                 // Service name  contains invalid characters, is empty or is
1058                                 // too long (max length = 80)
1059                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1060                                 Assert.IsNotNull (ex.Message, "#3");
1061                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
1062                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
1063                                 Assert.IsNull (ex.ParamName, "#6");
1064                                 Assert.IsNull (ex.InnerException, "#7");
1065                         }
1066                 }
1067
1068                 [Test]
1069                 public void Continue ()
1070                 {
1071                         if (RunningOnUnix)
1072                                 Assert.Ignore ("Running on Unix.");
1073
1074                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
1075                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
1076
1077                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
1078                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
1079
1080                         sc1.Pause ();
1081
1082                         try {
1083                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
1084                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
1085
1086                                 sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
1087
1088                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#C1");
1089                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
1090
1091                                 sc1.Continue ();
1092
1093                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#D1");
1094                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");
1095
1096                                 sc1.WaitForStatus (ServiceControllerStatus.Running, new TimeSpan (0, 0, 5));
1097
1098                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#E1");
1099                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#E2");
1100                         } finally {
1101                                 EnsureServiceIsRunning (sc1);
1102                                 sc2.Refresh ();
1103                         }
1104                 }
1105
1106                 [Test]
1107                 public void Continue_Machine_DoesNotExist ()
1108                 {
1109                         if (RunningOnUnix)
1110                                 Assert.Ignore ("Running on Unix.");
1111
1112                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
1113                                 "doesnotexist");
1114                         try {
1115                                 sc.Continue ();
1116                                 Assert.Fail ("#1");
1117                         } catch (InvalidOperationException ex) {
1118                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
1119                                 // This operation might require other priviliges
1120                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1121                                 Assert.IsNotNull (ex.Message, "#3");
1122                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
1123                                 Assert.IsNotNull (ex.InnerException, "#5");
1124
1125                                 // The RPC server is unavailable
1126                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
1127                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1128                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
1129                                 Assert.IsNotNull (win32Error.Message, "#8");
1130                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
1131                                 Assert.IsNull (win32Error.InnerException, "#10");
1132                         }
1133                 }
1134
1135                 [Test]
1136                 public void Continue_Service_Disabled ()
1137                 {
1138                         if (RunningOnUnix)
1139                                 Assert.Ignore ("Running on Unix.");
1140
1141                         ServiceController sc1 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
1142                         ServiceController sc2 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
1143
1144                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#A1");
1145                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#A2");
1146
1147                         try {
1148                                 sc1.Continue ();
1149                                 Assert.Fail ("#B1");
1150                         } catch (InvalidOperationException ex) {
1151                                 // Cannot resume NetDDE service on computer '.'
1152                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
1153                                 Assert.IsNotNull (ex.Message, "#B3");
1154                                 Assert.IsTrue (ex.Message.IndexOf (DISABLED_SERVICE.ServiceName) != -1, "#B4");
1155                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
1156                                 Assert.IsNotNull (ex.InnerException, "#B6");
1157
1158                                 // The service has not been started
1159                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
1160                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1161                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
1162                                 Assert.IsNotNull (win32Error.Message, "#B9");
1163                                 Assert.AreEqual (1062, win32Error.NativeErrorCode, "#B10");
1164                                 Assert.IsNull (win32Error.InnerException, "#B11");
1165                         }
1166
1167                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
1168                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#C2");
1169                 }
1170
1171                 [Test]
1172                 public void Continue_Service_DoesNotExist ()
1173                 {
1174                         if (RunningOnUnix)
1175                                 Assert.Ignore ("Running on Unix.");
1176
1177                         ServiceController sc = new ServiceController ("doesnotexist", ".");
1178                         try {
1179                                 sc.Continue ();
1180                                 Assert.Fail ("#1");
1181                         } catch (InvalidOperationException ex) {
1182                                 // Cannot open doesnotexist service on computer '.'
1183                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1184                                 Assert.IsNotNull (ex.Message, "#3");
1185                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
1186                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
1187                                 Assert.IsNotNull (ex.InnerException, "#6");
1188
1189                                 // The filename, directory name, or volume label is incorrect
1190                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
1191                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1192                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
1193                                 Assert.IsNotNull (win32Error.Message, "#9");
1194                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
1195                                 Assert.IsNull (win32Error.InnerException, "#11");
1196                         }
1197                 }
1198
1199                 [Test]
1200                 public void Continue_Service_OperationNotValid ()
1201                 {
1202                         if (RunningOnUnix)
1203                                 Assert.Ignore ("Running on Unix.");
1204
1205                         ServiceController sc1 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
1206                         ServiceController sc2 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
1207
1208                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
1209                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
1210
1211                         try {
1212                                 sc1.Continue ();
1213                                 Assert.Fail ("#B1");
1214                         } catch (InvalidOperationException ex) {
1215                                 // Cannot resume service on computer '.'
1216                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
1217                                 Assert.IsNotNull (ex.Message, "#B3");
1218                                 Assert.IsTrue (ex.Message.IndexOf (UNCONTROLLABLE_SERVICE.ServiceName) != -1, "#B4");
1219                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
1220                                 Assert.IsNotNull (ex.InnerException, "#B6");
1221
1222                                 // The requested control is not valid for this service
1223                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
1224                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1225                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
1226                                 Assert.IsNotNull (win32Error.Message, "#B9");
1227                                 Assert.AreEqual (1052, win32Error.NativeErrorCode, "#B10");
1228                                 Assert.IsNull (win32Error.InnerException, "#B11");
1229                         }
1230
1231                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#C1");
1232                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
1233                 }
1234
1235                 [Test]
1236                 public void Continue_Service_Running ()
1237                 {
1238                         if (RunningOnUnix)
1239                                 Assert.Ignore ("Running on Unix.");
1240
1241                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
1242                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
1243
1244                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
1245                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
1246
1247                         sc1.Continue ();
1248
1249                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
1250                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
1251                 }
1252
1253                 [Test]
1254                 public void Continue_Service_Stopped ()
1255                 {
1256                         if (RunningOnUnix)
1257                                 Assert.Ignore ("Running on Unix.");
1258
1259                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
1260                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
1261
1262                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
1263                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
1264
1265                         sc1.Stop ();
1266
1267                         try {
1268                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
1269                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
1270
1271                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
1272
1273                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
1274                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
1275
1276                                 sc1.Continue ();
1277                                 Assert.Fail ("#D1");
1278                         } catch (InvalidOperationException ex) {
1279                                 // Cannot resume the service on computer '.'
1280                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1281                                 Assert.IsNotNull (ex.Message, "#D3");
1282                                 Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#D4");
1283                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#D5");
1284                                 Assert.IsNotNull (ex.InnerException, "#D6");
1285
1286                                 // The service has not been started
1287                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#D7");
1288                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1289                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#D8");
1290                                 Assert.IsNotNull (win32Error.Message, "#D9");
1291                                 Assert.AreEqual (1062, win32Error.NativeErrorCode, "#D10");
1292                                 Assert.IsNull (win32Error.InnerException, "#D11");
1293                         } finally {
1294                                 EnsureServiceIsRunning (sc1);
1295                                 sc2.Refresh ();
1296                         }
1297
1298                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#E1");
1299                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#E2");
1300                 }
1301
1302                 [Test]
1303                 public void Continue_ServiceName_Empty ()
1304                 {
1305                         ServiceController sc = new ServiceController ();
1306                         try {
1307                                 sc.Continue ();
1308                                 Assert.Fail ("#1");
1309                         } catch (ArgumentException ex) {
1310                                 // Service name  contains invalid characters, is empty or is
1311                                 // too long (max length = 80)
1312                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1313                                 Assert.IsNotNull (ex.Message, "#3");
1314                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
1315                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
1316                                 Assert.IsNull (ex.ParamName, "#6");
1317                                 Assert.IsNull (ex.InnerException, "#7");
1318                         }
1319                 }
1320
1321                 [Test]
1322                 public void DependentServices ()
1323                 {
1324                         if (RunningOnUnix)
1325                                 Assert.Ignore ("Running on Unix.");
1326
1327                         ServiceController sc = null;
1328                         ServiceController [] dependentServices = null;
1329
1330                         // single dependent service
1331                         sc = new ServiceController (SERVICE_WITH_ONE_DEPENDENT.ServiceName, ".");
1332                         dependentServices = sc.DependentServices;
1333                         Assert.IsNotNull (dependentServices, "#A1");
1334                         Assert.AreEqual (1, dependentServices.Length, "#A2");
1335                         Assert.AreEqual (SERVICE_WITH_ONE_DEPENDENT.Dependents, ServiceNames (dependentServices), "#A3");
1336
1337                         // modifying ServiceName does not cause cache to be cleared:
1338                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
1339                         sc.ServiceName = SERVICE_WITH_NO_DEPENDENTS.ServiceName;
1340                         dependentServices = sc.DependentServices;
1341                         Assert.IsNotNull (dependentServices, "#B1");
1342                         Assert.AreEqual (1, dependentServices.Length, "#B2");
1343                         Assert.AreEqual (SERVICE_WITH_ONE_DEPENDENT.Dependents, ServiceNames (dependentServices), "#B3");
1344
1345                         // modifying DisplayName does not cause cache to be cleared:
1346                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
1347                         sc.DisplayName = SERVICE_WITH_MANY_DEPENDENTS.DisplayName;
1348                         dependentServices = sc.DependentServices;
1349                         Assert.IsNotNull (dependentServices, "#C1");
1350                         Assert.AreEqual (1, dependentServices.Length, "#C2");
1351                         Assert.AreEqual (SERVICE_WITH_ONE_DEPENDENT.Dependents, ServiceNames (dependentServices), "#C3");
1352
1353                         // modifying MachineName does not cause cache to be cleared:
1354                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
1355                         sc.MachineName = "doesnotexist";
1356                         dependentServices = sc.DependentServices;
1357                         Assert.IsNotNull (dependentServices, "#D1");
1358                         Assert.AreEqual (1, dependentServices.Length, "#D");
1359                         Assert.AreEqual (SERVICE_WITH_ONE_DEPENDENT.Dependents, ServiceNames (dependentServices), "#D3");
1360
1361                         // no dependent services
1362                         sc = new ServiceController (SERVICE_WITH_NO_DEPENDENTS.ServiceName, ".");
1363                         dependentServices = sc.DependentServices;
1364                         Assert.IsNotNull (dependentServices, "#E1");
1365                         Assert.AreEqual (0, dependentServices.Length, "#E2");
1366
1367                         // modifying ServiceName does not cause cache to be cleared:
1368                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
1369                         sc.ServiceName = SERVICE_WITH_MANY_DEPENDENTS.ServiceName;
1370                         dependentServices = sc.DependentServices;
1371                         Assert.IsNotNull (dependentServices, "#F1");
1372                         Assert.AreEqual (0, dependentServices.Length, "#F2");
1373
1374                         // modifying DisplayName does not cause cache to be cleared:
1375                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
1376                         sc.DisplayName = SERVICE_WITH_ONE_DEPENDENT.DisplayName;
1377                         dependentServices = sc.DependentServices;
1378                         Assert.IsNotNull (dependentServices, "#G1");
1379                         Assert.AreEqual (0, dependentServices.Length, "#G2");
1380
1381                         // modifying MachineName does not cause cache to be cleared:
1382                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
1383                         sc.MachineName = Environment.MachineName;
1384                         dependentServices = sc.DependentServices;
1385                         Assert.IsNotNull (dependentServices, "#H1");
1386                         Assert.AreEqual (0, dependentServices.Length, "#H2");
1387
1388                         // multiple dependent services
1389                         sc = new ServiceController (SERVICE_WITH_MANY_DEPENDENTS.ServiceName, ".");
1390                         dependentServices = sc.DependentServices;
1391                         Assert.IsNotNull (dependentServices, "#I1");
1392                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDENTS.Dependents.Length, dependentServices.Length, "#I2");
1393                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDENTS.Dependents, ServiceNames (dependentServices), "#I3");
1394
1395                         // modifying ServiceName does not cause cache to be cleared:
1396                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
1397                         sc.ServiceName = SERVICE_WITH_NO_DEPENDENTS.ServiceName;
1398                         dependentServices = sc.DependentServices;
1399                         Assert.IsNotNull (dependentServices, "#J1");
1400                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDENTS.Dependents.Length, dependentServices.Length, "#J3");
1401                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDENTS.Dependents, ServiceNames (dependentServices), "#J3");
1402
1403                         // modifying DisplayName does not cause cache to be cleared:
1404                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
1405                         sc.DisplayName = SERVICE_WITH_ONE_DEPENDENT.DisplayName;
1406                         dependentServices = sc.DependentServices;
1407                         Assert.IsNotNull (dependentServices, "#K1");
1408                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDENTS.Dependents.Length, dependentServices.Length, "#K2");
1409                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDENTS.Dependents, ServiceNames (dependentServices), "#K3");
1410
1411                         // modifying MachineName does not cause cache to be cleared:
1412                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
1413                         sc.MachineName = Environment.MachineName;
1414                         dependentServices = sc.DependentServices;
1415                         Assert.IsNotNull (dependentServices, "#L1");
1416                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDENTS.Dependents.Length, dependentServices.Length, "#L2");
1417                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDENTS.Dependents, ServiceNames (dependentServices), "#L3");
1418                 }
1419
1420                 [Test]
1421                 public void DependentServices_Machine_DoesNotExist ()
1422                 {
1423                         if (RunningOnUnix)
1424                                 Assert.Ignore ("Running on Unix.");
1425
1426                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
1427                                 "doesnotexist");
1428                         try {
1429                                 ServiceController [] dependenServices = sc.DependentServices;
1430                                 Assert.Fail ("#1: " + dependenServices.Length);
1431                         } catch (InvalidOperationException ex) {
1432                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
1433                                 // This operation might require other priviliges
1434                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1435                                 Assert.IsNotNull (ex.Message, "#3");
1436                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
1437                                 Assert.IsNotNull (ex.InnerException, "#5");
1438
1439                                 // The RPC server is unavailable
1440                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
1441                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1442                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
1443                                 Assert.IsNotNull (win32Error.Message, "#8");
1444                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
1445                                 Assert.IsNull (win32Error.InnerException, "#10");
1446                         }
1447                 }
1448
1449                 [Test]
1450                 public void DependentServices_Service_Disabled ()
1451                 {
1452                         if (RunningOnUnix)
1453                                 Assert.Ignore ("Running on Unix.");
1454
1455                         ServiceController sc = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
1456                         ServiceController [] dependentServices = sc.DependentServices;
1457                         Assert.IsNotNull (dependentServices, "#1");
1458                         Assert.AreEqual (DISABLED_SERVICE.Dependents, ServiceNames (dependentServices), "#2");
1459                 }
1460
1461                 [Test]
1462                 public void DependentServices_Service_DoesNotExist ()
1463                 {
1464                         if (RunningOnUnix)
1465                                 Assert.Ignore ("Running on Unix.");
1466
1467                         ServiceController sc = new ServiceController ("doesnotexist", ".");
1468                         try {
1469                                 ServiceController [] dependenServices = sc.DependentServices;
1470                                 Assert.Fail ("#1: " + dependenServices.Length);
1471                         } catch (InvalidOperationException ex) {
1472                                 // Cannot open doesnotexist service on computer '.'
1473                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1474                                 Assert.IsNotNull (ex.Message, "#3");
1475                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
1476                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
1477                                 Assert.IsNotNull (ex.InnerException, "#6");
1478
1479                                 // The filename, directory name, or volume label is incorrect
1480                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
1481                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1482                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
1483                                 Assert.IsNotNull (win32Error.Message, "#9");
1484                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
1485                                 Assert.IsNull (win32Error.InnerException, "#11");
1486                         }
1487                 }
1488
1489                 [Test]
1490                 public void DependentServices_ServiceName_Empty ()
1491                 {
1492                         ServiceController sc = new ServiceController ();
1493                         try {
1494                                 ServiceController [] dependenServices = sc.DependentServices;
1495                                 Assert.Fail ("#1: " + dependenServices.Length);
1496                         } catch (ArgumentException ex) {
1497                                 // Service name  contains invalid characters, is empty or is
1498                                 // too long (max length = 80)
1499                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1500                                 Assert.IsNotNull (ex.Message, "#3");
1501                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
1502                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
1503                                 Assert.IsNull (ex.ParamName, "#6");
1504                                 Assert.IsNull (ex.InnerException, "#7");
1505                         }
1506                 }
1507
1508                 [Test]
1509                 public void DisplayName ()
1510                 {
1511                         if (RunningOnUnix)
1512                                 Assert.Ignore ("Running on Unix.");
1513
1514                         var s1 = WORKSTATION_SERVICE;
1515                         var s2 = WINDOWS_SEARCH_SERVICE;
1516
1517                         ServiceController sc = new ServiceController ();
1518                         sc.DisplayName = s1.DisplayName.ToLower ();
1519                         Assert.AreEqual (s1.DisplayName.ToLower (), sc.DisplayName, "#A1");
1520                         Assert.AreEqual (s1.ServiceName, sc.ServiceName, "#A2");
1521
1522                         sc.DisplayName = s2.DisplayName.ToLower ();
1523                         Assert.AreEqual (s2.DisplayName.ToLower (), sc.DisplayName, "#B1");
1524                         Assert.AreEqual (s2.ServiceName, sc.ServiceName, "#B2");
1525
1526                         sc = new ServiceController (s1.DisplayName.ToLower ());
1527                         sc.DisplayName = s2.DisplayName.ToLower ();
1528                         Assert.AreEqual (s2.DisplayName.ToLower (), sc.DisplayName, "#C1");
1529                         Assert.AreEqual (s1.ServiceName, sc.ServiceName, "#C2");
1530                         Assert.AreEqual (s1.DisplayName.ToLower (), sc.DisplayName, "#C3");
1531
1532                         sc.DisplayName = s2.DisplayName.ToLower ();
1533                         Assert.AreEqual (s2.DisplayName.ToLower (), sc.DisplayName, "#D1");
1534                         Assert.AreEqual (s2.ServiceName, sc.ServiceName, "#D2");
1535
1536                         sc.DisplayName = s1.DisplayName;
1537                         Assert.AreEqual (s1.DisplayName, sc.DisplayName, "#E1");
1538                         Assert.AreEqual (s1.ServiceName, sc.ServiceName, "#E2");
1539
1540                         sc = new ServiceController (s1.DisplayName.ToLower ());
1541                         Assert.AreEqual (s1.DisplayName.ToLower (), sc.DisplayName, "#F1");
1542                         Assert.AreEqual (s1.ServiceName, sc.ServiceName, "#F2");
1543
1544                         sc.DisplayName = s1.DisplayName;
1545                         Assert.AreEqual (s1.DisplayName, sc.DisplayName, "#G1");
1546                         Assert.AreEqual (s1.ServiceName, sc.ServiceName, "#G2");
1547                 }
1548
1549                 [Test]
1550                 public void DisplayName_Machine_DoesNotExist ()
1551                 {
1552                         if (RunningOnUnix)
1553                                 Assert.Ignore ("Running on Unix.");
1554
1555                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
1556                                 "doesnotexist");
1557                         try {
1558                                 string displayName = sc.DisplayName;
1559                                 Assert.Fail ("#1: " + displayName);
1560                         } catch (InvalidOperationException ex) {
1561                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
1562                                 // This operation might require other priviliges
1563                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1564                                 Assert.IsNotNull (ex.Message, "#3");
1565                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
1566                                 Assert.IsNotNull (ex.InnerException, "#5");
1567
1568                                 // The RPC server is unavailable
1569                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
1570                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1571                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
1572                                 Assert.IsNotNull (win32Error.Message, "#8");
1573                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
1574                                 Assert.IsNull (win32Error.InnerException, "#10");
1575                         }
1576                 }
1577
1578                 [Test]
1579                 public void DisplayName_Service_Disabled ()
1580                 {
1581                         if (RunningOnUnix)
1582                                 Assert.Ignore ("Running on Unix.");
1583
1584                         ServiceController sc = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
1585                         Assert.AreEqual (DISABLED_SERVICE.DisplayName, sc.DisplayName);
1586                 }
1587
1588                 [Test]
1589                 public void DisplayName_Service_DoesNotExist ()
1590                 {
1591                         if (RunningOnUnix)
1592                                 Assert.Ignore ("Running on Unix.");
1593
1594                         ServiceController sc = new ServiceController ("doesnotexist", ".");
1595                         try {
1596                                 string displayName = sc.DisplayName;
1597                                 Assert.Fail ("#1: " + displayName);
1598                         } catch (InvalidOperationException ex) {
1599                                 // Cannot open doesnotexist service on computer '.'
1600                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1601                                 Assert.IsNotNull (ex.Message, "#3");
1602                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
1603                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
1604                                 Assert.IsNotNull (ex.InnerException, "#6");
1605
1606                                 // The filename, directory name, or volume label is incorrect
1607                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
1608                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1609                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
1610                                 Assert.IsNotNull (win32Error.Message, "#9");
1611                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
1612                                 Assert.IsNull (win32Error.InnerException, "#11");
1613                         }
1614                 }
1615
1616                 [Test]
1617                 public void DisplayName_ServiceName_Empty ()
1618                 {
1619                         if (RunningOnUnix)
1620                                 Assert.Ignore ("Running on Unix.");
1621
1622                         ServiceController sc = new ServiceController ();
1623                         sc.DisplayName = WORKSTATION_SERVICE.DisplayName.ToLower ();
1624                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName.ToLower (), sc.DisplayName, "#A1");
1625                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#A2");
1626                 }
1627
1628                 [Test]
1629                 public void DisplayName_Value_DoesNotExist ()
1630                 {
1631                         if (RunningOnUnix)
1632                                 Assert.Ignore ("Running on Unix.");
1633
1634                         ServiceController sc = new ServiceController ();
1635                         sc.DisplayName = "doesnotexist";
1636                         Assert.AreEqual ("doesnotexist", sc.DisplayName, "#1");
1637                         try {
1638                                 string serviceName = sc.ServiceName;
1639                                 Assert.Fail ("#2: " + serviceName);
1640                         } catch (InvalidOperationException ex) {
1641                                 // Service doesnotexist was not found on computer '.'
1642                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#3");
1643                                 Assert.IsNotNull (ex.Message, "#4");
1644                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#5");
1645                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#6");
1646                                 Assert.IsNotNull (ex.InnerException, "#7");
1647
1648                                 // The specified service does not exist as an installed service
1649                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#8");
1650                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
1651                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#9");
1652                                 Assert.IsNotNull (win32Error.Message, "#10");
1653                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#11");
1654                                 Assert.IsNull (win32Error.InnerException, "#12");
1655                         }
1656                         Assert.AreEqual ("doesnotexist", sc.DisplayName, "#13");
1657                 }
1658
1659                 [Test]
1660                 public void DisplayName_Value_Empty ()
1661                 {
1662                         if (RunningOnUnix)
1663                                 Assert.Ignore ("Running on Unix.");
1664
1665                         ServiceController sc = new ServiceController ();
1666                         Assert.AreEqual (string.Empty, sc.DisplayName, "#A1");
1667                         Assert.AreEqual (string.Empty, sc.ServiceName, "#A2");
1668
1669                         sc.DisplayName = WORKSTATION_SERVICE.DisplayName;
1670
1671                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName, sc.DisplayName, "#B1");
1672                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#B2");
1673
1674                         sc.DisplayName = string.Empty;
1675
1676                         Assert.AreEqual (string.Empty, sc.DisplayName, "#C1");
1677                         Assert.AreEqual (string.Empty, sc.ServiceName, "#C2");
1678                 }
1679
1680                 [Test]
1681                 public void DisplayName_Value_Null ()
1682                 {
1683                         if (RunningOnUnix)
1684                                 Assert.Ignore ("Running on Unix.");
1685
1686                         ServiceController sc = new ServiceController ();
1687                         sc.DisplayName = CONTROLLABLE_SERVICE.DisplayName;
1688                         try {
1689                                 sc.DisplayName = null;
1690                                 Assert.Fail ("#1");
1691                         } catch (ArgumentNullException ex) {
1692                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1693                                 Assert.IsNotNull (ex.Message, "#3");
1694                                 Assert.IsNotNull (ex.ParamName, "#4");
1695                                 Assert.AreEqual ("value", ex.ParamName, "#5");
1696                                 Assert.IsNull (ex.InnerException, "#6");
1697                         }
1698                         Assert.AreEqual (CONTROLLABLE_SERVICE.DisplayName, sc.DisplayName, "#7");
1699                 }
1700
1701                 [Test]
1702                 public void DisplayName_Value_ServiceName ()
1703                 {
1704                         if (RunningOnUnix)
1705                                 Assert.Ignore ("Running on Unix.");
1706
1707                         ServiceController sc = new ServiceController ();
1708                         sc.DisplayName = WORKSTATION_SERVICE.ServiceName;
1709                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.DisplayName, "#A1");
1710                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#A2");
1711                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName, sc.DisplayName, "#A3");
1712                 }
1713
1714                 [Test]
1715                 public void ExecuteCommand_Device_ControlCodes ()
1716                 {
1717                         if (RunningOnUnix)
1718                                 Assert.Ignore ("Running on Unix.");
1719
1720                         ServiceController sc = new ServiceController (DISK_DRIVER_SERVICE.ServiceName, ".");
1721                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
1722
1723                         try {
1724                                 try {
1725                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_CONTINUE);
1726                                         Assert.Fail ("#B1");
1727                                 } catch (InvalidOperationException ex) {
1728                                         // Cannot control XXX service on computer '.'
1729                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
1730                                         Assert.IsNotNull (ex.Message, "#B3");
1731                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#B4");
1732                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
1733                                         Assert.IsNotNull (ex.InnerException, "#B6");
1734
1735                                         // Access is denied
1736                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
1737                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1738                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
1739                                         Assert.IsNotNull (win32Error.Message, "#B9");
1740                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#B10");
1741                                         Assert.IsNull (win32Error.InnerException, "#B11");
1742                                 }
1743
1744                                 try {
1745                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_DEVICEEVENT);
1746                                         Assert.Fail ("#C1");
1747                                 } catch (InvalidOperationException ex) {
1748                                         // Cannot control XXX service on computer '.'
1749                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1750                                         Assert.IsNotNull (ex.Message, "#C3");
1751                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#C4");
1752                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#C5");
1753                                         Assert.IsNotNull (ex.InnerException, "#C6");
1754
1755                                         // The parameter is incorrect
1756                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#C7");
1757                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1758                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#C8");
1759                                         Assert.IsNotNull (win32Error.Message, "#C9");
1760                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#C10");
1761                                         Assert.IsNull (win32Error.InnerException, "#C11");
1762                                 }
1763
1764                                 try {
1765                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_HARDWAREPROFILECHANGE);
1766                                         Assert.Fail ("#D1");
1767                                 } catch (InvalidOperationException ex) {
1768                                         // Cannot control XXX service on computer '.'
1769                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1770                                         Assert.IsNotNull (ex.Message, "#D3");
1771                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#D4");
1772                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#D5");
1773                                         Assert.IsNotNull (ex.InnerException, "#D6");
1774
1775                                         // The parameter is incorrect
1776                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#D7");
1777                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1778                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#D8");
1779                                         Assert.IsNotNull (win32Error.Message, "#D9");
1780                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#D10");
1781                                         Assert.IsNull (win32Error.InnerException, "#D11");
1782                                 }
1783
1784                                 try {
1785                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_INTERROGATE);
1786                                         Assert.Fail ("#E1");
1787                                 } catch (InvalidOperationException ex) {
1788                                         // Cannot control XXX service on computer '.'
1789                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
1790                                         Assert.IsNotNull (ex.Message, "#E3");
1791                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#E4");
1792                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#E5");
1793                                         Assert.IsNotNull (ex.InnerException, "#E6");
1794
1795                                         // Access is denied
1796                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#E7");
1797                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1798                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#E8");
1799                                         Assert.IsNotNull (win32Error.Message, "#E9");
1800                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#E10");
1801                                         Assert.IsNull (win32Error.InnerException, "#E11");
1802                                 }
1803
1804                                 try {
1805                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_NETBINDADD);
1806                                         Assert.Fail ("#F1");
1807                                 } catch (InvalidOperationException ex) {
1808                                         // Cannot control XXX service on computer '.'
1809                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
1810                                         Assert.IsNotNull (ex.Message, "#F3");
1811                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#F4");
1812                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#F5");
1813                                         Assert.IsNotNull (ex.InnerException, "#F6");
1814
1815                                         // Access is denied
1816                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#F7");
1817                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1818                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#F8");
1819                                         Assert.IsNotNull (win32Error.Message, "#F9");
1820                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#F10");
1821                                         Assert.IsNull (win32Error.InnerException, "#F11");
1822                                 }
1823
1824                                 try {
1825                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_NETBINDDISABLE);
1826                                         Assert.Fail ("#G1");
1827                                 } catch (InvalidOperationException ex) {
1828                                         // Cannot control XXX service on computer '.'
1829                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
1830                                         Assert.IsNotNull (ex.Message, "#G3");
1831                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#G4");
1832                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#G5");
1833                                         Assert.IsNotNull (ex.InnerException, "#G6");
1834
1835                                         // Access is denied
1836                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#G7");
1837                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1838                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#G8");
1839                                         Assert.IsNotNull (win32Error.Message, "#G9");
1840                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#G10");
1841                                         Assert.IsNull (win32Error.InnerException, "#G11");
1842                                 }
1843
1844                                 try {
1845                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_NETBINDENABLE);
1846                                         Assert.Fail ("#H1");
1847                                 } catch (InvalidOperationException ex) {
1848                                         // Cannot control XXX service on computer '.'
1849                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#H2");
1850                                         Assert.IsNotNull (ex.Message, "#H3");
1851                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#H4");
1852                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#H5");
1853                                         Assert.IsNotNull (ex.InnerException, "#H6");
1854
1855                                         // Access is denied
1856                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#H7");
1857                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1858                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#H8");
1859                                         Assert.IsNotNull (win32Error.Message, "#H9");
1860                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#H10");
1861                                         Assert.IsNull (win32Error.InnerException, "#H11");
1862                                 }
1863
1864                                 try {
1865                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_NETBINDREMOVE);
1866                                         Assert.Fail ("#I1");
1867                                 } catch (InvalidOperationException ex) {
1868                                         // Cannot control XXX service on computer '.'
1869                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#I2");
1870                                         Assert.IsNotNull (ex.Message, "#I3");
1871                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#I4");
1872                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#I5");
1873                                         Assert.IsNotNull (ex.InnerException, "#I6");
1874
1875                                         // Access is denied
1876                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#I7");
1877                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1878                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#I8");
1879                                         Assert.IsNotNull (win32Error.Message, "#I9");
1880                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#I10");
1881                                         Assert.IsNull (win32Error.InnerException, "#I11");
1882                                 }
1883
1884                                 try {
1885                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_PARAMCHANGE);
1886                                         Assert.Fail ("#J1");
1887                                 } catch (InvalidOperationException ex) {
1888                                         // Cannot control XXX service on computer '.'
1889                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#J2");
1890                                         Assert.IsNotNull (ex.Message, "#J3");
1891                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#J4");
1892                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#J5");
1893                                         Assert.IsNotNull (ex.InnerException, "#J6");
1894
1895                                         // Access is denied
1896                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#J7");
1897                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1898                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#J8");
1899                                         Assert.IsNotNull (win32Error.Message, "#J9");
1900                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#J10");
1901                                         Assert.IsNull (win32Error.InnerException, "#J11");
1902                                 }
1903
1904                                 try {
1905                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_PAUSE);
1906                                         Assert.Fail ("#K1");
1907                                 } catch (InvalidOperationException ex) {
1908                                         // Cannot control XXX service on computer '.'
1909                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#K2");
1910                                         Assert.IsNotNull (ex.Message, "#K3");
1911                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#K4");
1912                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#K5");
1913                                         Assert.IsNotNull (ex.InnerException, "#K6");
1914
1915                                         // Access is denied
1916                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#K7");
1917                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1918                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#K8");
1919                                         Assert.IsNotNull (win32Error.Message, "#K9");
1920                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#K10");
1921                                         Assert.IsNull (win32Error.InnerException, "#K11");
1922                                 }
1923
1924                                 try {
1925                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_POWEREVENT);
1926                                         Assert.Fail ("#L1");
1927                                 } catch (InvalidOperationException ex) {
1928                                         // Cannot control XXX service on computer '.'
1929                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#L2");
1930                                         Assert.IsNotNull (ex.Message, "#L3");
1931                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#L4");
1932                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#L5");
1933                                         Assert.IsNotNull (ex.InnerException, "#L6");
1934
1935                                         // Access is denied
1936                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#L7");
1937                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1938                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#L8");
1939                                         Assert.IsNotNull (win32Error.Message, "#L9");
1940                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#L10");
1941                                         Assert.IsNull (win32Error.InnerException, "#L11");
1942                                 }
1943
1944                                 try {
1945                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_SESSIONCHANGE);
1946                                         Assert.Fail ("#M1");
1947                                 } catch (InvalidOperationException ex) {
1948                                         // Cannot control XXX service on computer '.'
1949                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#M2");
1950                                         Assert.IsNotNull (ex.Message, "#M3");
1951                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#M4");
1952                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#M5");
1953                                         Assert.IsNotNull (ex.InnerException, "#M6");
1954
1955                                         // The parameter is incorrect
1956                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#M7");
1957                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1958                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#M8");
1959                                         Assert.IsNotNull (win32Error.Message, "#M9");
1960                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#M10");
1961                                         Assert.IsNull (win32Error.InnerException, "#M11");
1962                                 }
1963
1964                                 try {
1965                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_SHUTDOWN);
1966                                         Assert.Fail ("#N1");
1967                                 } catch (InvalidOperationException ex) {
1968                                         // Cannot control XXX service on computer '.'
1969                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
1970                                         Assert.IsNotNull (ex.Message, "#N3");
1971                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#N4");
1972                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#N5");
1973                                         Assert.IsNotNull (ex.InnerException, "#N6");
1974
1975                                         // The parameter is incorrect
1976                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#N7");
1977                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1978                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#N8");
1979                                         Assert.IsNotNull (win32Error.Message, "#N9");
1980                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#N10");
1981                                         Assert.IsNull (win32Error.InnerException, "#N11");
1982                                 }
1983
1984                                 try {
1985                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_STOP);
1986                                         Assert.Fail ("#O1");
1987                                 } catch (InvalidOperationException ex) {
1988                                         // Cannot control XXX service on computer '.'
1989                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#O2");
1990                                         Assert.IsNotNull (ex.Message, "#O3");
1991                                         Assert.IsTrue (ex.Message.IndexOf (DISK_DRIVER_SERVICE.ServiceName) != -1, "#O4");
1992                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#O5");
1993                                         Assert.IsNotNull (ex.InnerException, "#O6");
1994
1995                                         // Access is denied
1996                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#O7");
1997                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
1998                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#O8");
1999                                         Assert.IsNotNull (win32Error.Message, "#O9");
2000                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#O10");
2001                                         Assert.IsNull (win32Error.InnerException, "#O11");
2002                                 }
2003                         } finally {
2004                                 EnsureServiceIsRunning (sc);
2005                         }
2006
2007                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#P");
2008                 }
2009
2010                 [Test]
2011                 public void ExecuteCommand_Machine_DoesNotExist ()
2012                 {
2013                         if (RunningOnUnix)
2014                                 Assert.Ignore ("Running on Unix.");
2015
2016                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
2017                                 "doesnotexist");
2018                         try {
2019                                 sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_PAUSE);
2020                                 Assert.Fail ("#1");
2021                         } catch (InvalidOperationException ex) {
2022                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
2023                                 // This operation might require other priviliges
2024                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
2025                                 Assert.IsNotNull (ex.Message, "#3");
2026                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
2027                                 Assert.IsNotNull (ex.InnerException, "#5");
2028
2029                                 // The RPC server is unavailable
2030                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
2031                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
2032                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
2033                                 Assert.IsNotNull (win32Error.Message, "#8");
2034                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
2035                                 Assert.IsNull (win32Error.InnerException, "#10");
2036                         }
2037                 }
2038
2039                 [Test]
2040                 public void ExecuteCommand_Parameter_Incorrect ()
2041                 {
2042                         if (RunningOnUnix)
2043                                 Assert.Ignore ("Running on Unix.");
2044
2045                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
2046                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
2047
2048                         try {
2049                                 try {
2050                                         sc.ExecuteCommand (127);
2051                                         Assert.Fail ("#B1");
2052                                 } catch (InvalidOperationException ex) {
2053                                         // Cannot control XXX service on computer '.'
2054                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
2055                                         Assert.IsNotNull (ex.Message, "#B3");
2056                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#B4");
2057                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
2058                                         Assert.IsNotNull (ex.InnerException, "#B6");
2059
2060                                         // The parameter is incorrect
2061                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
2062                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2063                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
2064                                         Assert.IsNotNull (win32Error.Message, "#B9");
2065                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#B10");
2066                                         Assert.IsNull (win32Error.InnerException, "#B11");
2067                                 }
2068
2069                                 sc.ExecuteCommand (128);
2070                                 sc.ExecuteCommand (255);
2071
2072                                 try {
2073                                         sc.ExecuteCommand (256);
2074                                         Assert.Fail ("#C1");
2075                                 } catch (InvalidOperationException ex) {
2076                                         // Cannot control XXX service on computer '.'
2077                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2078                                         Assert.IsNotNull (ex.Message, "#C3");
2079                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#C4");
2080                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#C5");
2081                                         Assert.IsNotNull (ex.InnerException, "#C6");
2082
2083                                         // The parameter is incorrect
2084                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#C7");
2085                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2086                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#C8");
2087                                         Assert.IsNotNull (win32Error.Message, "#C9");
2088                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#C10");
2089                                         Assert.IsNull (win32Error.InnerException, "#C11");
2090                                 }
2091                         } finally {
2092                                 EnsureServiceIsRunning (sc);
2093                         }
2094
2095                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#D");
2096                 }
2097
2098                 [Test]
2099                 public void ExecuteCommand_Service_ContinuePending ()
2100                 {
2101                         if (RunningOnUnix)
2102                                 Assert.Ignore ("Running on Unix.");
2103
2104                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
2105                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
2106
2107                         sc.Pause ();
2108
2109                         try {
2110                                 sc.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
2111                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc.Status, "#B");
2112
2113                                 sc.Continue ();
2114
2115                                 sc.ExecuteCommand (128);
2116
2117                                 try {
2118                                         sc.ExecuteCommand (127);
2119                                         Assert.Fail ("#C1");
2120                                 } catch (InvalidOperationException ex) {
2121                                         // Cannot control XXX service on computer '.'
2122                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2123                                         Assert.IsNotNull (ex.Message, "#C3");
2124                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#C4");
2125                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#C5");
2126                                         Assert.IsNotNull (ex.InnerException, "#C6");
2127
2128                                         // The parameter is incorrect
2129                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#C7");
2130                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2131                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#C8");
2132                                         Assert.IsNotNull (win32Error.Message, "#C9");
2133                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#C10");
2134                                         Assert.IsNull (win32Error.InnerException, "#C11");
2135                                 }
2136                         } finally {
2137                                 EnsureServiceIsRunning (sc);
2138                         }
2139
2140                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#E");
2141                 }
2142
2143                 [Test]
2144                 public void ExecuteCommand_Service_ControlCodes ()
2145                 {
2146                         if (RunningOnUnix)
2147                                 Assert.Ignore ("Running on Unix.");
2148
2149                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
2150                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
2151
2152                         try {
2153                                 try {
2154                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_CONTINUE);
2155                                         Assert.Fail ("#B1");
2156                                 } catch (InvalidOperationException ex) {
2157                                         // Cannot control XXX service on computer '.'
2158                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
2159                                         Assert.IsNotNull (ex.Message, "#B3");
2160                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#B4");
2161                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
2162                                         Assert.IsNotNull (ex.InnerException, "#B6");
2163
2164                                         // Access is denied
2165                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
2166                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2167                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
2168                                         Assert.IsNotNull (win32Error.Message, "#B9");
2169                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#B10");
2170                                         Assert.IsNull (win32Error.InnerException, "#B11");
2171                                 }
2172
2173                                 try {
2174                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_DEVICEEVENT);
2175                                         Assert.Fail ("#C1");
2176                                 } catch (InvalidOperationException ex) {
2177                                         // Cannot control XXX service on computer '.'
2178                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2179                                         Assert.IsNotNull (ex.Message, "#C3");
2180                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#C4");
2181                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#C5");
2182                                         Assert.IsNotNull (ex.InnerException, "#C6");
2183
2184                                         // The parameter is incorrect
2185                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#C7");
2186                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2187                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#C8");
2188                                         Assert.IsNotNull (win32Error.Message, "#C9");
2189                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#C10");
2190                                         Assert.IsNull (win32Error.InnerException, "#C11");
2191                                 }
2192
2193                                 try {
2194                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_HARDWAREPROFILECHANGE);
2195                                         Assert.Fail ("#D1");
2196                                 } catch (InvalidOperationException ex) {
2197                                         // Cannot control XXX service on computer '.'
2198                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
2199                                         Assert.IsNotNull (ex.Message, "#D3");
2200                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#D4");
2201                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#D5");
2202                                         Assert.IsNotNull (ex.InnerException, "#D6");
2203
2204                                         // The parameter is incorrect
2205                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#D7");
2206                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2207                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#D8");
2208                                         Assert.IsNotNull (win32Error.Message, "#D9");
2209                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#D10");
2210                                         Assert.IsNull (win32Error.InnerException, "#D11");
2211                                 }
2212
2213                                 try {
2214                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_INTERROGATE);
2215                                         Assert.Fail ("#E1");
2216                                 } catch (InvalidOperationException ex) {
2217                                         // Cannot control XXX service on computer '.'
2218                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
2219                                         Assert.IsNotNull (ex.Message, "#E3");
2220                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#E4");
2221                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#E5");
2222                                         Assert.IsNotNull (ex.InnerException, "#E6");
2223
2224                                         // Access is denied
2225                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#E7");
2226                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2227                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#E8");
2228                                         Assert.IsNotNull (win32Error.Message, "#E9");
2229                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#E10");
2230                                         Assert.IsNull (win32Error.InnerException, "#E11");
2231                                 }
2232
2233                                 try {
2234                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_NETBINDADD);
2235                                         Assert.Fail ("#F1");
2236                                 } catch (InvalidOperationException ex) {
2237                                         // Cannot control XXX service on computer '.'
2238                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
2239                                         Assert.IsNotNull (ex.Message, "#F3");
2240                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#F4");
2241                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#F5");
2242                                         Assert.IsNotNull (ex.InnerException, "#F6");
2243
2244                                         // Access is denied
2245                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#F7");
2246                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2247                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#F8");
2248                                         Assert.IsNotNull (win32Error.Message, "#F9");
2249                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#F10");
2250                                         Assert.IsNull (win32Error.InnerException, "#F11");
2251                                 }
2252
2253                                 try {
2254                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_NETBINDDISABLE);
2255                                         Assert.Fail ("#G1");
2256                                 } catch (InvalidOperationException ex) {
2257                                         // Cannot control XXX service on computer '.'
2258                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");
2259                                         Assert.IsNotNull (ex.Message, "#G3");
2260                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#G4");
2261                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#G5");
2262                                         Assert.IsNotNull (ex.InnerException, "#G6");
2263
2264                                         // Access is denied
2265                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#G7");
2266                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2267                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#G8");
2268                                         Assert.IsNotNull (win32Error.Message, "#G9");
2269                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#G10");
2270                                         Assert.IsNull (win32Error.InnerException, "#G11");
2271                                 }
2272
2273                                 try {
2274                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_NETBINDENABLE);
2275                                         Assert.Fail ("#H1");
2276                                 } catch (InvalidOperationException ex) {
2277                                         // Cannot control XXX service on computer '.'
2278                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#H2");
2279                                         Assert.IsNotNull (ex.Message, "#H3");
2280                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#H4");
2281                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#H5");
2282                                         Assert.IsNotNull (ex.InnerException, "#H6");
2283
2284                                         // Access is denied
2285                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#H7");
2286                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2287                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#H8");
2288                                         Assert.IsNotNull (win32Error.Message, "#H9");
2289                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#H10");
2290                                         Assert.IsNull (win32Error.InnerException, "#H11");
2291                                 }
2292
2293                                 try {
2294                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_NETBINDREMOVE);
2295                                         Assert.Fail ("#I1");
2296                                 } catch (InvalidOperationException ex) {
2297                                         // Cannot control XXX service on computer '.'
2298                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#I2");
2299                                         Assert.IsNotNull (ex.Message, "#I3");
2300                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#I4");
2301                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#I5");
2302                                         Assert.IsNotNull (ex.InnerException, "#I6");
2303
2304                                         // Access is denied
2305                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#I7");
2306                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2307                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#I8");
2308                                         Assert.IsNotNull (win32Error.Message, "#I9");
2309                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#I10");
2310                                         Assert.IsNull (win32Error.InnerException, "#I11");
2311                                 }
2312
2313                                 try {
2314                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_PARAMCHANGE);
2315                                         Assert.Fail ("#J1");
2316                                 } catch (InvalidOperationException ex) {
2317                                         // Cannot control XXX service on computer '.'
2318                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#J2");
2319                                         Assert.IsNotNull (ex.Message, "#J3");
2320                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#J4");
2321                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#J5");
2322                                         Assert.IsNotNull (ex.InnerException, "#J6");
2323
2324                                         // Access is denied
2325                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#J7");
2326                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2327                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#J8");
2328                                         Assert.IsNotNull (win32Error.Message, "#J9");
2329                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#J10");
2330                                         Assert.IsNull (win32Error.InnerException, "#J11");
2331                                 }
2332
2333                                 try {
2334                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_PAUSE);
2335                                         Assert.Fail ("#K1");
2336                                 } catch (InvalidOperationException ex) {
2337                                         // Cannot control XXX service on computer '.'
2338                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#K2");
2339                                         Assert.IsNotNull (ex.Message, "#K3");
2340                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#K4");
2341                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#K5");
2342                                         Assert.IsNotNull (ex.InnerException, "#K6");
2343
2344                                         // Access is denied
2345                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#K7");
2346                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2347                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#K8");
2348                                         Assert.IsNotNull (win32Error.Message, "#K9");
2349                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#K10");
2350                                         Assert.IsNull (win32Error.InnerException, "#K11");
2351                                 }
2352
2353                                 try {
2354                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_POWEREVENT);
2355                                         Assert.Fail ("#L1");
2356                                 } catch (InvalidOperationException ex) {
2357                                         // Cannot control XXX service on computer '.'
2358                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#L2");
2359                                         Assert.IsNotNull (ex.Message, "#L3");
2360                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#L4");
2361                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#L5");
2362                                         Assert.IsNotNull (ex.InnerException, "#L6");
2363
2364                                         // Access is denied
2365                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#L7");
2366                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2367                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#L8");
2368                                         Assert.IsNotNull (win32Error.Message, "#L9");
2369                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#L10");
2370                                         Assert.IsNull (win32Error.InnerException, "#L11");
2371                                 }
2372
2373                                 try {
2374                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_SESSIONCHANGE);
2375                                         Assert.Fail ("#M1");
2376                                 } catch (InvalidOperationException ex) {
2377                                         // Cannot control XXX service on computer '.'
2378                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#M2");
2379                                         Assert.IsNotNull (ex.Message, "#M3");
2380                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#M4");
2381                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#M5");
2382                                         Assert.IsNotNull (ex.InnerException, "#M6");
2383
2384                                         // The parameter is incorrect
2385                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#M7");
2386                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2387                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#M8");
2388                                         Assert.IsNotNull (win32Error.Message, "#M9");
2389                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#M10");
2390                                         Assert.IsNull (win32Error.InnerException, "#M11");
2391                                 }
2392
2393                                 try {
2394                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_SHUTDOWN);
2395                                         Assert.Fail ("#N1");
2396                                 } catch (InvalidOperationException ex) {
2397                                         // Cannot control XXX service on computer '.'
2398                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#N2");
2399                                         Assert.IsNotNull (ex.Message, "#N3");
2400                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#N4");
2401                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#N5");
2402                                         Assert.IsNotNull (ex.InnerException, "#N6");
2403
2404                                         // The parameter is incorrect
2405                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#N7");
2406                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2407                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#N8");
2408                                         Assert.IsNotNull (win32Error.Message, "#N9");
2409                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#N10");
2410                                         Assert.IsNull (win32Error.InnerException, "#N11");
2411                                 }
2412
2413                                 try {
2414                                         sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_STOP);
2415                                         Assert.Fail ("#O1");
2416                                 } catch (InvalidOperationException ex) {
2417                                         // Cannot control XXX service on computer '.'
2418                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#O2");
2419                                         Assert.IsNotNull (ex.Message, "#O3");
2420                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#O4");
2421                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#O5");
2422                                         Assert.IsNotNull (ex.InnerException, "#O6");
2423
2424                                         // Access is denied
2425                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#O7");
2426                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2427                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#O8");
2428                                         Assert.IsNotNull (win32Error.Message, "#O9");
2429                                         Assert.AreEqual (5, win32Error.NativeErrorCode, "#O10");
2430                                         Assert.IsNull (win32Error.InnerException, "#O11");
2431                                 }
2432                         } finally {
2433                                 EnsureServiceIsRunning (sc);
2434                         }
2435
2436                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#P");
2437                 }
2438
2439                 [Test]
2440                 public void ExecuteCommand_Service_DoesNotExist ()
2441                 {
2442                         if (RunningOnUnix)
2443                                 Assert.Ignore ("Running on Unix.");
2444
2445                         ServiceController sc = new ServiceController ("doesnotexist", ".");
2446                         try {
2447                                 sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_INTERROGATE);
2448                                 Assert.Fail ("#1");
2449                         } catch (InvalidOperationException ex) {
2450                                 // Cannot open doesnotexist service on computer '.'
2451                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
2452                                 Assert.IsNotNull (ex.Message, "#3");
2453                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
2454                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
2455                                 Assert.IsNotNull (ex.InnerException, "#6");
2456
2457                                 // The filename, directory name, or volume label is incorrect
2458                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
2459                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
2460                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
2461                                 Assert.IsNotNull (win32Error.Message, "#9");
2462                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
2463                                 Assert.IsNull (win32Error.InnerException, "#11");
2464                         }
2465                 }
2466
2467                 [Test]
2468                 public void ExecuteCommand_Service_Paused ()
2469                 {
2470                         if (RunningOnUnix)
2471                                 Assert.Ignore ("Running on Unix.");
2472
2473                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
2474                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
2475
2476                         sc.Pause ();
2477
2478                         try {
2479                                 sc.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
2480                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc.Status, "#B");
2481                                 sc.ExecuteCommand (154);
2482                                 sc.Refresh ();
2483                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc.Status, "#C");
2484                                 //sc.ExecuteCommand (127);
2485                         } finally {
2486                                 EnsureServiceIsRunning (sc);
2487                         }
2488
2489                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#D");
2490                 }
2491
2492                 [Test]
2493                 public void ExecuteCommand_Service_PausePending ()
2494                 {
2495                         if (RunningOnUnix)
2496                                 Assert.Ignore ("Running on Unix.");
2497
2498                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
2499                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
2500
2501                         sc.Pause ();
2502
2503                         try {
2504                                 sc.ExecuteCommand (128);
2505
2506                                 try {
2507                                         sc.ExecuteCommand (127);
2508                                         Assert.Fail ("#B1");
2509                                 } catch (InvalidOperationException ex) {
2510                                         // Cannot control XXX service on computer '.'
2511                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
2512                                         Assert.IsNotNull (ex.Message, "#B3");
2513                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#B4");
2514                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
2515                                         Assert.IsNotNull (ex.InnerException, "#B6");
2516
2517                                         // The parameter is incorrect
2518                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
2519                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2520                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
2521                                         Assert.IsNotNull (win32Error.Message, "#B9");
2522                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#B10");
2523                                         Assert.IsNull (win32Error.InnerException, "#B11");
2524                                 }
2525                         } finally {
2526                                 EnsureServiceIsRunning (sc);
2527                         }
2528
2529                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#C");
2530                 }
2531
2532                 [Test]
2533                 public void ExecuteCommand_Service_StartPending ()
2534                 {
2535                         if (RunningOnUnix)
2536                                 Assert.Ignore ("Running on Unix.");
2537
2538                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
2539                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
2540
2541                         sc.Stop ();
2542
2543                         try {
2544                                 sc.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
2545                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc.Status, "#B");
2546
2547                                 sc.Start ();
2548
2549                                 try {
2550                                         sc.ExecuteCommand (127);
2551                                         Assert.Fail ("#C1");
2552                                 } catch (InvalidOperationException ex) {
2553                                         // Cannot control XXX service on computer '.'
2554                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2555                                         Assert.IsNotNull (ex.Message, "#C3");
2556                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#C4");
2557                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#C5");
2558                                         Assert.IsNotNull (ex.InnerException, "#C6");
2559
2560                                         // The parameter is incorrect
2561                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#C7");
2562                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2563                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#C8");
2564                                         Assert.IsNotNull (win32Error.Message, "#C9");
2565                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#C10");
2566                                         Assert.IsNull (win32Error.InnerException, "#C11");
2567                                 }
2568
2569                                 try {
2570                                         sc.ExecuteCommand (128);
2571                                         Assert.Fail ("#D1");
2572                                 } catch (InvalidOperationException ex) {
2573                                         // Cannot control XXX service on computer '.'
2574                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
2575                                         Assert.IsNotNull (ex.Message, "#D3");
2576                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#D4");
2577                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#D5");
2578                                         Assert.IsNotNull (ex.InnerException, "#D6");
2579
2580                                         // The service cannot accept control messages at this time
2581                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#D7");
2582                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2583                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#D8");
2584                                         Assert.IsNotNull (win32Error.Message, "#D9");
2585                                         Assert.AreEqual (1061, win32Error.NativeErrorCode, "#D10");
2586                                         Assert.IsNull (win32Error.InnerException, "#D11");
2587                                 }
2588                         } finally {
2589                                 EnsureServiceIsRunning (sc);
2590                         }
2591
2592                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#D");
2593                 }
2594
2595                 [Test]
2596                 public void ExecuteCommand_Service_Stopped ()
2597                 {
2598                         if (RunningOnUnix)
2599                                 Assert.Ignore ("Running on Unix.");
2600
2601                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
2602                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
2603
2604                         sc.Stop ();
2605
2606                         try {
2607                                 sc.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
2608                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc.Status, "#B");
2609
2610                                 try {
2611                                         sc.ExecuteCommand (127);
2612                                         Assert.Fail ("#C1");
2613                                 } catch (InvalidOperationException ex) {
2614                                         // Cannot control XXX service on computer '.'
2615                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
2616                                         Assert.IsNotNull (ex.Message, "#C3");
2617                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#C4");
2618                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#C5");
2619                                         Assert.IsNotNull (ex.InnerException, "#C6");
2620
2621                                         // The parameter is incorrect
2622                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#C7");
2623                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2624                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#C8");
2625                                         Assert.IsNotNull (win32Error.Message, "#C9");
2626                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#C10");
2627                                         Assert.IsNull (win32Error.InnerException, "#C11");
2628                                 }
2629
2630                                 try {
2631                                         sc.ExecuteCommand (128);
2632                                         Assert.Fail ("#D1");
2633                                 } catch (InvalidOperationException ex) {
2634                                         // Cannot control XXX service on computer '.'
2635                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
2636                                         Assert.IsNotNull (ex.Message, "#D3");
2637                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#D4");
2638                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#D5");
2639                                         Assert.IsNotNull (ex.InnerException, "#D6");
2640
2641                                         // The service has not been started
2642                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#D7");
2643                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2644                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#D8");
2645                                         Assert.IsNotNull (win32Error.Message, "#D9");
2646                                         Assert.AreEqual (1062, win32Error.NativeErrorCode, "#D10");
2647                                         Assert.IsNull (win32Error.InnerException, "#D11");
2648                                 }
2649                         } finally {
2650                                 EnsureServiceIsRunning (sc);
2651                         }
2652
2653                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#E");
2654                 }
2655
2656                 [Test]
2657                 public void ExecuteCommand_Service_StopPending ()
2658                 {
2659                         if (RunningOnUnix)
2660                                 Assert.Ignore ("Running on Unix.");
2661
2662                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
2663                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
2664
2665                         sc.Stop ();
2666
2667                         try {
2668                                 try {
2669                                         sc.ExecuteCommand (127);
2670                                         Assert.Fail ("#B1");
2671                                 } catch (InvalidOperationException ex) {
2672                                         // Cannot control XXX service on computer '.'
2673                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
2674                                         Assert.IsNotNull (ex.Message, "#B3");
2675                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#B4");
2676                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
2677                                         Assert.IsNotNull (ex.InnerException, "#B6");
2678
2679                                         // The parameter is incorrect
2680                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
2681                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2682                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
2683                                         Assert.IsNotNull (win32Error.Message, "#B9");
2684                                         Assert.AreEqual (87, win32Error.NativeErrorCode, "#B10");
2685                                         Assert.IsNull (win32Error.InnerException, "#B11");
2686                                 }
2687
2688                                 try {
2689                                         sc.ExecuteCommand (128);
2690                                         Assert.Fail ("#C1");
2691                                 } catch (InvalidOperationException ex) {
2692                                         // Cannot control XXX service on computer '.'
2693                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
2694                                         Assert.IsNotNull (ex.Message, "#C3");
2695                                         Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#C4");
2696                                         Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#C5");
2697                                         Assert.IsNotNull (ex.InnerException, "#C6");
2698
2699                                         // The service cannot accept control messages at this time
2700                                         Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#C7");
2701                                         Win32Exception win32Error = (Win32Exception) ex.InnerException;
2702                                         //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#C8");
2703                                         Assert.IsNotNull (win32Error.Message, "#C9");
2704                                         Assert.AreEqual (1061, win32Error.NativeErrorCode, "#C10");
2705                                         Assert.IsNull (win32Error.InnerException, "#C11");
2706                                 }
2707                         } finally {
2708                                 EnsureServiceIsRunning (sc);
2709                         }
2710
2711                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#D");
2712                 }
2713
2714                 [Test]
2715                 public void ExecuteCommand_ServiceName_Empty ()
2716                 {
2717                         ServiceController sc = new ServiceController ();
2718                         try {
2719                                 sc.ExecuteCommand ((int) SERVICE_CONTROL_TYPE.SERVICE_CONTROL_INTERROGATE);
2720                                 Assert.Fail ("#1");
2721                         } catch (ArgumentException ex) {
2722                                 // Service name  contains invalid characters, is empty or is
2723                                 // too long (max length = 80)
2724                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
2725                                 Assert.IsNotNull (ex.Message, "#3");
2726                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
2727                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
2728                                 Assert.IsNull (ex.ParamName, "#6");
2729                                 Assert.IsNull (ex.InnerException, "#7");
2730                         }
2731                 }
2732
2733                 [Test]
2734                 public void GetDevices ()
2735                 {
2736                         if (RunningOnUnix)
2737                                 Assert.Ignore ("Running on Unix.");
2738
2739                         ServiceController [] devices = null;
2740
2741                         devices = ServiceController.GetDevices ();
2742                         Assert.IsNotNull (devices, "#A1");
2743
2744                         bool foundKernelService = false;
2745                         bool foundShareProcessService = false;
2746
2747                         foreach (ServiceController sc in devices) {
2748                                 if (sc.ServiceName.ToLower () == KERNEL_SERVICE.ServiceName.ToLower ()) {
2749                                         Assert.AreEqual (KERNEL_SERVICE.DisplayName, sc.DisplayName, "#A2");
2750                                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A3");
2751                                         foundKernelService = true;
2752                                 } else if (sc.ServiceName.ToLower () == SHARE_PROCESS_SERVICE.ServiceName.ToLower ()) {
2753                                         foundShareProcessService = true;
2754                                 }
2755                         }
2756
2757                         Assert.IsTrue (foundKernelService, "#A4");
2758                         Assert.IsFalse (foundShareProcessService, "#A5");
2759
2760                         devices = ServiceController.GetDevices (Environment.MachineName);
2761                         Assert.IsNotNull (devices, "#B1");
2762
2763                         foundKernelService = false;
2764                         foundShareProcessService = false;
2765
2766                         foreach (ServiceController sc in devices) {
2767                                 if (sc.ServiceName.ToLower () == KERNEL_SERVICE.ServiceName.ToLower ()) {
2768                                         Assert.AreEqual (KERNEL_SERVICE.DisplayName, sc.DisplayName, "#B2");
2769                                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#B3");
2770                                         foundKernelService = true;
2771                                 } else if (sc.ServiceName.ToLower () == SHARE_PROCESS_SERVICE.ServiceName.ToLower ()) {
2772                                         foundShareProcessService = true;
2773                                 }
2774                         }
2775
2776                         Assert.IsTrue (foundKernelService, "#B4");
2777                         Assert.IsFalse (foundShareProcessService, "#B5");
2778                 }
2779
2780                 [Test]
2781                 public void GetDevices_Machine_DoesNotExist ()
2782                 {
2783                         if (RunningOnUnix)
2784                                 Assert.Ignore ("Running on Unix.");
2785
2786                         try {
2787                                 ServiceController [] devices = ServiceController.GetDevices ("doesnotexist");
2788                                 Assert.Fail ("#1: " + devices.Length);
2789                         } catch (InvalidOperationException ex) {
2790                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
2791                                 // This operation might require other priviliges
2792                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
2793                                 Assert.IsNotNull (ex.Message, "#3");
2794                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
2795                                 Assert.IsNotNull (ex.InnerException, "#5");
2796
2797                                 // The RPC server is unavailable
2798                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
2799                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
2800                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
2801                                 Assert.IsNotNull (win32Error.Message, "#8");
2802                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
2803                                 Assert.IsNull (win32Error.InnerException, "#10");
2804                         }
2805                 }
2806
2807                 [Test]
2808                 public void GetDevices_MachineName_Empty ()
2809                 {
2810                         try {
2811                                 ServiceController.GetDevices (string.Empty);
2812                                 Assert.Fail ("#1");
2813                         } catch (ArgumentException ex) {
2814                                 // MachineName value  is invalid
2815                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
2816                                 Assert.IsNotNull (ex.Message, "#3");
2817                                 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
2818                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
2819                                 Assert.IsNull (ex.ParamName, "#6");
2820                                 Assert.IsNull (ex.InnerException, "#7");
2821                         }
2822                 }
2823
2824                 [Test]
2825                 public void GetDevices_MachineName_Null ()
2826                 {
2827                         try {
2828                                 ServiceController.GetDevices (null);
2829                                 Assert.Fail ("#1");
2830                         } catch (ArgumentException ex) {
2831                                 // MachineName value  is invalid
2832                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
2833                                 Assert.IsNotNull (ex.Message, "#3");
2834                                 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
2835                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
2836                                 Assert.IsNull (ex.ParamName, "#6");
2837                                 Assert.IsNull (ex.InnerException, "#7");
2838                         }
2839                 }
2840
2841                 [Test]
2842                 public void GetServices ()
2843                 {
2844                         if (RunningOnUnix)
2845                                 Assert.Ignore ("Running on Unix.");
2846
2847                         ServiceController [] services = null;
2848
2849                         services = ServiceController.GetServices ();
2850                         Assert.IsNotNull (services, "#A1");
2851
2852                         bool foundKernelService = false;
2853                         bool foundShareProcessService = false;
2854
2855                         foreach (ServiceController sc in services) {
2856                                 if (sc.ServiceName.ToLower () == KERNEL_SERVICE.ServiceName.ToLower ()) {
2857                                         foundKernelService = true;
2858                                 } else if (sc.ServiceName.ToLower () == SHARE_PROCESS_SERVICE.ServiceName.ToLower ()) {
2859                                         foundShareProcessService = true;
2860                                 }
2861                         }
2862
2863                         Assert.IsFalse (foundKernelService, "#A4");
2864                         Assert.IsTrue (foundShareProcessService, "#A5");
2865
2866                         services = ServiceController.GetServices (Environment.MachineName);
2867                         Assert.IsNotNull (services, "#B1");
2868
2869                         foundKernelService = false;
2870                         foundShareProcessService = false;
2871
2872                         foreach (ServiceController sc in services) {
2873                                 if (sc.ServiceName.ToLower () == KERNEL_SERVICE.ServiceName.ToLower ()) {
2874                                         foundKernelService = true;
2875                                 } else if (sc.ServiceName.ToLower () == SHARE_PROCESS_SERVICE.ServiceName.ToLower ()) {
2876                                         Assert.AreEqual (SHARE_PROCESS_SERVICE.DisplayName, sc.DisplayName, "#B2");
2877                                         Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#B3");
2878                                         foundShareProcessService = true;
2879                                 }
2880                         }
2881
2882                         Assert.IsFalse (foundKernelService, "#B4");
2883                         Assert.IsTrue (foundShareProcessService, "#B5");
2884                 }
2885
2886                 [Test]
2887                 public void GetServices_Machine_DoesNotExist ()
2888                 {
2889                         if (RunningOnUnix)
2890                                 Assert.Ignore ("Running on Unix.");
2891
2892                         try {
2893                                 ServiceController [] services = ServiceController.GetServices ("doesnotexist");
2894                                 Assert.Fail ("#1: " + services.Length);
2895                         } catch (InvalidOperationException ex) {
2896                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
2897                                 // This operation might require other priviliges
2898                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
2899                                 Assert.IsNotNull (ex.Message, "#3");
2900                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
2901                                 Assert.IsNotNull (ex.InnerException, "#5");
2902
2903                                 // The RPC server is unavailable
2904                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
2905                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
2906                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
2907                                 Assert.IsNotNull (win32Error.Message, "#8");
2908                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
2909                                 Assert.IsNull (win32Error.InnerException, "#10");
2910                         }
2911                 }
2912
2913                 [Test]
2914                 public void GetServices_MachineName_Empty ()
2915                 {
2916                         try {
2917                                 ServiceController.GetServices (string.Empty);
2918                                 Assert.Fail ("#1");
2919                         } catch (ArgumentException ex) {
2920                                 // MachineName value  is invalid
2921                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
2922                                 Assert.IsNotNull (ex.Message, "#3");
2923                                 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
2924                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
2925                                 Assert.IsNull (ex.ParamName, "#6");
2926                                 Assert.IsNull (ex.InnerException, "#7");
2927                         }
2928                 }
2929
2930                 [Test]
2931                 public void GetServices_MachineName_Null ()
2932                 {
2933                         try {
2934                                 ServiceController.GetServices (null);
2935                                 Assert.Fail ("#1");
2936                         } catch (ArgumentException ex) {
2937                                 // MachineName value  is invalid
2938                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
2939                                 Assert.IsNotNull (ex.Message, "#3");
2940                                 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
2941                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
2942                                 Assert.IsNull (ex.ParamName, "#6");
2943                                 Assert.IsNull (ex.InnerException, "#7");
2944                         }
2945                 }
2946
2947                 [Test]
2948                 public void MachineName ()
2949                 {
2950                         if (RunningOnUnix)
2951                                 Assert.Ignore ("Running on Unix.");
2952
2953                         ServiceController sc = new ServiceController ();
2954                         sc.ServiceName = WORKSTATION_SERVICE.ServiceName;
2955                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName, sc.DisplayName, "#A1");
2956                         Assert.AreEqual (".", sc.MachineName, "#A2");
2957                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#A3");
2958
2959                         sc.MachineName = Environment.MachineName;
2960                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName, sc.DisplayName, "#B1");
2961                         Assert.AreEqual (Environment.MachineName, sc.MachineName, "#B2");
2962                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#B3");
2963
2964                         sc.MachineName = "doesnotexist";
2965                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName, sc.DisplayName, "#C1");
2966                         Assert.AreEqual ("doesnotexist", sc.MachineName, "#C2");
2967                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#C3");
2968
2969                         sc.MachineName = "DoesNotExist";
2970                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName, sc.DisplayName, "#D1");
2971                         Assert.AreEqual ("DoesNotExist", sc.MachineName, "#D2");
2972                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#D3");
2973                 }
2974
2975                 [Test]
2976                 public void MachineName_Empty ()
2977                 {
2978                         if (RunningOnUnix)
2979                                 Assert.Ignore ("Running on Unix.");
2980
2981                         ServiceController sc = new ServiceController ();
2982                         sc.MachineName = Environment.MachineName;
2983                         try {
2984                                 sc.MachineName = string.Empty;
2985                                 Assert.Fail ("#1");
2986                         } catch (ArgumentException ex) {
2987                                 // MachineName value  is invalid
2988                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
2989                                 Assert.IsNotNull (ex.Message, "#3");
2990                                 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
2991                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
2992                                 Assert.IsNull (ex.ParamName, "#6");
2993                                 Assert.IsNull (ex.InnerException, "#7");
2994                         }
2995                         Assert.AreEqual (Environment.MachineName, sc.MachineName, "#8");
2996                 }
2997
2998                 [Test]
2999                 public void MachineName_Null ()
3000                 {
3001                         if (RunningOnUnix)
3002                                 Assert.Ignore ("Running on Unix.");
3003
3004                         ServiceController sc = new ServiceController ();
3005                         sc.MachineName = Environment.MachineName;
3006                         try {
3007                                 sc.MachineName = null;
3008                                 Assert.Fail ("#1");
3009                         } catch (ArgumentException ex) {
3010                                 // MachineName value  is invalid
3011                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3012                                 Assert.IsNotNull (ex.Message, "#3");
3013                                 Assert.IsTrue (ex.Message.IndexOf ("MachineName") != -1, "#4");
3014                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#5");
3015                                 Assert.IsNull (ex.ParamName, "#6");
3016                                 Assert.IsNull (ex.InnerException, "#7");
3017                         }
3018                         Assert.AreEqual (Environment.MachineName, sc.MachineName, "#8");
3019                 }
3020
3021                 [Test]
3022                 public void Pause ()
3023                 {
3024                         if (RunningOnUnix)
3025                                 Assert.Ignore ("Running on Unix.");
3026
3027                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3028                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3029
3030                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
3031                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
3032
3033                         sc1.Pause ();
3034
3035                         try {
3036                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
3037                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
3038
3039                                 sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
3040
3041                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#C1");
3042                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
3043                         } finally {
3044                                 EnsureServiceIsRunning (sc1);
3045                                 sc2.Refresh ();
3046                         }
3047
3048                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#D1");
3049                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");
3050                 }
3051
3052                 [Test]
3053                 public void Pause_Machine_DoesNotExist ()
3054                 {
3055                         if (RunningOnUnix)
3056                                 Assert.Ignore ("Running on Unix.");
3057
3058                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
3059                                 "doesnotexist");
3060                         try {
3061                                 sc.Pause ();
3062                                 Assert.Fail ("#1");
3063                         } catch (InvalidOperationException ex) {
3064                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
3065                                 // This operation might require other priviliges
3066                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
3067                                 Assert.IsNotNull (ex.Message, "#3");
3068                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
3069                                 Assert.IsNotNull (ex.InnerException, "#5");
3070
3071                                 // The RPC server is unavailable
3072                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
3073                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3074                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
3075                                 Assert.IsNotNull (win32Error.Message, "#8");
3076                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
3077                                 Assert.IsNull (win32Error.InnerException, "#10");
3078                         }
3079                 }
3080
3081                 [Test]
3082                 public void Pause_Service_Disabled ()
3083                 {
3084                         if (RunningOnUnix)
3085                                 Assert.Ignore ("Running on Unix.");
3086
3087                         ServiceController sc1 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
3088                         ServiceController sc2 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
3089
3090                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#A1");
3091                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#A2");
3092
3093                         try {
3094                                 sc1.Pause ();
3095                                 Assert.Fail ("#B1");
3096                         } catch (InvalidOperationException ex) {
3097                                 // Cannot pause NetDDE service on computer '.'
3098                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
3099                                 Assert.IsNotNull (ex.Message, "#B3");
3100                                 Assert.IsTrue (ex.Message.IndexOf (DISABLED_SERVICE.ServiceName) != -1, "#B4");
3101                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
3102                                 Assert.IsNotNull (ex.InnerException, "#B6");
3103
3104                                 // The service has not been started
3105                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
3106                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3107                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
3108                                 Assert.IsNotNull (win32Error.Message, "#B9");
3109                                 Assert.AreEqual (1062, win32Error.NativeErrorCode, "#B10");
3110                                 Assert.IsNull (win32Error.InnerException, "#B11");
3111                         }
3112
3113                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
3114                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#C2");
3115                 }
3116
3117                 [Test]
3118                 public void Pause_Service_DoesNotExist ()
3119                 {
3120                         if (RunningOnUnix)
3121                                 Assert.Ignore ("Running on Unix.");
3122
3123                         ServiceController sc = new ServiceController ("doesnotexist", ".");
3124                         try {
3125                                 sc.Pause ();
3126                                 Assert.Fail ("#1");
3127                         } catch (InvalidOperationException ex) {
3128                                 // Cannot open doesnotexist service on computer '.'
3129                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
3130                                 Assert.IsNotNull (ex.Message, "#3");
3131                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
3132                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
3133                                 Assert.IsNotNull (ex.InnerException, "#6");
3134
3135                                 // The filename, directory name, or volume label is incorrect
3136                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
3137                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3138                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
3139                                 Assert.IsNotNull (win32Error.Message, "#9");
3140                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
3141                                 Assert.IsNull (win32Error.InnerException, "#11");
3142                         }
3143                 }
3144
3145                 [Test]
3146                 public void Pause_Service_OperationNotValid ()
3147                 {
3148                         if (RunningOnUnix)
3149                                 Assert.Ignore ("Running on Unix.");
3150
3151                         ServiceController sc1 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
3152                         ServiceController sc2 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
3153
3154                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
3155                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
3156
3157                         try {
3158                                 sc1.Pause ();
3159                                 Assert.Fail ("#B1");
3160                         } catch (InvalidOperationException ex) {
3161                                 // Cannot pause XXX service on computer '.'
3162                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
3163                                 Assert.IsNotNull (ex.Message, "#B3");
3164                                 Assert.IsTrue (ex.Message.IndexOf (UNCONTROLLABLE_SERVICE.ServiceName) != -1, "#B4");
3165                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
3166                                 Assert.IsNotNull (ex.InnerException, "#B6");
3167
3168                                 // The requested control is not valid for this service
3169                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
3170                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3171                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
3172                                 Assert.IsNotNull (win32Error.Message, "#B9");
3173                                 Assert.AreEqual (1052, win32Error.NativeErrorCode, "#B10");
3174                                 Assert.IsNull (win32Error.InnerException, "#B11");
3175                         }
3176
3177                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#C1");
3178                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
3179                 }
3180
3181                 [Test]
3182                 public void Pause_Service_Paused ()
3183                 {
3184                         if (RunningOnUnix)
3185                                 Assert.Ignore ("Running on Unix.");
3186
3187                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3188                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3189
3190                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
3191                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
3192
3193                         sc1.Pause ();
3194
3195                         try {
3196                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
3197                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
3198
3199                                 sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
3200
3201                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#C1");
3202                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
3203
3204                                 sc1.Pause ();
3205
3206                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#D1");
3207                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");
3208                         } finally {
3209                                 EnsureServiceIsRunning (sc1);
3210                                 sc2.Refresh ();
3211                         }
3212
3213                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#E1");
3214                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#E2");
3215                 }
3216
3217                 [Test]
3218                 public void Pause_Service_Stopped ()
3219                 {
3220                         if (RunningOnUnix)
3221                                 Assert.Ignore ("Running on Unix.");
3222
3223                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3224                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3225
3226                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
3227                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
3228
3229                         sc1.Stop ();
3230
3231                         try {
3232                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
3233                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
3234
3235                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
3236
3237                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
3238                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
3239
3240                                 sc1.Pause ();
3241                                 Assert.Fail ("#D1");
3242                         } catch (InvalidOperationException ex) {
3243                                 // Cannot pause XXX service on computer '.'
3244                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
3245                                 Assert.IsNotNull (ex.Message, "#D3");
3246                                 Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#D4");
3247                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#D5");
3248                                 Assert.IsNotNull (ex.InnerException, "#D6");
3249
3250                                 // The service has not been started
3251                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#D7");
3252                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3253                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#D8");
3254                                 Assert.IsNotNull (win32Error.Message, "#D9");
3255                                 Assert.AreEqual (1062, win32Error.NativeErrorCode, "#D10");
3256                                 Assert.IsNull (win32Error.InnerException, "#D11");
3257                         } finally {
3258                                 EnsureServiceIsRunning (sc1);
3259                                 sc2.Refresh ();
3260                         }
3261
3262                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#E1");
3263                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#E2");
3264                 }
3265
3266                 [Test]
3267                 public void Pause_ServiceName_Empty ()
3268                 {
3269                         ServiceController sc = new ServiceController ();
3270                         try {
3271                                 sc.Pause ();
3272                                 Assert.Fail ("#1");
3273                         } catch (ArgumentException ex) {
3274                                 // Service name  contains invalid characters, is empty or is
3275                                 // too long (max length = 80)
3276                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3277                                 Assert.IsNotNull (ex.Message, "#3");
3278                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
3279                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
3280                                 Assert.IsNull (ex.ParamName, "#6");
3281                                 Assert.IsNull (ex.InnerException, "#7");
3282                         }
3283                 }
3284
3285                 [Test]
3286                 public void Refresh ()
3287                 {
3288                         if (RunningOnUnix)
3289                                 Assert.Ignore ("Running on Unix.");
3290
3291                         ServiceController sc = null;
3292                         ServiceController [] dependentServices = null;
3293                         ServiceController [] servicesDependedOn = null;
3294
3295                         sc = new ServiceController (SERVICE_1_WITH_DEPENDENTS_AND_DEPENDED_ON.ServiceName, ".");
3296                         dependentServices = sc.DependentServices;
3297                         Assert.IsNotNull (dependentServices, "#A1");
3298                         Assert.AreEqual (SERVICE_1_WITH_DEPENDENTS_AND_DEPENDED_ON.Dependents, ServiceNames (dependentServices), "#A2");
3299                         servicesDependedOn = sc.ServicesDependedOn;
3300                         Assert.AreEqual (SERVICE_1_WITH_DEPENDENTS_AND_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#A3");
3301
3302                         sc.ServiceName = SERVICE_2_WITH_DEPENDENTS_AND_DEPENDED_ON.ServiceName;
3303                         sc.Refresh ();
3304
3305                         dependentServices = sc.DependentServices;
3306                         Assert.IsNotNull (dependentServices, "#B1");
3307                         Assert.AreEqual (SERVICE_2_WITH_DEPENDENTS_AND_DEPENDED_ON.Dependents, ServiceNames (dependentServices), "#B2");
3308                         servicesDependedOn = sc.ServicesDependedOn;
3309                         Assert.IsNotNull (servicesDependedOn, "#B3");
3310                         Assert.AreEqual (SERVICE_2_WITH_DEPENDENTS_AND_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#A4");
3311
3312                         sc.DisplayName = SERVICE_3_WITH_DEPENDENTS_AND_DEPENDED_ON.ServiceName;
3313                         sc.Refresh ();
3314
3315                         dependentServices = sc.DependentServices;
3316                         Assert.IsNotNull (dependentServices, "#C1");
3317                         Assert.AreEqual (SERVICE_3_WITH_DEPENDENTS_AND_DEPENDED_ON.Dependents, ServiceNames (dependentServices), "#C2");
3318                         servicesDependedOn = sc.ServicesDependedOn;
3319                         Assert.IsNotNull (servicesDependedOn, "#C3");
3320                         Assert.AreEqual (SERVICE_3_WITH_DEPENDENTS_AND_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#C4");
3321                 }
3322
3323                 [Test]
3324                 public void Refresh_Machine_DoesNotExist ()
3325                 {
3326                         if (RunningOnUnix)
3327                                 Assert.Ignore ("Running on Unix.");
3328
3329                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
3330                                 "doesnotexist");
3331                         sc.Refresh ();
3332                 }
3333
3334                 [Test]
3335                 public void Refresh_Service_DoesNotExist ()
3336                 {
3337                         if (RunningOnUnix)
3338                                 Assert.Ignore ("Running on Unix.");
3339
3340                         ServiceController sc = new ServiceController ("doesnotexist", ".");
3341                         sc.Refresh ();
3342                 }
3343
3344                 [Test]
3345                 public void Refresh_Service_Paused ()
3346                 {
3347                         if (RunningOnUnix)
3348                                 Assert.Ignore ("Running on Unix.");
3349
3350                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3351                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3352
3353                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
3354                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
3355
3356                         sc1.Pause ();
3357
3358                         try {
3359                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
3360                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
3361
3362                                 sc1.Refresh ();
3363
3364                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#C1");
3365                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
3366
3367                                 sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
3368
3369                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#D1");
3370                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");
3371
3372                                 sc2.Refresh ();
3373
3374                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#E1");
3375                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc2.Status, "#E2");
3376                         } finally {
3377                                 EnsureServiceIsRunning (sc1);
3378                                 sc2.Refresh ();
3379                         }
3380
3381                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
3382                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
3383                 }
3384
3385                 [Test]
3386                 public void Refresh_Service_Running ()
3387                 {
3388                         if (RunningOnUnix)
3389                                 Assert.Ignore ("Running on Unix.");
3390
3391                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3392                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3393
3394                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
3395                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
3396
3397                         sc1.Stop ();
3398
3399                         try {
3400                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
3401                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
3402
3403                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
3404                                 sc2.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
3405
3406                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
3407                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#C2");
3408
3409                                 sc1.Start ();
3410
3411                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#D1");
3412                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#D2");
3413
3414                                 sc1.Refresh ();
3415
3416                                 Assert.AreEqual (ServiceControllerStatus.StartPending, sc1.Status, "#E1");
3417                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#E2");
3418
3419                                 sc1.WaitForStatus (ServiceControllerStatus.Running, new TimeSpan (0, 0, 5));
3420
3421                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
3422                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#F2");
3423
3424                                 sc2.Refresh ();
3425
3426                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#G1");
3427                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#G2");
3428                         } finally {
3429                                 EnsureServiceIsRunning (sc1);
3430                                 sc2.Refresh ();
3431                         }
3432
3433                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#H1");
3434                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#H2");
3435                 }
3436
3437                 [Test]
3438                 public void Refresh_Service_Stopped ()
3439                 {
3440                         if (RunningOnUnix)
3441                                 Assert.Ignore ("Running on Unix.");
3442
3443                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3444                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
3445
3446                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
3447                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
3448
3449                         sc1.Stop ();
3450
3451                         try {
3452                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
3453                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
3454
3455                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
3456
3457                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#D1");
3458                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");
3459
3460                                 sc2.Refresh ();
3461
3462                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#E1");
3463                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#E2");
3464                         } finally {
3465                                 EnsureServiceIsRunning (sc1);
3466                                 sc2.Refresh ();
3467                         }
3468
3469                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
3470                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
3471                 }
3472
3473                 [Test]
3474                 public void Refresh_ServiceName_Empty ()
3475                 {
3476                         if (RunningOnUnix)
3477                                 Assert.Ignore ("Running on Unix.");
3478
3479                         ServiceController sc = new ServiceController ();
3480                         sc.Refresh ();
3481                 }
3482
3483                 [Test]
3484                 public void ServiceName ()
3485                 {
3486                         if (RunningOnUnix)
3487                                 Assert.Ignore ("Running on Unix.");
3488
3489                         var s1 = WORKSTATION_SERVICE;
3490                         var s2 = WINDOWS_SEARCH_SERVICE;
3491
3492                         ServiceController sc = new ServiceController ();
3493                         sc.ServiceName = s1.ServiceName;
3494                         Assert.AreEqual (s1.DisplayName, sc.DisplayName, "#A1");
3495                         Assert.AreEqual (s1.ServiceName, sc.ServiceName, "#A2");
3496
3497                         sc.ServiceName = s2.ServiceName;
3498                         Assert.AreEqual (s2.DisplayName, sc.DisplayName, "#B1");
3499                         Assert.AreEqual (s2.ServiceName, sc.ServiceName, "#B2");
3500
3501                         sc = new ServiceController (s1.ServiceName);
3502                         sc.ServiceName = s2.ServiceName;
3503                         Assert.AreEqual (s2.ServiceName, sc.ServiceName, "#C1");
3504                         Assert.AreEqual (s2.DisplayName, sc.DisplayName, "#C2");
3505                         Assert.AreEqual (s2.DisplayName, sc.DisplayName, "#C3");
3506
3507                         sc.ServiceName = s2.ServiceName;
3508                         Assert.AreEqual (s2.ServiceName, sc.ServiceName, "#D1");
3509                         Assert.AreEqual (s2.DisplayName, sc.DisplayName, "#D2");
3510
3511                         sc.ServiceName = s1.ServiceName;
3512                         Assert.AreEqual (s1.ServiceName, sc.ServiceName, "#E1");
3513                         Assert.AreEqual (s1.DisplayName, sc.DisplayName, "#E2");
3514
3515                         sc = new ServiceController (s1.ServiceName.ToUpper ());
3516                         Assert.AreEqual (s1.ServiceName.ToUpper (), sc.ServiceName, "#F1");
3517                         Assert.AreEqual (s1.DisplayName, sc.DisplayName, "#F2");
3518
3519                         var serviceName = s1.ServiceName [0].ToString ().ToUpper () + s1.ServiceName.Substring (1).ToLower ();
3520                         sc.ServiceName = serviceName;
3521                         Assert.AreEqual (serviceName, sc.ServiceName, "#G1");
3522                         Assert.AreEqual (s1.DisplayName, sc.DisplayName, "#G2");
3523                 }
3524
3525                 [Test]
3526                 public void ServiceName_Machine_DoesNotExist ()
3527                 {
3528                         if (RunningOnUnix)
3529                                 Assert.Ignore ("Running on Unix.");
3530
3531                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
3532                                 "doesnotexist");
3533                         try {
3534                                 string serviceName = sc.ServiceName;
3535                                 Assert.Fail ("#1: " + serviceName);
3536                         } catch (InvalidOperationException ex) {
3537                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
3538                                 // This operation might require other priviliges
3539                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
3540                                 Assert.IsNotNull (ex.Message, "#3");
3541                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
3542                                 Assert.IsNotNull (ex.InnerException, "#5");
3543
3544                                 // The RPC server is unavailable
3545                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
3546                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3547                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
3548                                 Assert.IsNotNull (win32Error.Message, "#8");
3549                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
3550                                 Assert.IsNull (win32Error.InnerException, "#10");
3551                         }
3552                 }
3553
3554                 [Test]
3555                 public void ServiceName_Service_Disabled ()
3556                 {
3557                         if (RunningOnUnix)
3558                                 Assert.Ignore ("Running on Unix.");
3559
3560                         ServiceController sc = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
3561                         Assert.AreEqual (DISABLED_SERVICE.ServiceName, sc.ServiceName);
3562                 }
3563
3564                 [Test]
3565                 public void ServiceName_Service_DoesNotExist ()
3566                 {
3567                         if (RunningOnUnix)
3568                                 Assert.Ignore ("Running on Unix.");
3569
3570                         ServiceController sc = new ServiceController ("doesnotexist", ".");
3571                         try {
3572                                 string serviceName = sc.ServiceName;
3573                                 Assert.Fail ("#1: " + serviceName);
3574                         } catch (InvalidOperationException ex) {
3575                                 // Cannot open doesnotexist service on computer '.'
3576                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
3577                                 Assert.IsNotNull (ex.Message, "#3");
3578                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
3579                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
3580                                 Assert.IsNotNull (ex.InnerException, "#6");
3581
3582                                 // The filename, directory name, or volume label is incorrect
3583                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
3584                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3585                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
3586                                 Assert.IsNotNull (win32Error.Message, "#9");
3587                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
3588                                 Assert.IsNull (win32Error.InnerException, "#11");
3589                         }
3590                 }
3591
3592                 [Test]
3593                 public void ServiceName_DisplayName_Empty ()
3594                 {
3595                         if (RunningOnUnix)
3596                                 Assert.Ignore ("Running on Unix.");
3597
3598                         ServiceController sc = new ServiceController ();
3599                         sc.ServiceName = WORKSTATION_SERVICE.ServiceName;
3600                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName, sc.DisplayName, "#1");
3601                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#2");
3602                 }
3603
3604                 [Test]
3605                 public void ServiceName_Value_DoesNotExist ()
3606                 {
3607                         if (RunningOnUnix)
3608                                 Assert.Ignore ("Running on Unix.");
3609
3610                         ServiceController sc = new ServiceController ();
3611                         sc.ServiceName = "doesnotexist";
3612                         try {
3613                                 string displayName = sc.DisplayName;
3614                                 Assert.Fail ("#1: " + displayName);
3615                         } catch (InvalidOperationException ex) {
3616                                 // Service doesnotexist was not found on computer '.'
3617                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
3618                                 Assert.IsNotNull (ex.Message, "#3");
3619                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
3620                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
3621                                 Assert.IsNotNull (ex.InnerException, "#6");
3622
3623                                 // The specified service does not exist as an installed service
3624                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
3625                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3626                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
3627                                 Assert.IsNotNull (win32Error.Message, "#9");
3628                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
3629                                 Assert.IsNull (win32Error.InnerException, "#11");
3630                         }
3631                         Assert.AreEqual ("doesnotexist", sc.ServiceName, "#12");
3632                 }
3633
3634                 [Test]
3635                 public void ServiceName_Value_Empty ()
3636                 {
3637                         if (RunningOnUnix)
3638                                 Assert.Ignore ("Running on Unix.");
3639
3640                         ServiceController sc = new ServiceController ();
3641                         Assert.AreEqual (string.Empty, sc.DisplayName, "#A1");
3642                         Assert.AreEqual (string.Empty, sc.ServiceName, "#A2");
3643
3644                         sc.ServiceName = WORKSTATION_SERVICE.ServiceName;
3645
3646                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName, sc.DisplayName, "#B1");
3647                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#B2");
3648
3649                         try {
3650                                 sc.ServiceName = string.Empty;
3651                                 Assert.Fail ("#C1");
3652                         } catch (ArgumentException ex) {
3653                                 // Service name  contains invalid characters, is empty or is
3654                                 // too long (max length = 80)
3655                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
3656                                 Assert.IsNotNull (ex.Message, "#A3");
3657                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#A4");
3658                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#A5");
3659                                 Assert.IsNull (ex.ParamName, "#A6");
3660                                 Assert.IsNull (ex.InnerException, "#A7");
3661                         }
3662                 }
3663
3664                 [Test]
3665                 public void ServiceName_Value_Null ()
3666                 {
3667                         if (RunningOnUnix)
3668                                 Assert.Ignore ("Running on Unix.");
3669
3670                         ServiceController sc = new ServiceController ();
3671                         sc.ServiceName = WORKSTATION_SERVICE.ServiceName;
3672                         try {
3673                                 sc.ServiceName = null;
3674                                 Assert.Fail ("#1");
3675                         } catch (ArgumentNullException ex) {
3676                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
3677                                 Assert.IsNotNull (ex.Message, "#3");
3678                                 Assert.IsNotNull (ex.ParamName, "#4");
3679                                 Assert.AreEqual ("value", ex.ParamName, "#5");
3680                                 Assert.IsNull (ex.InnerException, "#6");
3681                         }
3682
3683                         Assert.AreEqual (WORKSTATION_SERVICE.ServiceName, sc.ServiceName, "#7");
3684                 }
3685
3686                 [Test]
3687                 public void ServiceName_Value_DisplayName ()
3688                 {
3689                         if (RunningOnUnix)
3690                                 Assert.Ignore ("Running on Unix.");
3691
3692                         ServiceController sc = new ServiceController ();
3693                         sc.ServiceName = WORKSTATION_SERVICE.DisplayName.ToLower ();
3694                         try {
3695                                 string displayName = sc.DisplayName;
3696                                 Assert.Fail ("#1: " + displayName);
3697                         } catch (InvalidOperationException ex) {
3698                                 // Display name could not be retrieved for service XXX
3699                                 // on computer '.'
3700                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
3701                                 Assert.IsNotNull (ex.Message, "#3");
3702                                 Assert.IsTrue (ex.Message.IndexOf (WORKSTATION_SERVICE.DisplayName.ToLower ()) != -1, "#4");
3703                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
3704                                 Assert.IsNotNull (ex.InnerException, "#6");
3705
3706                                 // The specified service does not exist as an installed service
3707                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
3708                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3709                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
3710                                 Assert.IsNotNull (win32Error.Message, "#9");
3711                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
3712                                 Assert.IsNull (win32Error.InnerException, "#11");
3713                         }
3714                         Assert.AreEqual (WORKSTATION_SERVICE.DisplayName.ToLower (), sc.ServiceName, "#12");
3715                 }
3716
3717                 [Test]
3718                 public void ServicesDependedOn ()
3719                 {
3720                         if (RunningOnUnix)
3721                                 Assert.Ignore ("Running on Unix.");
3722
3723                         ServiceController sc = null;
3724                         ServiceController [] servicesDependedOn = null;
3725
3726                         // single depended service
3727                         sc = new ServiceController (SERVICE_WITH_ONE_DEPENDED_ON.ServiceName, ".");
3728                         servicesDependedOn = sc.ServicesDependedOn;
3729                         Assert.IsNotNull (servicesDependedOn, "#A1");
3730                         Assert.AreEqual (1, servicesDependedOn.Length, "#A2");
3731                         Assert.AreEqual (SERVICE_WITH_ONE_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#A3");
3732
3733                         // modifying ServiceName does not cause cache to be cleared:
3734                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
3735                         sc.ServiceName = SERVICE_WITH_NO_DEPENDED_ON.ServiceName;
3736                         servicesDependedOn = sc.ServicesDependedOn;
3737                         Assert.IsNotNull (servicesDependedOn, "#B1");
3738                         Assert.AreEqual (1, servicesDependedOn.Length, "#B2");
3739                         Assert.AreEqual (SERVICE_WITH_ONE_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#B3");
3740
3741                         // modifying DisplayName does not cause cache to be cleared:
3742                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
3743                         sc.DisplayName = SERVICE_WITH_MANY_DEPENDED_ON.DisplayName;
3744                         servicesDependedOn = sc.ServicesDependedOn;
3745                         Assert.IsNotNull (servicesDependedOn, "#C1");
3746                         Assert.AreEqual (1, servicesDependedOn.Length, "#C2");
3747                         Assert.AreEqual (SERVICE_WITH_ONE_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#C3");
3748
3749                         // modifying MachineName does not cause cache to be cleared:
3750                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
3751                         sc.MachineName = "doesnotexist";
3752                         servicesDependedOn = sc.ServicesDependedOn;
3753                         Assert.IsNotNull (servicesDependedOn, "#D1");
3754                         Assert.AreEqual (1, servicesDependedOn.Length, "#D2");
3755                         Assert.AreEqual (SERVICE_WITH_ONE_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#D3");
3756
3757                         // no depended services
3758                         sc = new ServiceController (SERVICE_WITH_NO_DEPENDED_ON.ServiceName, ".");
3759                         servicesDependedOn = sc.ServicesDependedOn;
3760                         Assert.IsNotNull (servicesDependedOn, "#E1");
3761                         Assert.AreEqual (0, servicesDependedOn.Length, "#E2");
3762
3763                         // modifying ServiceName does not cause cache to be cleared:
3764                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
3765                         sc.ServiceName = SERVICE_WITH_MANY_DEPENDED_ON.ServiceName;
3766                         servicesDependedOn = sc.ServicesDependedOn;
3767                         Assert.IsNotNull (servicesDependedOn, "#F1");
3768                         Assert.AreEqual (0, servicesDependedOn.Length, "#F2");
3769
3770                         // modifying DisplayName does not cause cache to be cleared:
3771                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
3772                         sc.DisplayName = SERVICE_WITH_ONE_DEPENDED_ON.DisplayName;
3773                         servicesDependedOn = sc.ServicesDependedOn;
3774                         Assert.IsNotNull (servicesDependedOn, "#G1");
3775                         Assert.AreEqual (0, servicesDependedOn.Length, "#G2");
3776
3777                         // modifying MachineName does not cause cache to be cleared:
3778                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
3779                         sc.MachineName = Environment.MachineName;
3780                         servicesDependedOn = sc.ServicesDependedOn;
3781                         Assert.IsNotNull (servicesDependedOn, "#H1");
3782                         Assert.AreEqual (0, servicesDependedOn.Length, "#H2");
3783
3784                         // multiple depended services
3785                         sc = new ServiceController (SERVICE_WITH_MANY_DEPENDED_ON.ServiceName, ".");
3786                         servicesDependedOn = sc.ServicesDependedOn;
3787                         Assert.IsNotNull (servicesDependedOn, "#I1");
3788                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDED_ON.DependedOn.Length, servicesDependedOn.Length, "#I2");
3789                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#I3");
3790
3791                         // modifying ServiceName does not cause cache to be cleared:
3792                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
3793                         sc.ServiceName = SERVICE_WITH_NO_DEPENDED_ON.ServiceName;
3794                         servicesDependedOn = sc.ServicesDependedOn;
3795                         Assert.IsNotNull (servicesDependedOn, "#J1");
3796                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDED_ON.DependedOn.Length, servicesDependedOn.Length, "#J2");
3797                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#J3");
3798
3799                         // modifying DisplayName does not cause cache to be cleared:
3800                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
3801                         sc.DisplayName = SERVICE_WITH_ONE_DEPENDED_ON.DisplayName;
3802                         servicesDependedOn = sc.ServicesDependedOn;
3803                         Assert.IsNotNull (servicesDependedOn, "#K1");
3804                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDED_ON.DependedOn.Length, servicesDependedOn.Length, "#K2");
3805                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#K3");
3806
3807                         // modifying MachineName does not cause cache to be cleared:
3808                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=201762
3809                         sc.MachineName = Environment.MachineName;
3810                         servicesDependedOn = sc.ServicesDependedOn;
3811                         Assert.IsNotNull (servicesDependedOn, "#L1");
3812                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDED_ON.DependedOn.Length, servicesDependedOn.Length, "#L2");
3813                         Assert.AreEqual (SERVICE_WITH_MANY_DEPENDED_ON.DependedOn, ServiceNames (servicesDependedOn), "#L3");
3814                 }
3815
3816                 [Test]
3817                 public void ServicesDependedOn_Machine_DoesNotExist ()
3818                 {
3819                         if (RunningOnUnix)
3820                                 Assert.Ignore ("Running on Unix.");
3821
3822                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
3823                                 "doesnotexist");
3824                         try {
3825                                 ServiceController [] servicesDependedOn = sc.ServicesDependedOn;
3826                                 Assert.Fail ("#1: " + servicesDependedOn.Length);
3827                         } catch (InvalidOperationException ex) {
3828                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
3829                                 // This operation might require other priviliges
3830                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
3831                                 Assert.IsNotNull (ex.Message, "#3");
3832                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
3833                                 Assert.IsNotNull (ex.InnerException, "#5");
3834
3835                                 // The RPC server is unavailable
3836                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
3837                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3838                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
3839                                 Assert.IsNotNull (win32Error.Message, "#8");
3840                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
3841                                 Assert.IsNull (win32Error.InnerException, "#10");
3842                         }
3843                 }
3844
3845                 [Test]
3846                 public void ServicesDependedOn_Service_Disabled ()
3847                 {
3848                         if (RunningOnUnix)
3849                                 Assert.Ignore ("Running on Unix.");
3850
3851                         ServiceController sc = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
3852                         ServiceController [] servicesDependedOn = sc.ServicesDependedOn;
3853                         Assert.IsNotNull (servicesDependedOn, "#1");
3854                         Assert.AreEqual (DISABLED_SERVICE.DependedOn, ServiceNames (servicesDependedOn), "#2");
3855                 }
3856
3857                 [Test]
3858                 public void ServicesDependedOn_Service_DoesNotExist ()
3859                 {
3860                         if (RunningOnUnix)
3861                                 Assert.Ignore ("Running on Unix.");
3862
3863                         ServiceController sc = new ServiceController ("doesnotexist", ".");
3864                         try {
3865                                 ServiceController [] servicesDependedOn = sc.ServicesDependedOn;
3866                                 Assert.Fail ("#1: " + servicesDependedOn.Length);
3867                         } catch (InvalidOperationException ex) {
3868                                 // Cannot open doesnotexist service on computer '.'
3869                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
3870                                 Assert.IsNotNull (ex.Message, "#3");
3871                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
3872                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
3873                                 Assert.IsNotNull (ex.InnerException, "#6");
3874
3875                                 // The filename, directory name, or volume label is incorrect
3876                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
3877                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3878                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
3879                                 Assert.IsNotNull (win32Error.Message, "#9");
3880                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
3881                                 Assert.IsNull (win32Error.InnerException, "#11");
3882                         }
3883                 }
3884
3885                 [Test]
3886                 public void ServicesDependedOn_ServiceName_Empty ()
3887                 {
3888                         ServiceController sc = new ServiceController ();
3889                         try {
3890                                 ServiceController [] servicesDependedOn = sc.ServicesDependedOn;
3891                                 Assert.Fail ("#1: " + servicesDependedOn.Length);
3892                         } catch (ArgumentException ex) {
3893                                 // Service name  contains invalid characters, is empty or is
3894                                 // too long (max length = 80)
3895                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
3896                                 Assert.IsNotNull (ex.Message, "#3");
3897                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
3898                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
3899                                 Assert.IsNull (ex.ParamName, "#6");
3900                                 Assert.IsNull (ex.InnerException, "#7");
3901                         }
3902                 }
3903
3904                 [Test]
3905                 public void ServiceTypeTest ()
3906                 {
3907                         if (RunningOnUnix)
3908                                 Assert.Ignore ("Running on Unix.");
3909
3910                         ServiceController sc = null;
3911
3912                         sc = new ServiceController (SHARE_PROCESS_SERVICE.ServiceName, ".");
3913                         Assert.AreEqual (ServiceType.Win32ShareProcess, sc.ServiceType, "#A1");
3914                         sc.ServiceName = KERNEL_SERVICE.ServiceName;
3915                         Assert.AreEqual (ServiceType.KernelDriver, sc.ServiceType, "#A2");
3916                         sc.DisplayName = SHARE_PROCESS_SERVICE.ServiceName;
3917                         Assert.AreEqual (ServiceType.Win32ShareProcess, sc.ServiceType, "#A3");
3918                         sc.MachineName = "doesnotexist";
3919                         try {
3920                                 ServiceType serviceType = sc.ServiceType;
3921                                 Assert.Fail ("#A4: " + serviceType);
3922                         } catch (InvalidOperationException ex) {
3923                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
3924                                 // This operation might require other priviliges
3925                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A5");
3926                                 Assert.IsNotNull (ex.Message, "#A6");
3927                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#A7");
3928                                 Assert.IsNotNull (ex.InnerException, "#A8");
3929
3930                                 // The RPC server is unavailable
3931                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#A9");
3932                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3933                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#A10");
3934                                 Assert.IsNotNull (win32Error.Message, "#A11");
3935                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#A12");
3936                                 Assert.IsNull (win32Error.InnerException, "#A13");
3937                         }
3938
3939                         sc = new ServiceController (KERNEL_SERVICE.ServiceName, ".");
3940                         Assert.AreEqual (ServiceType.KernelDriver, sc.ServiceType, "#B1");
3941                         sc.DisplayName = SHARE_PROCESS_SERVICE.DisplayName;
3942                         Assert.AreEqual (ServiceType.Win32ShareProcess, sc.ServiceType, "#B2");
3943                         sc.MachineName = Environment.MachineName;
3944                         Assert.AreEqual (ServiceType.Win32ShareProcess, sc.ServiceType, "#B3");
3945                         sc.ServiceName = KERNEL_SERVICE.ServiceName;
3946                         Assert.AreEqual (ServiceType.KernelDriver, sc.ServiceType, "#B4");
3947                 }
3948
3949                 [Test]
3950                 public void ServiceType_Machine_DoesNotExist ()
3951                 {
3952                         if (RunningOnUnix)
3953                                 Assert.Ignore ("Running on Unix.");
3954
3955                         ServiceController sc = new ServiceController (SHARE_PROCESS_SERVICE.ServiceName,
3956                                 "doesnotexist");
3957                         try {
3958                                 ServiceType serviceType = sc.ServiceType;
3959                                 Assert.Fail ("#1: " + serviceType);
3960                         } catch (InvalidOperationException ex) {
3961                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
3962                                 // This operation might require other priviliges
3963                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
3964                                 Assert.IsNotNull (ex.Message, "#3");
3965                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
3966                                 Assert.IsNotNull (ex.InnerException, "#5");
3967
3968                                 // The RPC server is unavailable
3969                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
3970                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
3971                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
3972                                 Assert.IsNotNull (win32Error.Message, "#8");
3973                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
3974                                 Assert.IsNull (win32Error.InnerException, "#10");
3975                         }
3976                 }
3977
3978                 [Test]
3979                 public void ServiceType_Service_Disabled ()
3980                 {
3981                         if (RunningOnUnix)
3982                                 Assert.Ignore ("Running on Unix.");
3983
3984                         ServiceController sc = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
3985                         Assert.AreEqual (ServiceType.Win32ShareProcess, sc.ServiceType);
3986                 }
3987
3988                 [Test]
3989                 public void ServiceType_Service_DoesNotExist ()
3990                 {
3991                         if (RunningOnUnix)
3992                                 Assert.Ignore ("Running on Unix.");
3993
3994                         ServiceController sc = new ServiceController ("doesnotexist", ".");
3995                         try {
3996                                 ServiceType serviceType = sc.ServiceType;
3997                                 Assert.Fail ("#1: " + serviceType);
3998                         } catch (InvalidOperationException ex) {
3999                                 // Cannot open doesnotexist service on computer '.'
4000                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
4001                                 Assert.IsNotNull (ex.Message, "#3");
4002                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
4003                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
4004                                 Assert.IsNotNull (ex.InnerException, "#6");
4005
4006                                 // The filename, directory name, or volume label is incorrect
4007                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
4008                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
4009                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
4010                                 Assert.IsNotNull (win32Error.Message, "#9");
4011                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
4012                                 Assert.IsNull (win32Error.InnerException, "#11");
4013                         }
4014                 }
4015
4016                 [Test]
4017                 public void ServiceType_ServiceName_Empty ()
4018                 {
4019                         if (RunningOnUnix)
4020                                 Assert.Ignore ("Running on Unix.");
4021
4022                         ServiceController sc = null;
4023
4024                         sc = new ServiceController ();
4025                         sc.DisplayName = SHARE_PROCESS_SERVICE.DisplayName.ToLower ();
4026                         Assert.AreEqual (ServiceType.Win32ShareProcess, sc.ServiceType, "#1");
4027
4028                         sc = new ServiceController ();
4029                         sc.DisplayName = KERNEL_SERVICE.DisplayName.ToLower ();
4030                         Assert.AreEqual (ServiceType.KernelDriver, sc.ServiceType, "#2");
4031                 }
4032
4033                 [Test]
4034                 public void Start ()
4035                 {
4036                         // not sure if we need additional tests for this, as it's actually
4037                         // tested as part of the other unit tests
4038                 }
4039
4040                 [Test]
4041                 public void Status ()
4042                 {
4043                         // not sure if we need additional tests for this, as it's actually
4044                         // tested as part of the other unit tests
4045                 }
4046
4047                 [Test]
4048                 public void Stop ()
4049                 {
4050                         if (RunningOnUnix)
4051                                 Assert.Ignore ("Running on Unix.");
4052
4053                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4054                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4055
4056                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
4057                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
4058
4059                         sc1.Stop ();
4060
4061                         try {
4062                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
4063                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
4064
4065                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
4066
4067                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
4068                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
4069                         } finally {
4070                                 EnsureServiceIsRunning (sc1);
4071                                 sc2.Refresh ();
4072                         }
4073
4074                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#D1");
4075                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");
4076                 }
4077
4078                 [Test]
4079                 public void Stop_Machine_DoesNotExist ()
4080                 {
4081                         if (RunningOnUnix)
4082                                 Assert.Ignore ("Running on Unix.");
4083
4084                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
4085                                 "doesnotexist");
4086                         try {
4087                                 sc.Stop ();
4088                                 Assert.Fail ("#1");
4089                         } catch (InvalidOperationException ex) {
4090                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
4091                                 // This operation might require other priviliges
4092                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
4093                                 Assert.IsNotNull (ex.Message, "#3");
4094                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
4095                                 Assert.IsNotNull (ex.InnerException, "#5");
4096
4097                                 // The RPC server is unavailable
4098                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
4099                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
4100                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
4101                                 Assert.IsNotNull (win32Error.Message, "#8");
4102                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
4103                                 Assert.IsNull (win32Error.InnerException, "#10");
4104                         }
4105                 }
4106
4107                 [Test]
4108                 public void Stop_Service_Disabled ()
4109                 {
4110                         if (RunningOnUnix)
4111                                 Assert.Ignore ("Running on Unix.");
4112
4113                         ServiceController sc1 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
4114                         ServiceController sc2 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
4115
4116                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#A1");
4117                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#A2");
4118
4119                         try {
4120                                 sc1.Stop ();
4121                                 Assert.Fail ("#B1");
4122                         } catch (InvalidOperationException ex) {
4123                                 // Cannot stop NetDDE service on computer '.'
4124                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
4125                                 Assert.IsNotNull (ex.Message, "#B3");
4126                                 Assert.IsTrue (ex.Message.IndexOf (DISABLED_SERVICE.ServiceName) != -1, "#B4");
4127                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
4128                                 Assert.IsNotNull (ex.InnerException, "#B6");
4129
4130                                 // The service has not been started
4131                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
4132                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
4133                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
4134                                 Assert.IsNotNull (win32Error.Message, "#B9");
4135                                 Assert.AreEqual (1062, win32Error.NativeErrorCode, "#B10");
4136                                 Assert.IsNull (win32Error.InnerException, "#B11");
4137                         }
4138
4139                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
4140                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#C2");
4141                 }
4142
4143                 [Test]
4144                 public void Stop_Service_DoesNotExist ()
4145                 {
4146                         if (RunningOnUnix)
4147                                 Assert.Ignore ("Running on Unix.");
4148
4149                         ServiceController sc = new ServiceController ("doesnotexist", ".");
4150                         try {
4151                                 sc.Stop ();
4152                                 Assert.Fail ("#1");
4153                         } catch (InvalidOperationException ex) {
4154                                 // Cannot open doesnotexist service on computer '.'
4155                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
4156                                 Assert.IsNotNull (ex.Message, "#3");
4157                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
4158                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
4159                                 Assert.IsNotNull (ex.InnerException, "#6");
4160
4161                                 // The filename, directory name, or volume label is incorrect
4162                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
4163                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
4164                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
4165                                 Assert.IsNotNull (win32Error.Message, "#9");
4166                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
4167                                 Assert.IsNull (win32Error.InnerException, "#11");
4168                         }
4169                 }
4170
4171                 [Test]
4172                 public void Stop_Service_OperationNotValid ()
4173                 {
4174                         if (RunningOnUnix)
4175                                 Assert.Ignore ("Running on Unix.");
4176
4177                         ServiceController sc1 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
4178                         ServiceController sc2 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
4179
4180                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
4181                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
4182
4183                         try {
4184                                 sc1.Stop ();
4185                                 Assert.Fail ("#B1");
4186                         } catch (InvalidOperationException ex) {
4187                                 // Cannot stop XXX service on computer '.'
4188                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
4189                                 Assert.IsNotNull (ex.Message, "#B3");
4190                                 Assert.IsTrue (ex.Message.IndexOf (UNCONTROLLABLE_SERVICE.ServiceName) != -1, "#B4");
4191                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#B5");
4192                                 Assert.IsNotNull (ex.InnerException, "#B6");
4193
4194                                 // The requested control is not valid for this service
4195                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#B7");
4196                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
4197                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#B8");
4198                                 Assert.IsNotNull (win32Error.Message, "#B9");
4199                                 Assert.AreEqual (1052, win32Error.NativeErrorCode, "#B10");
4200                                 Assert.IsNull (win32Error.InnerException, "#B11");
4201                         }
4202
4203                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#C1");
4204                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
4205                 }
4206
4207                 [Test]
4208                 public void Stop_Service_Paused ()
4209                 {
4210                         if (RunningOnUnix)
4211                                 Assert.Ignore ("Running on Unix.");
4212
4213                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4214                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4215
4216                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
4217                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
4218
4219                         sc1.Pause ();
4220
4221                         try {
4222                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
4223                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
4224
4225                                 sc1.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
4226
4227                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#C1");
4228                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
4229
4230                                 sc1.Stop ();
4231
4232                                 Assert.AreEqual (ServiceControllerStatus.Paused, sc1.Status, "#D1");
4233                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");
4234
4235                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
4236
4237                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#E1");
4238                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#E2");
4239                         } finally {
4240                                 EnsureServiceIsRunning (sc1);
4241                                 sc2.Refresh ();
4242                         }
4243
4244                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
4245                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
4246                 }
4247
4248                 [Test]
4249                 public void Stop_Service_Stopped ()
4250                 {
4251                         if (RunningOnUnix)
4252                                 Assert.Ignore ("Running on Unix.");
4253
4254                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4255                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4256
4257                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
4258                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
4259
4260                         sc1.Stop ();
4261
4262                         try {
4263                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
4264                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
4265
4266                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
4267
4268                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
4269                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
4270
4271                                 sc1.Stop ();
4272                                 Assert.Fail ("#D1");
4273                         } catch (InvalidOperationException ex) {
4274                                 // Cannot stop XXX service on computer '.'
4275                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
4276                                 Assert.IsNotNull (ex.Message, "#D3");
4277                                 Assert.IsTrue (ex.Message.IndexOf (CONTROLLABLE_SERVICE.ServiceName) != -1, "#D4");
4278                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#D5");
4279                                 Assert.IsNotNull (ex.InnerException, "#D6");
4280
4281                                 // The service has not been started
4282                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#D7");
4283                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
4284                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#D8");
4285                                 Assert.IsNotNull (win32Error.Message, "#D9");
4286                                 Assert.AreEqual (1062, win32Error.NativeErrorCode, "#D10");
4287                                 Assert.IsNull (win32Error.InnerException, "#D11");
4288                         } finally {
4289                                 EnsureServiceIsRunning (sc1);
4290                                 sc2.Refresh ();
4291                         }
4292
4293                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#E1");
4294                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#E2");
4295                 }
4296
4297                 [Test]
4298                 public void Stop_ServiceName_Empty ()
4299                 {
4300                         ServiceController sc = new ServiceController ();
4301                         try {
4302                                 sc.Stop ();
4303                                 Assert.Fail ("#1");
4304                         } catch (ArgumentException ex) {
4305                                 // Service name  contains invalid characters, is empty or is
4306                                 // too long (max length = 80)
4307                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
4308                                 Assert.IsNotNull (ex.Message, "#3");
4309                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
4310                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
4311                                 Assert.IsNull (ex.ParamName, "#6");
4312                                 Assert.IsNull (ex.InnerException, "#7");
4313                         }
4314                 }
4315
4316                 [Test]
4317                 public void WaitForStatus ()
4318                 {
4319                         if (RunningOnUnix)
4320                                 Assert.Ignore ("Running on Unix.");
4321
4322                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4323                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4324
4325                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
4326                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
4327
4328                         sc1.Stop ();
4329
4330                         try {
4331                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#B1");
4332                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#B2");
4333
4334                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
4335
4336                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
4337                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
4338
4339                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped);
4340
4341                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#D1");
4342                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");
4343
4344                                 sc1.Start ();
4345
4346                                 Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#D1");
4347                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#D2");
4348
4349                                 sc1.WaitForStatus (ServiceControllerStatus.Running);
4350
4351                                 Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#E1");
4352                                 Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#E2");
4353                         } finally {
4354                                 EnsureServiceIsRunning (sc1);
4355                                 sc2.Refresh ();
4356                         }
4357
4358                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#F1");
4359                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#F2");
4360                 }
4361
4362                 [Test]
4363                 public void WaitForStatus_Machine_DoesNotExist ()
4364                 {
4365                         if (RunningOnUnix)
4366                                 Assert.Ignore ("Running on Unix.");
4367
4368                         ServiceController sc = new ServiceController (CONTROLLABLE_SERVICE.ServiceName,
4369                                 "doesnotexist");
4370                         try {
4371                                 sc.WaitForStatus (ServiceControllerStatus.Stopped,
4372                                         new TimeSpan (0, 0, 1));
4373                                 Assert.Fail ("#1");
4374                         } catch (InvalidOperationException ex) {
4375                                 // Cannot open Service Control Manager on computer 'doesnotexist'.
4376                                 // This operation might require other priviliges
4377                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
4378                                 Assert.IsNotNull (ex.Message, "#3");
4379                                 Assert.IsTrue (ex.Message.IndexOf ("'doesnotexist'") != -1, "#4");
4380                                 Assert.IsNotNull (ex.InnerException, "#5");
4381
4382                                 // The RPC server is unavailable
4383                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#6");
4384                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
4385                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#7");
4386                                 Assert.IsNotNull (win32Error.Message, "#8");
4387                                 Assert.AreEqual (1722, win32Error.NativeErrorCode, "#9");
4388                                 Assert.IsNull (win32Error.InnerException, "#10");
4389                         }
4390                 }
4391
4392                 [Test]
4393                 public void WaitForStatus_Service_Disabled ()
4394                 {
4395                         if (RunningOnUnix)
4396                                 Assert.Ignore ("Running on Unix.");
4397
4398                         ServiceController sc1 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
4399                         ServiceController sc2 = new ServiceController (DISABLED_SERVICE.ServiceName, ".");
4400
4401                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#A1");
4402                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#A2");
4403
4404                         sc1.WaitForStatus (ServiceControllerStatus.Stopped,
4405                                 new TimeSpan (0, 0, 1));
4406
4407                         try {
4408                                 sc1.WaitForStatus (ServiceControllerStatus.Running,
4409                                         new TimeSpan (0, 0, 1));
4410                                 Assert.Fail ("#B1");
4411                         } catch (TimeoutException ex) {
4412                                 // Time out has expired and the operation has not been completed
4413                                 Assert.AreEqual (typeof (TimeoutException), ex.GetType (), "#B2");
4414                                 Assert.IsNotNull (ex.Data, "#B3");
4415                                 Assert.AreEqual (0, ex.Data.Count, "#B4");
4416                                 Assert.IsNotNull (ex.Message, "#B5");
4417                                 Assert.IsNull (ex.InnerException, "#B6");
4418                         }
4419
4420                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc1.Status, "#C1");
4421                         Assert.AreEqual (ServiceControllerStatus.Stopped, sc2.Status, "#C2");
4422                 }
4423
4424                 [Test]
4425                 public void WaitForStatus_Service_DoesNotExist ()
4426                 {
4427                         if (RunningOnUnix)
4428                                 Assert.Ignore ("Running on Unix.");
4429
4430                         ServiceController sc = new ServiceController ("doesnotexist", ".");
4431                         try {
4432                                 sc.WaitForStatus (ServiceControllerStatus.Stopped);
4433                                 Assert.Fail ("#1");
4434                         } catch (InvalidOperationException ex) {
4435                                 // Cannot open doesnotexist service on computer '.'
4436                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
4437                                 Assert.IsNotNull (ex.Message, "#3");
4438                                 Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#4");
4439                                 Assert.IsTrue (ex.Message.IndexOf ("'.'") != -1, "#5");
4440                                 Assert.IsNotNull (ex.InnerException, "#6");
4441
4442                                 // The filename, directory name, or volume label is incorrect
4443                                 Assert.AreEqual (typeof (Win32Exception), ex.InnerException.GetType (), "#7");
4444                                 Win32Exception win32Error = (Win32Exception) ex.InnerException;
4445                                 //Assert.AreEqual (-2147467259, win32Error.ErrorCode, "#8");
4446                                 Assert.IsNotNull (win32Error.Message, "#9");
4447                                 Assert.AreEqual (1060, win32Error.NativeErrorCode, "#10");
4448                                 Assert.IsNull (win32Error.InnerException, "#11");
4449                         }
4450                 }
4451
4452                 [Test]
4453                 public void WaitForStatus_Service_OperationNotValid ()
4454                 {
4455                         if (RunningOnUnix)
4456                                 Assert.Ignore ("Running on Unix.");
4457
4458                         ServiceController sc1 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
4459                         ServiceController sc2 = new ServiceController (UNCONTROLLABLE_SERVICE.ServiceName, ".");
4460
4461                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
4462                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
4463
4464                         sc1.WaitForStatus (ServiceControllerStatus.Running,
4465                                 new TimeSpan (0, 0, 1));
4466
4467                         try {
4468                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped,
4469                                         new TimeSpan (0, 0, 1));
4470                                 Assert.Fail ("#B1");
4471                         } catch (TimeoutException ex) {
4472                                 // Time out has expired and the operation has not been completed
4473                                 Assert.AreEqual (typeof (TimeoutException), ex.GetType (), "#B2");
4474                                 Assert.IsNotNull (ex.Data, "#B3");
4475                                 Assert.AreEqual (0, ex.Data.Count, "#B4");
4476                                 Assert.IsNotNull (ex.Message, "#B5");
4477                                 Assert.IsNull (ex.InnerException, "#B6");
4478                         }
4479
4480                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#C1");
4481                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
4482                 }
4483
4484                 [Test]
4485                 public void WaitForStatus_ServiceName_Empty ()
4486                 {
4487                         ServiceController sc = new ServiceController ();
4488                         try {
4489                                 sc.WaitForStatus (ServiceControllerStatus.Stopped,
4490                                         new TimeSpan (0, 0, 1));
4491                                 Assert.Fail ("#1");
4492                         } catch (ArgumentException ex) {
4493                                 // Service name  contains invalid characters, is empty or is
4494                                 // too long (max length = 80)
4495                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
4496                                 Assert.IsNotNull (ex.Message, "#3");
4497                                 Assert.IsTrue (ex.Message.IndexOf ("  ") != -1, "#4");
4498                                 Assert.IsTrue (ex.Message.IndexOf ("80") != -1, "#5");
4499                                 Assert.IsNull (ex.ParamName, "#6");
4500                                 Assert.IsNull (ex.InnerException, "#7");
4501                         }
4502                 }
4503
4504                 [Test]
4505                 public void WaitForStatus_Timeout ()
4506                 {
4507                         if (RunningOnUnix)
4508                                 Assert.Ignore ("Running on Unix.");
4509
4510                         ServiceController sc1 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4511                         ServiceController sc2 = new ServiceController (CONTROLLABLE_SERVICE.ServiceName, ".");
4512
4513                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#A1");
4514                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#A2");
4515
4516                         try {
4517                                 sc1.WaitForStatus (ServiceControllerStatus.Stopped,
4518                                         new TimeSpan (0, 0, 1));
4519                                 Assert.Fail ("#B1");
4520                         } catch (TimeoutException ex) {
4521                                 // Time out has expired and the operation has not been completed
4522                                 Assert.AreEqual (typeof (TimeoutException), ex.GetType (), "#B2");
4523                                 Assert.IsNotNull (ex.Data, "#B3");
4524                                 Assert.AreEqual (0, ex.Data.Count, "#B4");
4525                                 Assert.IsNotNull (ex.Message, "#B5");
4526                                 Assert.IsNull (ex.InnerException, "#B6");
4527                         }
4528
4529                         Assert.AreEqual (ServiceControllerStatus.Running, sc1.Status, "#C1");
4530                         Assert.AreEqual (ServiceControllerStatus.Running, sc2.Status, "#C2");
4531                 }
4532
4533                 // Run this on .NET to generate ServiceInfo objects for services on the current machine
4534 //              [Test]
4535                 public static void DumpServices ()
4536                 {
4537                         foreach (ServiceController sc in ServiceController.GetServices ()) {
4538                                 try {
4539                                         var si = new ServiceInfo { ServiceName = sc.ServiceName, DisplayName = sc.DisplayName, ServiceType = sc.ServiceType, Dependents = ServiceNames (sc.DependentServices), DependedOn = ServiceNames (sc.ServicesDependedOn) };
4540                                         var l = new List<string> ();
4541                                         l.Add ($"ServiceName = \"{si.ServiceName}\"");
4542                                         l.Add ($"DisplayName = \"{si.DisplayName}\"");
4543                                         if (si.ServiceType != ServiceType.Win32ShareProcess)
4544                                                 l.Add ($"ServiceType = ServiceType.{si.ServiceType}");
4545                                         if (si.Dependents.Length > 0)
4546                                                 l.Add ("Dependents = new [] { \"" + String.Join ("\", \"", si.Dependents) + "\" }");
4547                                         if (si.DependedOn.Length > 0)
4548                                                 l.Add ("DependedOn = new [] { \"" + String.Join ("\", \"", si.DependedOn) + "\" }");
4549                                         Console.WriteLine ("static ServiceInfo " + si.DisplayName.ToUpper ().Replace (' ', '_').Replace ('-', '_') + "_SERVICE = new ServiceInfo { " + String.Join (", ", l) + " };");
4550                                 } catch {
4551                                 }
4552                         }
4553                 }
4554
4555                 private static void EnsureServiceIsRunning (ServiceController sc)
4556                 {
4557                         sc.Refresh ();
4558                         switch (sc.Status) {
4559                         case ServiceControllerStatus.ContinuePending:
4560                                 sc.WaitForStatus (ServiceControllerStatus.Running, new TimeSpan (0, 0, 5));
4561                                 break;
4562                         case ServiceControllerStatus.Paused:
4563                                 sc.Continue ();
4564                                 sc.WaitForStatus (ServiceControllerStatus.Running, new TimeSpan (0, 0, 5));
4565                                 break;
4566                         case ServiceControllerStatus.PausePending:
4567                                 sc.WaitForStatus (ServiceControllerStatus.Paused, new TimeSpan (0, 0, 5));
4568                                 sc.Continue ();
4569                                 sc.WaitForStatus (ServiceControllerStatus.Running, new TimeSpan (0, 0, 5));
4570                                 break;
4571                         case ServiceControllerStatus.StartPending:
4572                                 sc.WaitForStatus (ServiceControllerStatus.Running, new TimeSpan (0, 0, 5));
4573                                 break;
4574                         case ServiceControllerStatus.Stopped:
4575                                 sc.Start ();
4576                                 sc.WaitForStatus (ServiceControllerStatus.Running, new TimeSpan (0, 0, 5));
4577                                 break;
4578                         case ServiceControllerStatus.StopPending:
4579                                 sc.WaitForStatus (ServiceControllerStatus.Stopped, new TimeSpan (0, 0, 5));
4580                                 sc.Start ();
4581                                 sc.WaitForStatus (ServiceControllerStatus.Running, new TimeSpan (0, 0, 5));
4582                                 break;
4583                         }
4584                 }
4585
4586                 private static bool ContainsService (ServiceController [] services, string serviceName)
4587                 {
4588                         for (int i = 0; i < services.Length; i++) {
4589                                 if (services [i].ServiceName == serviceName)
4590                                         return true;
4591                         }
4592                         return false;
4593                 }
4594
4595                 private static string[] ServiceNames (ServiceController [] services)
4596                 {
4597                         var result = new string [services.Length];
4598                         for (var i = 0; i < result.Length; i++)
4599                                 result [i] = services [i].ServiceName.ToLower ();
4600                         Array.Sort<string> (result);
4601                         return result;
4602                 }
4603
4604                 private bool RunningOnUnix
4605                 {
4606                         get {
4607                                 int p = (int) Environment.OSVersion.Platform;
4608                                 return ((p == 4) || (p == 128) || (p == 6));
4609                         }
4610                 }
4611
4612                 private enum SERVICE_CONTROL_TYPE
4613                 {
4614                         SERVICE_CONTROL_STOP = 0x1,
4615                         SERVICE_CONTROL_PAUSE = 0x2,
4616                         SERVICE_CONTROL_CONTINUE = 0x3,
4617                         SERVICE_CONTROL_INTERROGATE = 0x4,
4618                         SERVICE_CONTROL_SHUTDOWN = 0x5,
4619                         SERVICE_CONTROL_PARAMCHANGE = 0x6,
4620                         SERVICE_CONTROL_NETBINDADD = 0x7,
4621                         SERVICE_CONTROL_NETBINDREMOVE = 0x8,
4622                         SERVICE_CONTROL_NETBINDENABLE = 0x9,
4623                         SERVICE_CONTROL_NETBINDDISABLE = 0xA,
4624                         SERVICE_CONTROL_DEVICEEVENT = 0xB,
4625                         SERVICE_CONTROL_HARDWAREPROFILECHANGE = 0xC,
4626                         SERVICE_CONTROL_POWEREVENT = 0xD,
4627                         SERVICE_CONTROL_SESSIONCHANGE = 0xE
4628                 }
4629         }
4630 }