win32-process 0.6.4 → 0.6.5

data/CHANGES

@@ -1,3 +1,15 @@
+= 0.6.5 - 27-Dec-2010
+* Fixed getpriority and setpriority so that the underlying process handle is
+  always closed. Thanks go to Rafal Michalski	for the spot and patch. 
+* Updated getpriority and setpriority so that there are no longer any
+  default arguments. This now matches the MRI spec.
+* Updated Process.create so that illegal options now raise an ArgumentError
+  instead of a Process::Error.
+* Fixed a bug in an error message in the Process.create method where the actual
+  error message was getting lost.
+* Refactored the test suite to use test-unit 2.x features, and make tests a
+  little more robust in general.
+
 = 0.6.4 - 13-Nov-2010
 * Altered the wait, wait2, waitpid and waitpid2 methods to match the current
   MRI interface, i.e. they accept and optional pid and flags, though the

data/README

@@ -1,14 +1,14 @@
 = Description
-  This package provides the fork, wait, wait2, waitpid, and waitpid2 methods
+  This library provides the fork, wait, wait2, waitpid, and waitpid2 methods
   for MS Windows. In addition, it provides a different implementation of the
   kill method, a proper implementation of Process.ppid, and decent analogues
-  of Process.getpriority, Process.setpriority and Process.getrlimit.
+  of Process.getpriority, Process.setpriority, Process.getrlimit and
+  Process.setrlimit.
 
 = Prerequisites
-  Ruby 1.8.2 or later.
-  The windows-pr library, 0.8.6 or later.
-  The sys-proctable library, 0.7.6 or later (test suite only).
-  The test-unit library, 2.0.3 or later (test suite only).
+  * windows-pr
+  * sys-proctable (dev only)
+  * test-unit 2 (dev only)
 
 = Supported Platforms
   This library is supported on Windows 2000 or later.
@@ -104,7 +104,7 @@
   Artistic 2.0
 	
 = Copyright
-  (C) 2003-2010 Daniel J. Berger
+  (C) 2003-2011 Daniel J. Berger
   All Rights Reserved
 		
 = Warranty

data/Rakefile

@@ -8,7 +8,7 @@ CLEAN.include('**/*.gem', '**/*.rbc')
 
 namespace :gem do
   desc 'Create the win32-process gem'
-  task :create do
+  task :create => [:clean] do
     spec = eval(IO.read('win32-process.gemspec'))
     Gem::Builder.new(spec).build
   end

data/lib/win32/process.rb

@@ -21,7 +21,13 @@ module Process
   undef_method :setpriority, :wait, :wait2, :waitpid, :waitpid2, :uid
    
   # The version of the win32-process library
-  WIN32_PROCESS_VERSION = '0.6.4'
+  WIN32_PROCESS_VERSION = '0.6.5'
+
+  # Defined for interface compatibility, but not used
+
+  PRIO_PROCESS = 0
+  PRIO_PGRP    = 1
+  PRIO_USER    = 2
   
   include Windows::Process
   include Windows::Thread
@@ -307,10 +313,10 @@ module Process
   end
 
   # Retrieves the priority class for the specified process id +int+. Unlike
-  # the default implementation, lower values do not necessarily correspond to
-  # higher priority classes.
+  # the default implementation, lower return values do not necessarily
+  # correspond to higher priority classes.
   #
-  # The +kind+ parameter is ignored but present for API compatibility.
+  # The +kind+ parameter is ignored but required for API compatibility.
   # You can only retrieve process information, not process group or user
   # information, so it is effectively always Process::PRIO_PROCESS.
   #
@@ -323,8 +329,11 @@ module Process
   # 16384 - Process::BELOW_NORMAL_PRIORITY_CLASS
   # 32768 - Process::ABOVE_NORMAL_PRIORITY_CLASS
   # 
-  def getpriority(kind = Process::PRIO_PROCESS, int = nil)
-    raise ArgumentError unless int
+  def getpriority(kind, int)
+    raise TypeError unless kind.is_a?(Integer)
+    raise TypeError unless int.is_a?(Integer)
+
+    int = Process.pid if int == 0 # Match spec
 
     handle = OpenProcess(PROCESS_QUERY_INFORMATION, 0 , int)
 
