win32-process 0.6.6 → 0.7.0

data/test/test_win32_process.rb

@@ -13,69 +13,19 @@
 ###############################################################################
 require 'test-unit'
 require 'win32/process'
-require 'sys/proctable'
 
 class TC_Win32Process < Test::Unit::TestCase
-
-  # Start two instances of notepad and give them a chance to fire up
   def self.startup
-    IO.popen('notepad')
-    IO.popen('notepad')
-    sleep 1 # Give the notepad instances a second to startup
-
-    @@pids = []
-
-    Sys::ProcTable.ps{ |struct|
-      next unless struct.comm =~ /notepad/i
-      @@pids << struct.pid
-    }
+    @@pids  = []
+    @@jruby = RUBY_PLATFORM == 'java'
   end
 
   def setup
-    @pri_class = Process::NORMAL_PRIORITY_CLASS
+    @priority = Process::BELOW_NORMAL_PRIORITY_CLASS
   end
 
   test "win32-process version is set to the correct value" do
-    assert_equal('0.6.6', Process::WIN32_PROCESS_VERSION)
-  end
-
-  test "kill basic functionality" do
-    assert_respond_to(Process, :kill)
-  end
-
-  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
-
-  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
-
-  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
-
-  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
-
-  test "fork basic functionality" do
-    assert_respond_to(Process, :fork)
+    assert_equal('0.7.0', Process::WIN32_PROCESS_VERSION)
   end
 
   test "create basic functionality" do
@@ -93,7 +43,7 @@ class TC_Win32Process < Test::Unit::TestCase
       ).process_id
     }
 
-    assert_nothing_raised{ Process.kill(1, @@pids.pop) }
+    assert_nothing_raised{ Process.kill(9, @@pids.pop) }
   end
 
   test "create requires a hash argument" do
@@ -117,36 +67,96 @@ class TC_Win32Process < Test::Unit::TestCase
   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") }
+    assert_raise(Errno::ENOENT){ Process.create(:app_name => "bogusapp.exe") }
   end
 
-  test "wait basic functionality" do
-    assert_respond_to(Process, :wait)
+  test "create passes local environment when environment is not specified" do
+    omit_if(@@jruby)
+    stdout_read, stdout_write = IO.pipe
+
+    ENV['AARDVARK'] = 'B'
+    assert_nothing_raised {
+      Process.create(
+        :app_name         => 'cmd.exe /c echo %AARDVARK%',
+        :creation_flags   => Process::DETACHED_PROCESS,
+        :startup_info     => { :stdout => stdout_write }
+      )
+    }
+
+    stdout_write.close
+    assert_equal('B', stdout_read.read.chomp)
   end
 
-  test "wait2 basic functionality" do
-    assert_respond_to(Process, :wait2)
+  test "create does not pass local environment when environment is specified" do
+    omit_if(@@jruby)
+    stdout_read, stdout_write = IO.pipe
+
+    ENV['AARDVARK'] = 'B'
+    assert_nothing_raised {
+      Process.create(
+        :app_name         => 'cmd.exe /c echo %AARDVARK%',
+        :creation_flags   => Process::DETACHED_PROCESS,
+        :environment      => "",
+        :startup_info     => { :stdout => stdout_write }
+      )
+    }
+
+    stdout_write.close
+    assert_equal('%AARDVARK%', stdout_read.read.chomp)
   end
 
-  test "waitpid basic functionality" do
-    assert_respond_to(Process, :waitpid)
+  test "create supports :environment as a string" do
+    omit_if(@@jruby)
+    stdout_read, stdout_write = IO.pipe
+
+    assert_nothing_raised {
+      Process.create(
+        :app_name         => 'cmd.exe /c echo %A% %C%',
+        :creation_flags   => Process::DETACHED_PROCESS,
+        :environment      => "A=B;C=D",
+        :startup_info     => { :stdout => stdout_write }
+      )
+    }
+
+    stdout_write.close
+    assert_equal("B D", stdout_read.read.chomp)
   end
 
