childprocess 0.8.0 → 3.0.0

data/lib/childprocess/windows/structs.rb

@@ -1,149 +1,149 @@
-module ChildProcess
-  module Windows
-    # typedef struct _STARTUPINFO {
-    #   DWORD  cb;
-    #   LPTSTR lpReserved;
-    #   LPTSTR lpDesktop;
-    #   LPTSTR lpTitle;
-    #   DWORD  dwX;
-    #   DWORD  dwY;
-    #   DWORD  dwXSize;
-    #   DWORD  dwYSize;
-    #   DWORD  dwXCountChars;
-    #   DWORD  dwYCountChars;
-    #   DWORD  dwFillAttribute;
-    #   DWORD  dwFlags;
-    #   WORD   wShowWindow;
-    #   WORD   cbReserved2;
-    #   LPBYTE lpReserved2;
-    #   HANDLE hStdInput;
-    #   HANDLE hStdOutput;
-    #   HANDLE hStdError;
-    # } STARTUPINFO, *LPSTARTUPINFO;
-
-    class StartupInfo < FFI::Struct
-      layout :cb,               :ulong,
-             :lpReserved,       :pointer,
-             :lpDesktop,        :pointer,
-             :lpTitle,          :pointer,
-             :dwX,              :ulong,
-             :dwY,              :ulong,
-             :dwXSize,          :ulong,
-             :dwYSize,          :ulong,
-             :dwXCountChars,    :ulong,
-             :dwYCountChars,    :ulong,
-             :dwFillAttribute,  :ulong,
-             :dwFlags,          :ulong,
-             :wShowWindow,      :ushort,
-             :cbReserved2,      :ushort,
-             :lpReserved2,      :pointer,
-             :hStdInput,        :pointer, # void ptr
-             :hStdOutput,       :pointer, # void ptr
-             :hStdError,        :pointer # void ptr
-    end
-
-    #
-    # typedef struct _PROCESS_INFORMATION {
-    #   HANDLE hProcess;
-    #   HANDLE hThread;
-    #   DWORD  dwProcessId;
-    #   DWORD  dwThreadId;
-    # } PROCESS_INFORMATION, *LPPROCESS_INFORMATION;
-    #
-
-    class ProcessInfo < FFI::Struct
-      layout :hProcess,    :pointer, # void ptr
-             :hThread,     :pointer, # void ptr
-             :dwProcessId, :ulong,
-             :dwThreadId,  :ulong
-    end
-
-    #
-    # typedef struct _SECURITY_ATTRIBUTES {
-    #   DWORD  nLength;
-    #   LPVOID lpSecurityDescriptor;
-    #   BOOL   bInheritHandle;
-    # } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
-    #
-
-    class SecurityAttributes < FFI::Struct
-      layout :nLength,              :ulong,
-             :lpSecurityDescriptor, :pointer, # void ptr
-             :bInheritHandle,       :int
-
-      def initialize(opts = {})
-        super()
-
-        self[:nLength]              = self.class.size
-        self[:lpSecurityDescriptor] = nil
-        self[:bInheritHandle]       = opts[:inherit] ? 1 : 0
-      end
-    end
-
-    #
-    # typedef struct _JOBOBJECT_BASIC_LIMIT_INFORMATION {
-    #   LARGE_INTEGER PerProcessUserTimeLimit;
-    #   LARGE_INTEGER PerJobUserTimeLimit;
-    #   DWORD         LimitFlags;
-    #   SIZE_T        MinimumWorkingSetSize;
-    #   SIZE_T        MaximumWorkingSetSize;
-    #   DWORD         ActiveProcessLimit;
-    #   ULONG_PTR     Affinity;
-    #   DWORD         PriorityClass;
-    #   DWORD         SchedulingClass;
-    # } JOBOBJECT_BASIC_LIMIT_INFORMATION, *PJOBOBJECT_BASIC_LIMIT_INFORMATION;
-    #
-    class JobObjectBasicLimitInformation < FFI::Struct
-      layout :PerProcessUserTimeLimit, :int64,
-             :PerJobUserTimeLimit,     :int64,
-             :LimitFlags,              :ulong,
-             :MinimumWorkingSetSize,   :size_t,
-             :MaximumWorkingSetSize,   :size_t,
-             :ActiveProcessLimit,      :ulong,
-             :Affinity,                :pointer,
-             :PriorityClass,           :ulong,
-             :SchedulingClass,         :ulong
-    end
-
-    #
-    # typedef struct _IO_COUNTERS {
-    #   ULONGLONG ReadOperationCount;
-    #   ULONGLONG WriteOperationCount;
-    #   ULONGLONG OtherOperationCount;
-    #   ULONGLONG ReadTransferCount;
-    #   ULONGLONG WriteTransferCount;
-    #   ULONGLONG OtherTransferCount;
-    # } IO_COUNTERS, *PIO_COUNTERS;
-    #
-
-    class IoCounters < FFI::Struct
-      layout :ReadOperationCount,  :ulong_long,
-             :WriteOperationCount, :ulong_long,
-             :OtherOperationCount, :ulong_long,
-             :ReadTransferCount,   :ulong_long,
-             :WriteTransferCount,  :ulong_long,
-             :OtherTransferCount,  :ulong_long
-    end
-    #
-    # typedef struct _JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
-    #   JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
-    #   IO_COUNTERS                       IoInfo;
-    #   SIZE_T                            ProcessMemoryLimit;
-    #   SIZE_T                            JobMemoryLimit;
-    #   SIZE_T                            PeakProcessMemoryUsed;
-    #   SIZE_T                            PeakJobMemoryUsed;
-    # } JOBOBJECT_EXTENDED_LIMIT_INFORMATION, *PJOBOBJECT_EXTENDED_LIMIT_INFORMATION;
-    #
-
-    class JobObjectExtendedLimitInformation < FFI::Struct
-      layout :BasicLimitInformation, JobObjectBasicLimitInformation,
-             :IoInfo,                IoCounters,
-             :ProcessMemoryLimit,    :size_t,
-             :JobMemoryLimit,        :size_t,
-             :PeakProcessMemoryUsed, :size_t,
-             :PeakJobMemoryUsed,     :size_t
-    end
-
-
-  end # Windows
+module ChildProcess
+  module Windows
+    # typedef struct _STARTUPINFO {
+    #   DWORD  cb;
+    #   LPTSTR lpReserved;
+    #   LPTSTR lpDesktop;
+    #   LPTSTR lpTitle;
+    #   DWORD  dwX;
+    #   DWORD  dwY;
+    #   DWORD  dwXSize;
+    #   DWORD  dwYSize;
+    #   DWORD  dwXCountChars;
+    #   DWORD  dwYCountChars;
+    #   DWORD  dwFillAttribute;
+    #   DWORD  dwFlags;
+    #   WORD   wShowWindow;
+    #   WORD   cbReserved2;
+    #   LPBYTE lpReserved2;
+    #   HANDLE hStdInput;
+    #   HANDLE hStdOutput;
+    #   HANDLE hStdError;
+    # } STARTUPINFO, *LPSTARTUPINFO;
+
+    class StartupInfo < FFI::Struct
+      layout :cb,               :ulong,
+             :lpReserved,       :pointer,
+             :lpDesktop,        :pointer,
+             :lpTitle,          :pointer,
+             :dwX,              :ulong,
+             :dwY,              :ulong,
+             :dwXSize,          :ulong,
+             :dwYSize,          :ulong,
+             :dwXCountChars,    :ulong,
+             :dwYCountChars,    :ulong,
+             :dwFillAttribute,  :ulong,
+             :dwFlags,          :ulong,
+             :wShowWindow,      :ushort,
+             :cbReserved2,      :ushort,
+             :lpReserved2,      :pointer,
+             :hStdInput,        :pointer, # void ptr
+             :hStdOutput,       :pointer, # void ptr
+             :hStdError,        :pointer # void ptr
+    end
+
+    #
+    # typedef struct _PROCESS_INFORMATION {
+    #   HANDLE hProcess;
+    #   HANDLE hThread;
+    #   DWORD  dwProcessId;
+    #   DWORD  dwThreadId;
+    # } PROCESS_INFORMATION, *LPPROCESS_INFORMATION;
+    #
+
+    class ProcessInfo < FFI::Struct
+      layout :hProcess,    :pointer, # void ptr
+             :hThread,     :pointer, # void ptr
+             :dwProcessId, :ulong,
+             :dwThreadId,  :ulong
+    end
+
+    #
+    # typedef struct _SECURITY_ATTRIBUTES {
+    #   DWORD  nLength;
+    #   LPVOID lpSecurityDescriptor;
+    #   BOOL   bInheritHandle;
+    # } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
+    #
+
+    class SecurityAttributes < FFI::Struct
+      layout :nLength,              :ulong,
+             :lpSecurityDescriptor, :pointer, # void ptr
+             :bInheritHandle,       :int
+
+      def initialize(opts = {})
+        super()
+
+        self[:nLength]              = self.class.size
+        self[:lpSecurityDescriptor] = nil
+        self[:bInheritHandle]       = opts[:inherit] ? 1 : 0
+      end
+    end
+
+    #
+    # typedef struct _JOBOBJECT_BASIC_LIMIT_INFORMATION {
+    #   LARGE_INTEGER PerProcessUserTimeLimit;
+    #   LARGE_INTEGER PerJobUserTimeLimit;
+    #   DWORD         LimitFlags;
+    #   SIZE_T        MinimumWorkingSetSize;
+    #   SIZE_T        MaximumWorkingSetSize;
+    #   DWORD         ActiveProcessLimit;
+    #   ULONG_PTR     Affinity;
+    #   DWORD         PriorityClass;
+    #   DWORD         SchedulingClass;
+    # } JOBOBJECT_BASIC_LIMIT_INFORMATION, *PJOBOBJECT_BASIC_LIMIT_INFORMATION;
+    #
+    class JobObjectBasicLimitInformation < FFI::Struct
+      layout :PerProcessUserTimeLimit, :int64,
+             :PerJobUserTimeLimit,     :int64,
+             :LimitFlags,              :ulong,
+             :MinimumWorkingSetSize,   :size_t,
+             :MaximumWorkingSetSize,   :size_t,
+             :ActiveProcessLimit,      :ulong,
+             :Affinity,                :pointer,
+             :PriorityClass,           :ulong,
+             :SchedulingClass,         :ulong
+    end
+
+    #
+    # typedef struct _IO_COUNTERS {
+    #   ULONGLONG ReadOperationCount;
+    #   ULONGLONG WriteOperationCount;
+    #   ULONGLONG OtherOperationCount;
+    #   ULONGLONG ReadTransferCount;
+    #   ULONGLONG WriteTransferCount;
+    #   ULONGLONG OtherTransferCount;
+    # } IO_COUNTERS, *PIO_COUNTERS;
+    #
+
+    class IoCounters < FFI::Struct
+      layout :ReadOperationCount,  :ulong_long,
+             :WriteOperationCount, :ulong_long,
+             :OtherOperationCount, :ulong_long,
+             :ReadTransferCount,   :ulong_long,
+             :WriteTransferCount,  :ulong_long,
+             :OtherTransferCount,  :ulong_long
+    end
+    #
+    # typedef struct _JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
+    #   JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
+    #   IO_COUNTERS                       IoInfo;
+    #   SIZE_T                            ProcessMemoryLimit;
+    #   SIZE_T                            JobMemoryLimit;
+    #   SIZE_T                            PeakProcessMemoryUsed;
+    #   SIZE_T                            PeakJobMemoryUsed;
+    # } JOBOBJECT_EXTENDED_LIMIT_INFORMATION, *PJOBOBJECT_EXTENDED_LIMIT_INFORMATION;
+    #
+
+    class JobObjectExtendedLimitInformation < FFI::Struct
+      layout :BasicLimitInformation, JobObjectBasicLimitInformation,
+             :IoInfo,                IoCounters,
+             :ProcessMemoryLimit,    :size_t,
+             :JobMemoryLimit,        :size_t,
+             :PeakProcessMemoryUsed, :size_t,
+             :PeakJobMemoryUsed,     :size_t
+    end
+
+
+  end # Windows
 end # ChildProcess