@@ -332,10 +341,14 @@ module Process
       raise Error, get_last_error
     end
 
-    priority_class = GetPriorityClass(handle)
+    begin
+      priority_class = GetPriorityClass(handle)
 
-    if priority_class == 0
-      raise Error, get_last_error
+      if priority_class == 0
+        raise Error, get_last_error
+      end
+    ensure
+      CloseHandle(handle)
     end
 
     priority_class
@@ -356,9 +369,12 @@ module Process
   # * Process::BELOW_NORMAL_PRIORITY_CLASS
   # * Process::ABOVE_NORMAL_PRIORITY_CLASS
   #
-  def setpriority(kind = nil, int = nil, int_priority = nil)
-    raise ArgumentError unless int
-    raise ArgumentError unless int_priority
+  def setpriority(kind, int, int_priority)
+    raise TypeError unless kind.is_a?(Integer)
+    raise TypeError unless int.is_a?(Integer)
+    raise TypeError unless int_priority.is_a?(Integer)
+
+    int = Process.pid if int == 0 # Match spec
 
     handle = OpenProcess(PROCESS_SET_INFORMATION, 0 , int)
 
@@ -366,8 +382,12 @@ module Process
       raise Error, get_last_error
     end
 
-    unless SetPriorityClass(handle, int_priority)
-      raise Error, get_last_error
+    begin
+      unless SetPriorityClass(handle, int_priority)
+        raise Error, get_last_error
+      end
+    ensure
+      CloseHandle(handle)
     end
 
     return 0 # Match the spec
@@ -384,6 +404,8 @@ module Process
   def uid(sid = false)
     token = 0.chr * 4
 
+    raise TypeError unless sid.is_a?(TrueClass) || sid.is_a?(FalseClass)
+
     unless OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, token)
       raise Error, get_last_error
     end
@@ -710,7 +732,7 @@ module Process
     args.each{ |key, val|
       key = key.to_s.downcase
       unless valid_keys.include?(key)
-        raise Error, "invalid key '#{key}'"
+        raise ArgumentError, "invalid key '#{key}'"
       end
       hash[key] = val
     }
@@ -722,7 +744,7 @@ module Process
       hash['startup_info'].each{ |key, val|
         key = key.to_s.downcase
         unless valid_si_keys.include?(key)
-          raise Error, "invalid startup_info key '#{key}'"
+          raise ArgumentError, "invalid startup_info key '#{key}'"
         end
         si_hash[key] = val
       }
@@ -735,7 +757,7 @@ module Process
         hash['command_line'] = hash['app_name']
         hash['app_name'] = nil
       else
-        raise Error, 'command_line or app_name must be specified'
+        raise ArgumentError, 'command_line or app_name must be specified'
       end
     end
       
@@ -864,7 +886,7 @@ module Process
     # TODO: Close stdin, stdout and stderr handles in the si_hash unless
     # they're pointing to one of the standard handles already. [Maybe]
     unless bool
-      raise Error, "CreateProcess() failed: ", get_last_error
+      raise Error, "CreateProcess() failed: " + get_last_error
     end
       
     # Automatically close the process and thread handles in the

data/test/test_win32_process.rb

@@ -17,7 +17,6 @@ gem 'test-unit'
 require 'test/unit'
 require 'win32/process'
 require 'sys/proctable'
-include Sys
 
 class TC_Win32Process < Test::Unit::TestCase  
 
@@ -29,55 +28,66 @@ class TC_Win32Process < Test::Unit::TestCase
       
     @@pids = []
 
