win32-service 1.0.1 → 2.1.2

data/examples/demo_daemon.rb

@@ -1,96 +0,0 @@
-LOG_FILE = 'C:\\Tmp\\win32_daemon_test.log'
-
-begin
-  require 'rubygems'
-  require 'win32/daemon'
-  include Win32
-
-  class DemoDaemon < Daemon
-    # This method fires off before the +service_main+ mainloop is entered.
-    # Any pre-setup code you need to run before your service's mainloop
-    # starts should be put here. Otherwise the service might fail with a
-    # timeout error when you try to start it.
-    #
-    def service_init
-      Dir.mkdir("C:/Tmp") unless File.exist?("C:/Tmp")
-      10.times{ |i|
-        File.open(LOG_FILE , 'a'){ |f| f.puts("#{i}") }
-        sleep 1
-      }
-    end
-
-    # This is the daemon's mainloop. In other words, whatever runs here
-    # is the code that runs while your service is running. Note that the
-    # loop is not implicit.
-    #
-    # You must setup a loop as I've done here with the 'while running?'
-    # code, or setup your own loop. Otherwise your service will exit and
-    # won't be especially useful.
-    #
-    # In this particular case, I've setup a loop to append a short message
-    # and timestamp to a file on your C: drive every 20 seconds. Be sure
-    # to stop the service when you're done!
-    #
-    def service_main(*args)
-      msg = 'service_main entered at: ' + Time.now.to_s
-
-      File.open(LOG_FILE, 'a'){ |f|
-        f.puts msg
-        f.puts "Args: " + args.join(',')
-      }
-
-      # While we're in here the daemon is running.
-      while running?
-        if state == RUNNING
-          sleep 20
-          msg = 'Service is running as of: ' + Time.now.to_s
-          File.open(LOG_FILE, 'a'){ |f| f.puts msg }
-        else # PAUSED or IDLE
-          sleep 0.5
-        end
-      end
-
-      # We've left the loop, the daemon is about to exit.
-
-      File.open(LOG_FILE, 'a'){ |f| f.puts "STATE: #{state}" }
-
-      msg = 'service_main left at: ' + Time.now.to_s
-
-      File.open(LOG_FILE, 'a'){ |f| f.puts msg }
-    end
-
-    # This event triggers when the service receives a signal to stop.
-    #
-    # NOTE: Older versions of this code used an explicit exit! call
-    # to force the Ruby interpreter to exit. Don't do that. It is no
-    # longer required and, in fact, may cause issues.
-    #
-    def service_stop
-      msg = 'Received stop signal at: ' + Time.now.to_s
-      File.open(LOG_FILE, 'a'){ |f| f.puts msg }
-    end
-
-    # This event triggers when the service receives a signal to pause.
-    #
-    def service_pause
-      msg = 'Received pause signal at: ' + Time.now.to_s
-      File.open(LOG_FILE, 'a'){ |f| f.puts msg }
-    end
-
-    # This event triggers when the service receives a signal to resume
-    # from a paused state.
-    #
-    def service_resume
-      msg = 'Received resume signal at: ' + Time.now.to_s
-      File.open(LOG_FILE, 'a'){ |f| f.puts msg }
-    end
-  end
-
-  # Create an instance of the Daemon and put it into a loop. I borrowed the
-  # method name 'mainloop' from Tk, btw.
-  #
-  DemoDaemon.mainloop
-rescue Exception => err
-  File.open(LOG_FILE, 'a'){ |fh| fh.puts "Daemon failure: #{err}" }
-  raise
-end

data/examples/demo_daemon_ctl.rb

