win32-service 0.7.2 → 0.8.0

data/lib/win32/windows/constants.rb

@@ -0,0 +1,137 @@
+module Windows
+  module Constants
+    SC_MANAGER_ALL_ACCESS         = 0xF003F
+    SC_MANAGER_CREATE_SERVICE     = 0x0002
+    SC_MANAGER_CONNECT            = 0x0001
+    SC_MANAGER_ENUMERATE_SERVICE  = 0x0004
+    SC_MANAGER_LOCK               = 0x0008
+    SC_MANAGER_MODIFY_BOOT_CONFIG = 0x0020
+    SC_MANAGER_QUERY_LOCK_STATUS  = 0x0010
+    SC_STATUS_PROCESS_INFO        = 0
+    SC_ENUM_PROCESS_INFO          = 0
+
+    # Service control action types
+    SC_ACTION_NONE        = 0
+    SC_ACTION_RESTART     = 1
+    SC_ACTION_REBOOT      = 2
+    SC_ACTION_RUN_COMMAND = 3
+
+    # Service access rights
+    SERVICE_ALL_ACCESS            = 0xF01FF
+    SERVICE_CHANGE_CONFIG         = 0x0002
+    SERVICE_ENUMERATE_DEPENDENTS  = 0x0008
+    SERVICE_INTERROGATE           = 0x0080
+    SERVICE_PAUSE_CONTINUE        = 0x0040
+    SERVICE_QUERY_CONFIG          = 0x0001
+    SERVICE_QUERY_STATUS          = 0x0004
+    SERVICE_START                 = 0x0010
+    SERVICE_STOP                  = 0x0020
+    SERVICE_USER_DEFINED_CONTROL  = 0x0100
+
+    # Service types
+    SERVICE_KERNEL_DRIVER       = 0x00000001
+    SERVICE_FILE_SYSTEM_DRIVER  = 0x00000002
+    SERVICE_ADAPTER             = 0x00000004
+    SERVICE_RECOGNIZER_DRIVER   = 0x00000008
+    SERVICE_WIN32_OWN_PROCESS   = 0x00000010
+    SERVICE_WIN32_SHARE_PROCESS = 0x00000020
+    SERVICE_WIN32               = 0x00000030
+    SERVICE_INTERACTIVE_PROCESS = 0x00000100
+    SERVICE_DRIVER              = 0x0000000B
+    SERVICE_TYPE_ALL            = 0x0000013F
+
+    # Error control
+    SERVICE_ERROR_IGNORE   = 0x00000000
+    SERVICE_ERROR_NORMAL   = 0x00000001
+    SERVICE_ERROR_SEVERE   = 0x00000002
+    SERVICE_ERROR_CRITICAL = 0x00000003
+
+    # Start types
+    SERVICE_BOOT_START   = 0x00000000
+    SERVICE_SYSTEM_START = 0x00000001
+    SERVICE_AUTO_START   = 0x00000002
+    SERVICE_DEMAND_START = 0x00000003
+    SERVICE_DISABLED     = 0x00000004
+
+    # Service control
+
+    SERVICE_CONTROL_STOP                   = 0x00000001
+    SERVICE_CONTROL_PAUSE                  = 0x00000002
+    SERVICE_CONTROL_CONTINUE               = 0x00000003
+    SERVICE_CONTROL_INTERROGATE            = 0x00000004
+    SERVICE_CONTROL_SHUTDOWN               = 0x00000005
+    SERVICE_CONTROL_PARAMCHANGE            = 0x00000006
+    SERVICE_CONTROL_NETBINDADD             = 0x00000007
+    SERVICE_CONTROL_NETBINDREMOVE          = 0x00000008
+    SERVICE_CONTROL_NETBINDENABLE          = 0x00000009
+    SERVICE_CONTROL_NETBINDDISABLE         = 0x0000000A
+    SERVICE_CONTROL_DEVICEEVENT            = 0x0000000B
+    SERVICE_CONTROL_HARDWAREPROFILECHANGE  = 0x0000000C
+    SERVICE_CONTROL_POWEREVENT             = 0x0000000D
+    SERVICE_CONTROL_SESSIONCHANGE          = 0x0000000E
+    SERVICE_CONTROL_PRESHUTDOWN            = 0x0000000F
+    SERVICE_CONTROL_TIMECHANGE             = 0x00000010
+    SERVICE_CONTROL_TRIGGEREVENT           = 0x00000020
+
+    # Service controls accepted
+
+    SERVICE_ACCEPT_STOP                    = 0x00000001
+    SERVICE_ACCEPT_PAUSE_CONTINUE          = 0x00000002
+    SERVICE_ACCEPT_SHUTDOWN                = 0x00000004
+    SERVICE_ACCEPT_PARAMCHANGE             = 0x00000008
+    SERVICE_ACCEPT_NETBINDCHANGE           = 0x00000010
+    SERVICE_ACCEPT_HARDWAREPROFILECHANGE   = 0x00000020
+    SERVICE_ACCEPT_POWEREVENT              = 0x00000040
+    SERVICE_ACCEPT_SESSIONCHANGE           = 0x00000080
+    SERVICE_ACCEPT_PRESHUTDOWN             = 0x00000100
+    SERVICE_ACCEPT_TIMECHANGE              = 0x00000200
+    SERVICE_ACCEPT_TRIGGEREVENT            = 0x00000400
+
+    # Service states
+    SERVICE_ACTIVE    = 0x00000001
+    SERVICE_INACTIVE  = 0x00000002
+    SERVICE_STATE_ALL = 0x00000003
+
+    # Service current states
+    SERVICE_STOPPED          = 0x00000001
+    SERVICE_START_PENDING    = 0x00000002
+    SERVICE_STOP_PENDING     = 0x00000003
+    SERVICE_RUNNING          = 0x00000004
+    SERVICE_CONTINUE_PENDING = 0x00000005
+    SERVICE_PAUSE_PENDING    = 0x00000006
+    SERVICE_PAUSED           = 0x00000007
+
+    # Info levels
+    SERVICE_CONFIG_DESCRIPTION              = 1
+    SERVICE_CONFIG_FAILURE_ACTIONS          = 2
+    SERVICE_CONFIG_DELAYED_AUTO_START_INFO  = 3
+    SERVICE_CONFIG_FAILURE_ACTIONS_FLAG     = 4
+    SERVICE_CONFIG_SERVICE_SID_INFO         = 5
+    SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO = 6
+    SERVICE_CONFIG_PRESHUTDOWN_INFO         = 7
+
+    # Configuration
+    SERVICE_NO_CHANGE = 0xffffffff
+
+    # Misc
+
+    WAIT_OBJECT_0 = 0
+    WAIT_TIMEOUT = 0x00000102
+    INFINITE = 0xFFFFFFFF
+
+    IDLE_CONTROL_CODE = 0
+
+    DELETE = 0x00010000
+    FORMAT_MESSAGE_FROM_SYSTEM    = 0x00001000
+    FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200
+
+    NO_ERROR = 0
+
+    # Errors
+
+    ERROR_INSUFFICIENT_BUFFER = 122
+    ERROR_MORE_DATA = 234
+    ERROR_FILE_NOT_FOUND = 2
+    WAIT_FAILED = 0xFFFFFFFF
+  end
+end

