WIP2

Author: katzer

test/process.rb

@@ -106,181 +106,181 @@ def assert_windows(*args, &block)
   assert_true Process.pid > 0
 end
 
-# assert('Process.spawn') do
-#   assert_raise(ArgumentError) { spawn }
-#   assert_raise(TypeError) { spawn 123 }
-
-#   pid = spawn 'exit 0'
-#   wait_for_pid(pid)
-
-#   assert_kind_of Integer, pid
-#   assert_true pid > 0
-#   assert_not_equal $PID, pid
-#   assert_kind_of Process::Status, $?
-#   assert_equal $?.pid, pid
-
-#   var = "#{ENV['RAND']}x"
-#   pid = spawn("echo #{var} > tmp/spawn.txt")
-
-#   wait_for_pid(pid)
-#   assert_equal var, read('tmp/spawn.txt')
-# end
-
-# assert('Process.spawn', 'env') do
-#   var = "x#{ENV['RAND']}"
-#   env = OS.posix? ? '$MYVAR' : '%MYVAR%'
-
-#   pid = spawn({ MYVAR: var }, "echo #{env} > tmp/spawn.txt")
-
-#   wait_for_pid(pid)
-#   assert_equal var, read('tmp/spawn.txt')
-# end
-
-# # TODO: More tests for edge cases! whatif no valid pipe,
-# assert('Process.spawn', 'pipe') do
-#   begin
-#     var = ENV['RAND']
-#     pip = IO.sysopen('tmp/pipe.txt', 'w')
-
-#     pid = spawn("echo #{var}", out: pip)
+assert('Process.spawn') do
+  assert_raise(ArgumentError) { spawn }
+  assert_raise(TypeError) { spawn 123 }
 
-#     wait_for_pid(pid)
-#     assert_equal var, read('tmp/pipe.txt')
-
-#     env = OS.posix? ? '$MYVAR' : '%MYVAR%'
-#     pid = spawn({ MYVAR: var }, "echo #{env}", out: pip)
-
-#     wait_for_pid(pid)
-#     assert_equal var * 2, read('tmp/pipe.txt')
+  pid = spawn 'exit 0'
+  wait_for_pid(pid)
 
-#     pid = spawn 'ruby', '-v', out: pip
+  assert_kind_of Integer, pid
+  assert_true pid > 0
+  assert_not_equal $PID, pid
+  assert_kind_of Process::Status, $?
+  assert_equal $?.pid, pid
 
-#     wait_for_pid(pid)
-#     assert_include read('tmp/pipe.txt'), 'ruby'
-#   ensure
-#     IO._sysclose(pip) if OS.posix?
-#   end
-# end
-
-# assert('Process.spawn', 'pipe error') do
-#   begin
-#     pip = IO.sysopen('tmp/pipe.err', 'w')
-#     pid = spawn('ruby unknown', err: pip)
-
-#     wait_for_pid(pid)
-#     assert_false read('tmp/pipe.err').empty?
-#   ensure
-#     IO._sysclose(pip) if OS.posix?
-#   end
-# end
-
-# assert('Process.exec', 'invalid signatures') do
-#   assert_raise(ArgumentError) { exec }
-#   assert_raise(TypeError)     { exec 123 }
-# end
+  var = "#{ENV['RAND']}x"
+  pid = spawn("echo #{var} > tmp/spawn.txt")
 
