posix-spawn 0.3.0

data/lib/posix/spawn/child.rb

@@ -0,0 +1,212 @@
+require 'posix/spawn'
+
+module POSIX
+  module Spawn
+    # POSIX::Spawn::Child includes logic for executing child processes and
+    # reading/writing from their standard input, output, and error streams. It's
+    # designed to take all input in a single string and provides all output
+    # (stderr and stdout) as single strings and is therefore not well-suited
+    # to streaming large quantities of data in and out of commands.
+    #
+    # Create and run a process to completion:
+    #
+    #   >> child = POSIX::Spawn::Child.new('git', '--help')
+    #
+    # Retrieve stdout or stderr output:
+    #
+    #   >> child.out
+    #   => "usage: git [--version] [--exec-path[=GIT_EXEC_PATH]]\n ..."
+    #   >> child.err
+    #   => ""
+    #
+    # Check process exit status information:
+    #
+    #   >> child.status
+    #   => #<Process::Status: pid=80718,exited(0)>
+    #
+    # To write data on the new process's stdin immediately after spawning:
+    #
+    #   >> child = POSIX::Spawn::Child.new('bc', :input => '40 + 2')
+    #   >> child.out
+    #   "42\n"
+    #
+    # Q: Why use POSIX::Spawn::Child instead of popen3, hand rolled fork/exec
+    # code, or Process::spawn?
+    #
+    # - It's more efficient than popen3 and provides meaningful process
+    #   hierarchies because it performs a single fork/exec. (popen3 double forks
+    #   to avoid needing to collect the exit status and also calls
+    #   Process::detach which creates a Ruby Thread!!!!).
+    #
+    # - It handles all max pipe buffer (PIPE_BUF) hang cases when reading and
+    #   writing semi-large amounts of data. This is non-trivial to implement
+    #   correctly and must be accounted for with popen3, spawn, or hand rolled
+    #   fork/exec code.
+    #
+    # - It's more portable than hand rolled pipe, fork, exec code because
+    #   fork(2) and exec aren't available on all platforms. In those cases,
+    #   POSIX::Spawn::Child falls back to using whatever janky substitutes
+    #   the platform provides.
+    class Child
+      include POSIX::Spawn
+
+      # Spawn a new process, write all input and read all output, and wait for
+      # the program to exit. Supports the standard spawn interface as described
+      # in the POSIX::Spawn module documentation:
+      #
+      #   new([env], command, [argv1, ...], [options])
+      #
+      # The following options are supported in addition to the standard
+      # POSIX::Spawn options:
+      #
+      #   :input   => str      Write str to the new process's standard input.
+      #   :timeout => int      Maximum number of seconds to allow the process
+      #                        to execute before aborting with a TimeoutExceeded
+      #                        exception.
+      #   :max     => total    Maximum number of bytes of output to allow the
+      #                        process to generate before aborting with a
+      #                        MaximumOutputExceeded exception.
+      #
+      # Returns a new Child instance whose underlying process has already
+      # executed to completion. The out, err, and status attributes are
+      # immediately available.
+      def initialize(*args)
+        @env, @argv, options = extract_process_spawn_arguments(*args)
+        @options = options.dup
+        @input = @options.delete(:input)
+        @timeout = @options.delete(:timeout)
+        @max = @options.delete(:max)
+        @options.delete(:chdir) if @options[:chdir].nil?
+        exec!
+      end
+
+      # All data written to the child process's stdout stream as a String.
+      attr_reader :out
+
+      # All data written to the child process's stderr stream as a String.
+      attr_reader :err
+
+      # A Process::Status object with information on how the child exited.
+      attr_reader :status
+
+      # Total command execution time (wall-clock time)
+      attr_reader :runtime
+
+      # Determine if the process did exit with a zero exit status.
+      def success?
+        @status && @status.success?
+      end
+
+    private
+      # Execute command, write input, and read output. This is called
+      # immediately when a new instance of this object is initialized.
+      def exec!
+        # spawn the process and hook up the pipes
+        pid, stdin, stdout, stderr = popen4(@env, *(@argv + [@options]))
+
+        # async read from all streams into buffers
+        @out, @err = read_and_write(@input, stdin, stdout, stderr, @timeout, @max)
+
+        # grab exit status
+        @status = waitpid(pid)
+      rescue Object => boom
+        [stdin, stdout, stderr].each { |fd| fd.close rescue nil }
+        if @status.nil?
+          ::Process.kill('TERM', pid) rescue nil
+          @status = waitpid(pid)      rescue nil
+        end
+        raise
+      ensure
+        # let's be absolutely certain these are closed
+        [stdin, stdout, stderr].each { |fd| fd.close rescue nil }
+      end
+
+      # Maximum buffer size for reading
+      BUFSIZE = (32 * 1024)
+
+      # Start a select loop writing any input on the child's stdin and reading
+      # any output from the child's stdout or stderr.
+      #
+      # input   - String input to write on stdin. May be nil.
+      # stdin   - The write side IO object for the child's stdin stream.
+      # stdout  - The read side IO object for the child's stdout stream.
+      # stderr  - The read side IO object for the child's stderr stream.
+      # timeout - An optional Numeric specifying the total number of seconds
+      #           the read/write operations should occur for.
+      #
+      # Returns an [out, err] tuple where both elements are strings with all
+      #   data written to the stdout and stderr streams, respectively.
+      # Raises TimeoutExceeded when all data has not been read / written within
+      #   the duration specified in the timeout argument.
+      # Raises MaximumOutputExceeded when the total number of bytes output
+      #   exceeds the amount specified by the max argument.
+      def read_and_write(input, stdin, stdout, stderr, timeout=nil, max=nil)
+        input ||= ''
+        max = nil if max && max <= 0
+        out, err = '', ''
+        offset = 0
+
+        timeout = nil if timeout && timeout <= 0.0
+        @runtime = 0.0
+        start = Time.now
+
+        writers = [stdin]
+        readers = [stdout, stderr]
+        t = timeout
+        while readers.any? || writers.any?
+          ready = IO.select(readers, writers, readers + writers, t)
+          raise TimeoutExceeded if ready.nil?
+
+          # write to stdin stream
+          ready[1].each do |fd|
+            begin
+              boom = nil
+              size = fd.write_nonblock(input)
+              input = input[size, input.size]
+            rescue Errno::EPIPE => boom
+            rescue Errno::EAGAIN, Errno::EINTR
+            end
+            if boom || input.size == 0
+              stdin.close
+              writers.delete(stdin)
+            end
+          end
+
+          # read from stdout and stderr streams
+          ready[0].each do |fd|
+            buf = (fd == stdout) ? out : err
+            begin
+              buf << fd.readpartial(BUFSIZE)
+            rescue Errno::EAGAIN, Errno::EINTR
+            rescue EOFError
+              readers.delete(fd)
+              fd.close
+            end
+          end
+
+          # keep tabs on the total amount of time we've spent here
+          @runtime = Time.now - start
+          if timeout
+            t = timeout - @runtime
+            raise TimeoutExceeded if t < 0.0
+          end
+
+          # maybe we've hit our max output
+          if max && ready[0].any? && (out.size + err.size) > max
+            raise MaximumOutputExceeded
+          end
+        end
+
+        [out, err]
+      end
+
+      # Wait for the child process to exit
+      #
+      # Returns the Process::Status object obtained by reaping the process.
+      def waitpid(pid)
+        ::Process::waitpid(pid)
+        $?
+      end
+    end
+  end
+end