data/lib/win32/windows/functions.rb

@@ -0,0 +1,63 @@
+require 'ffi'
+
+module Windows
+  module Functions
+    extend FFI::Library
+
+    typedef :ulong, :dword
+    typedef :uintptr_t, :handle
+    typedef :pointer, :ptr
+    typedef :string, :str
+
+    ffi_convention :stdcall
+
+    ffi_lib :kernel32
+
+    attach_function :CloseHandle, [:handle], :bool
+    attach_function :CreateEvent, :CreateEventA, [:ptr, :bool, :bool, :str], :handle
+    attach_function :CreateThread, [:ptr, :size_t, :ptr, :ptr, :dword, :ptr], :handle, :blocking => true
+    attach_function :EnterCriticalSection, [:ptr], :void
+    attach_function :FormatMessage, :FormatMessageA, [:ulong, :ptr, :ulong, :ulong, :str, :ulong, :ptr], :ulong
+    attach_function :InitializeCriticalSection, [:ptr], :void
+    attach_function :LeaveCriticalSection, [:ptr], :void
+    attach_function :SetEvent, [:handle], :bool
+    attach_function :WaitForSingleObject, [:handle, :dword], :dword, :blocking => true
+    attach_function :WaitForMultipleObjects, [:dword, :ptr, :bool, :dword], :dword
+
+    ffi_lib :advapi32
+
+    callback :handler_ex, [:ulong, :ulong, :ptr, :ptr], :void
+
+    attach_function :CloseServiceHandle, [:handle], :bool
+
+    attach_function :ChangeServiceConfig, :ChangeServiceConfigA,
+      [:handle, :dword, :dword, :dword, :str, :str, :ptr, :str, :str, :str, :str],
+      :bool
+
+    attach_function :ChangeServiceConfig2, :ChangeServiceConfig2A, [:handle, :dword, :ptr], :bool
+
+    attach_function :CreateService, :CreateServiceA,
+      [:handle, :string, :string, :dword, :dword, :dword, :dword,
+       :string, :string, :ptr, :pointer, :string, :string],
+       :handle
+
+    attach_function :ControlService, [:handle, :dword, :ptr], :bool
+    attach_function :DeleteService, [:handle], :bool
+
+    attach_function :EnumServicesStatusEx, :EnumServicesStatusExA,
+      [:handle, :int, :dword, :dword, :ptr, :dword, :ptr, :ptr, :ptr, :string],
+      :bool
+
+    attach_function :GetServiceDisplayName, :GetServiceDisplayNameA, [:handle, :string, :ptr, :ptr], :bool
+    attach_function :GetServiceKeyName, :GetServiceKeyNameA, [:handle, :string, :ptr, :ptr], :bool
+    attach_function :OpenSCManager, :OpenSCManagerA, [:ptr, :ptr, :dword], :handle
+    attach_function :OpenService, :OpenServiceA, [:handle, :string, :dword], :handle
+    attach_function :QueryServiceConfig, :QueryServiceConfigA, [:handle, :ptr, :dword, :ptr], :bool
+    attach_function :QueryServiceConfig2, :QueryServiceConfig2A, [:handle, :dword, :ptr, :dword, :ptr], :bool
+    attach_function :QueryServiceStatusEx, [:handle, :int, :ptr, :dword, :ptr], :bool
+    attach_function :RegisterServiceCtrlHandlerEx, :RegisterServiceCtrlHandlerExA, [:str, :handler_ex, :ptr], :handle
+    attach_function :SetServiceStatus, [:handle, :ptr], :bool
+    attach_function :StartService, :StartServiceA, [:handle, :dword, :ptr], :bool
+    attach_function :StartServiceCtrlDispatcher, :StartServiceCtrlDispatcherA, [:ptr], :bool, :blocking => true
+  end
+end

