win32-service 0.5.2 → 0.6.0

data/test/tc_daemon.rb

@@ -1,27 +1,23 @@
 #########################################################################
 # tc_daemon.rb
 #
-# Test suite for the Daemon class
+# Test suite for the Win32::Daemon class. You should run this test via
+# the 'rake test' or 'rake test_daemon' tasks.
+#
+# These tests are rather limited, since the acid test is to install
+# your daemon as a service and see how it behaves.
 #########################################################################
-if File.basename(Dir.pwd) == "test"
-	require "ftools"
-	Dir.chdir ".."
-	Dir.mkdir("win32") unless File.exists?("win32")
-   	File.copy("service.so","win32")
-   	$LOAD_PATH.unshift Dir.pwd
-end
-
-require "win32/service"
-require "test/unit"
+require 'win32/daemon'
+require 'test/unit'
 include Win32
 
 class TC_Daemon < Test::Unit::TestCase
    def setup
-      @d = Daemon.new
+      @daemon = Daemon.new
    end
    
    def test_version
-      assert_equal("0.5.2", Daemon::VERSION)
+      assert_equal('0.6.0', Daemon::VERSION)
    end
    
    def test_constructor
@@ -31,15 +27,15 @@ class TC_Daemon < Test::Unit::TestCase
    end
    
    def test_mainloop
-      assert_respond_to(@d, :mainloop)
+      assert_respond_to(@daemon, :mainloop)
    end
    
    def test_state
-      assert_respond_to(@d, :state)
+      assert_respond_to(@daemon, :state)
    end
    
    def test_running
-      assert_respond_to(@d, :running?)
+      assert_respond_to(@daemon, :running?)
    end
    
    def test_constants
@@ -54,6 +50,6 @@ class TC_Daemon < Test::Unit::TestCase
    end
    
    def teardown
-      @d = nil
+      @daemon = nil
    end
-end
+end

data/test/tc_service.rb

@@ -1,406 +1,260 @@
-###########################################################################
+##########################################################################
 # tc_service.rb
-#
-# Test suite for Win32::Service.  Note that this test suite will take
-# a few seconds to run.  There are some 'sleep' calls sprinkled throughout
-# this code.  These are necessary for some of the methods to complete
-# before subsequent tests are run.
-#
-# Also note that if the W32Time or Schedule services aren't running, some
-# of these tests will fail.
-###########################################################################
+# 
+# Test case for the Win32::Service class.
+##########################################################################
+require 'win32/service'
+require 'socket'
+require 'test/unit'
 
-info = <<HERE
-   This test will stop and start your Time service, as well as pause and
-   resume your Schedule service.  This is harmless unless you are actually
-   using these services at the moment you run this test.  Is it OK to
-   proceed? (y/N)
-HERE
-
-puts info
-ans = STDIN.gets.chomp.downcase
-unless ans == 'y'
-   puts "Exiting without running test suite..."
-   exit!
-end
-
-base = File.basename(Dir.pwd)
-if base == "test" || base =~ /win32-service/
-	require 'fileutils'
-	Dir.chdir("..") if base == "test"
-	Dir.mkdir("win32") unless File.exists?("win32")
-   FileUtils.cp("service.so", "win32")
-   $LOAD_PATH.unshift Dir.pwd
-   Dir.chdir("test") rescue nil
-end
-
-require 'yaml'
-puts Dir.pwd
-$HASH = YAML.load(File.open('tmp.yml'))
-
-puts "This will take a few seconds.  Be patient..."
-
-require "test/unit"
-require "win32/service"
-require "socket"
-include Win32
-
-class TC_Win32Service < Test::Unit::TestCase
+class TC_Win32_Service < Test::Unit::TestCase
    def setup
