WIP

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 }
+# 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)
 
-  pid = spawn 'exit 0'
-  wait_for_pid(pid)
+#     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')
 
-  assert_kind_of Integer, pid
-  assert_true pid > 0
-  assert_not_equal $PID, pid
-  assert_kind_of Process::Status, $?
-  assert_equal $?.pid, pid
+#     pid = spawn 'ruby', '-v', out: pip
 
-  var = "#{ENV['RAND']}x"
-  pid = spawn("echo #{var} > tmp/spawn.txt")
+#     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/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
+# assert_not_windows('Process.exec') do
+#   var = ENV['RAND']
+#   pid = fork { exec({ MYVAR: var }, 'echo $MYVAR > tmp/exec.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/exec.txt')
 
-  wait_for_pid(pid)
-  assert_equal var, read('tmp/exec.txt')
+#   var = "x#{var}"
+#   pid = fork { exec '/bin/sh', '-c', "echo #{var} > 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')
+# end
 
-  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
+# assert_not_windows('Process.exec', '$SHELL') do
+#   ['/bin/bash', '/bin/sh'].each do |shell|
+#     ENV['SHELL'] = shell
 
-  Process.kill :KILL, pid
+#     pid = fork { exec 'echo $SHELL > tmp/exec.txt' }
+#     wait_for_pid(pid)
 
-  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_equal shell, read('tmp/exec.txt')
+#   end
+# end
 
-assert('Process.waitall') do
-  assert_true Process.waitall.empty?
+# 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
 
-  pids = []
-  pids << spawn('exit 2')
-  pids << spawn('exit 1')
-  pids << spawn('exit 0')
+# assert('Process.wait2') do
+#   pid     = spawn('sleep 2')
+#   p, st   = Process.waitpid2(pid, Process::WNOHANG)
 
-  a = Process.waitall
+#   assert_nil p
+#   assert_nil st
 
-  pids.each do |pid|
-    assert_raise(RuntimeError) { Process.kill(0, pid) }
-  end
+#   Process.kill :KILL, pid
 
-  assert_kind_of Array, a
-  assert_equal 3, a.size
+#   loop do
+#     p, st = Process.waitpid2(pid, Process::WNOHANG)
+#     break if p
+#   end
 
-  pids.each do |pid|
-    pid_status = a.find { |i| i[0] == pid }
+#   assert_equal pid, p
+#   assert_kind_of Process::Status, st
+#   assert_include [9, nil], st.termsig
+# end
 
-    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.waitall') do
+#   assert_true Process.waitall.empty?
+
+#   pids = []
+#   pids << spawn('exit 2')
+#   pids << spawn('exit 1')
+#   pids << spawn('exit 0')
 
-assert('Process.system') do
-  assert_raise(ArgumentError) { system }
-  assert_raise(TypeError)     { system 123 }
+#   a = Process.waitall
 
-  assert_true  system 'exit 0'
-  assert_equal 0, $?.exitstatus
-  assert_false system 'exit 1'
-  assert_equal 1, $?.exitstatus
+#   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_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