data/lib/win32/windows/helper.rb

@@ -0,0 +1,41 @@
+require 'ffi'
+
+class FFI::Pointer
+  def read_array_of_null_separated_strings
+    elements = []
+    loc = self
+
+    while element = loc.read_string
+      break if element.nil? || element == ""
+      elements << element
+      loc += element.size + 1
+    end
+
+    elements
+  end
+end
+
+module FFI
+  extend FFI::Library
+
+  ffi_lib :kernel32
+
+  attach_function :FormatMessage, :FormatMessageA,
+    [:ulong, :pointer, :ulong, :ulong, :pointer, :ulong, :pointer], :ulong
+
+  def win_error(function, err=FFI.errno)
+    flags = 0x00001000 | 0x00000200
+    buf = FFI::MemoryPointer.new(:char, 1024)
+
+    FormatMessage(flags, nil, err , 0x0409, buf, 1024, nil)
+
+    function + ': ' + buf.read_string.strip
+  end
+
+  def raise_windows_error(function, err=FFI.errno)
+    raise SystemCallError.new(win_error(function, err), err)
+  end
+
+  module_function :win_error
+  module_function :raise_windows_error
+end

data/lib/win32/windows/structs.rb

@@ -0,0 +1,96 @@
+require 'ffi'
+
+module Windows
+  module Structs
+    extend FFI::Library
+
+    typedef :ulong, :dword
+
+    class SERVICE_STATUS < FFI::Struct
+      layout(
+        :dwServiceType, :ulong,
+        :dwCurrentState, :ulong,
+        :dwControlsAccepted, :ulong,
+        :dwWin32ExitCode, :ulong,
+        :dwServiceSpecificExitCode, :ulong,
+        :dwCheckPoint, :ulong,
+        :dwWaitHint, :ulong
+      )
+    end
+
+    class SERVICE_STATUS_PROCESS < FFI::Struct
+      layout(
+        :dwServiceType, :dword,
+        :dwCurrentState, :dword,
+        :dwControlsAccepted, :dword,
+        :dwWin32ExitCode, :dword,
+        :dwServiceSpecificExitCode, :dword,
+        :dwCheckPoint, :dword,
+        :dwWaitHint, :dword,
+        :dwProcessId, :dword,
+        :dwServiceFlags, :dword
+      )
+    end
+
+    class SERVICE_DESCRIPTION < FFI::Struct
+      layout(:lpDescription, :pointer)
+    end
+
+    class QUERY_SERVICE_CONFIG < FFI::Struct
+      layout(
+        :dwServiceType, :dword,
+        :dwStartType, :dword,
+        :dwErrorControl, :dword,
+        :lpBinaryPathName, :pointer,
+        :lpLoadOrderGroup, :pointer,
+        :dwTagId, :dword,
+        :lpDependencies, :pointer,
+        :lpServiceStartName, :pointer,
+        :lpDisplayName, :pointer
+      )
+    end
+
+    class SERVICE_STATUS_PROCESS < FFI::Struct
+      layout(
+        :dwServiceType, :dword,
+        :dwCurrentState, :dword,
+        :dwControlsAccepted, :dword,
+        :dwWin32ExitCode, :dword,
+        :dwServiceSpecificExitCode, :dword,
+        :dwCheckPoint, :dword,
+        :dwWaitHint, :dword,
+        :dwProcessId, :dword,
+        :dwServiceFlags, :dword
+      )
+    end
+
+    class ENUM_SERVICE_STATUS_PROCESS < FFI::Struct
+      layout(
+        :lpServiceName, :pointer,
+        :lpDisplayName, :pointer,
+        :ServiceStatusProcess, SERVICE_STATUS_PROCESS
+      )
+    end
+
+    class SC_ACTION < FFI::Struct
+      layout(:Type, :int, :Delay, :dword)
+    end
+
+    class SERVICE_FAILURE_ACTIONS < FFI::Struct
+      layout(
+        :dwResetPeriod, :dword,
+        :lpRebootMsg, :pointer,
+        :lpCommand, :pointer,
+        :cActions, :dword,
+        :lpsaActions, :pointer # Array of SC_ACTION structs
+      )
+    end
+
+    class SERVICE_TABLE_ENTRY < FFI::Struct
+      layout(
+        :lpServiceName, :pointer,
+        :lpServiceProc, :pointer
+      )
+    end
+  end
+end

