albino 1.2.3 → 1.3.0

data/albino.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'albino'
-  s.version           = '1.2.3'
-  s.date              = '2011-01-12'
+  s.version           = '1.3.0'
+  s.date              = '2011-03-03'
   s.rubyforge_project = 'albino'
 
   ## Make sure your summary is short. The description may be as long
@@ -33,6 +33,7 @@ Gem::Specification.new do |s|
   ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
   s.require_paths = %w[lib]
 
+  s.add_dependency('posix-spawn')
   s.add_development_dependency('mocha')
 
   ## Leave this section as-is. It will be automatically generated from the
@@ -45,9 +46,10 @@ Gem::Specification.new do |s|
     Rakefile
     albino.gemspec
     lib/albino.rb
-    lib/albino/process.rb
+    lib/albino/multi.rb
     test/albino_test.rb
-    test/process_test.rb
+    test/multi_albino_test.rb
+    vendor/multipygmentize
   ]
   # = MANIFEST =
 

data/lib/albino.rb

@@ -1,4 +1,5 @@
-require 'albino/process'
+require 'posix-spawn'
+
 ##
 # Wrapper for the Pygments command line tool, pygmentize.
 #
@@ -44,8 +45,9 @@ require 'albino/process'
 #
 class Albino
   class ShellArgumentError < ArgumentError; end
+  include POSIX::Spawn
 
-  VERSION = '1.2.3'
+  VERSION = '1.3.0'
 
   class << self
     attr_accessor :bin, :default_encoding, :timeout_threshold
@@ -69,7 +71,7 @@ class Albino
     proc_options[:timeout] = options.delete(:timeout) || self.class.timeout_threshold
     command = convert_options(options)
     command.unshift(bin)
-    Process.new(command, env={}, proc_options.merge(:input => write_target))
+    Child.new(*(command + [proc_options.merge(:input => write_target)]))
   end
 
   def colorize(options = {})

data/lib/albino/multi.rb

@@ -0,0 +1,98 @@
+require 'posix-spawn'
+
+class Albino
+  if !const_defined?(:ShellArgumentError)
+    class ShellArgumentError < ArgumentError; end
+  end
+
+  # Wrapper for a custom multipygmentize script.  Passes multiple code
+  # fragments in STDIN to Python.  This assumes both Python and pygments are
+  # installed.
+  #
+  # Use like so:
+  #
+  #   @syntaxer = Albino::Multi.new([ [:ruby, File.open("/some/file.rb")] ])
+  #   puts @syntaxer.colorize
+  #
+  # It takes an Array of two-element arrays [lexer, code].
+  #
+  # You can also use Albino::Multi as a drop-in replacement.  It currently has
+  # a few limitations however:
+  #
+  # * Only the HTML output format is supported.
+  # * UTF-8 encoding is forced.
+  #
+  # The default lexer is 'text'.  You need to specify a lexer yourself;
+  # because we are using STDIN there is no auto-detect.
+  #
+  # To see all lexers and formatters available, run `pygmentize -L`.
+  class Multi
+    include POSIX::Spawn
+
+    class << self
+      attr_accessor :bin, :timeout_threshold
+    end
+
+    self.timeout_threshold = 10
+    self.bin = File.join(File.dirname(__FILE__), *%w(.. .. vendor multipygmentize))
+
+    # Initializes a new Albino::Multi and runs #colorize.
+    def self.colorize(*args)
+      new(*args).colorize
+    end
+
+    # This method accepts two forms of input:
+    #
+    # DEFAULT
+    #
+    # target - The Array of two-element [lexer, code] Arrays:
+    #          lexer - The String lexer for the upcoming block of code.
+    #          code  - The String block of code to highlight.
+    #
+    # LEGACY
+    #
+    # target - The String block of code to highlight.
+    # lexer  - The String lexer for the block of code.
+    #
+    # Albino#initialize also takes format and encoding which are ignored.
+    def initialize(target, lexer = :text, *args)
+      @spec = case target
+        when Array
+          @multi = true
+          target
+        else
+          [[lexer, target]]
+      end
+    end
+
+    # Colorizes the code blocks.
+    #
+    # options - Specify options for the child process:
+    #           timeout - A Fixnum timeout for the child process.
+    #
+    # Returns an Array of HTML highlighted code block Strings if an array of
+    # targets are given to #initialize, or just a single HTML highlighted code
+    # block String.
+    def colorize(options = {})
+      options[:timeout] ||= self.class.timeout_threshold
+      options[:input]     = @spec.inject([]) do |memo, (lexer, code)|
+        memo << lexer << SEPARATOR
+
+        if code.respond_to?(:read)
+          out = code.read
+          code.close
+          code = out
+        end
+
+        memo << code << SEPARATOR
+      end.join("")
+      child  = Child.new(self.class.bin, options)
+      pieces = child.out.split(SEPARATOR)
+      @multi ? pieces : pieces.first
+    end
+
+    alias_method :to_s, :colorize
+
+    SEPARATOR = "\000".freeze
+  end
+end