@@ -1,123 +0,0 @@
-############################################################################
-# demo_daemon_ctl.rb
-#
-# This is a command line script for installing and/or running a small
-# Ruby program as a service. The service will simply write a small bit
-# of text to a file every 20 seconds. It will also write some text to the
-# file during the initialization (service_init) step.
-#
-# It should take about 10 seconds to start, which is intentional - it's a test
-# of the service_init hook, so don't be surprised if you see "one moment,
-# start pending" about 10 times on the command line.
-#
-# The file in question is C:\Tmp\win32_daemon_test.log. Feel free to delete
-# it when you're finished.
-#
-# To run the service, you must install it first.
-#
-# Usage: ruby demo_daemon_ctl.rb <option>
-#
-# Note that you *must* pass this program an option
-#
-# Options:
-#    install    - Installs the service.  The service name is "DemoSvc"
-#                 and the display name is "Demo".
-#    start      - Starts the service.  Make sure you stop it at some point or
-#                 you will eventually fill up your filesystem!.
-#    stop       - Stops the service.
-#    pause      - Pauses the service.
-#    resume     - Resumes the service.
-#    uninstall  - Uninstalls the service.
-#    delete     - Same as uninstall.
-#
-# You can also used the Windows Services GUI to start and stop the service.
-#
-# To get to the Windows Services GUI just follow:
-#    Start -> Control Panel -> Administrative Tools -> Services
-############################################################################
-require 'win32/service'
-require 'rbconfig'
-include Win32
-include RbConfig
-
-# Make sure you're using the version you think you're using.
-puts 'VERSION: ' + Service::VERSION
-
-SERVICE_NAME = 'DemoSvc'
-SERVICE_DISPLAYNAME = 'Demo'
-
-# Quote the full path to deal with possible spaces in the path name.
-ruby = File.join(CONFIG['bindir'], CONFIG['ruby_install_name']).tr('/', '\\')
-path = ' "' + File.dirname(File.expand_path($0)).tr('/', '\\')
-path += '\demo_daemon.rb"'
-cmd = ruby + path
-
-# You must provide at least one argument.
-raise ArgumentError, 'No argument provided' unless ARGV[0]
-
-case ARGV[0].downcase
-   when 'install'
-      Service.new(
-         :service_name     => SERVICE_NAME,
-         :display_name     => SERVICE_DISPLAYNAME,
-         :description      => 'Sample Ruby service',
-         :binary_path_name => cmd
-      )
-      puts 'Service ' + SERVICE_NAME + ' installed'
-   when 'start'
-      if Service.status(SERVICE_NAME).current_state != 'running'
-         Service.start(SERVICE_NAME, nil, 'hello', 'world')
-         while Service.status(SERVICE_NAME).current_state != 'running'
-            puts 'One moment...' + Service.status(SERVICE_NAME).current_state
-            sleep 1
-         end
-         puts 'Service ' + SERVICE_NAME + ' started'
-      else
-         puts 'Already running'
-      end
-   when 'stop'
-      if Service.status(SERVICE_NAME).current_state != 'stopped'
-         Service.stop(SERVICE_NAME)
-         while Service.status(SERVICE_NAME).current_state != 'stopped'
-            puts 'One moment...' + Service.status(SERVICE_NAME).current_state
-            sleep 1
-         end
-         puts 'Service ' + SERVICE_NAME + ' stopped'
-      else
-         puts 'Already stopped'
-      end
-   when 'uninstall', 'delete'
-      if Service.status(SERVICE_NAME).current_state != 'stopped'
-         Service.stop(SERVICE_NAME)
-      end
-      while Service.status(SERVICE_NAME).current_state != 'stopped'
-         puts 'One moment...' + Service.status(SERVICE_NAME).current_state
-         sleep 1
-      end
-      Service.delete(SERVICE_NAME)
-      puts 'Service ' + SERVICE_NAME + ' deleted'
-   when 'pause'
-      if Service.status(SERVICE_NAME).current_state != 'paused'
-         Service.pause(SERVICE_NAME)
-         while Service.status(SERVICE_NAME).current_state != 'paused'
-            puts 'One moment...' + Service.status(SERVICE_NAME).current_state
-            sleep 1
-         end
-         puts 'Service ' + SERVICE_NAME + ' paused'
-      else
-         puts 'Already paused'
-      end
-   when 'resume'
-      if Service.status(SERVICE_NAME).current_state != 'running'
-         Service.resume(SERVICE_NAME)
-         while Service.status(SERVICE_NAME).current_state != 'running'
-            puts 'One moment...' + Service.status(SERVICE_NAME).current_state
-            sleep 1
-         end
-         puts 'Service ' + SERVICE_NAME + ' resumed'
-      else
-         puts 'Already running'
-      end
-   else
-      raise ArgumentError, 'unknown option: ' + ARGV[0]
-end

