rb8-trepanning 0.1.3

data/test/example/classes.rb

@@ -0,0 +1,11 @@
+class Mine
+  def initialize
+    @myvar = 'init'
+  end
+  def mymethod(a, b=5, &block)
+  end
+  def self.classmeth
+  end
+end
+me = Mine.new
+metoo = Mine(new)

data/test/example/dollar-0.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# A test to see that rdebug set's $0 properly.
+puts $0
+puts __FILE__
+

data/test/example/except-bug1.rb

@@ -0,0 +1,4 @@
+def foo(n)
+  1/0
+end
+foo(5)

data/test/example/except-bug2.rb

@@ -0,0 +1,7 @@
+begin
+   exit
+   sleep 20
+rescue SystemExit
+   printf("Exception caught\n")
+end
+puts "You can't debug here"

data/test/example/file with space.rb

@@ -0,0 +1 @@
+puts 'Ha!'

data/test/example/gcd.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+# GCD. We assume positive numbers
+def gcd(a, b)
+  # Make: a <= b
+  if a > b
+    a, b = [b, a]
+  end
+
+  return nil if a <= 0
+
+  if a == 1 or b-a == 0
+    return a
+  end
+  return gcd(b-a, a)
+end
+
+gcd(3,5)

data/test/example/info-var-bug.rb

@@ -0,0 +1,47 @@
+class Lousy_inspect
+  attr_accessor :var
+  def inspect    # An unhelpful inspect
+    throw "Foo"  # Raises an exception
+  end
+  def initialize
+    @var = 'initialized'
+  end
+end
+class Lousy_inspect_and_to_s
+  attr_accessor :var
+  def inspect    # An unhelpful inspect
+    throw "Foo"  # Raises an exception
+  end
+  def to_s       # An unhelpful to_s
+    throw "bar"  # Raises an exception
+  end
+  def initialize
+    @var = 'initialized'  # Something to inspect
+  end
+end
+
+# Something that will be passed objects with
+# bad inspect or to_s methods
+class UnsuspectingClass
+  @@Const = 'A constant'
+  @@var = 'a class variable'
+  def initialize(a)
+    @a = a      # "info locals" will try to use
+                # inspect or to_s here
+    @b = 5
+  end
+end
+def test_Lousy_inspect
+  x = Lousy_inspect.new
+  return x
+end
+def test_lousy_inspect_and_to_s
+  x = Lousy_inspect_and_to_s.new
+  return x
+end
+x = test_Lousy_inspect
+y = test_lousy_inspect_and_to_s
+UnsuspectingClass.new(10)
+UnsuspectingClass.new(x)
+UnsuspectingClass.new(y)
+y = 2

data/test/example/info-var-bug2.rb

@@ -0,0 +1,2 @@
+s = '<%= PRODUCT[:name] %>'
+y = 0

data/test/example/null.rb

@@ -0,0 +1 @@
+# Nothing here. Move along.

data/test/example/pm-bug.rb

@@ -0,0 +1,3 @@
+a = 1
+@x = 2
+raise

data/test/example/pm.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# Test Debugger.catchpoint and post-mortem handling
+def zero_div
+  x = 5
+  1/0
+end
+x = 2
+zero_div
+raise RuntimeError
+x = 3
+

data/test/example/raise.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+raise ZeroDivisionError

data/test/integration/.gitignore