data/test/albino_test.rb

@@ -1,5 +1,5 @@
-require 'albino'
 require 'rubygems'
+require 'albino'
 require 'test/unit'
 require 'tempfile'
 require 'mocha'
@@ -25,7 +25,8 @@ class AlbinoTest < Test::Unit::TestCase
 
   def test_works_with_strings
     syntaxer = Albino.new("class New\nend", :ruby)
-    assert_match %r(highlight), syntaxer.colorize
+    assert_match %r(highlight), code=syntaxer.colorize
+    assert_match %(<span class="nc">New</span>\n), code
   end
 
   def test_works_with_files
@@ -55,4 +56,4 @@ class AlbinoTest < Test::Unit::TestCase
       @syntaxer.convert_options(:l => "'abc;'")
     end
   end
-end
+end

data/test/multi_albino_test.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'albino/multi'
+require 'test/unit'
+require 'tempfile'
+require 'mocha'
+
+class MultiTest < Test::Unit::TestCase
+  def setup
+    @syntaxer = Albino::Multi.new(File.new(__FILE__), :ruby)
+  end
+
+  def test_defaults_to_text
+    syntaxer = Albino::Multi.new('abc')
+    regex    = /span/
+    assert_no_match regex, syntaxer.colorize
+  end
+
+  def test_works_with_strings
+    syntaxer = Albino::Multi.new("class New\nend", :ruby)
+    assert_match %r(highlight), code=syntaxer.colorize
+    assert_match %(<span class="nc">New</span>\n), code
+  end
+
+  def test_works_with_multiple_code_fragments
+    syntaxer = Albino::Multi.new [
+      ['ruby', "class New\nend"],
+      ['python', "class New:\n  pass"]]
+    codes = syntaxer.colorize
+    assert_equal 2, codes.size
+    assert_match %r(highlight), codes[0]
+    assert_match %r(highlight), codes[1]
+    assert_match %(<span class="nc">New</span>\n), codes[0]
+    assert_match %(<span class="p">:</span>),      codes[1]
+  end
+
+  def test_works_with_files
+    contents = "class New\nend"
+    syntaxer = Albino::Multi.new(contents, :ruby)
+    file_output = syntaxer.colorize
+
+    Tempfile.open 'albino-test' do |tmp|
+      tmp << contents
+      tmp.flush
+      syntaxer = Albino::Multi.new(File.new(tmp.path), :ruby)
+      assert_equal file_output, syntaxer.colorize
+    end
+  end
+
+  def test_aliases_to_s
+    syntaxer = Albino::Multi.new(File.new(__FILE__), :ruby)
+    assert_equal @syntaxer.colorize, syntaxer.to_s
+  end
+
+  def test_class_method_colorize
+    assert_equal @syntaxer.colorize, Albino::Multi.colorize(File.new(__FILE__), :ruby)
+  end
+end
+

data/vendor/multipygmentize

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+
+# This script allows you to highlight multiple chunks of code with a single
+# invocation. Expected input is on STDIN and takes the form of:
+#
+#   <lexer>\000<code>\000<lexer>\000<code>...
+#
+# where <lexer> is the shortname of a Pygments lexer and <code> is the source
+# code to be highlighted. Each lexer and code pair is separated with a NULL
+# byte and pairs of lexer/code are also separated with NULL bytes.
+#
+# Output is a list of highlighted code blocks separated by NULL bytes in the
+# same order in which they were received.
+
+import sys, os, codecs
+
+sys.stdout = codecs.getwriter('UTF-8')(sys.stdout)
+
+vpath = os.path.realpath(__file__).split("/")
+vpath.pop()
+vpath.pop()
+vpath = "/".join(vpath)
+
+from pygments import highlight
+from pygments.lexers import get_lexer_by_name
+from pygments.formatters import HtmlFormatter
+
+parts = sys.stdin.read().split("\000")
+newparts = []
+
+for i in range(len(parts) / 2):
+    lang = parts[i * 2]
+    code = parts[i * 2 + 1]
+    try:
+        lexer = get_lexer_by_name(lang)
+    except:
+        lexer = get_lexer_by_name('text')
+    newparts.append([code, lexer])
+
+def hl(spec):
+    code = spec[0]
+    lexer = spec[1]
+    try:
+        return highlight(code, lexer, HtmlFormatter())
+    except:
+        lexer = get_lexer_by_name('text')
+        return highlight(code, lexer, HtmlFormatter())
+
+for spec in newparts:
+    sys.stdout.write(hl(spec))
+    sys.stdout.write("\000")
+

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: albino
 version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: false
   segments: 
   - 1