data/examples/demo_services.rb

@@ -1,30 +0,0 @@
-#######################################################################
-# demo_services.rb
-#
-# Test script for general futzing that shows off the basic
-# capabilities of this library. Modify as you see fit.
-#
-# You can run this sample program via the "example:services" task.
-#######################################################################
-require 'win32/service'
-include Win32
-
-puts "VERSION: " + Service::VERSION
-
-p Service.exists?('Schedule')
-p Service.exists?('bogusxxx')
-
-status = Service.status('Schedule')
-p status
-
-info = Service.config_info('Schedule')
-
-print "\n\nShowing config info for Schedule service\n\n"
-p info
-
-print "\n\nAbout to show all services\n\n"
-sleep 10
-
-Service.services{ |struct|
-  p struct
-}

data/test/test_win32_daemon.rb

@@ -1,58 +0,0 @@
-#########################################################################
-# test_win32_daemon.rb
-#
-# 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.
-#########################################################################
-require 'test-unit'
-require 'win32/daemon'
-include Win32
-
-class TC_Daemon < Test::Unit::TestCase
-  def setup
-    @daemon = Daemon.new
-  end
-
-  test "version number is set properly" do
-    assert_equal('0.8.10', Daemon::VERSION)
-  end
-
-  test "constructor basic functionality" do
-    assert_respond_to(Daemon, :new)
-    assert_nothing_raised{ Daemon.new }
-  end
-
-  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)
-    assert_not_nil(Daemon::PAUSED)
-    assert_not_nil(Daemon::RUNNING)
-    assert_not_nil(Daemon::START_PENDING)
-    assert_not_nil(Daemon::STOP_PENDING)
-    assert_not_nil(Daemon::STOPPED)
-    assert_not_nil(Daemon::IDLE)
-  end
-
-  def teardown
-    @daemon = nil
-  end
-end

data/test/test_win32_service.rb