data/test/test_win32_daemon.rb

@@ -7,22 +7,19 @@
 # These tests are rather limited, since the acid test is to install
 # your daemon as a service and see how it behaves.
 #########################################################################
-require 'rubygems'
-gem 'test-unit'
-
+require 'test-unit'
 require 'win32/daemon'
-require 'test/unit'
 include Win32
 
 class TC_Daemon < Test::Unit::TestCase
   def setup
     @daemon = Daemon.new
   end
-   
+
   test "version number is set properly" do
-    assert_equal('0.7.2', Daemon::VERSION)
+    assert_equal('0.8.0', Daemon::VERSION)
   end
-   
+
   test "constructor basic functionality" do
     assert_respond_to(Daemon, :new)
     assert_nothing_raised{ Daemon.new }
@@ -31,19 +28,19 @@ class TC_Daemon < Test::Unit::TestCase
   test "constructor does not accept any arguments" do
     assert_raises(ArgumentError){ Daemon.new(1) }
   end
-   
+
   test "mainloop basic functionality" do
     assert_respond_to(@daemon, :mainloop)
   end
-   
+
   test "state basic functionality" do
     assert_respond_to(@daemon, :state)
   end
-   
+
   test "is_running basic functionality" do
     assert_respond_to(@daemon, :running?)
   end
-   
+
   test "expected constants are defined" do
     assert_not_nil(Daemon::CONTINUE_PENDING)
     assert_not_nil(Daemon::PAUSE_PENDING)