@@ -0,0 +1,4 @@
+
+/*.out
+/*~
+/.ruby_inline

data/test/integration/config.yaml

@@ -0,0 +1,8 @@
+# Do not commit personal changes here back to the repository. Create
+# config.private.yaml which, if exists, is preferred to this one.
+
+# either should be on the $PATH or use full path
+ruby: ruby
+
+# possibility to specify interpreter parameters
+#ruby_params: -w

data/test/integration/helper.rb

@@ -0,0 +1,154 @@
+# Some common routines used in testing.
+require 'test/unit'
+require 'fileutils'
+require 'yaml'
+# require 'diff/lcs'
+# require 'diff/lcs/hunk'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+module TestHelper
+
+  module_function
+  def common_setup(file, testname=nil)
+    @srcdir   = File.dirname(file)
+    @testname = testname || File.basename(file, '.rb').split(/-/)[1]
+    @script   = File.join(%W(.. data #{@testname}.cmd))
+    @prefix   = "--script #{@script} --nx --basename -- "
+  end
+
+  # FIXME: turn args into a hash.
+  def run_debugger(testname, args='', outfile=nil, filter=nil, old_code=false,
+                   debug_pgm='tdebug.rb', rightfile=nil)
+    rightfile ||= File.join(%W(.. data #{testname}.right))
+    
+    outfile = "#{testname}.out" unless outfile
+
+    if File.exists?(outfile)
+      FileUtils.rm(outfile)
+    end
+    
+    ENV['TREPAN8'] = debug_pgm
+    ENV['TERM']   = ''
+
+    # The EMACS environment variable(s) cause output to 
+    # get prefaced with null which will mess up file compares.
+    # So turn off EMACS output processing.
+    ENV['EMACS'] = ENV['INSIDE_EMACS'] = nil
+
+    cmd = "#{load_ruby} #{load_params} " + 
+      "../../bin/trepan8 #{args} >#{outfile}"
+    puts "'#{cmd}'" if $DEBUG
+    output = `#{cmd}`
+    
+    got_lines     = File.read(outfile).split(/\n/)
+    correct_lines = File.read(rightfile).split(/\n/)
+    filter.call(got_lines, correct_lines) if filter
+    if cheap_diff(got_lines, correct_lines)
+      FileUtils.rm(outfile)
+      return true
+    end
+    return false
+  end
+
+  def cheap_diff(got_lines, correct_lines)
+    if $DEBUG
+      got_lines.each_with_index do |line, i|
+        printf "%3d %s\n", i+1, line
+      end
+    end
+    correct_lines.each_with_index do |line, i|
+      correct_lines[i].chomp!
+      if got_lines[i] != correct_lines[i]
+        puts "difference found at line #{i+1}"
+        puts "got : #{got_lines[i]}"
+        puts "need: #{correct_lines[i]}"
+        return false
+      end
+    end
+    if correct_lines.size != got_lines.size
+      puts("difference in number of lines: " + 
+           "#{correct_lines.size} vs. #{got_lines.size}")
+      return false
+    end
+    return true
+  end
+
+  # FIXME: using this causes the same test to get run several times 
+  # and some tests fail probably because of a lack of environment isolation.
+  # Many tests follow a basic pattern: run the debugger with a given
+  # debugger script and compare output produced. The following creates
+  # this kind of test.
+  def add_test(base_name, src_dir, script_name=nil, cmd=nil, test_name=nil)
+    puts "+++ Adding #{base_name} ++++" if $DEBUG
+    test_name   = File.join('.', 'example', base_name) unless test_name
+    script_name = File.join(%W(.. data ../#{test_name}.cmd)) unless script_name
+    p script_name
+    cmd         = 'gcd.rb 3 5' unless cmd
+    eval <<-EOF
+    def test_#{test_name}
+      Dir.chdir(\"#{src_dir}\") do 
+        assert_equal(true, 
+                     run_debugger(\"#{base_name}\", 
+                                  \"--script #{script_name} -- #{cmd}\"))
+      end
+    end
+    EOF
+  end
+  module_function :add_test
+               
+  # Adapted from the Ruby Cookbook, Section 6.10: Comparing two files.
+  # def diff_as_string(rightfile, checkfile, format=:unified, context_lines=3)
+  #   right_data = File.read(rightfile)
+  #   check_data = File.read(checkfile)
+  #   output = ''
+  #   diffs = Diff::LCS.diff(right_data, check_data)
+  #   return output if diffs.empty?
+  #   oldhunk = hunk = nil
+  #   file_length_difference = 0
+  #   diffs.each do |piece|
+  #     begin
+  #       hunk = Diff::LCS::Hunk.new(right_data, check_data, piece, 
+  #                                  context_lines, file_length_difference)
+  #       next unless oldhunk
+  #
+  #       # Hunks may overlap, which is why we need to be careful when our
+  #       # diff includes lines of context. Otherwise, we might print
+  #       # redundant lines.
+  #       if (context_lines > 0) and hunk.overlaps?(oldhunk)
+  #         hunk.unshift(oldhunk)
+  #         else
+  #         output << oldhunk.diff(format)
+  #       end
+  #     ensure
+  #       oldhunk = hunk
+  #       output << '\n'
+  #     end
+  #   end
+  
+  #   # Handle the last remaining hunk 
+  #   output << oldhunk.diff(format) << '\n'
+  # end
+  
+  # Loads key from the _config_._yaml_ file.
+  def config_load(key, may_be_nil=false, default_value='')
+    conf = File.join('config.private.yaml') # try private first
+    conf = File.join('config.yaml') unless File.exists?(conf)
+    value = YAML.load_file(conf)[key]
+    assert_not_nil(value, "#{key} is set in config.yaml") unless may_be_nil
+    value || default_value
+  end
+  module_function :config_load
+
+  def load_ruby
+    config_load('ruby', true)
+  end
+  module_function :load_ruby
+
+  def load_params
+    config_load('ruby_params', true)
+  end
+  module_function :load_params
+end
+

data/test/integration/test-break_bad.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+# require_relative '../../lib/trepanning'
+require_relative 'helper'
+
+# Test (mostly) invalid breakpoint commands
+class TestBadBreak < Test::Unit::TestCase
+  include TestHelper
+  def test_basic
+    common_setup(__FILE__)
+    Dir.chdir(@srcdir) do 
+      assert_equal(true, 
+                   run_debugger(@testname, @prefix + '../example/gcd.rb 3 5'))
+    end
+  end
+  
+  def test_break_loop
+    common_setup(__FILE__, 'break_loop_bug')
+    Dir.chdir(@srcdir) do 
+      assert_equal(true, 
+                   run_debugger(@testname, @prefix + 
+                                '../example/bp_loop_issue.rb'))
+    end
+  end
+
+end

data/test/integration/test-dollar-0.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+# require_relative '../../lib/trepanning'
+require_relative 'helper'
+
+# Test --no-stop and $0 setting.
+class TestDollar0 < Test::Unit::TestCase
+  include TestHelper
+  def test_basic
+    common_setup(__FILE__)
+    Dir.chdir(@srcdir) do 
+      home_save = ENV['HOME']
+      ENV['HOME'] = '.'
+      filter = Proc.new{|got_lines, correct_lines|
+        [got_lines, correct_lines].flatten.each do |s|
+          s.gsub!(/.*dollar-0.rb$/, 'dollar-0.rb')
+        end
+      }
+
+      @prefix = '--nx --basename --no-stop '
+      %w(dollar-0 dollar-0a dollar-0b).each do |testname|
+        assert_equal(true, 
+                     run_debugger(testname,
+                                  @prefix + 
+                                  File.join(%w(.. example dollar-0.rb)),
+                                  nil, filter, false, '../bin/trepan8'))
+      end
+      ENV['HOME'] = home_save
+    end
+  end
+end

data/test/integration/test-edit.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+# require_relative '../../lib/trepanning'
+require_relative 'helper'
+
+# Test 'edit' command handling.
+class TestEdit < Test::Unit::TestCase
+  include TestHelper
+  def test_basic
+    common_setup(__FILE__)
+    Dir.chdir(@srcdir) do 
+      ENV['EDITOR']='echo FAKE-EDITOR '
+      assert_equal(true,  
+                   run_debugger(@testname, @prefix + '../example/gcd.rb 3 5'))
+    end
+  end
+end

data/test/integration/test-file-with-space.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+# require_relative '../../lib/trepanning'
+require_relative 'helper'
+
+# Test Running a program wiht an embedded space
+class TestFileWithSpace < Test::Unit::TestCase
+  include TestHelper
+
+  def test_basic
+    testname='file-with-space'
+    common_setup(__FILE__)
+    Dir.chdir(@srcdir) do 
+      script = File.join(%W(.. data #{testname}.cmd))
+#       filter = Proc.new{|got_lines, correct_lines|
+#         [got_lines[0], correct_lines[0]].each do |s|
+#           s.sub!(/tdebug.rb:\d+/, 'rdebug:999')
+#         end
+#       }
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} --nx --basename -- " +
+                                "'../example/file with space.rb'"))
+    end
+  end
+end

data/test/integration/test-printvar.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+# require_relative '../../lib/trepanning'
+require_relative 'helper'
+
+# Test printing (evaluation) of variables
+class TestPrintVar < Test::Unit::TestCase
+  include TestHelper
+  # Test commands in stepping.rb
+  def test_basic
+    common_setup(__FILE__)
+    Dir.chdir(@srcdir) do 
+      assert_equal(true, 
+                   run_debugger(@testname, @prefix + '../example/gcd.rb 3 5'))
+    end
+  end
+end

data/test/integration/test-raise.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+# require_relative '../../lib/trepanning'
+require_relative 'helper'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test Debugger.load handles uncaught exceptions in the debugged program.
+class TestRaise < Test::Unit::TestCase
+  include TestHelper
+  def test_basic
+    skip "We get a SEGV here on an unpatched 1.9.2" if 
+      RUBY_VERSION =~ /1.9/
+    common_setup(__FILE__)
+    Dir.chdir(@srcdir) do 
+      assert_equal(true, 
+                   run_debugger(@testname, @prefix + '../example/raise.rb'))
+    end
+  end
+end