-  test "waitpid2 basic functionality" do
-    assert_respond_to(Process, :waitpid2)
+  test "create supports :environment as an array" do
+    omit_if(@@jruby)
+    stdout_read, stdout_write = IO.pipe
+
+    assert_nothing_raised {
+      Process.create(
+        :app_name         => 'cmd.exe /c echo %A% %C%',
+        :creation_flags   => Process::DETACHED_PROCESS,
+        :environment      => [ "A=B;X;", "C=;D;Y" ],
+        :startup_info     => { :stdout => stdout_write }
+      )
+    }
+
+    stdout_write.close
+    assert_equal("B;X; ;D;Y", stdout_read.read.chomp)
   end
 
-  test "ppid basic functionality" do
-    assert_respond_to(Process, :ppid)
-    assert_nothing_raised{ Process.ppid }
+  test "create supports empty :environment string" do
+    assert_nothing_raised {
+      Process.create(
+        :creation_flags => Process::DETACHED_PROCESS,
+        :app_name       => 'cmd.exe',
+        :environment    => ''
+      )
+    }
   end
 
-  test "ppid returns expected results" do
-    assert_kind_of(Integer, Process.ppid)
-    assert_true(Process.ppid > 0)
-    assert_false(Process.pid == Process.ppid)
+  test "create supports empty :environment array" do
+    assert_nothing_raised {
+      Process.create(
+        :creation_flags   => Process::DETACHED_PROCESS,
+        :app_name    => 'cmd.exe',
+        :environment => []
+      )
+    }
   end
 
   test "uid basic functionality" do
@@ -193,15 +203,16 @@ class TC_Win32Process < Test::Unit::TestCase
 
   test "setpriority basic functionality" do
     assert_respond_to(Process, :setpriority)
-    assert_nothing_raised{ Process.setpriority(0, Process.pid, @pri_class) }
+    assert_nothing_raised{ Process.setpriority(0, Process.pid, @priority) }
+    assert_equal(@priority, Process.getpriority(0, Process.pid))
   end
 
   test "setpriority returns zero on success" do
-    assert_equal(0, Process.setpriority(0, Process.pid, @pri_class))
+    assert_equal(0, Process.setpriority(0, Process.pid, @priority))
   end
 
   test "setpriority treats an int argument of zero as the current process" do
-    assert_equal(0, Process.setpriority(0, 0, @pri_class))
+    assert_equal(0, Process.setpriority(0, 0, @priority))
   end
 
   test "setpriority requires at least three arguments" do
@@ -211,8 +222,8 @@ class TC_Win32Process < Test::Unit::TestCase
   end
 
   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('test', 0, @priority) }
+    assert_raise(TypeError){ Process.setpriority(0, 'test', @priority) }
     assert_raise(TypeError){ Process.setpriority(0, 0, 'test') }
   end
 
@@ -233,6 +244,7 @@ class TC_Win32Process < Test::Unit::TestCase
   test "getrlimit basic functionality" do
     assert_respond_to(Process, :getrlimit)
     assert_nothing_raised{ Process.getrlimit(Process::RLIMIT_CPU) }
+    assert_nothing_raised{ Process.getrlimit(Process::RLIMIT_FSIZE) }
   end
 
   test "getrlimit returns an array of two numeric elements" do
@@ -248,25 +260,25 @@ class TC_Win32Process < Test::Unit::TestCase
   end
 
   test "getrlimit requires a valid resource value" do
-    assert_raise(Process::Error){ Process.getrlimit(9999) }
+    assert_raise(ArgumentError){ Process.getrlimit(9999) }
   end
 
   test "setrlimit basic functionality" do
-    assert_respond_to(Process, :getrlimit)
-    assert_nothing_raised{ Process.setrlimit(Process::RLIMIT_VMEM, 1024 * 4) }
+    assert_respond_to(Process, :setrlimit)
+    assert_nothing_raised{ Process.setrlimit(Process::RLIMIT_CPU, 1000000) }
   end
 
   test "setrlimit returns nil on success" do