data/lib/posix/spawn/version.rb

@@ -0,0 +1,5 @@
+module POSIX
+  module Spawn
+    VERSION = '0.3.0'
+  end
+end

data/posix-spawn.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path('../lib/posix/spawn/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = 'posix-spawn'
+  s.version = POSIX::Spawn::VERSION
+
+  s.summary = 'posix_spawnp(2) for ruby'
+  s.description = 'posix-spawn uses posix_spawnp(2) for faster process spawning'
+
+  s.homepage = 'http://github.com/rtomayko/posix-spawn'
+  s.has_rdoc = false
+
+  s.authors = ['Ryan Tomayko', 'Aman Gupta']
+  s.email = ['r@tomayko.com', 'aman@tmm1.net']
+
+  s.add_development_dependency 'rake-compiler', '0.7.6'
+
+  s.extensions = ['ext/extconf.rb']
+  s.executables << 'posix-spawn-benchmark'
+  s.require_paths = ['lib']
+
+  s.files = `git ls-files`.split("\n")
+  s.extra_rdoc_files = %w[ COPYING HACKING ]
+end

data/test/test_backtick.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require 'posix-spawn'
+
+class BacktickTest < Test::Unit::TestCase
+  include POSIX::Spawn
+
+  def test_backtick_simple
+    out = `exit`
+    assert_equal out, ''
+    assert_equal $?.exitstatus, 0
+  end
+
+  def test_backtick_output
+    out = `echo 123`
+    assert_equal out, "123\n"
+    assert_equal $?.exitstatus, 0
+  end
+
+  def test_backtick_failure
+    out = `nosuchcmd 2> /dev/null`
+    assert_equal out, ''
+    assert_equal $?.exitstatus, 127
+  end
+
+  def test_backtick_redirect
+    out = `nosuchcmd 2>&1`
+    assert_equal out, "/bin/sh: nosuchcmd: command not found\n"
+    assert_equal $?.exitstatus, 127
+  end
+
+  def test_backtick_huge
+    out = `yes | head -50000`
+    assert_equal out.size, 100000
+    assert_equal $?.exitstatus, 0
+  end
+end

data/test/test_child.rb

@@ -0,0 +1,107 @@
+require 'test/unit'
+require 'posix-spawn'
+
+class ChildTest < Test::Unit::TestCase
+  include POSIX::Spawn
+
+  def test_sanity
+    assert_same POSIX::Spawn::Child, Child
+  end
+
+  def test_argv_array_execs
+    p = Child.new('printf', '%s %s %s', '1', '2', '3 4')
+    assert p.success?
+    assert_equal "1 2 3 4", p.out
+  end
+
+  def test_argv_string_uses_sh
+    p = Child.new("echo via /bin/sh")
+    assert p.success?
+    assert_equal "via /bin/sh\n", p.out
+  end
+
+  def test_stdout
+    p = Child.new('echo', 'boom')
+    assert_equal "boom\n", p.out
+    assert_equal "", p.err
+  end
+
+  def test_stderr
+    p = Child.new('echo boom 1>&2')
+    assert_equal "", p.out
+    assert_equal "boom\n", p.err
+  end
+
+  def test_status
+    p = Child.new('exit 3')
+    assert !p.status.success?
+    assert_equal 3, p.status.exitstatus
+  end
+
+  def test_env
+    p = Child.new({ 'FOO' => 'BOOYAH' }, 'echo $FOO')
+    assert_equal "BOOYAH\n", p.out
+  end
+
+  def test_chdir
+    p = Child.new("pwd", :chdir => File.dirname(Dir.pwd))
+    assert_equal File.dirname(Dir.pwd) + "\n", p.out
+  end
+
+  def test_input
+    input = "HEY NOW\n" * 100_000 # 800K
+    p = Child.new('wc', '-l', :input => input)
+    assert_equal 100_000, p.out.strip.to_i
+  end
+
+  def test_max
+    assert_raise MaximumOutputExceeded do
+      Child.new('yes', :max => 100_000)
+    end
+  end
+
+  def test_max_with_child_hierarchy
+    assert_raise MaximumOutputExceeded do
+      Child.new('/bin/sh', '-c', 'yes', :max => 100_000)
+    end
+  end
+
+  def test_max_with_stubborn_child
+    assert_raise MaximumOutputExceeded do
+      Child.new("trap '' TERM; yes", :max => 100_000)
+    end
+  end
+
+  def test_timeout
+    assert_raise TimeoutExceeded do
+      Child.new('sleep', '1', :timeout => 0.05)
+    end
+  end
+
+  def test_timeout_with_child_hierarchy
+    assert_raise TimeoutExceeded do
+      Child.new('/bin/sh', '-c', 'sleep 1', :timeout => 0.05)
+    end
+  end
+
+  def test_lots_of_input_and_lots_of_output_at_the_same_time
+    input = "stuff on stdin \n" * 1_000
+    command = "
+      while read line
+      do
+        echo stuff on stdout;
+        echo stuff on stderr 1>&2;
+      done
+    "
+    p = Child.new(command, :input => input)
+    assert_equal input.size, p.out.size
+    assert_equal input.size, p.err.size
+    assert p.success?
+  end
+
+  def test_input_cannot_be_written_due_to_broken_pipe
+    input = "1" * 100_000
+    p = Child.new('false', :input => input)
+    assert !p.success?
+  end
+end

data/test/test_popen.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'posix-spawn'
+
+class PopenTest < Test::Unit::TestCase
+  include POSIX::Spawn
+
+  def test_popen4
+    pid, i, o, e = popen4("cat")
+    i.write "hello world"
+    i.close
+    ::Process.wait(pid)
+
+    assert_equal o.read, "hello world"
+    assert_equal $?.exitstatus, 0
+  ensure
+    [i, o, e].each{ |io| io.close rescue nil }
+  end
+end

data/test/test_spawn.rb

@@ -0,0 +1,360 @@
+require 'test/unit'
+require 'posix-spawn'
+
+module SpawnImplementationTests
+  def test_spawn_simple
+    pid = _spawn('true')
+    assert_process_exit_ok pid
+  end
+
+  def test_spawn_with_args
+    pid = _spawn('true', 'with', 'some stuff')
+    assert_process_exit_ok pid
+  end
+
+  def test_spawn_with_shell
+    pid = _spawn('true && exit 13')
+    assert_process_exit_status pid, 13
+  end
+
+  def test_spawn_with_cmdname_and_argv0_tuple
+    pid = _spawn(['true', 'not-true'], 'some', 'args', 'toooo')
+    assert_process_exit_ok pid
+  end
+
+  def test_spawn_with_invalid_argv
+    assert_raise ArgumentError do
+      _spawn(['echo','b','c','d'])
+    end
+  end
+
+  ##
+  # Environ
+
+  def test_spawn_inherit_env
+    ENV['PSPAWN'] = 'parent'
+    pid = _spawn('test "$PSPAWN" = "parent"')
+    assert_process_exit_ok pid
+  ensure
+    ENV.delete('PSPAWN')
+  end
+
+  def test_spawn_clean_env
+    ENV['PSPAWN'] = 'parent'
+    pid = _spawn({'TEMP'=>'child'}, 'test -z "$PSPAWN" && test "$TEMP" = "child"', :unsetenv_others => true)
+    assert_process_exit_ok pid
+  ensure
+    ENV.delete('PSPAWN')
+  end
+
+  def test_spawn_set_env
+    ENV['PSPAWN'] = 'parent'
+    pid = _spawn({'PSPAWN'=>'child'}, 'test "$PSPAWN" = "child"')
+    assert_process_exit_ok pid
+  ensure
+    ENV.delete('PSPAWN')
+  end
+
+  def test_spawn_unset_env
+    ENV['PSPAWN'] = 'parent'
+    pid = _spawn({'PSPAWN'=>nil}, 'test -z "$PSPAWN"')
+    assert_process_exit_ok pid
+  ensure
+    ENV.delete('PSPAWN')
+  end
+
+  ##
+  # FD => :close options
+
+  def test_sanity_of_checking_clone_with_sh
+    rd, wr = IO.pipe
+    pid = _spawn("exec 2>/dev/null 100<&#{rd.to_i} || exit 1", rd => rd)
+    assert_process_exit_status pid, 0
+  ensure
+    [rd, wr].each { |fd| fd.close rescue nil }
+  end
+
+  def test_spawn_close_option_with_symbolic_standard_stream_names
+    pid = _spawn('exec 2>/dev/null 100<&0 || exit 1', :in => :close)
+    assert_process_exit_status pid, 1
+
+    pid = _spawn('exec 2>/dev/null 101>&1 102>&2 || exit 1',
+                 :out => :close, :err => :close)
+    assert_process_exit_status pid, 1
+  end
+
+  def test_spawn_close_on_standard_stream_io_object
+    pid = _spawn('exec 2>/dev/null 100<&0 || exit 1', STDIN => :close)
+    assert_process_exit_status pid, 1
+
+    pid = _spawn('exec 2>/dev/null 101>&1 102>&2 || exit 1',
+                 STDOUT => :close, STDOUT => :close)
+    assert_process_exit_status pid, 1
+  end
+
+  def test_spawn_close_option_with_fd_number
+    rd, wr = IO.pipe
+    pid = _spawn("exec 2>/dev/null 100<&#{rd.to_i} || exit 1", rd.to_i => :close)
+    assert_process_exit_status pid, 1
+
+    assert !rd.closed?
+    assert !wr.closed?
+  ensure
+    [rd, wr].each { |fd| fd.close rescue nil }
+  end
+
+  def test_spawn_close_option_with_io_object
+    rd, wr = IO.pipe
+    pid = _spawn("exec 2>/dev/null 100<&#{rd.to_i} || exit 1", rd => :close)
+    assert_process_exit_status pid, 1
+
+    assert !rd.closed?
+    assert !wr.closed?
+  ensure
+    [rd, wr].each { |fd| fd.close rescue nil }
+  end
+
+  def test_spawn_close_invalid_fd_raises_exception
+    pid = _spawn("echo", "hiya", 250 => :close)
+    assert_process_exit_status pid, 127
+  rescue Errno::EBADF
+    # this happens on darwin only. GNU does spawn and exits 127.
+  end
+
+  def test_spawn_closing_multiple_fds_with_array_keys
+    rd, wr = IO.pipe
+    pid = _spawn("exec 2>/dev/null 101>&#{wr.to_i} || exit 1", [rd, wr, :out] => :close)
+    assert_process_exit_status pid, 1
+  ensure
+    [rd, wr].each { |fd| fd.close rescue nil }
+  end
+
+  ##
+  # FD => FD options
+
+  def test_spawn_redirect_fds_with_symbolic_names_and_io_objects
+    rd, wr = IO.pipe
+    pid = _spawn("echo", "hello world", :out => wr, rd => :close)
+    wr.close
+    output = rd.read
+    assert_process_exit_ok pid
+    assert_equal "hello world\n", output
+  ensure
+    [rd, wr].each { |fd| fd.close rescue nil }
+  end
+
+  def test_spawn_redirect_fds_with_fd_numbers
+    rd, wr = IO.pipe
+    pid = _spawn("echo", "hello world", 1 => wr.fileno, rd.fileno => :close)
+    wr.close
+    output = rd.read
+    assert_process_exit_ok pid
+    assert_equal "hello world\n", output
+  ensure
+    [rd, wr].each { |fd| fd.close rescue nil }
+  end
+
+  def test_spawn_redirect_invalid_fds_raises_exception
+    pid = _spawn("echo", "hiya", 250 => 3)
+    assert_process_exit_status pid, 127
+  rescue Errno::EBADF
+    # this happens on darwin only. GNU does spawn and exits 127.
+  end
+
+  def test_spawn_redirect_stderr_and_stdout_to_same_fd
+    rd, wr = IO.pipe
+    pid = _spawn("echo hello world 1>&2", :err => wr, :out => wr, rd => :close)
+    wr.close
+    output = rd.read
+    assert_process_exit_ok pid
+    assert_equal "hello world\n", output
+  ensure
+    [rd, wr].each { |fd| fd.close rescue nil }
+  end
+
+  def test_spawn_does_not_close_fd_when_redirecting
+    pid = _spawn("exec 2>&1", :err => :out)
+    assert_process_exit_ok pid
+  end
+
+  # Ruby 1.9 Process::spawn closes all fds by default. To keep an fd open, you
+  # have to pass it explicitly as fd => fd.
+  def test_explicitly_passing_an_fd_as_open
+    rd, wr = IO.pipe
+    pid = _spawn("exec 101>&#{wr.to_i} || exit 1", wr => wr)
+    assert_process_exit_ok pid
+  ensure
+    [rd, wr].each { |fd| fd.close rescue nil }
+  end
+
+  ##
+  # FD => file options
+
+  def test_spawn_redirect_fd_to_file_with_symbolic_name
+    file = File.expand_path('../test-output', __FILE__)
+    text = 'redirect_fd_to_file_with_symbolic_name'
+    pid = _spawn('echo', text, :out => file)
+    assert_process_exit_ok pid
+    assert File.exist?(file)
+    assert_equal "#{text}\n", File.read(file)
+  ensure
+    File.unlink(file) rescue nil
+  end
+
+  def test_spawn_redirect_fd_to_file_with_fd_number
+    file = File.expand_path('../test-output', __FILE__)
+    text = 'redirect_fd_to_file_with_fd_number'
+    pid = _spawn('echo', text, 1 => file)
+    assert_process_exit_ok pid
+    assert File.exist?(file)
+    assert_equal "#{text}\n", File.read(file)
+  ensure
+    File.unlink(file) rescue nil
+  end
+
+  def test_spawn_redirect_fd_to_file_with_io_object
+    file = File.expand_path('../test-output', __FILE__)
+    text = 'redirect_fd_to_file_with_io_object'
+    pid = _spawn('echo', text, STDOUT => file)
+    assert_process_exit_ok pid
+    assert File.exist?(file)
+    assert_equal "#{text}\n", File.read(file)
+  ensure
+    File.unlink(file) rescue nil
+  end
+
+  def test_spawn_redirect_fd_from_file_with_symbolic_name
+    file = File.expand_path('../test-input', __FILE__)
+    text = 'redirect_fd_from_file_with_symbolic_name'
+    File.open(file, 'w') { |fd| fd.write(text) }
+
+    pid = _spawn(%Q{test "$(cat)" = "#{text}"}, :in => file)
+    assert_process_exit_ok pid
+  ensure
+    File.unlink(file) rescue nil
+  end
+
+  def test_spawn_redirect_fd_from_file_with_fd_number
+    file = File.expand_path('../test-input', __FILE__)
+    text = 'redirect_fd_from_file_with_fd_number'
+    File.open(file, 'w') { |fd| fd.write(text) }
+
+    pid = _spawn(%Q{test "$(cat)" = "#{text}"}, 0 => file)
+    assert_process_exit_ok pid
+  ensure
+    File.unlink(file) rescue nil
+  end
+
+  def test_spawn_redirect_fd_from_file_with_io_object
+    file = File.expand_path('../test-input', __FILE__)
+    text = 'redirect_fd_from_file_with_io_object'
+    File.open(file, 'w') { |fd| fd.write(text) }
+
+    pid = _spawn(%Q{test "$(cat)" = "#{text}"}, STDIN => file)
+    assert_process_exit_ok pid
+  ensure
+    File.unlink(file) rescue nil
+  end
+
+  def test_spawn_redirect_fd_to_file_with_symbolic_name_and_flags
+    file = File.expand_path('../test-output', __FILE__)
+    text = 'redirect_fd_to_file_with_symbolic_name'
+    5.times do
+        pid = _spawn('echo', text, :out => [file, 'a'])
+        assert_process_exit_ok pid
+    end
+    assert File.exist?(file)
+    assert_equal "#{text}\n" * 5, File.read(file)
+  ensure
+    File.unlink(file) rescue nil
+  end
+
+  ##
+  # Exceptions
+
+  def test_spawn_raises_exception_on_unsupported_options
+    exception = nil
+
+    assert_raise ArgumentError do
+      begin
+        _spawn('echo howdy', :out => '/dev/null', :oops => 'blaahh')
+      rescue Exception => e
+        exception = e
+        raise e
+      end
+    end
+
+    assert_match /oops/, exception.message
+  end
+
+  ##
+  # Assertion Helpers
+
+  def assert_process_exit_ok(pid)
+    assert_process_exit_status pid, 0
+  end
+
+  def assert_process_exit_status(pid, status)
+    assert pid.to_i > 0, "pid [#{pid}] should be > 0"
+    chpid = ::Process.wait(pid)
+    assert_equal chpid, pid
+    assert_equal status, $?.exitstatus
+  end
+end
+
+class SpawnTest < Test::Unit::TestCase
+  include POSIX::Spawn
+
+  def test_spawn_methods_exposed_at_module_level
+    assert POSIX::Spawn.respond_to?(:pspawn)
+    assert POSIX::Spawn.respond_to?(:_pspawn)
+  end
+
+  ##
+  # Options Preprocessing
+
+  def test_extract_process_spawn_arguments_with_options
+    assert_equal [{}, [['echo', 'echo'], 'hello', 'world'], {:err => :close}],
+      extract_process_spawn_arguments('echo', 'hello', 'world', :err => :close)
+  end
+
+  def test_extract_process_spawn_arguments_with_options_and_env
+    options = {:err => :close}
+    env = {'X' => 'Y'}
+    assert_equal [env, [['echo', 'echo'], 'hello world'], options],
+      extract_process_spawn_arguments(env, 'echo', 'hello world', options)
+  end
+
+  def test_extract_process_spawn_arguments_with_shell_command
+    assert_equal [{}, [['/bin/sh', '/bin/sh'], '-c', 'echo hello world'], {}],
+      extract_process_spawn_arguments('echo hello world')
+  end
+
+  def test_extract_process_spawn_arguments_with_special_cmdname_argv_tuple
+    assert_equal [{}, [['echo', 'fuuu'], 'hello world'], {}],
+      extract_process_spawn_arguments(['echo', 'fuuu'], 'hello world')
+  end
+end
+
+class PosixSpawnTest < Test::Unit::TestCase
+  include SpawnImplementationTests
+  def _spawn(*argv)
+    POSIX::Spawn.pspawn(*argv)
+  end
+end
+
+class ForkSpawnTest < Test::Unit::TestCase
+  include SpawnImplementationTests
+  def _spawn(*argv)
+    POSIX::Spawn.fspawn(*argv)
+  end
+end
+
+if ::Process::respond_to?(:spawn)
+  class NativeSpawnTest < Test::Unit::TestCase
+    include SpawnImplementationTests
+    def _spawn(*argv)
+      ::Process.spawn(*argv)
+    end
+  end
+end