-# assert_not_windows('Process.exec') do
-#   var = ENV['RAND']
-#   pid = fork { exec({ MYVAR: var }, 'echo $MYVAR > tmp/exec.txt') }
+  wait_for_pid(pid)
+  assert_equal var, read('tmp/spawn.txt')
+end
+
+assert('Process.spawn', 'env') do
+  var = "x#{ENV['RAND']}"
+  env = OS.posix? ? '$MYVAR' : '%MYVAR%'
+
+  pid = spawn({ MYVAR: var }, "echo #{env} > tmp/spawn.txt")
+
+  wait_for_pid(pid)
+  assert_equal var, read('tmp/spawn.txt')
+end
+
+# TODO: More tests for edge cases! whatif no valid pipe,
+assert('Process.spawn', 'pipe') do
+  begin
+    var = ENV['RAND']
+    pip = IO.sysopen('tmp/pipe.txt', 'w')
+
+    pid = spawn("echo #{var}", out: pip)
+
+    wait_for_pid(pid)
+    assert_equal var, read('tmp/pipe.txt')
+
+    env = OS.posix? ? '$MYVAR' : '%MYVAR%'
+    pid = spawn({ MYVAR: var }, "echo #{env}", out: pip)
+
+    wait_for_pid(pid)
+    assert_equal var * 2, read('tmp/pipe.txt')
+
+    pid = spawn 'ruby', '-v', out: pip
+
+    wait_for_pid(pid)
+    assert_include read('tmp/pipe.txt'), 'ruby'
+  ensure
+    IO._sysclose(pip) if OS.posix?
+  end
+end
+
+assert('Process.spawn', 'pipe error') do
+  begin
+    pip = IO.sysopen('tmp/pipe.err', 'w')
+    pid = spawn('ruby unknown', err: pip)
+
+    wait_for_pid(pid)
+    assert_false read('tmp/pipe.err').empty?
+  ensure
+    IO._sysclose(pip) if OS.posix?
+  end
+end
+
+assert('Process.exec', 'invalid signatures') do
+  assert_raise(ArgumentError) { exec }
+  assert_raise(TypeError)     { exec 123 }
+end
 
-#   wait_for_pid(pid)
-#   assert_equal var, read('tmp/exec.txt')
+assert_not_windows('Process.exec') do
+  var = ENV['RAND']
+  pid = fork { exec({ MYVAR: var }, 'echo $MYVAR > tmp/exec.txt') }
 
-#   var = "x#{var}"
-#   pid = fork { exec '/bin/sh', '-c', "echo #{var} > tmp/exec.txt" }
+  wait_for_pid(pid)
+  assert_equal var, read('tmp/exec.txt')
 
-#   wait_for_pid(pid)
-#   assert_equal var, read('tmp/exec.txt')
-# end
+  var = "x#{var}"
+  pid = fork { exec '/bin/sh', '-c', "echo #{var} > tmp/exec.txt" }
 
-# assert_not_windows('Process.exec', '$SHELL') do
-#   ['/bin/bash', '/bin/sh'].each do |shell|
-#     ENV['SHELL'] = shell
+  wait_for_pid(pid)
+  assert_equal var, read('tmp/exec.txt')
+end
+
+assert_not_windows('Process.exec', '$SHELL') do
+  ['/bin/bash', '/bin/sh'].each do |shell|
+    ENV['SHELL'] = shell
+
+    pid = fork { exec 'echo $SHELL > tmp/exec.txt' }
+    wait_for_pid(pid)
+
+    assert_equal shell, read('tmp/exec.txt')
+  end
+end
+
+assert('Process.kill') do
+  assert_nothing_raised { Process.kill(:EXIT, Process.pid) }
+  assert_nothing_raised { Process.kill('EXIT', Process.pid) }
+  assert_nothing_raised { Process.kill(0, Process.pid) }
+  assert_equal 1, Process.kill(0, Process.pid), 'killed an innocent process'
+  assert_equal 2, Process.kill(0, Process.pid, Process.pid)
+  assert_raise(TypeError) { Process.kill(0.0, Process.pid) }
+  assert_raise(TypeError) { Process.kill(0, 'Process.pid') }
+  assert_raise(ArgumentError) { Process.kill(:UNKNOWN, Process.pid) }
+end
+
+assert('Process.wait2') do
+  pid     = spawn('sleep 2')
+  p, st   = Process.waitpid2(pid, Process::WNOHANG)
+
+  assert_nil p
+  assert_nil st
 
-#     pid = fork { exec 'echo $SHELL > tmp/exec.txt' }
-#     wait_for_pid(pid)
+  Process.kill :KILL, pid
 
-#     assert_equal shell, read('tmp/exec.txt')
-#   end
-# end
+  loop do
+    p, st = Process.waitpid2(pid, Process::WNOHANG)
+    break if p
+  end
+
+  assert_equal pid, p
+  assert_kind_of Process::Status, st
+  assert_include [9, nil], st.termsig
+end
 