@@ -52,9 +49,9 @@ class TC_Daemon < Test::Unit::TestCase
     assert_not_nil(Daemon::START_PENDING)
     assert_not_nil(Daemon::STOP_PENDING)
     assert_not_nil(Daemon::STOPPED)
-    assert_not_nil(Daemon::IDLE) 
+    assert_not_nil(Daemon::IDLE)
   end
-   
+
   def teardown
     @daemon = nil
   end

data/test/test_win32_service.rb

@@ -1,14 +1,12 @@
 ##########################################################################
 # test_win32_service.rb
-# 
+#
 # Tests for the Win32::Service class.
 ##########################################################################
-require 'rubygems'
-gem 'test-unit'
-
+require 'test-unit'
 require 'win32/service'
+require 'win32/security'
 require 'socket'
-require 'test/unit'
 
 class TC_Win32_Service < Test::Unit::TestCase
   def self.startup
@@ -21,6 +19,7 @@ class TC_Win32_Service < Test::Unit::TestCase
     @service_name = 'stisvc'
     @service_stat = nil
     @services     = []
+    @elevated     = Win32::Security.elevated_security?
   end
 
   def start_service(service)
@@ -42,7 +41,7 @@ class TC_Win32_Service < Test::Unit::TestCase
     end
     wait_for_status('stopped')
   end
-   
+
   # Helper method that waits for a status to change its state since state
   # changes aren't usually instantaneous.
   def wait_for_status(status)
@@ -50,28 +49,28 @@ class TC_Win32_Service < Test::Unit::TestCase
   end
 
   test "version number is expected value" do
-    assert_equal('0.7.2', Win32::Service::VERSION)
+    assert_equal('0.8.0', Win32::Service::VERSION)
   end
-   
+
   test "services basic functionality" do
     assert_respond_to(Win32::Service, :services)
     assert_nothing_raised{ Win32::Service.services }
     assert_nothing_raised{ Win32::Service.services(nil) }
     assert_nothing_raised{ Win32::Service.services(nil, 'network') }
   end
-      
+
   test "services method returns an array without a block" do
     assert_nothing_raised{ @services = Win32::Service.services }
     assert_kind_of(Array, @services)
     assert_kind_of(Struct::ServiceInfo, @services[0])
   end
-   
+
   test "services method yields service objects when a block is provided" do
     assert_nothing_raised{ Win32::Service.services{ |s| @services << s } }
     assert_kind_of(Array, @services)
-    assert_kind_of(Struct::ServiceInfo, @services[0])      
+    assert_kind_of(Struct::ServiceInfo, @services[0])
   end
-      
+
   test "the host argument must be a string or an error is raised" do
     assert_raise(TypeError){ Win32::Service.services(1) }
   end
@@ -85,29 +84,29 @@ class TC_Win32_Service < Test::Unit::TestCase
   end
 
   test "a valid hostname must be provided or an error is raised" do
-    assert_raise(Win32::Service::Error){ Win32::Service.services('bogus') }
-  end   
-   
+    assert_raise(SystemCallError){ Win32::Service.services('bogus') }
+  end
+
   test "delete method basic functionality" do
     assert_respond_to(Win32::Service, :delete)
   end
-   
+
   test "a service name must be provided to the delete method" do
     assert_raise(ArgumentError){ Win32::Service.delete }
   end
 
   test "delete method raises an error if a bogus service name is provided" do
-    assert_raise(Win32::Service::Error){ Win32::Service.delete('bogus') }
+    assert_raise(SystemCallError){ Win32::Service.delete('bogus') }
   end
 
   test "delete method raises an error if a bogus host name is provided" do
-    assert_raise(Win32::Service::Error){ Win32::Service.delete('bogus', 'bogus') }
+    assert_raise(SystemCallError){ Win32::Service.delete('bogus', 'bogus') }
   end
 
   test "delete method only accepts up to two arguments" do
     assert_raise(ArgumentError){ Win32::Service.delete('x', 'y', 'z') }
   end
-   
+
   test "pause basic functionality" do
     assert_respond_to(Win32::Service, :pause)
   end
@@ -117,6 +116,7 @@ class TC_Win32_Service < Test::Unit::TestCase
   end
 
   test "pause and resume work as expected" do