-    assert_nil(Process.setrlimit(Process::RLIMIT_VMEM, 1024 * 4))
+    assert_nil(Process.setrlimit(Process::RLIMIT_CPU, 1000000))
   end
 
   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))
+    assert_nothing_raised{ Process.setrlimit(Process::RLIMIT_CPU, 1000000) }
+    assert_equal([1000000, 1000000], Process.getrlimit(Process::RLIMIT_CPU))
   end
 
   test "setrlimit raises an error if the resource value is invalid" do
-    assert_raise(Process::Error){ Process.setrlimit(9999, 100) }
+    assert_raise(ArgumentError){ Process.setrlimit(9999, 100) }
   end
 
   test "is_job basic functionality" do
@@ -282,12 +294,26 @@ class TC_Win32Process < Test::Unit::TestCase
     assert_raise(ArgumentError){ Process.job?(Process.pid) }
   end
 
+  test "volume_type is a private method" do
+    assert_not_respond_to(Process, :volume_type)
+  end
+
+  test "ffi functions are private" do
+    assert_not_respond_to(Process, :CloseHandle)
+    assert_not_respond_to(Process, :GetCurrentProcess)
+    assert_not_respond_to(Process, :GetProcessAffinityMask)
+    assert_not_respond_to(Process, :GetPriorityClass)
+    assert_not_respond_to(Process, :IsProcessInJob)
+    assert_not_respond_to(Process, :OpenProcess)
+    assert_not_respond_to(Process, :SetHandleInformation)
+    assert_not_respond_to(Process, :SetPriorityClass)
+  end
+
   def teardown
-    @pri_class = nil
+    @priority = nil
   end
 
   def self.shutdown
-    @@pids.each{ |pid| Process.kill(1, pid) }
-    @@pids = []
+    @@pids = nil
   end
 end

data/test/test_win32_process_kill.rb