-      @service = Service.new
-      @stop_start_service = 'W32Time'
-      @pause_resume_service = 'Schedule'
-      
-      # Not to panic - we don't stop or disable these services in this test.
-      # These are only used for getting the service name and display name.
-      @dname = "Remote Procedure Call (RPC)"
-      @sname = "dmadmin"
-   end
-   
-   def test_version
-      assert_equal("0.5.2", Service::VERSION, "Bad version")
-   end
-   
-   def test_class_type
-      assert_kind_of(Win32::Service, @service)
-   end
-   
-   def test_open
-      assert_respond_to(Service, :open)
-      assert_nothing_raised{ Service.open(@stop_start_service){} }
-      assert_nothing_raised{ @service = Service.open(@stop_start_service) }
-      assert_nil(Service.open(@stop_start_service){})
-      assert_kind_of(Win32::Service, @service )
-   end
-   
-   def test_machine_name
-      assert_respond_to(@service, :machine_name)
-      assert_respond_to(@service, :machine_name=)
-      assert_nothing_raised{ @service.machine_name }
-      assert_nothing_raised{ @service.machine_name = Socket.gethostname }
-   end
-   
-   def test_machine_name_expected_errors
-      assert_raises(ArgumentError){ @service.machine_name(1) }
-   end
-   
-   def test_service_name
-      assert_respond_to(@service, :service_name)
-      assert_respond_to(@service, :service_name=)
-      assert_nothing_raised{ @service.service_name }
-      assert_nothing_raised{ @service.service_name = 'foo' }
-   end
-   
-   def test_service_name_expected_errors
-      assert_raises(ArgumentError){ @service.service_name(1) }
-   end
-   
-   def test_display_name
-      assert_respond_to(@service, :display_name)
-      assert_respond_to(@service, :display_name=)
-      assert_nothing_raised{ @service.display_name }
-      assert_nothing_raised{ @service.display_name = "foosvc" }
-   end
-   
-   def test_display_name_expected_errors
-      assert_raises(ArgumentError){ @service.display_name(1) }
-   end
-   
-   def test_binary_path_name
-      assert_respond_to(@service, :binary_path_name)
-      assert_respond_to(@service, :binary_path_name=)
-      assert_nothing_raised{ @service.binary_path_name }
-      assert_nothing_raised{ @service.binary_path_name = "C:/foo/bar" }
-   end
-   
-   def test_binary_path_name_expected_errors
-      assert_raises(ArgumentError){ @service.binary_path_name(1) }
-   end
-   
-   def test_load_order_group
-      assert_respond_to(@service, :load_order_group)
-      assert_respond_to(@service, :load_order_group=)
-      assert_nothing_raised{ @service.load_order_group }
-      assert_nothing_raised{ @service.load_order_group = 'foo' }
-   end
-   
-   def test_load_order_group_expected_errors
-      assert_raises(ArgumentError){ @service.load_order_group(1) }
-   end
-   
-   def test_dependencies
-      assert_respond_to(@service, :dependencies)
-      assert_respond_to(@service, :dependencies=)     
-      assert_nothing_raised{ @service.dependencies = ['foo', "bar"] }
-   end
-   
-   def test_dependencies_expected_errors
-      assert_raises(ArgumentError){ @service.dependencies(1) }
-      assert_raises(TypeError){ @service.dependencies = 'foo' }
-      assert_raises(TypeError){ @service.dependencies = 1 }
-   end
-   
-   def test_start_name
-      assert_respond_to(@service, :start_name)
-      assert_respond_to(@service, :start_name=)
-      assert_nothing_raised{ @service.start_name }
-      assert_nothing_raised{ @service.start_name = 'foo' }
-   end
-   
-   def test_start_name_expected_errors
-      assert_raises(ArgumentError){ @service.start_name(1) }
-   end
-   
-   def test_password
-      assert_respond_to(@service, :password)
-      assert_respond_to(@service, :password=)
-      assert_nothing_raised{ @service.password }
-      assert_nothing_raised{ @service.password = "mypass" }
-   end
-   
-   def test_password_expected_errors
-      assert_raises(ArgumentError){ @service.password(1) }
+      @display_name = "Task Scheduler"
+      @service_name = "Schedule"      
+      @service_stat = nil
+      @services     = []
    end
    
-   def test_error_control
-      assert_respond_to(@service, :error_control)
-      assert_respond_to(@service, :error_control=)
-      assert_nothing_raised{ @service.error_control }
-      assert_nothing_raised{ @service.error_control = "test" }
+   def wait_for_status(status)
+      sleep 0.1 while Win32::Service.status(@service_name).current_state != status
    end
-   
-   def test_error_control_expected_errors
-      assert_raises(ArgumentError){ @service.error_control(1) }
+
+   def test_version
+      assert_equal('0.6.0', Win32::Service::VERSION)
    end
-   
-   def test_start_type
-      assert_respond_to(@service, :start_type)
-      assert_respond_to(@service, :start_type=)
-      assert_nothing_raised{ @service.start_type }
-      assert_nothing_raised{ @service.start_type = Service::DEMAND_START }
+
+   def test_service_configure
+      assert_respond_to(Win32::Service, :configure)
    end
    