@@ -1,468 +0,0 @@
-##########################################################################
-# test_win32_service.rb
-#
-# Tests for the Win32::Service class. Some tests are skipped unless
-# run with admin privileges either because they are somewhat invasive,
-# or because they take too long.
-##########################################################################
-require 'test-unit'
-require 'win32/security'
-require 'win32/service'
-require 'socket'
-
-class TC_Win32_Service < Test::Unit::TestCase
-  def self.startup
-    @@host = Socket.gethostname
-    @@service_name = 'stisvc'
-    @@elevated = Win32::Security.elevated_security?
-  end
-
-  def setup
-    @display_name = 'Windows Image Acquisition (WIA)'
-    @service_name = 'stisvc'
-    @service_stat = nil
-    @services     = []
-    @elevated     = Win32::Security.elevated_security?
-
-    @singleton_methods = Win32::Service.methods.map{ |m| m.to_s }
-    @instance_methods  = Win32::Service.instance_methods.map{ |m| m.to_s }
-  end
-
-  def omit_unless_elevated
-    omit_unless(@elevated, "Skipped unless run with admin privileges")
-  end
-
-  def start_service(service)
-    status = Win32::Service.status(@service_name).current_state
-
-    if @elevated
-      if status == 'paused'
-        Win32::Service.resume(service)
-      else
-        unless ['running', 'start pending'].include?(status)
-          Win32::Service.start(service)
-        end
-      end
-      wait_for_status('running')
-    end
-  end
-
-  def stop_service(service)
-    status = Win32::Service.status(@service_name).current_state
-    if @elevated
-      unless ['stopped', 'stop pending'].include?(status)
-        Win32::Service.stop(service)
-      end
-      wait_for_status('stopped')
-    end
-  end
-
-  # Helper method that waits for a status to change its state since state
-  # changes aren't usually instantaneous.
-  def wait_for_status(status)
-    sleep 0.1 while Win32::Service.status(@service_name).current_state != status
-  end
-
-  test "version number is expected value" do
-    assert_equal('0.8.10', Win32::Service::VERSION)
-  end
-
-  test "services basic functionality" do
-    assert_respond_to(Win32::Service, :services)
-  end
-
-  test "services with no arguments works as expected" do
-    assert_nothing_raised{ Win32::Service.services }
-  end
-
-  test "services with explicit host works as expected" do
-    assert_nothing_raised{ Win32::Service.services(@@host) }
-  end
-
-  test "services with explicit host and group works as expected" do
-    assert_nothing_raised{ Win32::Service.services(@@host, '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])
-  end
-
-  test "the host argument must be a string or an error is raised" do
-    assert_raise(TypeError){ Win32::Service.services(1) }
-  end
-
-  test "the group argument must be a string or an error is raised" do
-    assert_raise(TypeError){ Win32::Service.services(nil, 1) }
-  end
-
-  test "the services method only accepts 2 arguments" do
-    assert_raise(ArgumentError){ Win32::Service.services(nil, 'network', 1) }
-  end
-
-  test "a valid hostname must be provided or an error is raised" do
-    omit_unless_elevated
-    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
-    omit_unless_elevated
-    assert_raise(SystemCallError){ Win32::Service.delete('bogus') }
-  end
-
-  test "delete method raises an error if a bogus host name is provided" do
-    omit_unless_elevated
-    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
-
-  test "resume basic functionality" do
-    assert_respond_to(Win32::Service, :resume)
-  end
-
-  test "pause and resume work as expected" do
-    omit_unless_elevated
-    start_service(@service_name)
-
-    assert_nothing_raised{ Win32::Service.pause(@service_name) }
-    wait_for_status('paused')
-
-    assert_nothing_raised{ Win32::Service.resume(@service_name) }
-    wait_for_status('running')
-  end
-
-  test "pausing an already paused service is harmless" do
-    omit_unless_elevated
-    start_service(@service_name)
-
-    assert_nothing_raised{ Win32::Service.pause(@service_name) }
-    wait_for_status('paused')
-    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(SystemCallError){ Win32::Service.pause('bogus') }
-  end
-
-  test "pausing a service on an unrecognized host raises an error" do
-    omit_unless_elevated
-    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(SystemCallError){ Win32::Service.resume('bogus') }
-  end
-
-  test "resume method with an unrecognized host name raises an error" do
-    omit_unless_elevated
-    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
-
-  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
-
-  test "stop and start methods work as expected" do
-    omit_unless_elevated
-    start_service(@service_name)
-
-    assert_nothing_raised{ Win32::Service.stop(@service_name) }
-    wait_for_status('stopped')
-
-    assert_nothing_raised{ Win32::Service.start(@service_name) }
-    wait_for_status('running')
-  end
-
-  test "attempting to stop a stopped service raises an error" do
-    omit_unless_elevated
-    start_service(@service_name)
-
-    assert_nothing_raised{ Win32::Service.stop(@service_name) }
-    wait_for_status('stopped')
-    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(SystemCallError){ Win32::Service.stop('bogus') }
-  end
-
-  test "stop method raises an error if the host is unrecognized" do
-    omit_unless_elevated
-    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
-    omit_unless_elevated
-    start_service(@service_name)
-    assert_raise(SystemCallError){ Win32::Service.start(@service_name) }
-  end
-
-  test "attempting to start an unrecognized service raises an error" do
-    assert_raise(SystemCallError){ Win32::Service.start('bogus') }
-  end
-
-  test "attempting to start a service on an unknown host raises an error" do
-    omit_unless_elevated
-    assert_raise(SystemCallError){ Win32::Service.start('bogus', 'bogus') }
-  end
-
-  test "stop requires at least one argument" do
-    assert_raise(ArgumentError){ Win32::Service.stop }
-  end
-
-  test "stop raises an error with an unrecognized service name" do
-    assert_raise(SystemCallError){ Win32::Service.stop('bogus') }
-  end
-
-  test "stop raises an error with an unrecognized host" do
-    omit_unless_elevated
-    assert_raise(SystemCallError){ Win32::Service.stop('W32Time', 'bogus') }
-  end
-
-  test "stop accepts a maximum of 2 arguments" do
-    assert_raise(ArgumentError){ Win32::Service.stop('a', 'b', 'c') }
-  end
-
-  test "status basic functionality" do
-    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
-
-  test "get_service_name basic functionality" do
-    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
-
-  test "get_service_name returns expected results" do
-    assert_equal(@service_name, Win32::Service.get_service_name(@display_name))
-  end
-
-  test "getservicename is an alias for get_service_name" do
-    assert_respond_to(Win32::Service, :getservicename)
-    assert_alias_method(Win32::Service, :getservicename, :get_service_name)
-  end
-
-  test "get_service_name requires at least one argument" do
-    assert_raise(ArgumentError){ Win32::Service.get_service_name }
-  end
-
-  test "get_service_name raises an error if a bogus service name is provided" do
-    assert_raise(SystemCallError){ Win32::Service.get_service_name('bogus') }
-  end
-
-  test "get_service_name raises an error if a bogus host is provided" do
-    omit_unless_elevated
-    assert_raise(SystemCallError){ Win32::Service.get_service_name('foo', 'bogus') }
-  end
-
-  test "get_service_name accepts a maximum of two arguments" do
-    assert_raise(ArgumentError){ Win32::Service.get_service_name('x', 'y', 'z') }
-  end
-
-  test "get_display_name basic functionality" do
-    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
-
-  test "get_display_name returns expected results" do
-    assert_equal(@display_name, Win32::Service.get_display_name(@service_name))
-  end
-
-  test "getdisplayname is an alias for get_display_name" do
-    assert_respond_to(Win32::Service, :getdisplayname)
-    assert_alias_method(Win32::Service, :getdisplayname, :get_display_name)
-  end
-
-  test "get_display_name requires at least one argument" do
-    assert_raise(ArgumentError){ Win32::Service.get_display_name }
-  end
-
-  test "get_display_name raises an error if the service does not exist" do
-    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
-    omit_unless_elevated
-    assert_raise(SystemCallError){ Win32::Service.get_display_name('W32Time', 'bogus') }
-  end
-
-  test "get_display_name takes a maximum of two arguments" do
-    assert_raise(ArgumentError){ Win32::Service.get_display_name('x', 'y', 'z') }
-  end
-
-  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
-
-  test "exists method returns expected results" do
-    assert_true(Win32::Service.exists?('W32Time'))
-    assert_false(Win32::Service.exists?('foobar'))
-  end
-
-  test "exists method requires at least one argument or an error is raised" do
-    assert_raises(ArgumentError){ Win32::Service.exists? }
-  end
-
-  test "exists method raises an error if a bogus host is passed" do
-    omit_unless_elevated
-    assert_raises(SystemCallError){ Win32::Service.exists?('foo', 'bogus') }
-  end
-
-  test "exists method only accepts up to two arguments" do
-    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)
-    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
-
-  test "service specific constants are defined" do
-    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
-
-  test "service type constants are defined" do
-    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
-
-  test "service start option constants are defined" do
-    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
-
-  test "service error control constants are defined" do
-    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
-
-  test "service state constants are defined" do
-    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
-
-  test "internal ffi functions are not public as singleton methods" do
-    assert_false(@singleton_methods.include?('CloseHandle'))
-    assert_false(@singleton_methods.include?('ControlService'))
-    assert_false(@singleton_methods.include?('DeleteService'))
-  end
-
-  test "internal ffi functions are not public as instance methods" do
-    assert_false(@instance_methods.include?('CloseHandle'))
-    assert_false(@instance_methods.include?('ControlService'))
-    assert_false(@instance_methods.include?('DeleteService'))
-  end
-
-  def teardown
-    @display_name = nil
-    @service_name = nil
-    @service_stat = nil
-    @services     = nil
-  end
-
-  def self.shutdown
-    @@host = nil
-    status = Win32::Service.status(@@service_name).current_state
-
-    if @elevated
-      if status == 'paused'
-        Win32::Service.resume(@@service_name)
-      end
-
-      unless ['running', 'start pending'].include?(status)
-        Win32::Service.start(@@service_name)
-      end
-    end
-
-    @@elevated = nil
-  end
-end