@@ -0,0 +1,144 @@
+########################################################################
+# test_win32_process_kill.rb
+#
+# Tests for the custom Process.kill method
+########################################################################
+require 'win32/process'
+require 'test-unit'
+
+class TC_Win32_Process_Kill < Test::Unit::TestCase
+  def self.startup
+    @@signals = Signal.list
+  end
+
+  def setup
+    @ruby = RUBY_PLATFORM == 'java' ? 'jruby' : 'ruby'
+    @cmd  = "#{@ruby} -e 'sleep 10'"
+    @pid  = nil
+  end
+
+  test "kill basic functionality" do
+    assert_respond_to(Process, :kill)
+  end
+
+  test "kill with signal 0 does not actually send a signal" do
+    assert_nothing_raised{ Process.kill(0, Process.pid) }
+  end
+
+  test "kill with signal 0 returns 1 if the process exists" do
+    assert_equal(1, Process.kill(0, Process.pid))
+  end
+
+  test "kill with signal 0 raises an ESRCH error if any process does not exist" do
+    assert_raise(Errno::ESRCH){ Process.kill(0, 99999999) }
+    assert_raise(Errno::ESRCH){ Process.kill(0, Process.pid, 99999999) }
+  end
+
+  test "kill accepts multiple pid values" do
+    pid = Process.pid
+    assert_nothing_raised{ Process.kill(0, pid, pid, pid, pid) }
+  end
+
+  test "kill with any signal returns the number of killed processes" do
+    pid1 = Process.spawn(@cmd)
+    pid2 = Process.spawn(@cmd)
+    assert_equal(2, Process.kill(9, pid1, pid2))
+  end
+
+  test "kill accepts a string as a signal name" do
+    pid = Process.spawn(@cmd)
+    assert_nothing_raised{ Process.kill('SIGKILL', pid) }
+  end
+
+  test "kill accepts a string without 'SIG' as a signal name" do
+    pid = Process.spawn(@cmd)
+    assert_nothing_raised{ Process.kill('KILL', pid) }
+  end
+
+  test "kill accepts a symbol as a signal name" do
+    pid = Process.spawn(@cmd)
+    assert_nothing_raised{ Process.kill(:KILL, pid) }
+  end
+
+  test "kill coerces the pid to an integer" do
+    pid = Process.pid.to_f + 0.7
+    assert_nothing_raised{ Process.kill(0, pid) }
+  end
+
+  test "an EINVAL error is raised on Windows if the signal is negative" do
+    @pid = Process.spawn(@cmd)
+    assert_raise(Errno::EINVAL){ Process.kill(-3, @pid) }
+  end
+
+  test "an EINVAL error is raised on Windows if the pid is 0 and it's not a SIGINT" do
+    assert_raise(Errno::EINVAL){ Process.kill(9, 0) }
+  end
+
+  # We break from the spec here.
+  #test "an EINVAL error is raised if the pid is the current process and it's not a 0 or SIGKILL" do
+  #  assert_raise(Errno::EINVAL){ Process.kill(1, Process.pid) }
+  #end
+
+  test "kill requires at least two arguments" do
+    assert_raise(ArgumentError){ Process.kill }
+    assert_raise(ArgumentError){ Process.kill(@pid) }
+  end
+
+  test "the first argument to kill must be an integer or string" do
+    assert_raise(ArgumentError){ Process.kill([], 0) }
+  end
+
+  test "kill raises an ArgumentError if the signal name is invalid" do
+    assert_raise(ArgumentError){ Process.kill("BOGUS", 0) }
+  end
+
+  test "kill does not accept lowercase signal names" do
+    assert_raise(ArgumentError){ Process.kill("kill", 0) }
+  end
+
+  test "kill raises an EINVAL error if the signal number is invalid" do
+    assert_raise(Errno::EINVAL){ Process.kill(999999, 0) }
+  end
+
+  test "kill raises an TypeError if the pid value is not an integer" do
+    assert_raise(TypeError){ Process.kill(0, "BOGUS") }
+  end
+
+  # TODO: Fix this
+  #test "kill raises an EPERM if user does not have proper privileges" do
+  #  omit_if(Process.uid == 0)
+  #  assert_raise(Errno::EPERM){ Process.kill(9, 1) }
+  #end
+
+  test "kill raises a SecurityError if $SAFE level is 2 or greater" do
+    omit_if(@ruby == 'jruby')
+    assert_raise(SecurityError){
+      proc do
+        $SAFE = 2
+        @pid = Process.spawn(@cmd)
+        Process.kill(9, @pid)
+      end.call
+    }
+  end
+
+  test "kill works if the $SAFE level is 1 or lower" do
+    omit_if(@ruby == 'jruby')
+    assert_nothing_raised{
+      proc do
+        $SAFE = 1
+        @pid = Process.spawn(@cmd)
+        Process.kill(9, @pid)
+      end.call
+    }
+  end
+
+  def teardown
+    @cmd  = nil
+    @ruby = nil
+    Process.kill(9, @pid) if @pid rescue nil
+  end
+
+  def self.teardown
+    @@signals = nil
+  end
+end

data/win32-process.gemspec

@@ -2,12 +2,11 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'win32-process'
-  spec.version    = '0.6.6'
+  spec.version    = '0.7.0'
   spec.license    = 'Artistic 2.0'
   spec.authors    = ['Daniel Berger', 'Park Heesob']
   spec.email      = 'djberg96@gmail.com'
-  spec.homepage   = 'http://www.rubyforge.org/projects/win32utils'
-  spec.platform   = Gem::Platform::RUBY
+  spec.homepage   = 'https://github.com/djberg96/win32-process'
   spec.summary    = 'Adds and redefines several Process methods for MS Windows'
   spec.test_files = Dir['test/*.rb']
   spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
@@ -15,14 +14,14 @@ Gem::Specification.new do |spec|
   spec.rubyforge_project = 'win32utils'
   spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
 
-  spec.add_dependency('windows-pr', '>= 1.2.2')
-  spec.add_development_dependency('test-unit')
-  spec.add_development_dependency('sys-proctable')
+  spec.required_ruby_version = '> 1.9.0'
+  spec.add_dependency('ffi', '>= 1.0.0')
+  spec.add_development_dependency('test-unit', '>= 2.4.0')
 
   spec.description = <<-EOF
     The win32-process library implements several Process methods that are
     either unimplemented or dysfunctional in some way in the default Ruby
