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