-  - 2
   - 3
-  version: 1.2.3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Chris Wanstrath
@@ -14,21 +15,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-12 00:00:00 -08:00
+date: 2011-03-03 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: mocha
+  name: posix-spawn
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
-  type: :development
+  type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: Ruby wrapper for pygmentize.
 email: chris@wanstrath.com
 executables: []
@@ -43,9 +60,10 @@ files:
 - Rakefile
 - albino.gemspec
 - lib/albino.rb
-- lib/albino/process.rb
+- lib/albino/multi.rb
 - test/albino_test.rb
-- test/process_test.rb
+- test/multi_albino_test.rb
+- vendor/multipygmentize
 has_rdoc: true
 homepage: http://github.com/github/albino
 licenses: []
@@ -56,23 +74,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: albino
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 2
 summary: Ruby wrapper for pygmentize.

data/lib/albino/process.rb

@@ -1,294 +0,0 @@
-class Albino
-  # Albino::Process includes logic for executing child processes and
-  # reading/writing from their standard input, output, and error streams.
-  #
-  # Create an run a process to completion:
-  #
-  #   >> process = Albino::Process.new(['git', '--help'])
-  #
-  # Retrieve stdout or stderr output:
-  #
-  #   >> process.out
-  #   => "usage: git [--version] [--exec-path[=GIT_EXEC_PATH]]\n ..."
-  #   >> process.err
-  #   => ""
-  #
-  # Check process exit status information:
-  #
-  #   >> process.status
-  #   => #<Process::Status: pid=80718,exited(0)>
-  #
-  # Albino::Process is designed to take all input in a single string and
-  # provides all output as single strings. It is therefore not well suited
-  # to streaming large quantities of data in and out of commands.
-  #
-  # Q: Why not use popen3 or hand-roll fork/exec code?
-  #
-  # - 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's more portable than hand rolled pipe, fork, exec code because
-  #   fork(2) and exec(2) aren't available on all platforms. In those cases,
-  #   Albino::Process falls back to using whatever janky substitutes the platform
-  #   provides.
-  #
-  # - It handles all max pipe buffer hang cases, which is non trivial to
-  #   implement correctly and must be accounted for with either popen3 or
-  #   hand rolled fork/exec code.
-  class Process
-    # Create and execute a new process.
-    #
-    # argv    - Array of [command, arg1, ...] strings to use as the new
-    #           process's argv. When argv is a String, the shell is used
-    #           to interpret the command.
-    # env     - The new process's environment variables. This is merged with
-    #           the current environment as if by ENV.merge(env).
-    # options - Additional options:
-    #             :input   => str to write str to the process's stdin.
-    #             :timeout => int number of seconds before we given up.
-    #             :max     => total number of output bytes
-    #           A subset of Process:spawn options are also supported on all
-    #           platforms:
-    #             :chdir => str to start the process in different working dir.
-    #
-    # Returns a new Process instance that has already executed to completion.
-    # The out, err, and status attributes are immediately available.
-    def initialize(argv, env={}, options={})
-      @argv = argv
-      @env = env
-
-      @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!
-      # when argv is a string, use /bin/sh to interpret command
-      argv = @argv
-      argv = ['/bin/sh', '-c', argv.to_str] if argv.respond_to?(:to_str)
-
-      # 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
-    end
-
-    # Exception raised when the total number of bytes output on the command's
-    # stderr and stdout streams exceeds the maximum output size (:max option).
-    class MaximumOutputExceeded < StandardError
-    end
-
-    # Exception raised when timeout is exceeded.
-    class TimeoutExceeded < StandardError
-    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
-
-    # Spawn a child process, perform IO redirection and environment prep, and
-    # return the running process's pid.
-    #
-    # This method implements a limited subset of Ruby 1.9's Process::spawn.
-    # The idea is that we can just use that when available, since most platforms
-    # will eventually build in special (and hopefully good) support for it.
-    #
-    #   env     - Hash of { name => val } environment variables set in the child
-    #             process.
-    #   argv    - New process's argv as an Array. When this value is a string,
-    #             the command may be run through the system /bin/sh or
-    #   options - Supports a subset of Process::spawn options, including:
-    #             :chdir => str to change the directory to str in the child
-    #                 FD => :close to close a file descriptor in the child
-    #                :in => FD to redirect child's stdin to FD
-    #               :out => FD to redirect child's stdout to FD
-    #               :err => FD to redirect child's stderr to FD
-    #
-    # Returns the pid of the new process as an integer. The process exit status
-    # must be obtained using Process::waitpid.
-    def spawn(env, *argv)
-      options = (argv.pop if argv[-1].kind_of?(Hash)) || {}
-      fork do
-        # { fd => :close } in options means close that fd
-        options.each { |k,v| k.close if v == :close && !k.closed? }
-
-        # reopen stdin, stdout, and stderr on provided fds
-        STDIN.reopen(options[:in])
-        STDOUT.reopen(options[:out])
-        STDERR.reopen(options[:err])
-
-        # setup child environment
-        env.each { |k, v| ENV[k] = v }
-
-        # { :chdir => '/' } in options means change into that dir
-        ::Dir.chdir(options[:chdir]) if options[:chdir]
-
-        # do the deed
-        ::Kernel::exec(*argv)
-        exit! 1
-      end
-    end
-
-    # Start a process with spawn options and return
-    # popen4([env], command, arg1, arg2, [opt])
-    #
-    #   env     - The child process's environment as a Hash.
-    #   command - The command and zero or more arguments.
-    #   options - An options hash.
-    #
-    # See Ruby 1.9 IO.popen and Process::spawn docs for more info:
-    # http://www.ruby-doc.org/core-1.9/classes/IO.html#M001640
-    #
-    # Returns a [pid, stdin, stderr, stdout] tuple where pid is the child
-    # process's pid, stdin is a writeable IO object, and stdout + stderr are
-    # readable IO objects.
-    def popen4(*argv)
-      # create some pipes (see pipe(2) manual -- the ruby docs suck)
-      ird, iwr = IO.pipe
-      ord, owr = IO.pipe
-      erd, ewr = IO.pipe
-
-      # spawn the child process with either end of pipes hooked together
-      opts =
-        ((argv.pop if argv[-1].is_a?(Hash)) || {}).merge(
-          # redirect fds        # close other sides
-          :in  => ird,          iwr  => :close,
-          :out => owr,          ord  => :close,
-          :err => ewr,          erd  => :close
-        )
-      pid = spawn(*(argv + [opts]))
-
-      [pid, iwr, ord, erd]
-    ensure
-      # we're in the parent, close child-side fds
-      [ird, owr, ewr].each { |fd| fd.close }
-    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
-
-    # Use native Process::spawn implementation on Ruby 1.9.
-    if ::Process.respond_to?(:spawn)
-      def spawn(*argv)
-        ::Process.spawn(*argv)
-      end
-    end
-  end
-end