-   def test_start_type_expected_errors
-      assert_raises(ArgumentError){ @service.start_type(1) }
+   def test_service_configure_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.configure }
+      assert_raise(ArgumentError){ Win32::Service.configure('bogus') }
+      assert_raise(ArgumentError){ Win32::Service.configure('bogus', 'bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.configure('x', nil, :description => 'Test') }
+      assert_raise(Win32::Service::Error){ Win32::Service.configure('x', 'y', :description => 'Test') }      
    end
    
-   def test_desired_access
-      assert_respond_to(@service, :desired_access)
-      assert_respond_to(@service, :desired_access=)
-      assert_nothing_raised{ @service.desired_access }
-      assert_nothing_raised{ @service.desired_access = Service::MANAGER_LOCK }
+   def test_services_basic
+      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
    
-   def test_desired_access_expected_errors
-      assert_raises(ArgumentError){ @service.desired_access(1) }
+   def test_services_non_block_form
+      assert_nothing_raised{ @services = Win32::Service.services }
+      assert_kind_of(Array, @services)
+      assert_kind_of(Struct::ServiceInfo, @services[0])
    end
    
-   def test_service_type
-      assert_respond_to(@service, :service_type)
-      assert_respond_to(@service, :service_type=)
-      assert_nothing_raised{ @service.service_type }
-      assert_nothing_raised{
-         @service.service_type = Service::WIN32_OWN_PROCESS
-      }
+   def test_services_block_form
+      assert_nothing_raised{ Win32::Service.services{ |s| @services << s } }
+      assert_kind_of(Array, @services)
+      assert_kind_of(Struct::ServiceInfo, @services[0])      
    end
-   
-   def test_service_type_expected_errors
-      assert_raises(ArgumentError){ @service.service_type(1) }
+      
+   def test_services_expected_errors
+      assert_raise(TypeError){ Win32::Service.services(1) }
+      assert_raise(TypeError){ Win32::Service.services(nil, 1) }
+      assert_raise(ArgumentError){ Win32::Service.services(nil, 'network', 1) }
+      assert_raise(Win32::Service::Error){ Win32::Service.services('bogus') }
+   end   
+   
+   def test_delete
+      assert_respond_to(Win32::Service, :delete)
+   end
+   
+   def test_delete_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.delete }
+      assert_raise(Win32::Service::Error){ Win32::Service.delete('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.delete('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.delete('x', 'y', 'z') }
+   end
+   
+   def test_service_pause_and_resume
+      assert_respond_to(Win32::Service, :pause)
+      assert_respond_to(Win32::Service, :resume)
+      assert_nothing_raised{ Win32::Service.pause(@service_name) }
+      assert_nothing_raised{ wait_for_status('paused') }
+      assert_nothing_raised{ Win32::Service.pause(@service_name) }  
+      assert_nothing_raised{ Win32::Service.resume(@service_name) }
+      assert_nothing_raised{ wait_for_status('running') }
+   end
+   
+   def test_pause_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.pause }
+      assert_raise(Win32::Service::Error){ Win32::Service.pause('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.pause('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.pause('x', 'y', 'z') }
+   end
+   
+   def test_resume_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.resume }
+      assert_raise(Win32::Service::Error){ Win32::Service.resume('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.resume('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.resume('bogus', 'bogus', 'a') }
+   end          
+   
+   def test_service_stop_and_start
+      assert_respond_to(Win32::Service, :stop)
+      assert_respond_to(Win32::Service, :start)
+      assert_nothing_raised{ Win32::Service.stop(@service_name) }
+      assert_nothing_raised{ wait_for_status('stopped') }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop(@service_name) }  
+      assert_nothing_raised{ Win32::Service.start(@service_name) }
+      assert_nothing_raised{ wait_for_status('running') }
+   end
+   
+   def test_stop_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.stop }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.stop('x', 'y', 'z') }
+   end
+   
+   def test_start_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.start }
+      assert_raise(Win32::Service::Error){ Win32::Service.start(@service_name) } # Started
+      assert_raise(Win32::Service::Error){ Win32::Service.start('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.start('bogus', 'bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.start('bogus', 'bogus', 'a') }
+      assert_raise(Win32::Service::Error){ Win32::Service.start('a', 'b', 'c', 'd') }
+   end   
+   
+   def test_service_stop_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.stop }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.stop('a', 'b', 'c') }
    end
-   
-   def test_constructor_arguments
-      assert_nothing_raised{ Service.new{} }
-      assert_nothing_raised{ Service.new(Socket.gethostname){} }
-      assert_nothing_raised{
-         Service.new(Socket.gethostname, Service::MANAGER_ALL_ACCESS){}
-      }
+
+   def test_service_status_basic
+      assert_respond_to(Win32::Service, :status)
+      assert_nothing_raised{ Win32::Service.status(@service_name) }
+      assert_kind_of(Struct::ServiceStatus, Win32::Service.status(@service_name))
    end
-   
-   def test_constructor_expected_errors
-      assert_raises(ArgumentError){ Service.new("test", 1, 1){} }
-      assert_raises(TypeError){ Service.new(1){} }
+
+   def test_service_get_service_name_basic
+      assert_respond_to(Win32::Service, :get_service_name)
+      assert_nothing_raised{ Win32::Service.get_service_name(@display_name) }
+      assert_kind_of(String, Win32::Service.get_service_name(@display_name))
    end
-   
-   # This occasionally fails for some reason with an error about an invalid
-   # handle value.  I'm not sure why.
-   def test_services
-      assert_respond_to(Service, :services)
-      assert_nothing_raised{ Service.services{ } }
-      assert_nothing_raised{ Service.services }
-      assert_kind_of(Array, Service.services)
-      assert_kind_of(Struct::Win32Service, Service.services.first)
+
+   def test_service_getservicename_alias_basic
+      assert_respond_to(Win32::Service, :getservicename)
+      assert_nothing_raised{ Win32::Service.getservicename(@display_name) }
+      assert_kind_of(String, Win32::Service.getservicename(@display_name))
    end
-   
-   def test_services_expected_errors
-      assert_raises(TypeError){ Service.services(1) }
+
+   def test_service_get_service_name
+      assert_equal(@service_name, Win32::Service.get_service_name(@display_name))
+      assert_equal(@service_name, Win32::Service.getservicename(@display_name))
    end
 