-    implementation. Examples include Process.kill, Process.waitpid,
-    Process.create and an experimental Process.fork method.
+    implementation. Examples include Process.kill, Process.uid and
+    Process.create.
   EOF
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: win32-process
 version: !ruby/object:Gem::Version
-  version: 0.6.6
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,16 +10,16 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-19 00:00:00.000000000 Z
+date: 2012-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: windows-pr
+  name: ffi
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.2.2
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,7 +27,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.2.2
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -35,7 +35,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,27 +43,10 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: sys-proctable
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.4.0
 description: ! "    The win32-process library implements several Process methods that
   are\n    either unimplemented or dysfunctional in some way in the default Ruby\n
-  \   implementation. Examples include Process.kill, Process.waitpid,\n    Process.create
-  and an experimental Process.fork method.\n"
+  \   implementation. Examples include Process.kill, Process.uid and\n    Process.create.\n"
 email: djberg96@gmail.com
 executables: []
 extensions: []
@@ -74,16 +57,19 @@ extra_rdoc_files:
 files:
 - CHANGES
 - examples/example_create.rb
-- examples/example_fork_wait.rb
-- examples/example_fork_waitpid.rb
 - examples/example_kill.rb
+- lib/win32/process/constants.rb
+- lib/win32/process/functions.rb
+- lib/win32/process/helper.rb
+- lib/win32/process/structs.rb
 - lib/win32/process.rb
 - MANIFEST
 - Rakefile
 - README
 - test/test_win32_process.rb
+- test/test_win32_process_kill.rb
 - win32-process.gemspec
-homepage: http://www.rubyforge.org/projects/win32utils
+homepage: https://github.com/djberg96/win32-process
 licenses:
 - Artistic 2.0
 post_install_message: 
@@ -93,9 +79,9 @@ require_paths:
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -110,3 +96,4 @@ specification_version: 3
 summary: Adds and redefines several Process methods for MS Windows
 test_files:
 - test/test_win32_process.rb
+- test/test_win32_process_kill.rb

data/examples/example_fork_wait.rb

@@ -1,29 +0,0 @@
-##########################################################################
-# example_fork_wait.rb
-#
-# Generic test script for futzing around with the block form of
-# fork/wait. You can run this example via the 'example:fork_wait' task.
-##########################################################################
-require 'win32/process'
-
-puts "VERSION: " + Process::WIN32_PROCESS_VERSION
-
-# In the child, using block form
-fork{
-  7.times { |i|
-    puts "Child: #{i}"
-    sleep 1
-  }
-}
-
-# Back in the parent
-4.times{ |i|
-  puts "Parent: #{i}"
-  sleep 1
-}
-
-# Wait for the children
-Process.wait
-
-# Children should be done here before continuing on
-puts "Continuing on..."

data/examples/example_fork_waitpid.rb

@@ -1,46 +0,0 @@
-##########################################################################
-# example_fork_waitpid.rb
-#
-# Generic test script for futzing around with the traditional form of
-# fork/wait, plus waitpid and waitpid2.
-#
-# You can run this code via the 'example:fork_waitpid' task.
-##########################################################################
-require 'win32/process'
-
-puts "VERSION: " + Process::WIN32_PROCESS_VERSION
-
-pid = Process.fork
-puts "PID1: #{pid}"
-
-#child
-if pid.nil?
-  7.times{ |i|
-    puts "Child: #{i}"
-    sleep 1
-  }
-  exit(-1)
-end
-
-pid2 = Process.fork
-puts "PID2: #{pid2}"
-
-#child2
-if pid2.nil?
-  7.times{ |i|
-    puts "Child2: #{i}"
-    sleep 1
-  }
-  exit(1)
-end
-
-#parent
-2.times { |i|
-  puts "Parent: #{i}"
-  sleep 1
-}
-
-p Process.waitpid2(pid)
-p Process.waitpid2(pid2)
-
-puts "Continuing on..."