data/test/process_test.rb

@@ -1,102 +0,0 @@
-require 'albino'
-require 'rubygems'
-require 'test/unit'
-
-class TestProcess < Test::Unit::TestCase
-  def test_argv_array_execs
-    p = Albino::Process.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 = Albino::Process.new("echo via /bin/sh")
-    assert p.success?
-    assert_equal "via /bin/sh\n", p.out
-  end
-
-  def test_stdout
-    p = Albino::Process.new(['echo', 'boom'])
-    assert_equal "boom\n", p.out
-    assert_equal "", p.err
-  end
-
-  def test_stderr
-    p = Albino::Process.new('echo boom 1>&2')
-    assert_equal "", p.out
-    assert_equal "boom\n", p.err
-  end
-
-  def test_status
-    p = Albino::Process.new('exit 3')
-    assert !p.status.success?
-    assert_equal 3, p.status.exitstatus
-  end
-
-  def test_env
-    p = Albino::Process.new('echo $FOO', { 'FOO' => 'BOOYAH' })
-    assert_equal "BOOYAH\n", p.out
-  end
-
-  def test_chdir
-    p = Albino::Process.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 = Albino::Process.new(['wc', '-l'], {}, :input => input)
-    assert_equal 100_000, p.out.strip.to_i
-  end
-
-  def test_max
-    assert_raise Albino::Process::MaximumOutputExceeded do
-      Albino::Process.new(['yes'], {}, :max => 100_000)
-    end
-  end
-
-  def test_max_with_child_hierarchy
-    assert_raise Albino::Process::MaximumOutputExceeded do
-      Albino::Process.new(['/bin/sh', '-c', 'yes'], {}, :max => 100_000)
-    end
-  end
-
-  def test_max_with_stubborn_child
-    assert_raise Albino::Process::MaximumOutputExceeded do
-      Albino::Process.new("trap '' TERM; yes", {}, :max => 100_000)
-    end
-  end
-
-  def test_timeout
-    assert_raise Albino::Process::TimeoutExceeded do
-      Albino::Process.new(['sleep 1'], {}, :timeout => 0.05)
-    end
-  end
-
-  def test_timeout_with_child_hierarchy
-    assert_raise Albino::Process::TimeoutExceeded do
-      Albino::Process.new(['/bin/sh', '-c', 'yes'], {}, :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 = Albino::Process.new(['/bin/sh', '-c', 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 = Albino::Process.new(['false'], {}, :input => input)
-    assert !p.success?
-  end
-end