-# assert('Process.kill') do
-#   assert_nothing_raised { Process.kill(:EXIT, Process.pid) }
-#   assert_nothing_raised { Process.kill('EXIT', Process.pid) }
-#   assert_nothing_raised { Process.kill(0, Process.pid) }
-#   assert_equal 1, Process.kill(0, Process.pid), 'killed an innocent process'
-#   assert_equal 2, Process.kill(0, Process.pid, Process.pid)
-#   assert_raise(TypeError) { Process.kill(0.0, Process.pid) }
-#   assert_raise(TypeError) { Process.kill(0, 'Process.pid') }
-#   assert_raise(ArgumentError) { Process.kill(:UNKNOWN, Process.pid) }
-# end
+assert('Process.waitall') do
+  assert_true Process.waitall.empty?
 
-# assert('Process.wait2') do
-#   pid     = spawn('sleep 2')
-#   p, st   = Process.waitpid2(pid, Process::WNOHANG)
+  pids = []
+  pids << spawn('exit 2')
+  pids << spawn('exit 1')
+  pids << spawn('exit 0')
 
-#   assert_nil p
-#   assert_nil st
+  a = Process.waitall
 
-#   Process.kill :KILL, pid
+  pids.each do |pid|
+    assert_raise(RuntimeError) { Process.kill(0, pid) }
+  end
 
-#   loop do
-#     p, st = Process.waitpid2(pid, Process::WNOHANG)
-#     break if p
-#   end
+  assert_kind_of Array, a
+  assert_equal 3, a.size
 
-#   assert_equal pid, p
-#   assert_kind_of Process::Status, st
-#   assert_include [9, nil], st.termsig
-# end
+  pids.each do |pid|
+    pid_status = a.find { |i| i[0] == pid }
 
-# assert('Process.waitall') do
-#   assert_true Process.waitall.empty?
-
-#   pids = []
-#   pids << spawn('exit 2')
-#   pids << spawn('exit 1')
-#   pids << spawn('exit 0')
+    assert_kind_of Array, pid_status
+    assert_equal 2, pid_status.size
+    assert_equal pid, pid_status.first
+    assert_kind_of Process::Status, pid_status.last
+  end
+end
 
-#   a = Process.waitall
+assert('Process.system') do
+  assert_raise(ArgumentError) { system }
+  assert_raise(TypeError)     { system 123 }
 
-#   pids.each do |pid|
-#     assert_raise(RuntimeError) { Process.kill(0, pid) }
-#   end
-
-#   assert_kind_of Array, a
-#   assert_equal 3, a.size
-
-#   pids.each do |pid|
-#     pid_status = a.find { |i| i[0] == pid }
-
-#     assert_kind_of Array, pid_status
-#     assert_equal 2, pid_status.size
-#     assert_equal pid, pid_status.first
-#     assert_kind_of Process::Status, pid_status.last
-#   end
-# end
-
-# assert('Process.system') do
-#   assert_raise(ArgumentError) { system }
-#   assert_raise(TypeError)     { system 123 }
-
-#   assert_true  system 'exit 0'
-#   assert_equal 0, $?.exitstatus
-#   assert_false system 'exit 1'
-#   assert_equal 1, $?.exitstatus
+  assert_true  system 'exit 0'
+  assert_equal 0, $?.exitstatus
+  assert_false system 'exit 1'
+  assert_equal 1, $?.exitstatus
 
-#   assert_nothing_raised { system 'exit' }
+  assert_nothing_raised { system 'exit' }
 
-#   var = ENV['RAND']
-#   env = OS.posix? ? '$MYVAR' : '%MYVAR%'
+  var = ENV['RAND']
+  env = OS.posix? ? '$MYVAR' : '%MYVAR%'
 
-#   system({ MYVAR: var }, "echo #{env} > tmp/system.txt")
+  system({ MYVAR: var }, "echo #{env} > tmp/system.txt")
 
-#   assert_equal var, read('tmp/system.txt')
-# end
+  assert_equal var, read('tmp/system.txt')
+end
 
-# assert_windows('Process.fork') do
-#   assert_false Process.respond_to? :fork
-#   assert_false Kernel.respond_to? :fork
-# end
+assert_windows('Process.fork') do
+  assert_false Process.respond_to? :fork
+  assert_false Kernel.respond_to? :fork
+end