expectr 0.9.1 → 1.0.0

data/lib/expectr.rb

@@ -1,290 +1,287 @@
-# = expectr.rb
-#
-#  Copyright (c) Chris Wuest <chris@chriswuest.com>
-#  Expectr is freely distributable under the terms of an MIT-style license.
-#  See COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-begin
-	require 'pty'
-rescue LoadError
-	require 'popen4'
-end
-
+require 'pty'
 require 'timeout'
 require 'thread'
 
-# Fixes specifically for Ruby 1.8
-if RUBY_VERSION =~ /^1.8/
-	# Enforcing encoding is not needed in 1.8 (probably.)  So, we'll define
-	# String#encode! to do nothing, for interoperability.
-	class String #:nodoc:
-		def encode!(encoding)
-		end
-	end
-
-	# In Ruby 1.8, we want to ignore SIGCHLD.  This is for two reasons:
-	# * SIGCHLD will be sent (and cause exceptions) for every Expectr object
-	#   created
-	# * As John Carter documented in his RExpect library, calls to files which
-	#   do not exist can cause odd and unexpected behavior.
-	trap 'CHLD', Proc.new { nil }
-end
+require 'expectr/error'
 
-# == Description
-# Expectr is an implementation of the Expect library in ruby (see
-# http://expect.nist.gov).
+# Public: Expectr is an API to the functionality of Expect (see
+# http://expect.nist.gov) implemented in ruby.
 #
 # Expectr contrasts with Ruby's built-in Expect class by avoiding tying in
-# with IO and instead creating a new object entirely to allow for more
-# fine-grained control over the execution and display of the program being
+# with the IO class, instead creating a new object entirely to allow for more
+# grainular control over the execution and display of the program being
 # run.
 #
-# == Examples
-# === Simple task automation
-#
-# Connect via telnet to remote.example.com, run my_command, and return the
-# output
-#
-#   exp = Expectr.new "telnet remote.example.com"
-#   exp.expect "username:"
-#   exp.send "example\r"
-#   exp.expect "password:"
-#   exp.send "my_password\r"
-#   exp.expect "%"
-#   exp.send "my_command\r"
-#   exp.expect "%"
-#   exp.send "logout"
-#
-#   output = exp.discard
-#
-# === Interactive control
-# Silently connect via ssh to remote.example.com, log in automatically, then
-# relinquish control to the user.  Expect slow networking, so increase
-# timeout.
+# Examples
 #
-#   exp = Expectr.new "ssh remote.example.com", :timeout=>45, :flush_buffer=>false
+#   # SSH Login to another machine
+#   exp = Expectr.new('ssh user@example.com')
+#   exp.expect("Password:")
+#   exp.send('password')
+#   exp.interact!(blocking: true)
 #
-#   match = exp.expect /password|yes\/no/
-#   case match.to_s
-#     when /password/
-#       exp.send "my_password\r"
-#     when /yes\/no/
-#       exp.send "yes\r"
-#       exp.expect /password/
-#       exp.send "my_password\r"
-#     else
-#       puts "Cannot connect to remote.example.com!"
-#       die
+#   # See if a web server is running on the local host, react accordingly
+#   exp = Expectr.new('netstat -ntl|grep ":80 " && echo "WEB"', timeout: 1)
+#   if exp.expeect("WEB")
+#     # Do stuff if we see 'WEB' in the output
+#   else
+#     # Do other stuff
 #   end
-#
-#   exp.expect "$"
-#   exp.interact
-#
 class Expectr
-	# Amount of time in seconds a call to +expect+ may last (default 30)
-	attr_accessor :timeout
-	# Size of buffer in bytes to attempt to read in at once (default 8 KiB)
-	attr_accessor :buffer_size
-	# Whether to flush program output to STDOUT (default true)
-	attr_accessor :flush_buffer
-	# PID of running process
-	attr_reader :pid
-	# Active buffer to match against
-	attr_reader :buffer
-	# Buffer passed since last +expect+ match
-	attr_reader :discard
+  # Public: Gets/sets the number of seconds a call to Expectr#expect may last
+  attr_accessor :timeout
+  # Public: Gets/sets the number of bytes to use for the internal buffer
+  attr_accessor :buffer_size
+  # Public: Gets/sets whether to constrain the buffer to the buffer size
+  attr_accessor :constrain
+  # Public: Gets/sets whether to flush program output to STDOUT
+  attr_accessor :flush_buffer
+  # Public: Returns the PID of the running process
+  attr_reader :pid
+  # Public: Returns the active buffer to match against
+  attr_reader :buffer
+  # Public: Returns the buffer discarded by the latest call to Expectr#expect
+  attr_reader :discard
 