+    omit_unless(@elevated, "Skipped unless run with admin privileges")
     start_service(@service_name)
 
     assert_nothing_raised{ Win32::Service.pause(@service_name) }
@@ -129,47 +129,47 @@ class TC_Win32_Service < Test::Unit::TestCase
   test "pausing an already paused service is harmless" do
     start_service(@service_name)
 
-    assert_nothing_raised{ Win32::Service.pause(@service_name) }  
+    assert_nothing_raised{ Win32::Service.pause(@service_name) }
     wait_for_status('paused')
-    assert_nothing_raised{ Win32::Service.pause(@service_name) }  
+    assert_nothing_raised{ Win32::Service.pause(@service_name) }
   end
-   
+
   test "pause requires a service name as an argument" do
     assert_raise(ArgumentError){ Win32::Service.pause }
   end
 
   test "pausing an unrecognized service name raises an error" do
-    assert_raise(Win32::Service::Error){ Win32::Service.pause('bogus') }
+    assert_raise(SystemCallError){ Win32::Service.pause('bogus') }
   end
 
   test "pausing a service on an unrecognized host raises an error" do
-    assert_raise(Win32::Service::Error){ Win32::Service.pause('W32Time', 'bogus') }
+    assert_raise(SystemCallError){ Win32::Service.pause('W32Time', 'bogus') }
   end
 
   test "pause method accepts a maximum of two arguments" do
     assert_raise(ArgumentError){ Win32::Service.pause('x', 'y', 'z') }
   end
-   
+
   test "resume method requires a service name" do
     assert_raise(ArgumentError){ Win32::Service.resume }
   end
 
   test "resume method with an unrecognized service name raises an error" do
-    assert_raise(Win32::Service::Error){ Win32::Service.resume('bogus') }
+    assert_raise(SystemCallError){ Win32::Service.resume('bogus') }
   end
 
   test "resume method with an unrecognized host name raises an error" do
-    assert_raise(Win32::Service::Error){ Win32::Service.resume('W32Time', 'bogus') }
+    assert_raise(SystemCallError){ Win32::Service.resume('W32Time', 'bogus') }
   end
 
   test "resume method accepts a maximum of two arguments" do
     assert_raise(ArgumentError){ Win32::Service.resume('W32Time', @@host, true) }
-  end          
+  end
 
   test "stop method basic functionality" do
     assert_respond_to(Win32::Service, :stop)
   end
-   
+
   test "start method basic functionality" do
     assert_respond_to(Win32::Service, :start)
   end
@@ -189,41 +189,41 @@ class TC_Win32_Service < Test::Unit::TestCase
 
     assert_nothing_raised{ Win32::Service.stop(@service_name) }
     wait_for_status('stopped')
-    assert_raise(Win32::Service::Error){ Win32::Service.stop(@service_name) }  
+    assert_raise(SystemCallError){ Win32::Service.stop(@service_name) }
 
     assert_nothing_raised{ Win32::Service.start(@service_name) }
   end
-   
+
   test "stop method requires a service name" do
     assert_raise(ArgumentError){ Win32::Service.stop }
   end
 
   test "stop method raises an error if the service name is unrecognized" do
-    assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus') }
+    assert_raise(SystemCallError){ Win32::Service.stop('bogus') }
   end
 
   test "stop method raises an error if the host is unrecognized" do
-    assert_raise(Win32::Service::Error){ Win32::Service.stop('W32Time', 'bogus') }
+    assert_raise(SystemCallError){ Win32::Service.stop('W32Time', 'bogus') }
   end
 
   test "stop metho accepts a maximum of two arguments" do
     assert_raise(ArgumentError){ Win32::Service.stop('W32Time', @@host, true) }
   end
-   
+
   test "start method requires a service name" do
     assert_raise(ArgumentError){ Win32::Service.start }
   end
 
   test "attempting to start a running service raises an error" do
-    assert_raise(Win32::Service::Error){ Win32::Service.start(@service_name) }
+    assert_raise(SystemCallError){ Win32::Service.start(@service_name) }
   end
 
   test "attempting to start an unrecognized service raises an error" do