data/spec/abstract_io_spec.rb

@@ -1,12 +1,12 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-describe ChildProcess::AbstractIO do
-  let(:io) { ChildProcess::AbstractIO.new }
-
-  it "inherits the parent's IO streams" do
-    io.inherit!
-
-    expect(io.stdout).to eq STDOUT
-    expect(io.stderr).to eq STDERR
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+describe ChildProcess::AbstractIO do
+  let(:io) { ChildProcess::AbstractIO.new }
+
+  it "inherits the parent's IO streams" do
+    io.inherit!
+
+    expect(io.stdout).to eq STDOUT
+    expect(io.stderr).to eq STDERR
+  end
+end

data/spec/childprocess_spec.rb

@@ -1,391 +1,447 @@
-# encoding: utf-8
-
-require File.expand_path('../spec_helper', __FILE__)
-require 'rubygems/mock_gem_ui'
-
-
-describe ChildProcess do
-
-  here = File.dirname(__FILE__)
-
-  let(:gemspec) { eval(File.read "#{here}/../childprocess.gemspec") }
-
-  it 'validates cleanly' do
-    mock_ui = Gem::MockGemUi.new
-    Gem::DefaultUserInteraction.use_ui(mock_ui) { gemspec.validate }
-
-    expect(mock_ui.error).to_not match(/warn/i)
-  end
-
-
-  it "returns self when started" do
-    process = sleeping_ruby
-
-    expect(process.start).to eq process
-    expect(process).to be_alive
-  end
-
-  # We can't detect failure to execve() when using posix_spawn() on Linux
-  # without waiting for the child to exit with code 127.
-  #
-  # See e.g. http://repo.or.cz/w/glibc.git/blob/669704fd:/sysdeps/posix/spawni.c#l34
-  #
-  # We could work around this by doing the PATH search ourselves, but not sure
-  # it's worth it.
-  it "raises ChildProcess::LaunchError if the process can't be started", :posix_spawn_on_linux => false do
-    expect { invalid_process.start }.to raise_error(ChildProcess::LaunchError)
-  end
-
-  it 'raises ArgumentError if given a non-string argument' do
-    expect { ChildProcess.build(nil, "unlikelytoexist") }.to raise_error(ArgumentError)
-    expect { ChildProcess.build("foo", 1) }.to raise_error(ArgumentError)
-  end
-
-  it "knows if the process crashed" do
-    process = exit_with(1).start
-    process.wait
-
-    expect(process).to be_crashed
-  end
-
-  it "knows if the process didn't crash" do
-    process = exit_with(0).start
-    process.wait
-
-    expect(process).to_not be_crashed
-  end
-
-  it "can wait for a process to finish" do
-    process = exit_with(0).start
-    return_value = process.wait
-
-    expect(process).to_not be_alive
-    expect(return_value).to eq 0
-  end
-
-  it 'ignores #wait if process already finished' do
-    process = exit_with(0).start
-    sleep 0.01 until process.exited?
-
-    expect(process.wait).to eql 0
-  end
-
-  it "escalates if TERM is ignored" do
-    process = ignored('TERM').start
-    process.stop
-    expect(process).to be_exited
-  end
-
-  it "accepts a timeout argument to #stop" do
-    process = sleeping_ruby.start
-    process.stop(exit_timeout)
-  end
-
-  it "lets child process inherit the environment of the current process" do
-    Tempfile.open("env-spec") do |file|
-      with_env('INHERITED' => 'yes') do
-        process = write_env(file.path).start
-        process.wait
-      end
-
-      child_env = eval rewind_and_read(file)
-      expect(child_env['INHERITED']).to eql 'yes'
-    end
-  end
-
-  it "can override env vars only for the current process" do
-    Tempfile.open("env-spec") do |file|
-      process = write_env(file.path)
-      process.environment['CHILD_ONLY'] = '1'
-      process.start
-
-      expect(ENV['CHILD_ONLY']).to be_nil
-
-      process.wait
-
-      child_env = eval rewind_and_read(file)
-      expect(child_env['CHILD_ONLY']).to eql '1'
-    end
-  end
-
-  it "inherits the parent's env vars also when some are overridden" do
-    Tempfile.open("env-spec") do |file|
-      with_env('INHERITED' => 'yes', 'CHILD_ONLY' => 'no') do
-        process = write_env(file.path)
-        process.environment['CHILD_ONLY'] = 'yes'
-
-        process.start
-        process.wait
-
-        child_env = eval rewind_and_read(file)
-
-        expect(child_env['INHERITED']).to eq 'yes'
-        expect(child_env['CHILD_ONLY']).to eq 'yes'
-      end
-    end
-  end
-
-  it "can unset env vars" do
-    Tempfile.open("env-spec") do |file|
-      ENV['CHILDPROCESS_UNSET'] = '1'
-      process = write_env(file.path)
-      process.environment['CHILDPROCESS_UNSET'] = nil
-      process.start
-
-      process.wait
-
-      child_env = eval rewind_and_read(file)
-      expect(child_env).to_not have_key('CHILDPROCESS_UNSET')
-    end
-  end
-
-  it 'does not see env vars unset in parent' do
-    Tempfile.open('env-spec') do |file|
-      ENV['CHILDPROCESS_UNSET'] = nil
-      process = write_env(file.path)
-      process.start
-
-      process.wait
-
-      child_env = eval rewind_and_read(file)
-      expect(child_env).to_not have_key('CHILDPROCESS_UNSET')
-    end
-  end
-
-
-  it "passes arguments to the child" do
-    args = ["foo", "bar"]
-
-    Tempfile.open("argv-spec") do |file|
-      process = write_argv(file.path, *args).start
-      process.wait
-
-      expect(rewind_and_read(file)).to eql args.inspect
-    end
-  end
-
-  it "lets a detached child live on" do
-    p_pid = nil
-    c_pid = nil
-
-    Tempfile.open('grandparent_out') do |gp_file|
-      # Create a parent and detached child process that will spit out their PID. Make sure that the child process lasts longer than the parent.
-      p_process = ruby("require 'childprocess' ; c_process = ChildProcess.build('ruby', '-e', 'puts \\\"Child PID: \#{Process.pid}\\\" ; sleep 5') ; c_process.io.inherit! ; c_process.detach = true ;  c_process.start ; puts \"Child PID: \#{c_process.pid}\" ; puts \"Parent PID: \#{Process.pid}\"")
-      p_process.io.stdout = p_process.io.stderr = gp_file
-
-      # Let the parent process die
-      p_process.start
-      p_process.wait
-
-
-      # Gather parent and child PIDs
-      pids = rewind_and_read(gp_file).split("\n")
-      pids.collect! { |pid| pid[/\d+/].to_i }
-      c_pid, p_pid = pids
-    end
-
-    # Check that the parent process has dies but the child process is still alive
-    expect(alive?(p_pid)).to_not be true
-    expect(alive?(c_pid)).to be true
-  end
-
-  it "preserves Dir.pwd in the child" do
-    Tempfile.open("dir-spec-out") do |file|
-      process = ruby("print Dir.pwd")
-      process.io.stdout = process.io.stderr = file
-
-      expected_dir = nil
-      Dir.chdir(Dir.tmpdir) do
-        expected_dir = Dir.pwd
-        process.start
-      end
-
-      process.wait
-
-      expect(rewind_and_read(file)).to eq expected_dir
-    end
-  end
-
-  it "can handle whitespace, special characters and quotes in arguments" do
-    args = ["foo bar", 'foo\bar', "'i-am-quoted'", '"i am double quoted"']
-
-    Tempfile.open("argv-spec") do |file|
-      process = write_argv(file.path, *args).start
-      process.wait
-
-      expect(rewind_and_read(file)).to eq args.inspect
-    end
-  end
-
-  it 'handles whitespace in the executable name' do
-    path = File.expand_path('foo bar')
-
-    with_executable_at(path) do |proc|
-      expect(proc.start).to eq proc
-      expect(proc).to be_alive
-    end
-  end
-
-  it "times out when polling for exit" do
-    process = sleeping_ruby.start
-    expect { process.poll_for_exit(0.1) }.to raise_error(ChildProcess::TimeoutError)
-  end
-
-  it "can change working directory" do
-    process = ruby "print Dir.pwd"
-
-    with_tmpdir { |dir|
-      process.cwd = dir
-
-      orig_pwd = Dir.pwd
-
-      Tempfile.open('cwd') do |file|
-        process.io.stdout = file
-
-        process.start
-        process.wait
-
-        expect(rewind_and_read(file)).to eq dir
-      end
-
-      expect(Dir.pwd).to eq orig_pwd
-    }
-  end
-
-  it 'kills the full process tree', :process_builder => false do
-    Tempfile.open('kill-process-tree') do |file|
-      process = write_pid_in_sleepy_grand_child(file.path)
-      process.leader = true
-      process.start
-
-      pid = wait_until(30) do
-        Integer(rewind_and_read(file)) rescue nil
-      end
-
-      process.stop
-      wait_until(3) { expect(alive?(pid)).to eql(false) }
-    end
-  end
-
-  it 'releases the GIL while waiting for the process' do
-    time = Time.now
-    threads = []
-
-    threads << Thread.new { sleeping_ruby(1).start.wait }
-    threads << Thread.new(time) { expect(Time.now - time).to be < 0.5 }
-
-    threads.each { |t| t.join }
-  end
-
-  it 'can check if a detached child is alive' do
-    proc = ruby_process("-e", "sleep")
-    proc.detach = true
-
-    proc.start
-
-    expect(proc).to be_alive
-    proc.stop(0)
-
-    expect(proc).to be_exited
-  end
-
-
-  it 'has a logger' do
-    expect(ChildProcess).to respond_to(:logger)
-  end
-
-  it 'can change its logger' do
-    expect(ChildProcess).to respond_to(:logger=)
-
-    original_logger = ChildProcess.logger
-    begin
-      ChildProcess.logger = :some_other_logger
-      expect(ChildProcess.logger).to eq(:some_other_logger)
-    ensure
-      ChildProcess.logger = original_logger
-    end
-  end
-
-
-  describe 'logger' do
-
-    before(:each) do
-      ChildProcess.logger = logger
-    end
-
-    after(:all) do
-      ChildProcess.logger = nil
-    end
-
-
-    context 'with the default logger' do
-
-      let(:logger) { nil }
-
-
-      it 'logs at INFO level by default' do
-        expect(ChildProcess.logger.level).to eq(Logger::INFO)
-      end
-
-      it 'logs at DEBUG level by default if $DEBUG is on' do
-        original_debug = $DEBUG
-
-        begin
-          $DEBUG = true
-
-          expect(ChildProcess.logger.level).to eq(Logger::DEBUG)
-        ensure
-          $DEBUG = original_debug
-        end
-      end
-
-      it "logs to stderr by default" do
-        cap = capture_std { generate_log_messages }
-
-        expect(cap.stdout).to be_empty
-        expect(cap.stderr).to_not be_empty
-      end
-
-    end
-
-    context 'with a custom logger' do
-
-      let(:logger) { Logger.new($stdout) }
-
-      it "logs to configured logger" do
-        cap = capture_std { generate_log_messages }
-
-        expect(cap.stdout).to_not be_empty
-        expect(cap.stderr).to be_empty
-      end
-
-    end
-
-  end
-
-  describe '#started?' do
-    subject { process.started? }
-
-    context 'when not started' do
-      let(:process) { sleeping_ruby(1) }
-
-      it { is_expected.to be false }
-    end
-
-    context 'when started' do
-      let(:process) { sleeping_ruby(1).start }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when finished' do
-      before(:each) { process.wait }
-
-      let(:process) { sleeping_ruby(0).start }
-
-      it { is_expected.to be true }
-    end
-
-  end
-
-end
+# encoding: utf-8
+
+require File.expand_path('../spec_helper', __FILE__)
+require 'rubygems/mock_gem_ui'
+
+
+describe ChildProcess do
+
+  here = File.dirname(__FILE__)
+
+  let(:gemspec) { eval(File.read "#{here}/../childprocess.gemspec") }
+
+  it 'validates cleanly' do
+    mock_ui = Gem::MockGemUi.new
+    Gem::DefaultUserInteraction.use_ui(mock_ui) { gemspec.validate }
+
+    expect(mock_ui.error).to_not match(/warn/i)
+  end
+
+
+  it "returns self when started" do
+    process = sleeping_ruby
+
+    expect(process.start).to eq process
+    expect(process).to be_alive
+  end
+
+  # We can't detect failure to execve() when using posix_spawn() on Linux
+  # without waiting for the child to exit with code 127.
+  #
+  # See e.g. http://repo.or.cz/w/glibc.git/blob/669704fd:/sysdeps/posix/spawni.c#l34
+  #
+  # We could work around this by doing the PATH search ourselves, but not sure
+  # it's worth it.
+  it "raises ChildProcess::LaunchError if the process can't be started", :posix_spawn_on_linux => false do
+    expect { invalid_process.start }.to raise_error(ChildProcess::LaunchError)
+  end
+
+  it 'raises ArgumentError if given a non-string argument' do
+    expect { ChildProcess.build(nil, "unlikelytoexist") }.to raise_error(ArgumentError)
+    expect { ChildProcess.build("foo", 1) }.to raise_error(ArgumentError)
+  end
+
+  it "knows if the process crashed" do
+    process = exit_with(1).start
+    process.wait
+
+    expect(process).to be_crashed
+  end
+
+  it "knows if the process didn't crash" do
+    process = exit_with(0).start
+    process.wait
+
+    expect(process).to_not be_crashed
+  end
+
+  it "can wait for a process to finish" do
+    process = exit_with(0).start
+    return_value = process.wait
+
+    expect(process).to_not be_alive
+    expect(return_value).to eq 0
+  end
+
+  it 'ignores #wait if process already finished' do
+    process = exit_with(0).start
+    sleep 0.01 until process.exited?
+
+    expect(process.wait).to eql 0
+  end
+
+  it "escalates if TERM is ignored" do
+    process = ignored('TERM').start
+    process.stop
+    expect(process).to be_exited
+  end
+
+  it "accepts a timeout argument to #stop" do
+    process = sleeping_ruby.start
+    process.stop(exit_timeout)
+  end
+
+  it "lets child process inherit the environment of the current process" do
+    Tempfile.open("env-spec") do |file|
+      file.close
+      with_env('INHERITED' => 'yes') do
+        process = write_env(file.path).start
+        process.wait
+      end
+
+      file.open
+      child_env = eval rewind_and_read(file)
+      expect(child_env['INHERITED']).to eql 'yes'
+    end
+  end
+
+  it "can override env vars only for the current process" do
+    Tempfile.open("env-spec") do |file|
+      file.close
+      process = write_env(file.path)
+      process.environment['CHILD_ONLY'] = '1'
+      process.start
+
+      expect(ENV['CHILD_ONLY']).to be_nil
+
+      process.wait
+
+      file.open
+      child_env = eval rewind_and_read(file)
+      expect(child_env['CHILD_ONLY']).to eql '1'
+    end
+  end
+
+  it 'allows unicode characters in the environment' do
+    Tempfile.open("env-spec") do |file|
+      file.close
+      process = write_env(file.path)
+      process.environment['FOö'] = 'baör'
+      process.start
+      process.wait
+
+      file.open
+      child_env = eval rewind_and_read(file)
+
+      expect(child_env['FOö']).to eql 'baör'
+    end
+  end
+
+  it "inherits the parent's env vars also when some are overridden" do
+    Tempfile.open("env-spec") do |file|
+      file.close
+      with_env('INHERITED' => 'yes', 'CHILD_ONLY' => 'no') do
+        process = write_env(file.path)
+        process.environment['CHILD_ONLY'] = 'yes'
+
+        process.start
+        process.wait
+
+        file.open
+        child_env = eval rewind_and_read(file)
+
+        expect(child_env['INHERITED']).to eq 'yes'
+        expect(child_env['CHILD_ONLY']).to eq 'yes'
+      end
+    end
+  end
+
+  it "can unset env vars" do
+    Tempfile.open("env-spec") do |file|
+      file.close
+      ENV['CHILDPROCESS_UNSET'] = '1'
+      process = write_env(file.path)
+      process.environment['CHILDPROCESS_UNSET'] = nil
+      process.start
+
+      process.wait
+
+      file.open
+      child_env = eval rewind_and_read(file)
+      expect(child_env).to_not have_key('CHILDPROCESS_UNSET')
+    end
+  end
+
+  it 'does not see env vars unset in parent' do
+    Tempfile.open('env-spec') do |file|
+      file.close
+      ENV['CHILDPROCESS_UNSET'] = nil
+      process = write_env(file.path)
+      process.start
+
+      process.wait
+
+      file.open
+      child_env = eval rewind_and_read(file)
+      expect(child_env).to_not have_key('CHILDPROCESS_UNSET')
+    end
+  end
+
+
+  it "passes arguments to the child" do
+    args = ["foo", "bar"]
+
+    Tempfile.open("argv-spec") do |file|
+      process = write_argv(file.path, *args).start
+      process.wait
+
+      expect(rewind_and_read(file)).to eql args.inspect
+    end
+  end
+
+  it "lets a detached child live on" do
+    p_pid = nil
+    c_pid = nil
+
+    Tempfile.open('grandparent_out') do |gp_file|
+      # Create a parent and detached child process that will spit out their PID. Make sure that the child process lasts longer than the parent.
+      p_process = ruby("require 'childprocess' ; c_process = ChildProcess.build('ruby', '-e', 'puts \\\"Child PID: \#{Process.pid}\\\" ; sleep 5') ; c_process.io.inherit! ; c_process.detach = true ;  c_process.start ; puts \"Child PID: \#{c_process.pid}\" ; puts \"Parent PID: \#{Process.pid}\"")
+      p_process.io.stdout = p_process.io.stderr = gp_file
+
+      # Let the parent process die
+      p_process.start
+      p_process.wait
+
+
+      # Gather parent and child PIDs
+      pids = rewind_and_read(gp_file).split("\n")
+      pids.collect! { |pid| pid[/\d+/].to_i }
+      c_pid, p_pid = pids
+    end
+
+    # Check that the parent process has dies but the child process is still alive
+    expect(alive?(p_pid)).to_not be true
+    expect(alive?(c_pid)).to be true
+  end
+
+  it "preserves Dir.pwd in the child" do
+    Tempfile.open("dir-spec-out") do |file|
+      process = ruby("print Dir.pwd")
+      process.io.stdout = process.io.stderr = file
+
+      expected_dir = nil
+      Dir.chdir(Dir.tmpdir) do
+        expected_dir = Dir.pwd
+        process.start
+      end
+
+      process.wait
+
+      expect(rewind_and_read(file)).to eq expected_dir
+    end
+  end
+
+  it "can handle whitespace, special characters and quotes in arguments" do
+    args = ["foo bar", 'foo\bar', "'i-am-quoted'", '"i am double quoted"']
+
+    Tempfile.open("argv-spec") do |file|
+      process = write_argv(file.path, *args).start
+      process.wait
+
+      expect(rewind_and_read(file)).to eq args.inspect
+    end
+  end
+
+  it 'handles whitespace in the executable name' do
+    path = File.expand_path('foo bar')
+
+    with_executable_at(path) do |proc|
+      expect(proc.start).to eq proc
+      expect(proc).to be_alive
+    end
+  end
+
+  it "times out when polling for exit" do
+    process = sleeping_ruby.start
+    expect { process.poll_for_exit(0.1) }.to raise_error(ChildProcess::TimeoutError)
+  end
+
+  it "can change working directory" do
+    process = ruby "print Dir.pwd"
+
+    with_tmpdir { |dir|
+      process.cwd = dir
+
+      orig_pwd = Dir.pwd
+
+      Tempfile.open('cwd') do |file|
+        process.io.stdout = file
+
+        process.start
+        process.wait
+
+        expect(rewind_and_read(file)).to eq dir
+      end
+
+      expect(Dir.pwd).to eq orig_pwd
+    }
+  end
+
+  it 'kills the full process tree', :process_builder => false do
+    Tempfile.open('kill-process-tree') do |file|
+      process = write_pid_in_sleepy_grand_child(file.path)
+      process.leader = true
+      process.start
+
+      pid = wait_until(30) do
+        Integer(rewind_and_read(file)) rescue nil
+      end
+
+      process.stop
+      wait_until(3) { expect(alive?(pid)).to eql(false) }
+    end
+  end
+
+  it 'releases the GIL while waiting for the process' do
+    time = Time.now
+    threads = []
+
+    threads << Thread.new { sleeping_ruby(1).start.wait }
+    threads << Thread.new(time) { expect(Time.now - time).to be < 0.5 }
+
+    threads.each { |t| t.join }
+  end
+
+  it 'can check if a detached child is alive' do
+    proc = ruby_process("-e", "sleep")
+    proc.detach = true
+
+    proc.start
+
+    expect(proc).to be_alive
+    proc.stop(0)
+
+    expect(proc).to be_exited
+  end
+
+  describe 'OS detection' do
+
+    before(:all) do
+      # Save off original OS so that it can be restored later
+      @original_host_os = RbConfig::CONFIG['host_os']
+    end
+
+    after(:each) do
+      # Restore things to the real OS instead of the fake test OS
+      RbConfig::CONFIG['host_os'] = @original_host_os
+      ChildProcess.instance_variable_set(:@os, nil)
+    end
+
+
+    # TODO: add tests for other OSs
+    context 'on a BSD system' do
+
+      let(:bsd_patterns) { ['bsd', 'dragonfly'] }
+
+      it 'correctly identifies BSD systems' do
+        bsd_patterns.each do |pattern|
+          RbConfig::CONFIG['host_os'] = pattern
+          ChildProcess.instance_variable_set(:@os, nil)
+
+          expect(ChildProcess.os).to eq(:bsd)
+        end
+      end
+
+    end
+
+  end
+
+  it 'has a logger' do
+    expect(ChildProcess).to respond_to(:logger)
+  end
+
+  it 'can change its logger' do
+    expect(ChildProcess).to respond_to(:logger=)
+
+    original_logger = ChildProcess.logger
+    begin
+      ChildProcess.logger = :some_other_logger
+      expect(ChildProcess.logger).to eq(:some_other_logger)
+    ensure
+      ChildProcess.logger = original_logger
+    end
+  end
+
+
+  describe 'logger' do
+
+    before(:each) do
+      ChildProcess.logger = logger
+    end
+
+    after(:all) do
+      ChildProcess.logger = nil
+    end
+
+
+    context 'with the default logger' do
+
+      let(:logger) { nil }
+
+
+      it 'logs at INFO level by default' do
+        expect(ChildProcess.logger.level).to eq(Logger::INFO)
+      end
+
+      it 'logs at DEBUG level by default if $DEBUG is on' do
+        original_debug = $DEBUG
+
+        begin
+          $DEBUG = true
+
+          expect(ChildProcess.logger.level).to eq(Logger::DEBUG)
+        ensure
+          $DEBUG = original_debug
+        end
+      end
+
+      it "logs to stderr by default" do
+        cap = capture_std { generate_log_messages }
+
+        expect(cap.stdout).to be_empty
+        expect(cap.stderr).to_not be_empty
+      end
+
+    end
+
+    context 'with a custom logger' do
+
+      let(:logger) { Logger.new($stdout) }
+
+      it "logs to configured logger" do
+        cap = capture_std { generate_log_messages }
+
+        expect(cap.stdout).to_not be_empty
+        expect(cap.stderr).to be_empty
+      end
+
+    end
+
+  end
+
+  describe '#started?' do
+    subject { process.started? }
+
+    context 'when not started' do
+      let(:process) { sleeping_ruby(1) }
+
+      it { is_expected.to be false }
+    end
+
+    context 'when started' do
+      let(:process) { sleeping_ruby(1).start }
+
+      it { is_expected.to be true }
+    end
+
+    context 'when finished' do
+      before(:each) { process.wait }
+
+      let(:process) { sleeping_ruby(0).start }
+
+      it { is_expected.to be true }
+    end
+
+  end
+
+end