-	# 
-	# === Synopsis
-	#
-	#   Expectr.new(cmd, args)
-	#
-	# === Arguments
-	# +cmd+::
-	#   Command to be executed (String or File)
-	# +args+::
-	#   Hash of modifiers for Expectr.  Meaningful values are:
-	# * :buffer_size::
-	#   Amount of data to read at a time.  Default 8 KiB
-	# * :flush_buffer::
-	#   Flush buffer to STDOUT during execution?  Default true
-	# * :timeout::
-	#   Timeout in seconds for each +expect+ call.  Default 30
-	#
-	# === Description
-	#
-	# Spawn +cmd+ and attach to STDIN and STDOUT for new process.  Fall back
-	# to using Open4 if PTY is not present (this is the case on Windows
-	# implementations of ruby.
+  # Public: Initialize a new Expectr object.
+  # Spawns a sub-process and attaches to STDIN and STDOUT for the new process.
   #
-	def initialize(cmd, args={})
-		raise ArgumentError, "String or File expected, was given #{cmd.class}" unless cmd.kind_of? String or cmd.kind_of? File
-		cmd = cmd.path if cmd.kind_of? File
+  # cmd  - A String or File referencing the application to launch
+  # args - A Hash used to specify options for the new object (default: {}):
+  #        :timeout      - Number of seconds that a call to Expectr#expect has
+  #                        to complete (default: 30)
+  #        :flush_buffer - Whether to flush output of the process to the
+  #                        console (default: true)
+  #        :buffer_size  - Number of bytes to attempt to read from sub-process
+  #                        at a time.  If :constrain is true, this will be the
+  #                        maximum size of the internal buffer as well.
+  #                        (default: 8192)
+  #        :constrain    - Whether to constrain the internal buffer from the
+  #                        sub-process to :buffer_size (default: false)
+  def initialize(cmd, args={})
+    unless cmd.kind_of? String or cmd.kind_of? File
+     raise ArgumentError, "String or File expected"
+    end
+
+    cmd = cmd.path if cmd.kind_of? File
+
+    @buffer = ''.encode("UTF-8")
+    @discard = ''.encode("UTF-8")
+
+    @timeout = args[:timeout] || 30
+    @flush_buffer = args[:flush_buffer].nil? ? true : args[:flush_buffer]
+    @buffer_size = args[:buffer_size] || 8192
+    @constrain = args[:constrain] || false
+
+    @out_mutex = Mutex.new
+    @out_update = false
+    @interact = false
+
+    @stdout,@stdin,@pid = PTY.spawn(cmd)
+
+    Thread.new do
+      while @pid > 0
+        unless select([@stdout], nil, nil, @timeout).nil?
+          buf = ''.encode("UTF-8")
+
+          begin
+            @stdout.sysread(@buffer_size, buf)
+          rescue Errno::EIO #Application went away.
+            @pid = 0
+            break
+          end
+
+          print_buffer(buf)
 
-		args[0] = {} unless args[0]
-		@buffer = String.new
-		@discard = String.new
-		@timeout = args[:timeout] || 30
-		@flush_buffer = args[:flush_buffer].nil? ? true : args[:flush_buffer]
-		@buffer_size = args[:buffer_size] || 8192
-		@out_mutex = Mutex.new
-		@out_update = false
+          @out_mutex.synchronize do
+            @buffer << buf
+            if @buffer.length > @buffer_size && @constrain
+              @buffer = @buffer[-@buffer_size..-1]
+            end
+            @out_update = true
+          end
+        end
+      end
+    end
 
-		[@buffer, @discard].each {|x| x.encode! "UTF-8" }
+    Thread.new do
+      Process.wait @pid
+      @pid = 0
+    end
+  end
 
-		if defined? PTY
-			@stdout,@stdin,@pid = PTY.spawn cmd
-		else
-			cmd << " 2>&1" if cmd[/2\s*>/].nil?
-			@pid, @stdin, @stdout, stderr = Open4::popen4 cmd
-		end
+  # Public: Relinquish control of the running process to the controlling
+  # terminal, acting as a pass-through for the life of the process.  SIGINT
+  # will be caught and sent to the application as "\C-c".
+  #
+  # args - A Hash used to specify options to be used for interaction (default:
+  #        {}):
+  #        :flush_buffer - explicitly set @flush_buffer to the value specified
+  #        :blocking     - Whether to block on this call or allow code
+  #                        execution to continue (default: false)
+  #
+  # Returns the interaction Thread
+  def interact!(args = {})
+    raise ProcessError if @interact
 
-		Thread.new do
-			while @pid > 0
-				unless select([@stdout], nil, nil, @timeout).nil?
-					buf = ''
+    blocking = args[:blocking] || false
+    @flush_buffer = args[:flush_buffer].nil? ? true : args[:flush_buffer]
+    @interact = true
 
-					begin
-						@stdout.sysread(@buffer_size, buf)
-					rescue Errno::EIO #Application went away.
-						@pid = 0
-						break
-					end
+    # Save our old tty settings and set up our new environment
+    old_tty = `stty -g`
+    `stty -icanon min 1 time 0 -echo`
 
-					buf.encode! "UTF-8"
-					print_buffer buf
+    # SIGINT should be set along to the program
+    oldtrap = trap 'INT' do
+      send "\C-c"
+    end
+    
+    interact = Thread.new do
+      input = ''.encode("UTF-8")
+      while @pid > 0 && @interact
+        if select([STDIN], nil, nil, 1)
+          c = STDIN.getc.chr
+          send c unless c.nil?
+        end
+      end
 
-					@out_mutex.synchronize do
-						@buffer << buf
-						@out_update = true
-					end
-				end
-			end
-		end
+      trap 'INT', oldtrap
+      `stty #{old_tty}`
+      @interact = false
+    end
 
-		Thread.new do
-			Process.wait @pid
-			@pid = 0
-		end
-	end
+    blocking ? interact.join : interact
+  end
 
-	# 
-	# Clear output buffer
-	#
-	def clear_buffer
-		@out_mutex.synchronize do
-			@buffer = ''
-			@out_update = false
-		end
-	end
+  # Public: Report whether or not current Expectr object is in interact mode
+  #
+  # Returns true or false
+  def interact?
+    @interact
+  end
+
+  # Public: Cause the current Expectr object to drop out of interact mode
+  #
+  # Returns nothing.
+  def leave!
+    @interact=false
+  end
 
-	# 
-	# === Synopsis
-	#
-	#   Expectr#interact
-	# 
-	# === Description
-	#
-	# Relinquish control of the running process to the controlling terminal,
-	# acting simply as a pass-through for the life of the process.
-	#
-	# Interrupts should be caught and sent to the application.
-	#
-	def interact
-		oldtrap = trap 'INT' do
-				send "\C-c"
-		end
+  # Public: Kill the running process, raise ProcessError if the pid isn't > 1
+  #
+  # signal - Symbol, String, or Fixnum representing the signal to send to the
+  #          running process. (default: :TERM)
+  #
+  # Returns true if the process was successfully killed, false otherwise
+  def kill!(signal=:TERM)
+    raise ProcessError unless @pid > 0
+    (Process::kill(signal.to_sym, @pid) == 1)
+  end
 
-		@flush_buffer = true
-		old_tty = `stty -g`
-		`stty -icanon min 1 time 0 -echo`
-		
-		in_thread = Thread.new do
-			input = ''
-			while @pid > 0
-				if select([STDIN], nil, nil, 1)
-					send STDIN.getc.chr
-				end
-			end
-		end
+  # Public: Send input to the active process
+  #
+  # str - String to be sent to the active process
+  #
+  # Returns nothing.
+  # Raises Expectr::ProcessError if the process isn't running
+  def send(str)
+    begin
+      @stdin.syswrite str
+    rescue Errno::EIO #Application went away.
+      @pid = 0
+    end
+    raise Expectr::ProcessError unless @pid > 0
+  end
 
-		in_thread.join
-		trap 'INT', oldtrap
-		`stty #{old_tty}`
-		return nil
-	end
-	alias :interact! :interact
+  # Public: Wraps Expectr#send, appending a newline to the end of the string
+  #
+  # str - String to be sent to the active process (default: '')
+  #
+  # Returns nothing.
+  def puts(str = '')
+    send str + "\n"
+  end
 
-	#
-	# Send +str+ to application
-	#
-	def send(str)
-		begin
-			@stdin.syswrite str
-		rescue Errno::EIO #Application went away.
-			@pid = 0
-		end
-		raise ArgumentError unless @pid > 0
-	end
+  # Public: Begin a countdown and search for a given String or Regexp in the
+  # output buffer.
+  #
+  # pattern     - String or Regexp representing what we want to find
+  # recoverable - Denotes whether failing to match the pattern should cause the
+  #               method to raise an exception (default: false)
+  #
+  # Examples
+  #
+  #   exp.expect("this should exist")
+  #   # => MatchData
+  #
+  #   exp.expect("this should exist") do
+  #     # ...
+  #   end
+  #
+  #   exp.expect(/not there/)
+  #   # Raises Timeout::Error
+  #
+  #   exp.expect(/not there/, true)
+  #   # => nil
+  # 
+  # Returns a MatchData object once a match is found if no block is given
+  # Yields the MatchData object representing the match
+  # Raises TypeError if something other than a String or Regexp is given
+  # Raises Timeout::Error if a match isn't found in time, unless recoverable
+  def expect(pattern, recoverable = false)
+    match = nil
 
-	# 
-	# === Synopsis
-	#
-	#   Expectr#expect /regexp/, recoverable=false
-	#   Expectr#expect "String", recoverable=true
-	# 
-	# === Arguments
-	#
-	# +pattern+::
-	#   String or regexp to match against
-	# +recoverable+::
-	#   Determines if execution can continue after a timeout
-	#
-	# === Description
-	#
-	# Wait +timeout+ seconds to match +pattern+ in +buffer+.  If timeout is
-	# reached, raise an error unless +recoverable+ is true.
-	#
-	def expect(pattern, recoverable = false)
-		match = nil
+    case pattern
+    when String
+      pattern = Regexp.new(Regexp.quote(pattern))
+    when Regexp
+    else
+      raise TypeError, "Pattern class should be String or Regexp"
+    end
 
-		case pattern
-			when String
-				pattern = Regexp.new(Regexp.quote(pattern))
-			when Regexp
-			else raise TypeError, "Pattern class should be String or Regexp, passed: #{pattern.class}"
-		end
+    begin
+      Timeout::timeout(@timeout) do
+        while match.nil?
+          if @out_update
+            @out_mutex.synchronize do
+              match = pattern.match @buffer
+              @out_update = false
+            end
+          end
+          sleep 0.1
+        end
+      end
 
-		begin
-			Timeout::timeout(@timeout) do
-				while match.nil?
-					if @out_update
-						@out_mutex.synchronize do
-							match = pattern.match @buffer
-							@out_update = false
-						end
-					end
-					sleep 0.1
-				end
-			end
+      @out_mutex.synchronize do
+        @discard = @buffer[0..match.begin(0)-1]
+        @buffer = @buffer[match.end(0)..-1]
+        @out_update = true
+      end
+    rescue Timeout::Error => details
+      raise details unless recoverable
+    end
 
-			@out_mutex.synchronize do
-				@discard = @buffer[0..match.begin(0)-1]
-				@buffer = @buffer[match.end(0)..-1]
-				@out_update = true
-			end
-		rescue Timeout::Error => details
-			raise details unless recoverable
-		end
+    block_given? ? yield(match) : match
+  end
 
-		return match
-	end
+  # Public: Clear output buffer
+  #
+  # Returns nothing.
+  def clear_buffer!
+    @out_mutex.synchronize do
+      @buffer = ''.encode("UTF-8")
+      @out_update = false
+    end
+  end
 
-	#
-	# Print buffer to STDOUT only if +flush_buffer+ is true
-	#
-	def print_buffer(buf)
-		print buf if @flush_buffer
-		STDOUT.flush
-	end
+  # Internal: Print buffer to STDOUT if @flush_buffer is true
+  #
+  # buf - String to be printed to STDOUT
+  #
+  # Returns nothing.
+  def print_buffer(buf)
+    print buf if @flush_buffer
+    STDOUT.flush unless STDOUT.sync
+  end
 end

data/lib/expectr/error.rb

@@ -0,0 +1,5 @@
+class Expectr
+  # Public: Error to denote a problem with the running Process associated with
+  # the current Expectr object
+  class ProcessError < StandardError; end
+end

data/lib/expectr/version.rb

@@ -1,3 +1,3 @@
 class Expectr
-	VERSION = '0.9.1'
+  VERSION = '1.0.0'
 end

data/test/test_core.rb

@@ -0,0 +1,38 @@
+require 'helper'
+
+class CoreTests < Test::Unit::TestCase
+  # For the purpose of testing, we will assume we are working within a POSIX
+  # environment.
+  def setup
+    @exp = Expectr.new("ls /dev", :flush_buffer => false, :timeout => 1,
+                       :buffer_size => 4096)
+  end
+
+  def test_object_consistency
+    assert_equal false, @exp.flush_buffer
+    assert_equal 1, @exp.timeout
+    assert_equal 4096, @exp.buffer_size
+  end
+
+  # POSIX specifies /dev/console, /dev/null and /dev/tty must exist.
+  def test_match_sets_discard
+    assert_not_equal nil, @exp.expect(/null/)
+    assert_not_equal '', @exp.discard
+  end
+
+  def test_match_failure
+    assert_raises(Timeout::Error) { @exp.expect(/ThisFileShouldNotExist/) }
+    assert_nothing_raised { @exp.expect(/ThisFileShouldNotExist/, true) }
+  end
+
+  def test_clear_buffer
+    sleep 1
+    assert_not_equal @exp.buffer, ''
+    @exp.clear_buffer!
+    assert_equal '', @exp.buffer
+  end
+
+  def test_pid_set
+    assert @exp.pid > 0
+  end
+end

data/test/test_initialization.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class InitializationTests < Test::Unit::TestCase
+  def test_spawn_with_file
+    assert_nothing_raised { exp = Expectr.new(File.new("/bin/ls"), :flush_buffer => false) }
+  end
+
+  def test_spawn_with_string
+    assert_nothing_raised { exp = Expectr.new(File.new("/bin/ls"), :flush_buffer => false) }
+  end
+
+  # lib/expectr.rb's permissions should hopefully be set to 0644
+  def test_spawn_failures
+    assert_raises(Errno::ENOENT) { exp = Expectr.new("lib/ThisFileShouldNotExist", :flush_buffer => false) }
+    assert_raises(Errno::EACCES) { exp = Expectr.new("lib/expectr.rb", :flush_buffer => false) }
+  end
+end

data/test/test_interaction.rb

@@ -0,0 +1,114 @@
+require 'helper'
+
+class InteractionTest < Test::Unit::TestCase
+  # Assume that bc(1) exists on the system for these tests
+  def setup
+    @exp = Expectr.new("bc", :flush_buffer => false, :timeout => 1)
+  end
+
+  def test_send_and_expect
+    assert_nothing_raised do
+      @exp.send("300+21\n")
+      @exp.expect("321")
+      @exp.puts("quit")
+    end
+  end
+
+  def test_expect_with_block
+    assert_nothing_raised do
+      @exp.send("300+21\n")
+      @exp.expect("321") { |m| m.nil? ? raise(ArgumentError) : true }
+    end
+
+    assert_raises(TimeoutError) do
+      @exp.send("300+21\n")
+      @exp.expect("xxx") { |m| m.nil? ? raise(ArgumentError) : true }
+    end
+
+    assert_raises(ArgumentError) do
+      @exp.send("300+21\n")
+      @exp.expect("xxx", true) { |m| m.nil? ? raise(ArgumentError) : true }
+    end
+  end
+
+  def test_send_to_terminated_fails
+    @exp.send("quit\n")
+    sleep 2
+    assert_raises(Expectr::ProcessError) { @exp.send("test\n") }
+  end
+
+  def test_interact_sets_appropriate_flags
+    [
+      Thread.new {
+        assert_equal false, @exp.interact?
+
+        sleep 0.5
+        @exp.interact!.join
+      },
+      Thread.new {
+        sleep 1
+        assert_equal true, @exp.flush_buffer
+        assert_equal true, @exp.interact?
+
+        @exp.flush_buffer = false
+        @exp.send("quit\n")
+      }
+    ].each {|x| x.join}
+  end
+
+  def test_interact_mode
+    [
+      Thread.new {
+        sleep 0.5
+        @exp.interact!.join
+      },
+      Thread.new {
+        sleep 1
+        @exp.flush_buffer = false
+        @exp.send("300+21\n")
+        @exp.send("quit\n")
+      }
+    ].each {|x| x.join}
+
+    assert_not_nil @exp.expect(/321/)
+  end
+
+  def test_leaving_interact_mode
+    [
+      Thread.new {
+        sleep 0.5
+        @exp.interact!.join
+      },
+      Thread.new {
+        sleep 1
+        @exp.flush_buffer = false
+        assert_nothing_raised { @exp.leave! }
+        assert_equal false, @exp.interact?
+        @exp.send("quit\n")
+      }
+    ].each {|x| x.join}
+  end
+
+  def test_blocking_interact_mode
+    [
+      Thread.new {
+        sleep 0.5
+        @exp.interact!(blocking: true)
+      },
+      Thread.new {
+        sleep 1
+        @exp.flush_buffer = false
+        @exp.send("300+21\n")
+        @exp.send("quit\n")
+      }
+    ].each {|x| x.join}
+
+    assert_not_nil @exp.expect(/321/)
+  end
+
+  def test_kill_process
+    assert_equal true, @exp.kill!
+    assert_equal 0, @exp.pid
+    assert_raises(Expectr::ProcessError) { @exp.send("test\n") }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expectr
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-19 00:00:00.000000000 Z
+date: 2012-10-30 00:00:00.000000000 Z
 dependencies: []
 description: Expectr is an interface to the functionality of Expect in Ruby
 email: chris@chriswuest.com