-    assert_raise(Win32::Service::Error){ Win32::Service.start('bogus') }
+    assert_raise(SystemCallError){ Win32::Service.start('bogus') }
   end
 
   test "attempting to start a service on an unknown host raises an error" do
-    assert_raise(Win32::Service::Error){ Win32::Service.start('bogus', 'bogus') }
+    assert_raise(SystemCallError){ Win32::Service.start('bogus', 'bogus') }
   end
 
   test "stop requires at least one argument" do
@@ -231,11 +231,11 @@ class TC_Win32_Service < Test::Unit::TestCase
   end
 
   test "stop raises an error with an unrecognized service name" do
-    assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus') }
+    assert_raise(SystemCallError){ Win32::Service.stop('bogus') }
   end
 
   test "stop raises an error with an unrecognized host" do
-    assert_raise(Win32::Service::Error){ Win32::Service.stop('W32Time', 'bogus') }
+    assert_raise(SystemCallError){ Win32::Service.stop('W32Time', 'bogus') }
   end
 
   test "stop accepts a maximum of 2 arguments" do
@@ -268,11 +268,11 @@ class TC_Win32_Service < Test::Unit::TestCase
   end
 
   test "get_service_name raises an error if a bogus service name is provided" do
-    assert_raise(Win32::Service::Error){ Win32::Service.get_service_name('bogus') }
+    assert_raise(SystemCallError){ Win32::Service.get_service_name('bogus') }
   end
 
   test "get_service_name raises an error if a bogus host is provided" do
-    assert_raise(Win32::Service::Error){ Win32::Service.get_service_name('foo', 'bogus') }
+    assert_raise(SystemCallError){ Win32::Service.get_service_name('foo', 'bogus') }
   end
 
   test "get_service_name accepts a maximum of two arguments" do
@@ -299,11 +299,11 @@ class TC_Win32_Service < Test::Unit::TestCase
   end
 
   test "get_display_name raises an error if the service does not exist" do
-    assert_raise(Win32::Service::Error){ Win32::Service.get_display_name('bogus') }
+    assert_raise(SystemCallError){ Win32::Service.get_display_name('bogus') }
   end
 
   test "get_display_name raises an error if a bad host name is provided" do
-    assert_raise(Win32::Service::Error){ Win32::Service.get_display_name('W32Time', 'bogus') }
+    assert_raise(SystemCallError){ Win32::Service.get_display_name('W32Time', 'bogus') }
   end
 
   test "get_display_name takes a maximum of two arguments" do
@@ -312,6 +312,7 @@ class TC_Win32_Service < Test::Unit::TestCase
 
   test "exists method basic functionality" do
     assert_respond_to(Win32::Service, :exists?)
+    assert_boolean(Win32::Service.exists?('W32Time'))
     assert_nothing_raised{ Win32::Service.exists?('W32Time') }
   end
 
@@ -325,13 +326,17 @@ class TC_Win32_Service < Test::Unit::TestCase
   end
 
   test "exists method raises an error if a bogus host is passed" do
-    assert_raises(Win32::Service::Error){Win32::Service.exists?('foo', 'bogushost') }
+    assert_raises(SystemCallError){
+      Win32::Service.exists?('foo', 'bogushost')
+    }
   end
 
   test "exists method only accepts up to two arguments" do
-    assert_raises(ArgumentError){ Win32::Service.exists?('foo', 'bar', 'baz') }
+    assert_raises(ArgumentError){
+      Win32::Service.exists?('foo', 'bar', 'baz')
+    }
   end
-      
+
   test "scm security constants are defined" do
     assert_not_nil(Win32::Service::MANAGER_ALL_ACCESS)
     assert_not_nil(Win32::Service::MANAGER_CREATE_SERVICE)
@@ -384,14 +389,15 @@ class TC_Win32_Service < Test::Unit::TestCase
     assert_not_nil(Win32::Service::RUNNING)
     assert_not_nil(Win32::Service::START_PENDING)
     assert_not_nil(Win32::Service::STOP_PENDING)
-    assert_not_nil(Win32::Service::STOPPED)      
+    assert_not_nil(Win32::Service::STOPPED)
   end
-   
+
   def teardown
     @display_name = nil
     @service_name = nil
     @service_stat = nil
     @services     = nil
+    @elevated     = nil
   end
 
   def self.shutdown