1 files changed, 310 insertions, 150 deletions

diff --git a/spec/ruby/core/process/spawn_spec.rb b/spec/ruby/core/process/spawn_spec.rb
index 1bd1dfac83..fb619dce42 100644
--- a/spec/ruby/core/process/spawn_spec.rb
+++ b/spec/ruby/core/process/spawn_spec.rb
@@ -7,27 +7,25 @@ platform_is :windows do
 end
 
 describe :process_spawn_does_not_close_std_streams, shared: true do
-  platform_is_not :windows do
-    it "does not close STDIN" do
-      code = "STDOUT.puts STDIN.read(0).inspect"
-      cmd = "Process.wait Process.spawn(#{ruby_cmd(code).inspect}, #{@options.inspect})"
-      ruby_exe(cmd, args: "> #{@output}")
-      File.binread(@output).should == %[""#{newline}]
-    end
+  it "does not close STDIN" do
+    code = "puts STDIN.read"
+    cmd = "Process.wait Process.spawn(#{ruby_cmd(code).inspect}, #{@options.inspect})"
+    ruby_exe(cmd, args: "< #{fixture(__FILE__, "in.txt")} > #{@name}")
+    File.binread(@name).should == %[stdin#{newline}]
+  end
 
-    it "does not close STDOUT" do
-      code = "STDOUT.puts 'hello'"
-      cmd = "Process.wait Process.spawn(#{ruby_cmd(code).inspect}, #{@options.inspect})"
-      ruby_exe(cmd, args: "> #{@output}")
-      File.binread(@output).should == "hello#{newline}"
-    end
+  it "does not close STDOUT" do
+    code = "STDOUT.puts 'hello'"
+    cmd = "Process.wait Process.spawn(#{ruby_cmd(code).inspect}, #{@options.inspect})"
+    ruby_exe(cmd, args: "> #{@name}")
+    File.binread(@name).should == "hello#{newline}"
+  end
 
-    it "does not close STDERR" do
-      code = "STDERR.puts 'hello'"
-      cmd = "Process.wait Process.spawn(#{ruby_cmd(code).inspect}, #{@options.inspect})"
-      ruby_exe(cmd, args: "2> #{@output}")
-      File.binread(@output).should =~ /hello#{newline}/
-    end
+  it "does not close STDERR" do
+    code = "STDERR.puts 'hello'"
+    cmd = "Process.wait Process.spawn(#{ruby_cmd(code).inspect}, #{@options.inspect})"
+    ruby_exe(cmd, args: "2> #{@name}")
+    File.binread(@name).should =~ /hello#{newline}/
   end
 end
 
@@ -47,13 +45,13 @@ describe "Process.spawn" do
   end
 
   it "executes the given command" do
-    lambda { Process.wait Process.spawn("echo spawn") }.should output_to_fd("spawn\n")
+    -> { Process.wait Process.spawn("echo spawn") }.should output_to_fd("spawn\n")
   end
 
-  it "returns the process ID of the new process as a Fixnum" do
+  it "returns the process ID of the new process as an Integer" do
     pid = Process.spawn(*ruby_exe, "-e", "exit")
     Process.wait pid
-    pid.should be_an_instance_of(Fixnum)
+    pid.should.instance_of?(Integer)
   end
 
   it "returns immediately" do
@@ -69,43 +67,43 @@ describe "Process.spawn" do
   describe "with a single argument" do
     platform_is_not :windows do
       it "subjects the specified command to shell expansion" do
-        lambda { Process.wait Process.spawn("echo *") }.should_not output_to_fd("*\n")
+        -> { Process.wait Process.spawn("echo *") }.should_not output_to_fd("*\n")
       end
 
       it "creates an argument array with shell parsing semantics for whitespace" do
-        lambda { Process.wait Process.spawn("echo a b  c   d") }.should output_to_fd("a b c d\n")
+        -> { Process.wait Process.spawn("echo a b  c   d") }.should output_to_fd("a b c d\n")
       end
     end
 
     platform_is :windows do
       # There is no shell expansion on Windows
       it "does not subject the specified command to shell expansion on Windows" do
-        lambda { Process.wait Process.spawn("echo *") }.should output_to_fd("*\n")
+        -> { Process.wait Process.spawn("echo *") }.should output_to_fd("*\n")
       end
 
       it "does not create an argument array with shell parsing semantics for whitespace on Windows" do
-        lambda { Process.wait Process.spawn("echo a b  c   d") }.should output_to_fd("a b  c   d\n")
+        -> { Process.wait Process.spawn("echo a b  c   d") }.should output_to_fd("a b  c   d\n")
       end
     end
 
     it "calls #to_str to convert the argument to a String" do
       o = mock("to_str")
       o.should_receive(:to_str).and_return("echo foo")
-      lambda { Process.wait Process.spawn(o) }.should output_to_fd("foo\n")
+      -> { Process.wait Process.spawn(o) }.should output_to_fd("foo\n")
     end
 
     it "raises an ArgumentError if the command includes a null byte" do
-      lambda { Process.spawn "\000" }.should raise_error(ArgumentError)
+      -> { Process.spawn "\000" }.should.raise(ArgumentError)
     end
 
     it "raises a TypeError if the argument does not respond to #to_str" do
-      lambda { Process.spawn :echo }.should raise_error(TypeError)
+      -> { Process.spawn :echo }.should.raise(TypeError)
     end
   end
 
   describe "with multiple arguments" do
     it "does not subject the arguments to shell expansion" do
-      lambda { Process.wait Process.spawn("echo", "*") }.should output_to_fd("*\n")
+      -> { Process.wait Process.spawn("echo", "*") }.should output_to_fd("*\n")
     end
 
     it "preserves whitespace in passed arguments" do
@@ -114,36 +112,36 @@ describe "Process.spawn" do
         # The echo command on Windows takes quotes literally
         out = "\"a b  c   d\"\n"
       end
-      lambda { Process.wait Process.spawn("echo", "a b  c   d") }.should output_to_fd(out)
+      -> { Process.wait Process.spawn("echo", "a b  c   d") }.should output_to_fd(out)
     end
 
     it "calls #to_str to convert the arguments to Strings" do
       o = mock("to_str")
       o.should_receive(:to_str).and_return("foo")
-      lambda { Process.wait Process.spawn("echo", o) }.should output_to_fd("foo\n")
+      -> { Process.wait Process.spawn("echo", o) }.should output_to_fd("foo\n")
     end
 
     it "raises an ArgumentError if an argument includes a null byte" do
-      lambda { Process.spawn "echo", "\000" }.should raise_error(ArgumentError)
+      -> { Process.spawn "echo", "\000" }.should.raise(ArgumentError)
     end
 
     it "raises a TypeError if an argument does not respond to #to_str" do
-      lambda { Process.spawn "echo", :foo }.should raise_error(TypeError)
+      -> { Process.spawn "echo", :foo }.should.raise(TypeError)
     end
   end
 
   describe "with a command array" do
     it "uses the first element as the command name and the second as the argv[0] value" do
       platform_is_not :windows do
-        lambda { Process.wait Process.spawn(["/bin/sh", "argv_zero"], "-c", "echo $0") }.should output_to_fd("argv_zero\n")
+        -> { Process.wait Process.spawn(["/bin/sh", "argv_zero"], "-c", "echo $0") }.should output_to_fd("argv_zero\n")
       end
       platform_is :windows do
-        lambda { Process.wait Process.spawn(["cmd.exe", "/C"], "/C", "echo", "argv_zero") }.should output_to_fd("argv_zero\n")
+        -> { Process.wait Process.spawn(["cmd.exe", "/C"], "/C", "echo", "argv_zero") }.should output_to_fd("argv_zero\n")
       end
     end
 
     it "does not subject the arguments to shell expansion" do
-      lambda { Process.wait Process.spawn(["echo", "echo"], "*") }.should output_to_fd("*\n")
+      -> { Process.wait Process.spawn(["echo", "echo"], "*") }.should output_to_fd("*\n")
     end
 
     it "preserves whitespace in passed arguments" do
@@ -152,47 +150,47 @@ describe "Process.spawn" do
         # The echo command on Windows takes quotes literally
         out = "\"a b  c   d\"\n"
       end
-      lambda { Process.wait Process.spawn(["echo", "echo"], "a b  c   d") }.should output_to_fd(out)
+      -> { Process.wait Process.spawn(["echo", "echo"], "a b  c   d") }.should output_to_fd(out)
     end
 
     it "calls #to_ary to convert the argument to an Array" do
       o = mock("to_ary")
       platform_is_not :windows do
         o.should_receive(:to_ary).and_return(["/bin/sh", "argv_zero"])
-        lambda { Process.wait Process.spawn(o, "-c", "echo $0") }.should output_to_fd("argv_zero\n")
+        -> { Process.wait Process.spawn(o, "-c", "echo $0") }.should output_to_fd("argv_zero\n")
       end
       platform_is :windows do
         o.should_receive(:to_ary).and_return(["cmd.exe", "/C"])
-        lambda { Process.wait Process.spawn(o, "/C", "echo", "argv_zero") }.should output_to_fd("argv_zero\n")
+        -> { Process.wait Process.spawn(o, "/C", "echo", "argv_zero") }.should output_to_fd("argv_zero\n")
       end
     end
 
     it "calls #to_str to convert the first element to a String" do
       o = mock("to_str")
       o.should_receive(:to_str).and_return("echo")
-      lambda { Process.wait Process.spawn([o, "echo"], "foo") }.should output_to_fd("foo\n")
+      -> { Process.wait Process.spawn([o, "echo"], "foo") }.should output_to_fd("foo\n")
     end
 
     it "calls #to_str to convert the second element to a String" do
       o = mock("to_str")
       o.should_receive(:to_str).and_return("echo")
-      lambda { Process.wait Process.spawn(["echo", o], "foo") }.should output_to_fd("foo\n")
+      -> { Process.wait Process.spawn(["echo", o], "foo") }.should output_to_fd("foo\n")
     end
 
     it "raises an ArgumentError if the Array does not have exactly two elements" do
-      lambda { Process.spawn([]) }.should raise_error(ArgumentError)
-      lambda { Process.spawn([:a]) }.should raise_error(ArgumentError)
-      lambda { Process.spawn([:a, :b, :c]) }.should raise_error(ArgumentError)
+      -> { Process.spawn([]) }.should.raise(ArgumentError)
+      -> { Process.spawn([:a]) }.should.raise(ArgumentError)
+      -> { Process.spawn([:a, :b, :c]) }.should.raise(ArgumentError)
     end
 
     it "raises an ArgumentError if the Strings in the Array include a null byte" do
-      lambda { Process.spawn ["\000", "echo"] }.should raise_error(ArgumentError)
-      lambda { Process.spawn ["echo", "\000"] }.should raise_error(ArgumentError)
+      -> { Process.spawn ["\000", "echo"] }.should.raise(ArgumentError)
+      -> { Process.spawn ["echo", "\000"] }.should.raise(ArgumentError)
     end
 
     it "raises a TypeError if an element in the Array does not respond to #to_str" do
-      lambda { Process.spawn ["echo", :echo] }.should raise_error(TypeError)
-      lambda { Process.spawn [:echo, "echo"] }.should raise_error(TypeError)
+      -> { Process.spawn ["echo", :echo] }.should.raise(TypeError)
+      -> { Process.spawn [:echo, "echo"] }.should.raise(TypeError)
     end
   end
 
@@ -209,13 +207,29 @@ describe "Process.spawn" do
 
   it "unsets environment variables whose value is nil" do
     ENV["FOO"] = "BAR"
-    Process.wait Process.spawn({"FOO" => nil}, "echo #{@var}>#{@name}")
-    expected = "\n"
-    platform_is :windows do
-      # Windows does not expand the variable if it is unset
-      expected = "#{@var}\n"
+    -> do
+      Process.wait Process.spawn({"FOO" => nil}, ruby_cmd("p ENV['FOO']"))
+    end.should output_to_fd("nil\n")
+  end
+
+  platform_is_not :windows do
+    it "uses the passed env['PATH'] to search the executable" do
+      dir = tmp("spawn_path_dir")
+      mkdir_p dir
+      begin
+        exe = 'process-spawn-executable-in-path'
+        path = "#{dir}/#{exe}"
+        File.write(path, "#!/bin/sh\necho $1")
+        File.chmod(0755, path)
+
+        env = { "PATH" => "#{dir}#{File::PATH_SEPARATOR}#{ENV['PATH']}" }
+        Process.wait Process.spawn(env, exe, 'OK', out: @name)
+        $?.should.success?
+        File.read(@name).should == "OK\n"
+      ensure
+        rm_r dir
+      end
     end
-    File.read(@name).should == expected
   end
 
   it "calls #to_hash to convert the environment" do
@@ -240,21 +254,21 @@ describe "Process.spawn" do
   end
 
   it "raises an ArgumentError if an environment key includes an equals sign" do
-    lambda do
+    -> do
       Process.spawn({"FOO=" => "BAR"}, "echo #{@var}>#{@name}")
-    end.should raise_error(ArgumentError)
+    end.should.raise(ArgumentError)
   end
 
   it "raises an ArgumentError if an environment key includes a null byte" do
-    lambda do
+    -> do
       Process.spawn({"\000" => "BAR"}, "echo #{@var}>#{@name}")
-    end.should raise_error(ArgumentError)
+    end.should.raise(ArgumentError)
   end
 
   it "raises an ArgumentError if an environment value includes a null byte" do
-    lambda do
+    -> do
       Process.spawn({"FOO" => "\000"}, "echo #{@var}>#{@name}")
-    end.should raise_error(ArgumentError)
+    end.should.raise(ArgumentError)
   end
 
   # :unsetenv_others
@@ -271,7 +285,7 @@ describe "Process.spawn" do
     it "unsets other environment variables when given a true :unsetenv_others option" do
       ENV["FOO"] = "BAR"
       Process.wait Process.spawn(*@common_env_spawn_args, unsetenv_others: true)
-      $?.success?.should be_true
+      $?.success?.should == true
       File.read(@name).should == "\n"
     end
   end
@@ -279,7 +293,7 @@ describe "Process.spawn" do
   it "does not unset other environment variables when given a false :unsetenv_others option" do
     ENV["FOO"] = "BAR"
     Process.wait Process.spawn(*@common_env_spawn_args, unsetenv_others: false)
-    $?.success?.should be_true
+    $?.success?.should == true
     File.read(@name).should == "BAR\n"
   end
 
@@ -287,7 +301,7 @@ describe "Process.spawn" do
     it "does not unset environment variables included in the environment hash" do
       env = @minimal_env.merge({"FOO" => "BAR"})
       Process.wait Process.spawn(env, "echo #{@var}>#{@name}", unsetenv_others: true)
-      $?.success?.should be_true
+      $?.success?.should == true
       File.read(@name).should == "BAR\n"
     end
   end
@@ -296,25 +310,25 @@ describe "Process.spawn" do
 
   platform_is_not :windows do
     it "joins the current process group by default" do
-      lambda do
+      -> do
         Process.wait Process.spawn(ruby_cmd("print Process.getpgid(Process.pid)"))
       end.should output_to_fd(Process.getpgid(Process.pid).to_s)
     end
 
     it "joins the current process if pgroup: false" do
-      lambda do
+      -> do
         Process.wait Process.spawn(ruby_cmd("print Process.getpgid(Process.pid)"), pgroup: false)
       end.should output_to_fd(Process.getpgid(Process.pid).to_s)
     end
 
     it "joins the current process if pgroup: nil" do
-      lambda do
+      -> do
         Process.wait Process.spawn(ruby_cmd("print Process.getpgid(Process.pid)"), pgroup: nil)
       end.should output_to_fd(Process.getpgid(Process.pid).to_s)
     end
 
     it "joins a new process group if pgroup: true" do
-      process = lambda do
+      process = -> do
         Process.wait Process.spawn(ruby_cmd("print Process.getpgid(Process.pid)"), pgroup: true)
       end
 
@@ -323,7 +337,7 @@ describe "Process.spawn" do
     end
 
     it "joins a new process group if pgroup: 0" do
-      process = lambda do
+      process = -> do
         Process.wait Process.spawn(ruby_cmd("print Process.getpgid(Process.pid)"), pgroup: 0)
       end
 
@@ -333,23 +347,33 @@ describe "Process.spawn" do
 
     it "joins the specified process group if pgroup: pgid" do
       pgid = Process.getpgid(Process.pid)
-      lambda do
-        Process.wait Process.spawn(ruby_cmd("print Process.getpgid(Process.pid)"), pgroup: pgid)
-      end.should output_to_fd(pgid.to_s)
+      # The process group is not available on all platforms.
+      # See "man proc" - /proc/[pid]/stat - (5) pgrp
+      # In Travis aarch64 environment, the value is 0.
+      #
+      # $ cat /proc/[pid]/stat
+      # 19179 (ruby) S 19160 0 0 ...
+      unless pgid.zero?
+        -> do
+          Process.wait Process.spawn(ruby_cmd("print Process.getpgid(Process.pid)"), pgroup: pgid)
+        end.should output_to_fd(pgid.to_s)
+      else
+        skip "The process group is not available."
+      end
     end
 
     it "raises an ArgumentError if given a negative :pgroup option" do
-      lambda { Process.spawn("echo", pgroup: -1) }.should raise_error(ArgumentError)
+      -> { Process.spawn("echo", pgroup: -1) }.should.raise(ArgumentError)
     end
 
     it "raises a TypeError if given a symbol as :pgroup option" do
-      lambda { Process.spawn("echo", pgroup: :true) }.should raise_error(TypeError)
+      -> { Process.spawn("echo", pgroup: :true) }.should.raise(TypeError)
     end
   end
 
   platform_is :windows do
     it "raises an ArgumentError if given :pgroup option" do
-      lambda { Process.spawn("echo", pgroup: false) }.should raise_error(ArgumentError)
+      -> { Process.spawn("echo", pgroup: false) }.should.raise(ArgumentError)
     end
   end
 
@@ -360,7 +384,7 @@ describe "Process.spawn" do
   # :chdir
 
   it "uses the current working directory as its working directory" do
-    lambda do
+    -> do
       Process.wait Process.spawn(ruby_cmd("print Dir.pwd"))
     end.should output_to_fd(Dir.pwd)
   end
@@ -376,7 +400,7 @@ describe "Process.spawn" do
     end
 
     it "changes to the directory passed for :chdir" do
-      lambda do
+      -> do
         Process.wait Process.spawn(ruby_cmd("print Dir.pwd"), chdir: @dir)
       end.should output_to_fd(@dir)
     end
@@ -385,23 +409,67 @@ describe "Process.spawn" do
       dir = mock("spawn_to_path")
       dir.should_receive(:to_path).and_return(@dir)
 
-      lambda do
+      -> do
         Process.wait Process.spawn(ruby_cmd("print Dir.pwd"), chdir: dir)
       end.should output_to_fd(@dir)
     end
   end
 
+  # chdir
+
+  platform_is :linux do
+    describe "inside Dir.chdir" do
+      def child_pids(pid)
+        `pgrep -P #{pid}`.lines.map { |child| Integer(child) }
+      end
+
+      it "does not create extra process without chdir" do
+        pid = Process.spawn("sleep 10")
+        begin
+          child_pids(pid).size.should == 0
+        ensure
+          Process.kill("TERM", pid)
+          Process.wait(pid)
+        end
+      end
+
+      it "kills extra chdir processes" do
+        pid = nil
+        Dir.chdir("/") do
+          pid = Process.spawn("sleep 10")
+        end
+
+        children = child_pids(pid)
+        children.size.should <= 1
+
+        Process.kill("TERM", pid)
+        Process.wait(pid)
+
+        if children.size > 0
+          # wait a bit for children to die
+          sleep(1)
+
+          children.each do |child|
+            -> do
+              Process.kill("TERM", child)
+            end.should.raise(Errno::ESRCH)
+          end
+        end
+      end
+    end
+  end
+
   # :umask
 
   it "uses the current umask by default" do
-    lambda do
+    -> do
       Process.wait Process.spawn(ruby_cmd("print File.umask"))
     end.should output_to_fd(File.umask.to_s)
   end
 
   platform_is_not :windows do
     it "sets the umask if given the :umask option" do
-      lambda do
+      -> do
         Process.wait Process.spawn(ruby_cmd("print File.umask"), umask: 146)
       end.should output_to_fd("146")
     end
@@ -409,9 +477,19 @@ describe "Process.spawn" do
 
   # redirection
 
-  it "redirects STDOUT to the given file descriptior if out: Fixnum" do
+  it 'redirects to the wrapped IO using wrapped_io.to_io if out: wrapped_io' do
+    File.open(@name, 'w') do |file|
+      -> do
+        wrapped_io = mock('wrapped IO')
+        wrapped_io.should_receive(:to_io).and_return(file)
+        Process.wait Process.spawn('echo Hello World', out: wrapped_io)
+      end.should output_to_fd("Hello World\n", file)
+    end
+  end
+
+  it "redirects STDOUT to the given file descriptor if out: Integer" do
     File.open(@name, 'w') do |file|
-      lambda do
+      -> do
         Process.wait Process.spawn("echo glark", out: file.fileno)
       end.should output_to_fd("glark\n", file)
     end
@@ -419,7 +497,7 @@ describe "Process.spawn" do
 
   it "redirects STDOUT to the given file if out: IO" do
     File.open(@name, 'w') do |file|
-      lambda do
+      -> do
         Process.wait Process.spawn("echo glark", out: file)
       end.should output_to_fd("glark\n", file)
     end
@@ -435,9 +513,9 @@ describe "Process.spawn" do
     File.read(@name).should == "glark\n"
   end
 
-  it "redirects STDERR to the given file descriptior if err: Fixnum" do
+  it "redirects STDERR to the given file descriptor if err: Integer" do
     File.open(@name, 'w') do |file|
-      lambda do
+      -> do
         Process.wait Process.spawn("echo glark>&2", err: file.fileno)
       end.should output_to_fd("glark\n", file)
     end
@@ -445,7 +523,7 @@ describe "Process.spawn" do
 
   it "redirects STDERR to the given file descriptor if err: IO" do
     File.open(@name, 'w') do |file|
-      lambda do
+      -> do
         Process.wait Process.spawn("echo glark>&2", err: file)
       end.should output_to_fd("glark\n", file)
     end
@@ -458,15 +536,15 @@ describe "Process.spawn" do
 
   it "redirects STDERR to child STDOUT if :err => [:child, :out]" do
     File.open(@name, 'w') do |file|
-      lambda do
+      -> do
         Process.wait Process.spawn("echo glark>&2", :out => file, :err => [:child, :out])
       end.should output_to_fd("glark\n", file)
     end
   end
 
-  it "redirects both STDERR and STDOUT to the given file descriptior" do
+  it "redirects both STDERR and STDOUT to the given file descriptor" do
     File.open(@name, 'w') do |file|
-      lambda do
+      -> do
         Process.wait Process.spawn(ruby_cmd("print(:glark); STDOUT.flush; STDERR.print(:bang)"),
                                    [:out, :err] => file.fileno)
       end.should output_to_fd("glarkbang", file)
@@ -475,7 +553,7 @@ describe "Process.spawn" do
 
   it "redirects both STDERR and STDOUT to the given IO" do
     File.open(@name, 'w') do |file|
-      lambda do
+      -> do
         Process.wait Process.spawn(ruby_cmd("print(:glark); STDOUT.flush; STDERR.print(:bang)"),
                                    [:out, :err] => file)
       end.should output_to_fd("glarkbang", file)
@@ -488,128 +566,208 @@ describe "Process.spawn" do
     File.read(@name).should == "glarkbang"
   end
 
-  context "when passed close_others: true" do
-    before :each do
-      @output = tmp("spawn_close_others_true")
-      @options = { close_others: true }
-    end
-
-    after :each do
-      rm_r @output
+  platform_is_not :windows, :android do
+    it "closes STDERR in the child if :err => :close" do
+      File.open(@name, 'w') do |file|
+        -> do
+          code = "begin; STDOUT.puts 'out'; STDERR.puts 'hello'; rescue => e; puts 'rescued'; end"
+          Process.wait Process.spawn(ruby_cmd(code), :out => file, :err => :close)
+        end.should output_to_fd("out\nrescued\n", file)
+      end
     end
+  end
 
-    it "closes file descriptors >= 3 in the child process" do
-      IO.pipe do |r, w|
-        begin
-          pid = Process.spawn(ruby_cmd("while File.exist? '#{@name}'; sleep 0.1; end"), @options)
-          w.close
-          lambda { r.read_nonblock(1) }.should raise_error(EOFError)
-        ensure
-          rm_r @name
-          Process.wait(pid) if pid
-        end
+  platform_is_not :windows do
+    it "redirects non-default file descriptor to itself" do
+      File.open(@name, 'w') do |file|
+        -> do
+          Process.wait Process.spawn(
+            ruby_cmd("f = IO.new(#{file.fileno}, 'w'); f.print(:bang); f.flush"), file.fileno => file.fileno)
+        end.should output_to_fd("bang", file)
       end
     end
-
-    it_should_behave_like :process_spawn_does_not_close_std_streams
   end
 
-  context "when passed close_others: false" do
-    before :each do
-      @output = tmp("spawn_close_others_false")
-      @options = { close_others: false }
-    end
+  it "redirects default file descriptor to itself" do
+    -> do
+      Process.wait Process.spawn(
+        ruby_cmd("f = IO.new(#{STDOUT.fileno}, 'w'); f.print(:bang); f.flush"), STDOUT.fileno => STDOUT.fileno)
+    end.should output_to_fd("bang", STDOUT)
+  end
 
-    after :each do
-      rm_r @output
-    end
+  # :close_others
 
-    it "closes file descriptors >= 3 in the child process because they are set close_on_exec by default" do
-      IO.pipe do |r, w|
-        begin
-          pid = Process.spawn(ruby_cmd("while File.exist? '#{@name}'; sleep 0.1; end"), @options)
+  platform_is_not :windows do
+    context "defaults :close_others to" do
+      it "false" do
+        IO.pipe do |r, w|
+          w.close_on_exec = false
+          code = "io = IO.new(#{w.fileno}); io.puts('inherited'); io.close"
+          pid = Process.spawn(ruby_cmd(code))
           w.close
-          lambda { r.read_nonblock(1) }.should raise_error(EOFError)
-        ensure
-          rm_r @name
-          Process.wait(pid) if pid
+          Process.wait(pid)
+          r.read.should == "inherited\n"
         end
       end
     end
 
-    platform_is_not :windows do
-      it "does not close file descriptors >= 3 in the child process if fds are set close_on_exec=false" do
+    context "when passed close_others: true" do
+      before :each do
+        @options = { close_others: true }
+      end
+
+      it "closes file descriptors >= 3 in the child process even if fds are set close_on_exec=false" do
+        touch @name
         IO.pipe do |r, w|
           r.close_on_exec = false
           w.close_on_exec = false
+
           begin
             pid = Process.spawn(ruby_cmd("while File.exist? '#{@name}'; sleep 0.1; end"), @options)
             w.close
-            lambda { r.read_nonblock(1) }.should raise_error(Errno::EAGAIN)
+            r.read(1).should == nil
           ensure
             rm_r @name
             Process.wait(pid) if pid
           end
         end
       end
+
+      it_should_behave_like :process_spawn_does_not_close_std_streams
     end
 
-    it_should_behave_like :process_spawn_does_not_close_std_streams
+    context "when passed close_others: false" do
+      before :each do
+        @options = { close_others: false }
+      end
+
+      it "closes file descriptors >= 3 in the child process because they are set close_on_exec by default" do
+        touch @name
+        IO.pipe do |r, w|
+          begin
+            pid = Process.spawn(ruby_cmd("while File.exist? '#{@name}'; sleep 0.1; end"), @options)
+            w.close
+            r.read(1).should == nil
+          ensure
+            rm_r @name
+            Process.wait(pid) if pid
+          end
+        end
+      end
+
+      it "does not close file descriptors >= 3 in the child process if fds are set close_on_exec=false" do
+        IO.pipe do |r, w|
+          r.close_on_exec = false
+          w.close_on_exec = false
+
+          code = "fd = IO.for_fd(#{w.fileno}); fd.autoclose = false; fd.write 'abc'; fd.close"
+          pid = Process.spawn(ruby_cmd(code), @options)
+          begin
+            w.close
+            r.read.should == 'abc'
+          ensure
+            Process.wait(pid)
+          end
+        end
+      end
+
+      it_should_behave_like :process_spawn_does_not_close_std_streams
+    end
   end
 
   # error handling
 
   it "raises an ArgumentError if passed no command arguments" do
-    lambda { Process.spawn }.should raise_error(ArgumentError)
+    -> { Process.spawn }.should.raise(ArgumentError)
   end
 
   it "raises an ArgumentError if passed env or options but no command arguments" do
-    lambda { Process.spawn({}) }.should raise_error(ArgumentError)
+    -> { Process.spawn({}) }.should.raise(ArgumentError)
   end
 
   it "raises an ArgumentError if passed env and options but no command arguments" do
-    lambda { Process.spawn({}, {}) }.should raise_error(ArgumentError)
+    -> { Process.spawn({}, {}) }.should.raise(ArgumentError)
   end
 
   it "raises an Errno::ENOENT for an empty string" do
-    lambda { Process.spawn "" }.should raise_error(Errno::ENOENT)
+    -> { Process.spawn "" }.should.raise(Errno::ENOENT)
   end
 
   it "raises an Errno::ENOENT if the command does not exist" do
-    lambda { Process.spawn "nonesuch" }.should raise_error(Errno::ENOENT)
+    -> { Process.spawn "nonesuch" }.should.raise(Errno::ENOENT, "No such file or directory - nonesuch")
+  end
+
+  it "sets $? to exit status 127 when the command does not exist" do
+    Process.spawn("nonesuch") rescue nil
+    $?.exitstatus.should == 127
+  end
+
+  it "raises an Errno::ENOENT if the file does not exist" do
+    -> { Process.spawn "./nonesuch" }.should.raise(Errno::ENOENT, "No such file or directory - ./nonesuch")
+  end
+
+  it "sets $? to exit status 127 when the file does not exist" do
+    Process.spawn("./nonesuch") rescue nil
+    $?.exitstatus.should == 127
+  end
+
+  platform_is_not :windows do
+    it "raises an Errno::EACCES when the path is a directory" do
+      -> { Process.spawn "./" }.should.raise(Errno::EACCES, "Permission denied - ./")
+    end
   end
 
   unless File.executable?(__FILE__) # Some FS (e.g. vboxfs) locate all files executable
     platform_is_not :windows do
       it "raises an Errno::EACCES when the file does not have execute permissions" do
-        lambda { Process.spawn __FILE__ }.should raise_error(Errno::EACCES)
+        -> { Process.spawn __FILE__ }.should.raise(Errno::EACCES, "Permission denied - #{__FILE__}")
+      end
+
+      it "sets $? to exit status 127 when the file does not have execute permissions" do
+        Process.spawn(__FILE__) rescue nil
+        $?.exitstatus.should == 127
+      end
+
+      it "raises an Errno::ENOENT when a non-executable file is found in PATH" do
+        dir = tmp("spawn_path_non_executable_dir")
+        mkdir_p dir
+        begin
+          exe = 'process-spawn-non-executable-in-path'
+          File.write("#{dir}/#{exe}", "#!/bin/sh\necho hi")
+          File.chmod(0644, "#{dir}/#{exe}")
+          env = { "PATH" => "#{dir}#{File::PATH_SEPARATOR}#{ENV['PATH']}" }
+          -> { Process.spawn(env, exe) }.should.raise(Errno::ENOENT, "No such file or directory - #{exe}")
+          $?.exitstatus.should == 127
+        ensure
+          rm_r dir
+        end
       end
     end
 
     platform_is :windows do
       it "raises Errno::EACCES or Errno::ENOEXEC when the file is not an executable file" do
-        lambda { Process.spawn __FILE__ }.should raise_error(SystemCallError) { |e|
-          [Errno::EACCES, Errno::ENOEXEC].should include(e.class)
+        -> { Process.spawn __FILE__ }.should.raise(SystemCallError) { |e|
+          [Errno::EACCES, Errno::ENOEXEC].should.include?(e.class)
         }
       end
     end
   end
 
   it "raises an Errno::EACCES or Errno::EISDIR when passed a directory" do
-    lambda { Process.spawn File.dirname(__FILE__) }.should raise_error(SystemCallError) { |e|
-      [Errno::EACCES, Errno::EISDIR].should include(e.class)
+    -> { Process.spawn __dir__ }.should.raise(SystemCallError) { |e|
+      [Errno::EACCES, Errno::EISDIR].should.include?(e.class)
     }
   end
 
   it "raises an ArgumentError when passed a string key in options" do
-    lambda { Process.spawn("echo", "chdir" => Dir.pwd) }.should raise_error(ArgumentError)
+    -> { Process.spawn("echo", "chdir" => Dir.pwd) }.should.raise(ArgumentError)
   end
 
   it "raises an ArgumentError when passed an unknown option key" do
-    lambda { Process.spawn("echo", nonesuch: :foo) }.should raise_error(ArgumentError)
+    -> { Process.spawn("echo", nonesuch: :foo) }.should.raise(ArgumentError)
   end
 
-  platform_is_not :windows do
+  platform_is_not :windows, :aix do
     describe "with Integer option keys" do
       before :each do
         @name = tmp("spawn_fd_map.txt")
@@ -623,13 +781,15 @@ describe "Process.spawn" do
       end
 
       it "maps the key to a file descriptor in the child that inherits the file descriptor from the parent specified by the value" do
-        child_fd = @io.fileno + 1
-        args = ruby_cmd(fixture(__FILE__, "map_fd.rb"), args: [child_fd.to_s])
-        pid = Process.spawn(*args, { child_fd => @io })
-        Process.waitpid pid
-        @io.rewind
-
-        @io.read.should == "writing to fd: #{child_fd}"
+        File.open(__FILE__, "r") do |f|
+          child_fd = f.fileno
+          args = ruby_cmd(fixture(__FILE__, "map_fd.rb"), args: [child_fd.to_s])
+          pid = Process.spawn(*args, { child_fd => @io })
+          Process.waitpid pid
+          @io.rewind
+
+          @io.read.should == "writing to fd: #{child_fd}"
+        end
       end
     end
   end