-    ProcTable.ps{ |struct|
+    Sys::ProcTable.ps{ |struct|
       next unless struct.comm =~ /notepad/i
       @@pids << struct.pid
     }
   end
 
   def setup
-    @pid = nil
     @pri_class = Process::NORMAL_PRIORITY_CLASS
   end
   
-  def test_version
-    assert_equal('0.6.4', Process::WIN32_PROCESS_VERSION)
+  test "win32-process version is set to the correct value" do
+    assert_equal('0.6.5', Process::WIN32_PROCESS_VERSION)
   end
    
-  def test_kill
+  test "kill basic functionality" do
     assert_respond_to(Process, :kill)
   end
    
-  def test_kill_expected_errors
+  test "kill requires at least one argument" do
     assert_raises(ArgumentError){ Process.kill }
+  end
+
+  test "kill raises an error if an invalid signal is provided" do
     assert_raises(Process::Error){ Process.kill('SIGBOGUS') }
+  end
+
+  test "kill raises an error if an invalid process id is provided" do
     assert_raises(Process::Error){ Process.kill(0, 9999999) }
   end
    
-  def test_kill_signal_0
+  test "kill with signal 0 does not kill the process" do
     pid = @@pids.first
     assert_nothing_raised{ Process.kill(0, pid) }
+    assert_not_nil(Sys::ProcTable.ps(pid))
   end
    
-  def test_kill_signal_1
+  test "kill with signal 1 kills the process normally" do
     pid = @@pids.shift
     assert_nothing_raised{ Process.kill(1, pid) }
+    assert_nil(Sys::ProcTable.ps(pid))
   end
    
-  def test_kill_signal_9
+  test "kill with signal 9 kills the process brutally" do
     pid = @@pids.pop
     msg = "Could not find pid #{pid}"
     assert_nothing_raised(msg){ Process.kill(9, pid) }
+    assert_nil(Sys::ProcTable.ps(pid))
   end
 
-  def test_fork
+  test "fork basic functionality" do
     assert_respond_to(Process, :fork)
   end
       	
-  def test_create
+  test "create basic functionality" do
     assert_respond_to(Process, :create)
+  end
+
+  test "create with common flags works as expected" do
     assert_nothing_raised{
-      @pid = Process.create(
+      @@pids << Process.create(
          :app_name         => "notepad.exe",
          :creation_flags   => Process::DETACHED_PROCESS,
          :process_inherit  => false,
@@ -86,66 +96,130 @@ class TC_Win32Process < Test::Unit::TestCase
       ).process_id
     }
 
-    assert_nothing_raised{ Process.kill(1, @pid) }
+    assert_nothing_raised{ Process.kill(1, @@pids.pop) }
   end
    
-  def test_create_expected_errors
-    assert_raises(TypeError){ Process.create("bogusapp.exe") }
-    assert_raises(Process::Error){ Process.create(:app_name => "bogusapp.exe") }
+  test "create requires a hash argument" do
+    assert_raise(TypeError){ Process.create("bogusapp.exe") }
+  end
+
+  test "create does not accept invalid keys" do
+    assert_raise(ArgumentError){ Process.create(:bogus => 'test.exe') }
+    assert_raise_message("invalid key 'bogus'"){
+      Process.create(:bogus => 'test.exe')
+    }
+  end
+
+  test "create does not accept invalid startup_info keys" do
+    assert_raise(ArgumentError){
+      Process.create(:startup_info => {:foo => 'test'})
+    }
+    assert_raise_message("invalid startup_info key 'foo'"){
+      Process.create(:startup_info => {:foo => 'test'})
+    }
+  end
+
+  test "create raises an error if the executable cannot be found" do
+    err = "CreateProcess() failed: The system cannot find the file specified."
+    assert_raise(Process::Error){ Process.create(:app_name => "bogusapp.exe") }
+    assert_raise_message(err){ Process.create(:app_name => "bogusapp.exe") }
   end
    
-  def test_wait
+  test "wait basic functionality" do
     assert_respond_to(Process, :wait)
   end
    
-  def test_wait2
+  test "wait2 basic functionality" do
     assert_respond_to(Process, :wait2)
   end
    
-  def test_waitpid
+  test "waitpid basic functionality" do
     assert_respond_to(Process, :waitpid)
   end
    
-  def test_waitpid2
+  test "waitpid2 basic functionality" do
     assert_respond_to(Process, :waitpid2)
   end
 
-  def test_ppid
+  test "ppid basic functionality" do
     assert_respond_to(Process, :ppid)
-    assert_equal(true, Process.ppid > 0)
-    assert_equal(false, Process.pid == Process.ppid)
+    assert_nothing_raised{ Process.ppid }
+  end
+
+  test "ppid returns expected results" do
+    assert_kind_of(Integer, Process.ppid)
+    assert_true(Process.ppid > 0)
+    assert_false(Process.pid == Process.ppid)
   end
    
-  def test_uid
+  test "uid basic functionality" do
     assert_respond_to(Process, :uid)
     assert_kind_of(Fixnum, Process.uid)
+  end
+
+  test "uid accepts a boolean argument" do  
+    assert_nothing_raised{ Process.uid(true) }
+    assert_nothing_raised{ Process.uid(true) }
+  end
+
+  test "uid returns a string if its argument is true" do
     assert_kind_of(String, Process.uid(true))      
   end
 
-  def test_getpriority
+  test "uid accepts a maximum of one argument" do
+    assert_raise(ArgumentError){ Process.uid(true, true) }
+  end
+
+  test "argument to uid must be a boolean" do
+    assert_raise(TypeError){ Process.uid('test') }
+  end
+
+  test "getpriority basic functionality" do
     assert_respond_to(Process, :getpriority)
-    assert_nothing_raised{ Process.getpriority(nil, Process.pid) }
-    assert_kind_of(Fixnum, Process.getpriority(nil, Process.pid))
+    assert_nothing_raised{ Process.getpriority(Process::PRIO_PROCESS, Process.pid) }
+    assert_kind_of(Fixnum, Process.getpriority(Process::PRIO_PROCESS, Process.pid))
   end
 
-  def test_getpriority_expected_errors
-    assert_raise{ Process.getpriority }
-    assert_raise{ Process.getpriority(nil) }
+  test "getpriority treats an int argument of zero as the current process" do
+    assert_nothing_raised{ Process.getpriority(0, 0) }
   end
 
-  def test_setpriority
+  test "getpriority requires both a kind and an int" do
+    assert_raise(ArgumentError){ Process.getpriority }
+    assert_raise(ArgumentError){ Process.getpriority(Process::PRIO_PROCESS) }
+  end
+
+  test "getpriority requires integer arguments" do
+    assert_raise(TypeError){ Process.getpriority('test', 0) }
+    assert_raise(TypeError){ Process.getpriority(Process::PRIO_PROCESS, 'test') }
+  end
+
+  test "setpriority basic functionality" do
     assert_respond_to(Process, :setpriority)
-    assert_nothing_raised{ Process.setpriority(nil, Process.pid, @pri_class) }
-    assert_equal(0, Process.setpriority(nil, Process.pid, @pri_class))
+    assert_nothing_raised{ Process.setpriority(0, Process.pid, @pri_class) }
+  end
+
+  test "setpriority returns zero on success" do
+    assert_equal(0, Process.setpriority(0, Process.pid, @pri_class))
+  end
+
+  test "setpriority treats an int argument of zero as the current process" do
+    assert_equal(0, Process.setpriority(0, 0, @pri_class))
   end
 
-  def test_setpriority_expected_errors
-    assert_raise{ Process.setpriority }
-    assert_raise{ Process.setpriority(nil) }
-    assert_raise{ Process.setpriority(nil, Process.pid) }
+  test "setpriority requires at least three arguments" do
+    assert_raise(ArgumentError){ Process.setpriority }
+    assert_raise(ArgumentError){ Process.setpriority(0) }
+    assert_raise(ArgumentError){ Process.setpriority(0, 0) }
   end
-  	
-  def test_creation_constants
+
+  test "arguments to setpriority must be numeric" do
+    assert_raise(TypeError){ Process.setpriority('test', 0, @pri_class) }
+    assert_raise(TypeError){ Process.setpriority(0, 'test', @pri_class) }
+    assert_raise(TypeError){ Process.setpriority(0, 0, 'test') }
+  end
+
+  test "custom creation constants are defined" do
     assert_not_nil(Process::CREATE_DEFAULT_ERROR_MODE)
     assert_not_nil(Process::CREATE_NEW_CONSOLE)
     assert_not_nil(Process::CREATE_NEW_PROCESS_GROUP)
@@ -159,49 +233,64 @@ class TC_Win32Process < Test::Unit::TestCase
     assert_not_nil(Process::DETACHED_PROCESS)
   end
 
-  def test_getrlimit
+  test "getrlimit basic functionality" do
     assert_respond_to(Process, :getrlimit)
     assert_nothing_raised{ Process.getrlimit(Process::RLIMIT_CPU) }
+  end
+
+  test "getrlimit returns an array of two numeric elements" do
     assert_kind_of(Array, Process.getrlimit(Process::RLIMIT_CPU))
     assert_equal(2, Process.getrlimit(Process::RLIMIT_CPU).length)
+    assert_kind_of(Integer, Process.getrlimit(Process::RLIMIT_CPU).first)
   end
 
-  def test_getrlimit_can_be_called_multiple_times
+  test "getrlimit can be called multiple times without issue" do
     assert_nothing_raised{ Process.getrlimit(Process::RLIMIT_CPU) }
     assert_nothing_raised{ Process.getrlimit(Process::RLIMIT_CPU) }
     assert_nothing_raised{ Process.getrlimit(Process::RLIMIT_CPU) }
   end
 
-  def test_getrlimit_raises_an_error_if_the_resource_is_invalid
+  test "getrlimit requires a valid resource value" do
     assert_raise(Process::Error){ Process.getrlimit(9999) }
   end
 
-  def test_setrlimit_basic
+  test "setrlimit basic functionality" do
     assert_respond_to(Process, :getrlimit)
     assert_nothing_raised{ Process.setrlimit(Process::RLIMIT_VMEM, 1024 * 4) }
+  end
+
+  test "setrlimit returns nil on success" do
     assert_nil(Process.setrlimit(Process::RLIMIT_VMEM, 1024 * 4))
   end
 
-  def test_setrlimit_sets_the_resource_as_expected
+  test "setrlimit sets the resource limit as expected" do
     assert_nothing_raised{ Process.setrlimit(Process::RLIMIT_VMEM, 1024 * 4) }
     assert_equal([4096, 4096], Process.getrlimit(Process::RLIMIT_VMEM))
   end
 
-  def test_setrlimit_raises_an_error_if_the_resource_is_invalid
+  test "setrlimit raises an error if the resource value is invalid" do
     assert_raise(Process::Error){ Process.setrlimit(9999, 100) }
   end
 
-  def test_is_job
+  test "is_job basic functionality" do
     assert_respond_to(Process, :job?)
     assert_nothing_raised{ Process.job? }
+  end
+
+  test "is_job returns a boolean value" do
     assert_boolean(Process.job?)
   end
+
+  test "is_job does not accept any arguments" do
+    assert_raise(ArgumentError){ Process.job?(Process.pid) }
+  end
    
   def teardown
-    @pid = nil
+    @pri_class = nil
   end
 
   def self.shutdown
+    @@pids.each{ |pid| Process.kill(1, pid) }
     @@pids = []
   end
 end

data/win32-process.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'win32-process'
-  spec.version    = '0.6.4'
+  spec.version    = '0.6.5'
   spec.license    = 'Artistic 2.0'
   spec.authors    = ['Daniel Berger', 'Park Heesob']
   spec.email      = 'djberg96@gmail.com'
@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   spec.rubyforge_project = 'win32utils'
   spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
 
-  spec.add_dependency('windows-pr', '>= 1.1.0')
+  spec.add_dependency('windows-pr', '>= 1.1.2')
   spec.add_development_dependency('test-unit', '>= 2.1.1')
   spec.add_development_dependency('sys-proctable')
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: win32-process
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: false
   segments: 
   - 0
   - 6
-  - 4
-  version: 0.6.4
+  - 5
+  version: 0.6.5
 platform: ruby
 authors: 
 - Daniel Berger
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-13 00:00:00 -07:00
+date: 2010-12-27 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,12 +27,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 23
         segments: 
         - 1
         - 1
-        - 0
-        version: 1.1.0
+        - 2
+        version: 1.1.2
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency