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