@@ -23,9 +23,12 @@ files:
 - Rakefile
 - expectr.gemspec
 - lib/expectr.rb
+- lib/expectr/error.rb
 - lib/expectr/version.rb
 - test/helper.rb
-- test/test_expectr.rb
+- test/test_core.rb
+- test/test_initialization.rb
+- test/test_interaction.rb
 homepage: http://github.com/cwuest/expectr
 licenses:
 - MIT
@@ -52,4 +55,6 @@ signing_key:
 specification_version: 3
 summary: Expect for Ruby
 test_files:
-- test/test_expectr.rb
+- test/test_core.rb
+- test/test_initialization.rb
+- test/test_interaction.rb

data/test/test_expectr.rb

@@ -1,81 +0,0 @@
-require 'helper'
-
-class TestExpectr < Test::Unit::TestCase
-	def setup
-		@exp = Expectr.new "ls /bin", :flush_buffer => false, :timeout => 2, :buffer_size => 4096
-	end
-
-	def test_execution
-		assert_equal @exp.flush_buffer, false
-		assert_equal @exp.timeout, 2
-		assert_equal @exp.buffer_size, 4096
-	end
-
-	def test_match
-		assert_not_equal @exp.expect(/sh/), nil
-		assert_not_equal @exp.discard, ''
-	end
-
-	def test_match_failure
-		assert_raises(Timeout::Error) { @exp.expect /ThisFileShouldNotExist/ }
-		assert_nothing_raised { @exp.expect /ThisFileShouldNotExist/, true }
-	end
-
-	def test_send
-		exp = Expectr.new "bc", :flush_buffer => false
-		exp.send "20+301\n"
-		exp.expect /321/
-	end
-
-	def test_send_to_terminated
-		exp = Expectr.new "ls", :flush_buffer => false
-		sleep 1
-		assert_raises(ArgumentError) { exp.send "test\n" }
-	end
-
-	def test_clear_buffer
-		sleep 1
-		assert_not_equal @exp.buffer, ''
-		@exp.clear_buffer
-		assert_equal @exp.buffer, ''
-	end
-
-	def test_pid_set
-		assert @exp.pid > 0
-	end
-
-	def test_interact
-		unless RUBY_VERSION =~ /1.8/
-			exp = Expectr.new "bc", :flush_buffer => false
-			[
-				Thread.new {
-					sleep 1
-					exp.interact
-				},
-				Thread.new {
-					sleep 2
-					assert_equal exp.flush_buffer, true
-					exp.flush_buffer = false
-					exp.send "300+21\n"
-					exp.send "quit\n"
-				}
-			].each {|x| x.join}
-
-			assert_not_nil exp.expect /321/
-		end
-	end
-
-	def test_create_with_file
-		assert_nothing_raised { exp = Expectr.new File.new("/bin/ls"), :flush_buffer => false }
-	end
-
-	def test_executable
-		assert_nothing_raised { exp = Expectr.new "/bin/ls", :flush_buffer => false }
-
-		# Ruby 1.8's PTY allows execution of non-executable/nonexistent files without complaint
-		unless RUBY_VERSION =~ /1.8/
-			assert_raises(Errno::ENOENT) { exp = Expectr.new "/bin/ThisFileShouldNotExist", :flush_buffer => false }
-			assert_raises(Errno::EACCES) { exp = Expectr.new "lib/expectr.rb", :flush_buffer => false }
-		end
-	end
-end