-   # This test will fail if the W32Time service isn't started.
-   def test_stop_start
-      assert_nothing_raised{ Service.stop(@stop_start_service) }
-      sleep 3
-      assert_nothing_raised{ Service.start(@stop_start_service) }
+   def test_service_get_service_name_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.get_service_name }
+      assert_raise(Win32::Service::Error){ Win32::Service.get_service_name('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.get_service_name('foo','bogus') }
+      assert_raise(ArgumentError){ Win32::Service.get_service_name('x', 'y', 'z') }
    end
 
-   def test_start_failure
-      assert_raises(ServiceError){ Service.start('bogus') }
-      assert_raises(ServiceError){ Service.start('winmgmt') }
+   def test_service_get_display_name_basic
+      assert_respond_to(Win32::Service, :get_display_name)
+      assert_nothing_raised{ Win32::Service.get_display_name(@service_name) }
+      assert_kind_of(String, Win32::Service.get_display_name(@service_name))
    end
-   
-   # Trying to stop a non-existant should fail, as well as trying to
-   # pause a service that isn't running.  Here I use the Telnet server for
-   # the latter case because it is disabled by default.
-   #
-   def test_stop_failure
-      assert_raises(ServiceError){ Service.stop('bogus') }
-      assert_raises(ServiceError){ Service.stop('TlntSvr') }
+
+   def test_service_getdisplayname_alias_basic
+      assert_respond_to(Win32::Service, :getdisplayname)
+      assert_nothing_raised{ Win32::Service.getdisplayname(@service_name) }
+      assert_kind_of(String, Win32::Service.getdisplayname(@service_name))
    end
-   
-   # Trying to pause a non-existant should fail, as well as trying to
-   # pause a service that isn't running.  Here I use the Telnet server for
-   # the latter case because it is disabled by default.
-   # 
-   def test_pause_failure
-      assert_raises(ServiceError){ Service.pause('bogus') }
-      assert_raises(ServiceError){ Service.pause('TlntSvr') }
+
+   def test_service_get_display_name
+      assert_equal(@display_name, Win32::Service.get_display_name(@service_name))
+      assert_equal(@display_name, Win32::Service.getdisplayname(@service_name))
    end
-   
-   # Trying to resume a non-existant should fail, as well as trying to
-   # resume a service that is already running.
-   #
-   def test_resume_failure
-      assert_raises(ServiceError){ Service.resume('bogus') }
-      assert_raises(ServiceError){ Service.resume('W32Time') }
+
+   def test_service_get_display_name_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.get_display_name }
+      assert_raise(Win32::Service::Error){ Win32::Service.get_display_name('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.get_display_name('foo','bogus') }
+      assert_raise(ArgumentError){ Win32::Service.get_display_name('x', 'y', 'z') }
    end
-   
-   def test_pause_resume
-      assert_nothing_raised{ Service.pause(@pause_resume_service) }
-      sleep 2
-      assert_nothing_raised{ Service.resume(@pause_resume_service) }
-      sleep 2
+
+   def test_service_exists
+      assert_respond_to(Win32::Service, :exists?)
+      assert_nothing_raised{ Win32::Service.exists?('W32Time') }
+      assert_equal(true, Win32::Service.exists?('W32Time'))
+      assert_equal(false, Win32::Service.exists?('foobar'))
    end
-   
-   def test_getservicename
-      assert_respond_to(Service, :getservicename)
-      assert_nothing_raised{ Service.getservicename(@dname) }
-      assert_kind_of(String, Service.getservicename(@dname))
+
+   def test_service_exists_expected_errors
+      assert_raises(ArgumentError){ Win32::Service.exists? }
+      assert_raises(Win32::Service::Error){Win32::Service.exists?('foo', 'bogushost') }
+      assert_raises(ArgumentError){ Win32::Service.exists?('foo', 'bar', 'baz') }
    end
-   
-   def test_getdisplayname
-      assert_respond_to(Service, :getdisplayname)
-      assert_nothing_raised{ Service.getdisplayname(@sname) }
-      assert_kind_of(String, Service.getdisplayname(@sname))
+      
+   def test_scm_security_constants
+      assert_not_nil(Win32::Service::MANAGER_ALL_ACCESS)
+      assert_not_nil(Win32::Service::MANAGER_CREATE_SERVICE)
+      assert_not_nil(Win32::Service::MANAGER_CONNECT)
+      assert_not_nil(Win32::Service::MANAGER_ENUMERATE_SERVICE)
+      assert_not_nil(Win32::Service::MANAGER_LOCK)
+      assert_not_nil(Win32::Service::MANAGER_QUERY_LOCK_STATUS)
    end
-   
-   def test_create_delete
-      assert_nothing_raised{
-         @service.create_service{ |s|
-            s.service_name = 'foo'
-            s.display_name = "Foo Test"
-            s.binary_path_name = "C:\\ruby\\bin\\rubyw.exe -v"
-         }
-      }
-      sleep 2
-      assert_nothing_raised{ Service.delete('foo') }
-      sleep 2
-      assert_raises(ServiceError){ Service.delete('foo') }
+
+   def test_service_specific_constants
+      assert_not_nil(Win32::Service::ALL_ACCESS)
+      assert_not_nil(Win32::Service::CHANGE_CONFIG)
+      assert_not_nil(Win32::Service::ENUMERATE_DEPENDENTS)
+      assert_not_nil(Win32::Service::INTERROGATE)
+      assert_not_nil(Win32::Service::PAUSE_CONTINUE)
+      assert_not_nil(Win32::Service::QUERY_CONFIG)
+      assert_not_nil(Win32::Service::QUERY_STATUS)
+      assert_not_nil(Win32::Service::STOP)
+      assert_not_nil(Win32::Service::START)
+      assert_not_nil(Win32::Service::USER_DEFINED_CONTROL)
    end
-   
-   def test_configure_service
-      assert_nothing_raised{
-         @service.configure_service{ |s|
-            s.service_name = 'W32Time'
-            s.display_name = "Hammer Time"
-         }
-      }
-      sleep 2
-      assert_nothing_raised{
-         @service.configure_service{ |s|
-            s.service_name = 'W32Time'
-            s.display_name = "Windows Time"
-         }
-      }  
+
+   def test_service_type_constants
+      assert_not_nil(Win32::Service::FILE_SYSTEM_DRIVER)
+      assert_not_nil(Win32::Service::KERNEL_DRIVER)
+      assert_not_nil(Win32::Service::WIN32_OWN_PROCESS)
+      assert_not_nil(Win32::Service::WIN32_SHARE_PROCESS)
+      assert_not_nil(Win32::Service::INTERACTIVE_PROCESS)
    end
-   
-   def test_configure_expected_errors
-      assert_raises(LocalJumpError){ @service.configure_service }
+
+   def test_service_start_option_constants
+      assert_not_nil(Win32::Service::AUTO_START)
+      assert_not_nil(Win32::Service::BOOT_START)
+      assert_not_nil(Win32::Service::DEMAND_START)
+      assert_not_nil(Win32::Service::DISABLED)
+      assert_not_nil(Win32::Service::SYSTEM_START)
    end
-   
-   def test_status
-      members = %w/service_type current_state controls_accepted/
-      members.push(%w/win32_exit_code service_specific_exit_code/)
-      members.push(%w/check_point wait_hint interactive/)
 
-      if $HASH['HAVE_QUERYSERVICESTATUSEX']
-         members.push(%w/pid service_flags/)
-      end
-      members.flatten!
-      
-      assert_nothing_raised{ Service.status('W32Time') }
-      struct = Service.status('W32Time')
-      assert_kind_of(Struct::Win32ServiceStatus, struct)
-      assert_equal(members, struct.members)
-   end 
-   
-   def test_constants
-      assert_not_nil(Service::MANAGER_ALL_ACCESS)
-      assert_not_nil(Service::MANAGER_CREATE_SERVICE)
-      assert_not_nil(Service::MANAGER_CONNECT)
-      assert_not_nil(Service::MANAGER_ENUMERATE_SERVICE)
-      assert_not_nil(Service::MANAGER_LOCK)
-      #assert_not_nil(Service::MANAGER_BOOT_CONFIG)
-      assert_not_nil(Service::MANAGER_QUERY_LOCK_STATUS)
-      
-      assert_not_nil(Service::ALL_ACCESS)
-      assert_not_nil(Service::CHANGE_CONFIG)
-      assert_not_nil(Service::ENUMERATE_DEPENDENTS)
-      assert_not_nil(Service::INTERROGATE)
-      assert_not_nil(Service::PAUSE_CONTINUE)
-      assert_not_nil(Service::QUERY_CONFIG)
-      assert_not_nil(Service::QUERY_STATUS)
-      assert_not_nil(Service::STOP)
-      assert_not_nil(Service::START)
-      assert_not_nil(Service::USER_DEFINED_CONTROL)
-      
-      assert_not_nil(Service::FILE_SYSTEM_DRIVER)
-      assert_not_nil(Service::KERNEL_DRIVER)
-      assert_not_nil(Service::WIN32_OWN_PROCESS)
-      assert_not_nil(Service::WIN32_SHARE_PROCESS)
-      assert_not_nil(Service::INTERACTIVE_PROCESS)
-      
-      assert_not_nil(Service::AUTO_START)
-      assert_not_nil(Service::BOOT_START)
-      assert_not_nil(Service::DEMAND_START)
-      assert_not_nil(Service::DISABLED)
-      assert_not_nil(Service::SYSTEM_START)
-      
-      assert_not_nil(Service::ERROR_IGNORE)
-      assert_not_nil(Service::ERROR_NORMAL)
-      assert_not_nil(Service::ERROR_SEVERE)
-      assert_not_nil(Service::ERROR_CRITICAL)
-      
-      assert_not_nil(Service::CONTINUE_PENDING)
-      assert_not_nil(Service::PAUSE_PENDING)
-      assert_not_nil(Service::PAUSED)
-      assert_not_nil(Service::RUNNING)
-      assert_not_nil(Service::START_PENDING)
-      assert_not_nil(Service::STOP_PENDING)
-      assert_not_nil(Service::STOPPED)      
+   def test_service_error_control_constants
+      assert_not_nil(Win32::Service::ERROR_IGNORE)
+      assert_not_nil(Win32::Service::ERROR_NORMAL)
+      assert_not_nil(Win32::Service::ERROR_SEVERE)
+      assert_not_nil(Win32::Service::ERROR_CRITICAL)
    end
-   
-   def test_exists
-      assert_nothing_raised{ Service.exists?('W32Time') }
-      assert_raises(ArgumentError){ Service.exists? }
-      assert_equal(true, Service.exists?('W32Time'))
-      assert_equal(false, Service.exists?('foobar'))
+
+   def test_service_state_constants
+      assert_not_nil(Win32::Service::CONTINUE_PENDING)
+      assert_not_nil(Win32::Service::PAUSE_PENDING)
+      assert_not_nil(Win32::Service::PAUSED)
+      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)      
    end
    
    def teardown
-      begin
-         @service.close
-      rescue ServiceError
-         # Ignore - not sure why this happens
-      end
-      @service = nil
-   end
-end
+      @display_name = nil
+      @service_name = nil
+      @service_stat = nil
+      @services     = nil
+   end
+end