rbx-trepanning 0.0.2-universal-rubinius-1.2

data/test/functional/test-tbreak.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestTBreak < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def foo
+    a = 3
+    b = 4
+    c = 5
+    d = 6
+  end
+
+  def test_basic
+    # Check that temporary breaks are, well, temporary.
+    # The last "continue" below isn't used. It to make sure we finish
+    # the test even when the breakpoint isn't temporary.
+    cmds = ['tbreak TestTBreak#foo', 'continue', 'continue', 'continue'] 
+    d = strarray_setup(cmds)
+    d.start
+    ##############################
+    2.times do 
+      foo
+    end
+    ##############################
+    d.stop # ({:remove => true})
+    out = ['-- ',
+           '2.times do ',
+           'Set temporary breakpoint 1: foo.rb:55 (@3)',
+           "x1 ",
+           'a = 3'
+          ]
+    compare_output(out, d, cmds)
+  end
+
+end
+
+

data/test/integration/file-diff.rb

@@ -0,0 +1,89 @@
+require 'rubygems'
+require 'diff/lcs'
+
+# Consider turning this into 'diff/lcs/file' or some such thing.
+
+module DiffFile
+  def find_next(sdiff, i)
+    i += 1 while i < sdiff.size && sdiff[i].action == '='
+    return i
+  end
+  
+  def find_pos(sdiff, i)
+    i += 1 while i < sdiff.size && sdiff[i].action != '='
+    return sdiff[i].old_position, sdiff[i].new_position
+  end
+
+  # Unix style context diff using files. 
+  def diff_file(from_file, to_file, context=3)
+    seq1       = File.open(from_file).readlines
+    from_mtime = File.stat(from_file).mtime
+    seq2       = File.open(to_file).readlines
+    to_mtime   = File.stat(to_file).mtime
+    sdiff = Diff::LCS.sdiff(seq1, seq2)
+    diff_lines(seq1, seq2, from_file, to_file, from_mtime, 
+               to_mtime, context)
+  end
+
+  # Unix style context diff with file/line stat info passed in.
+
+  # There may be some imprecision in position stuff here and there's a
+  # bug when context ranges overlap.
+
+  # FIXME: consider turning into an enumerator.
+  def diff_lines(seq1, seq2, from_file, to_file, 
+                 from_mtime, to_mtime, context=3)
+    sdiff = Diff::LCS.sdiff(seq1, seq2)
+    # PP.pp sdiff
+    # puts '-' * 40
+    started = false
+    result = []
+    i = 0
+    n = -(context+1)
+    while true do
+      i = find_next(sdiff, i)
+      break if i >= sdiff.size
+      if n < i-context
+        if started
+          result << '***************'
+        else
+          result << "*** #{from_file}\t#{from_mtime}"
+          result << "--- #{to_file}\t#{to_mtime}"
+          started = true
+        end
+        result << '*** %d,%d ****' % find_pos(sdiff, i)
+        context.downto(1) do |j|
+          result << ' ' + sdiff[i-j].new_element.chomp
+        end
+      end
+      i += 1
+      while i < sdiff.size && (action = sdiff[i-1].action) != '='
+        element = 
+          if action == '+'  
+            sdiff[i-1].new_element
+          else
+            sdiff[i-1].old_element
+          end
+        result << action + element.chomp
+        i += 1
+      end
+      -1.upto(context-2) do |j|
+        n = i+j
+        break if sdiff[n].action != '='
+        result << ' ' + sdiff[n].new_element.chomp
+      end
+    end
+    return result
+  end
+end
+
+if __FILE__ == $0
+  include DiffFile
+  eg_dir   = File.join(File.dirname(__FILE__), %w(.. example))
+  filename = {}
+  %w(gcd gcd1 gcd-xx).each do |short|
+    filename[short] = File.join(eg_dir, short + '.rb')
+  end
+  puts diff_file(filename['gcd'], filename['gcd1']).join("\n")
+  puts diff_file(filename['gcd'], filename['gcd-xx']).join("\n")
+end

data/test/integration/helper.rb

@@ -0,0 +1,78 @@
+require 'diff/lcs'
+require 'fileutils'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/run' # for ruby_path
+
+DEFAULT_DEBUGGER_OPTS = {
+  :args        => '', 
+  :dbgr        => '', 
+  :outfile     => nil,
+  :short_cmd   => nil,
+  :short_right => nil, 
+  :do_diff     => true,
+}
+
+def run_debugger(testname, ruby_file, opts={})
+  opts       = DEFAULT_DEBUGGER_OPTS.merge(opts)
+  srcdir     = File.dirname(__FILE__)
+  datadir    = File.join(srcdir, %w(.. data))
+  progdir    = File.join(srcdir, %w(.. example)) 
+  
+  dbgr_dir   = File.join(srcdir, %w(.. ..))
+  dbgr_short = File.join(%w(bin trepanx))
+  dbgr_path  = File.join(dbgr_dir, dbgr_short)
+
+  short_right = "#{opts[:short_right] || testname}.right"
+  rightfile  = File.join(datadir, short_right)
+
+  short_cmd   = "#{opts[:short_cmd] || testname}.cmd"
+  cmdfile     = File.join(datadir, short_cmd)
+  outfile     = opts[:outfile] ||
+    File.join(srcdir,  "#{testname}.out")
+  programfile = ruby_file ? File.join(progdir, ruby_file) : ''
+
+  FileUtils.rm(outfile) if File.exist?(outfile)
+
+  cmd = 
+    if opts[:xdebug]
+    "%s -Xdebug '%s' %s >%s <%s" %
+        [Trepanning::ruby_path, programfile, opts[:args], outfile, cmdfile]
+    else
+      "%s %s --nx --command %s %s '%s' %s >%s" %
+        [Trepanning::ruby_path, dbgr_path, cmdfile, opts[:dbgr], 
+         programfile, opts[:args], outfile]
+    end
+  
+  system(cmd)
+  return false unless 0 == $?.exitstatus 
+  if opts[:do_diff]
+    from_file  = rightfile
+    # fromdate  = time.ctime(os.stat(fromfile).st_mtime)
+    from_lines = File.open(from_file).readlines()
+    to_file    = outfile
+    # todate    = time.ctime(os.stat(tofile).st_mtime)
+    to_lines   = File.open(to_file).readlines()
+    
+    # Seems to be a bug in LCS in that it will return a diff even if two
+    # files are the same.
+    return true if from_lines == to_lines
+    
+    sdiffs = Diff::LCS.sdiff(from_lines, to_lines)
+    
+    if sdiffs.empty?
+      FileUtils.rm(outfile)
+    else 
+      puts cmd
+      sdiffs.each do |diff|
+        p diff
+      end
+    end
+    return sdiffs.empty?
+  else
+    return true  # We already tested for false above
+  end
+end
+    
+if __FILE__ == $0
+  run_debugger('testing', 'gcd1.rb')
+end

data/test/integration/test-fname-with-blank.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'helper'
+
+class TestFnameWithBlank < Test::Unit::TestCase
+  @@NAME = File.basename(__FILE__, '.rb')[5..-1]
+
+  def test_it
+    assert_equal(true, run_debugger(@@NAME, 'fname with blank.rb'))
+  end
+end

data/test/integration/test-quit.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'helper'
+
+class TestQuit < Test::Unit::TestCase
+  @@NAME = File.basename(__FILE__, '.rb')[5..-1]
+
+  def test_trepanx_call
+    assert_equal(true, run_debugger(@@NAME, 'null.rb'))
+  end
+
+  def test_xcode_call
+    no_error = run_debugger('quit-Xdebug', 'null.rb',
+                            {:xdebug => true,
+                              :short_cmd => @@NAME,
+                              :do_diff => false
+                            })
+    assert_equal(true, no_error)
+    if no_error
+      outfile = File.join(File.dirname(__FILE__), 'quit-Xdebug.out')
+      FileUtils.rm(outfile)
+    end
+  end
+end

data/test/unit/cmd-helper.rb

@@ -0,0 +1,46 @@
+require 'rubygems'; require 'require_relative'
+# require_relative '../../app/core'
+require_relative '../../processor/mock'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+require_relative '../../processor/frame'
+
+
+module UnitHelper
+
+  def common_setup
+    @dbg      = MockDebugger::MockDebugger.new(:nx => true)
+    @cmdproc  = Trepan::CmdProcessor.new(@dbg)
+    @cmdproc.frame_initialize
+    @cmdproc.dbgr  = @dbg
+    @cmds     = @cmdproc.commands
+
+    def @cmdproc.msg(message)
+      @msgs << message
+    end
+    def @cmdproc.errmsg(message)
+      @errmsgs << message
+    end
+    def @cmdproc.errmsgs
+      @errmsgs
+    end
+    def @cmdproc.msgs
+      @msgs
+    end
+    reset_cmdproc_vars
+  end
+  module_function :common_setup
+  
+  def reset_cmdproc_vars
+    @cmdproc.instance_variable_set('@msgs', [])
+    @cmdproc.instance_variable_set('@errmsgs', [])
+  end
+  module_function :reset_cmdproc_vars
+end
+
+if __FILE__ == $0
+  include UnitHelper
+  common_setup
+  p @cmdproc.msgs
+  p @dbg
+end

data/test/unit/test-app-brkpt.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/breakpoint'
+
+class TestAppBrkpt < Test::Unit::TestCase
+
+  def test_basic
+    method = Rubinius::CompiledMethod.of_sender
+    b1 = Trepanning::Breakpoint.new('<start>', method, 1, 2, 0)
+    assert_equal(false, b1.temp?)
+    assert_equal(0, b1.hits)
+    assert_equal('B', b1.icon_char)
+    # assert_equal(true, b1.condition?)
+    # assert_equal(1, b1.hits)
+    # assert_equal(b1.source_container, tf.source_container)
+    b1.enabled = false
+    assert_equal('b', b1.icon_char)
+    # assert_raises TypeError do 
+    #   Trepanning::Breakpoint.new(iseq, iseq.iseq_size, :temp => true)
+    # end
+    # assert_raises TypeError do 
+    #   Trepanning::Breakpoint.new(0, 5)
+    # end
+    # require_relative '../../lib/trepanning.rb'
+    b2 = Trepanning::Breakpoint.new('temp brkpt', method, 2, 3, 0, 
+                                    :temp => true)
+    assert_equal('t', b2.icon_char)
+  end
+end

data/test/unit/test-app-brkptmgr.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/brkptmgr'
+require_relative '../../app/breakpoint'
+
+class TestLibAppBrkptMgr < Test::Unit::TestCase
+
+  def setup
+    @meth = Rubinius::CompiledMethod.of_sender
+    @brkpts = BreakpointMgr.new
+    @offset = 0
+  end
+
+  def test_basic
+    assert_equal(0, @brkpts.size)
+    b1 = @brkpts.add("<start>", @meth, @offset, 0, 1)
+    assert_equal(b1, @brkpts.find(@meth, @offset))
+    assert_equal(1, @brkpts.size)
+    # require 'trepanning'
+    # dbgr = Trepan.new(:set_restart => true); dbgr.start
+    assert_equal(b1, @brkpts.delete(b1.id))
+    assert_equal(0, @brkpts.size)
+
+    # Try adding via << rather than .add
+    b2 = @brkpts << Trepanning::Breakpoint.new(@meth, 5, nil, :temp => true)
+
+    assert_equal(nil, @brkpts.find(@meth, 6))
+    @brkpts.reset
+    assert_equal(0, @brkpts.size)
+  end
+
+  def test_multiple_brkpt_per_offset
+    b1 = @brkpts.add("b1", @meth, @offset, 5, 2)
+    b2 = @brkpts.add("b2", @meth, @offset, 5, 2)
+    assert_equal(2, @brkpts.size)
+    assert_equal(1, @brkpts.set.size, 
+                 'Two breakpoints but only one @meth/offset')
+    @brkpts.delete_by_brkpt(b1)
+    assert_equal(1, @brkpts.size, 
+                 'One breakpoint after 2nd breakpoint deleted')
+    assert_equal(1, @brkpts.set.size, 
+                 'Two breakpoints, but only one @meth/offset')
+    @brkpts.delete_by_brkpt(b2)
+    assert_equal(0, @brkpts.size, 
+                 'Both breakpoints deleted')
+    assert_equal(0, @brkpts.set.size, 
+                 'Second breakpoint delete should delete @meth/offset')
+  end
+
+end

data/test/unit/test-app-iseq.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/iseq'
+
+class TestAppISeq < Test::Unit::TestCase
+  include Trepanning::ISeq
+
+  def test_disasm_prefix
+    meth = Rubinius::VM.backtrace(0, true)[0].method
+    assert_equal(' -->', disasm_prefix(0, 0, meth))
+    assert_equal('    ', disasm_prefix(0, 1, meth))
+    meth.set_breakpoint(0, nil)
+    assert_equal('B-->', disasm_prefix(0, 0, meth))
+    assert_equal('B   ', disasm_prefix(0, 1, meth))
+  end
+
+  def test_basic
+
+    def single_return
+      meth = Rubinius::VM.backtrace(0, true)[0].method
+      first, last = [meth.lines.first, meth.lines.last]
+      [last, yield_or_return_between(meth, first, last)]
+    end
+
+    def branching(bool)
+      meth = Rubinius::VM.backtrace(0, true)[0].method
+      first, last = [meth.lines.first, meth.lines.last]
+      if bool
+        x = 5
+      else
+        x = 6
+      end
+      goto_between(meth, first, last)
+    end
+
+    def no_branching
+      meth = Rubinius::VM.backtrace(0, true)[0].method
+      first, last = [meth.lines.first, meth.lines.last]
+      goto_between(meth, first, last)
+    end
+
+    last, return_ips = single_return
+    assert_equal([last-1], return_ips)
+    assert_equal(-2, no_branching)
+    assert_equal(2, branching(true).size)
+  end
+
+end

data/test/unit/test-app-method.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/method'
+
+class TestAppMethod < Test::Unit::TestCase
+
+  def test_find_method_with_line
+    method = Rubinius::VM.backtrace(0, true)[0].method
+    line = __LINE__
+    ##############################
+    def foo                        # line +  2
+      a = 5                        # line +  3
+      b = 6                        # line +  4
+    end                            # line +  5
+    1.times do                     # line +  6 
+      1.times do                   # line +  7
+        x = 11                     # line +  8
+        foo                        # line +  9
+      end                          # line + 10
+      c = 14                       # line + 11
+    end                            # line + 12
+    ################################################
+    meths = []                     # line + 14
+    expect = Array.new(22, true)  # line + 15
+    [5, 10, 12, 13, 18].each do |i|
+      expect[i] = false             # line + 17
+    end                            # line + 18
+    (2..21).each do |l|            # line + 19
+      meth = Trepanning::Method.find_method_with_line(method, line+l)
+      meths << meth                # line + 21
+      assert_equal(expect[l], !!meth, "Mismatched line #{line+l}")
+    end
+    pairs = [[1,2], [0,4], [5,9], [6,7], [14,15], [20,21]]
+    pairs.each do |pair|
+      assert_equal(meths[pair[0]].inspect, meths[pair[1]].inspect, 
+                   "Method compare")
+    end
+  end
+  def test_valid_ip?
+    meth = Rubinius::VM.backtrace(0, true)[0].method
+    ip = Trepanning::Method.locate_line( __LINE__, meth)[1]
+    assert_equal(true, ip.kind_of?(Fixnum), 
+                 "locate line of #{__LINE__} should have gotten an IP;" +
+                 " got: #{ip.inspect}")
+    [[-1, false],
+     [ 0, true], 
+     [ip, true], 
+     [100000, false]].each do |ip, expect|
+      assert_equal expect, Trepanning::Method.valid_ip?(meth, ip)
+    end
+  end
+
+end

data/test/unit/test-app-options.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'stringio'
+require 'tempfile'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/options'
+
+# To have something to work with.
+load 'tmpdir.rb'
+
+class TestAppStringIO < Test::Unit::TestCase
+  include Trepanning
+
+  def setup
+    @options = DEFAULT_CMDLINE_SETTINGS.clone
+    @stderr  = StringIO.new
+    @stdout  = StringIO.new
+    @options = copy_default_options
+    @opts = setup_options(@options, @stdout, @stderr)
+  end
+
+  def test_cd
+    rest = @opts.parse(['--cd', Dir.tmpdir])
+    assert_equal(Dir.tmpdir, @options[:chdir])
+    assert_equal('', @stderr.string)
+    assert_equal('', @stdout.string)
+
+    setup
+    tf    = Tempfile.new("delete-me")
+    orig_cd = @options[:chdir]
+    rest = @opts.parse(['--cd', tf.path])
+    assert_equal(orig_cd, @options[:chdir])
+    assert_not_equal('', @stderr.string)
+    assert_equal('', @stdout.string)
+    # FIXME: add test where directory isn't executable.
+  end
+
+  def test_binary_opts
+    %w(nx).each do |name|
+      setup
+      o    = ["--#{name}"]
+      rest = @opts.parse o
+      assert_equal('', @stderr.string)
+      assert_equal(true, @options[name.to_sym])
+    end
+  end
+
+  def test_help_and_version_opts
+    %w(help version).each do |name|
+      setup
+      o    = ["--#{name}"]
+      rest = @opts.parse o
+      assert_not_equal('', @stdout.string)
+      assert_equal('', @stderr.string)
+      assert_equal(true, @options[name.to_sym])
+      other_sym = 'help' == name ? :version : :help
+      assert_equal(false, @options.member?(other_sym))
+    end
+  end
+
+end

data/test/unit/test-app-run.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/run'
+
+class TestAppRun < Test::Unit::TestCase
+  include Trepanning
+  def test_basic
+    assert_equal(true, File.executable?(whence_file('irb')))
+    ng = whence_file('probably-does-not-exist')
+    assert_equal(true, File.executable?(ng) || ng == 'probably-does-not-exist')
+    rp = ruby_path
+    assert_equal(true, File.executable?(rp))
+  end
+
+end

data/test/unit/test-app-util.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/util'
+
+class TestAppUtil < Test::Unit::TestCase
+  include Trepan::Util
+  def test_safe_repr
+    string = 'The time has come to talk of many things.'
+    assert_equal(string, safe_repr(string, 50))
+    assert_equal('The time...  things.', safe_repr(string, 17))
+    assert_equal('"The tim... things."', safe_repr(string.inspect, 17))
+    string = "'The time has come to talk of many things.'"
+    assert_equal("'The tim... things.'", safe_repr(string, 17))
+  end
+
+  def test_find_main_script
+    locs = Rubinius::VM.backtrace(0, true)
+    i = find_main_script(locs)
+    assert_equal(true, !!i)
+    j = locs.size - i
+    if j > 0
+      locs = Rubinius::VM.backtrace(j, true)
+      assert_equal(false, !!find_main_script(locs))
+    end
+  end
+
+end

data/test/unit/test-app-validate.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/validate'
+
+class TestAppValidate < Test::Unit::TestCase
+  include Trepan::Validate
+  def test_line_or_ip
+    [['o1',  [1, nil]],
+     ['O2',   [2, nil]],
+     ['oink', [nil, nil]],
+     ['1'   , [nil, 1]],
+     ['12',   [nil, 12]],
+     ['-12',  [nil, -12]]].each do |arg, expect|
+      assert_equal(line_or_ip(arg), expect)
+    end
+  end
+end

data/test/unit/test-base-subcmd.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+# require_relative '../../app/core'
+require_relative '../../processor/main'
+require_relative '../../processor/command/exit'
+require_relative '../../processor/command/base/subcmd'
+
+# Mock debugger stub. FIXME: put in comment helper routine.
+class Trepan
+end
+
+$errors = []
+class TestBaseCommandHelp < Test::Unit::TestCase
+
+  Trepan::Subcommand.const_set(:NAME, 'bogus')
+  def setup
+    $errors   = []
+    $msgs     = []
+    @dbgr     = Trepan.new
+    # @core     = Trepan::Core.new(@dbgr)
+    @cmdproc  = Trepan::CmdProcessor.new(@dbgr)
+    @cmds     = @cmdproc.instance_variable_get('@commands')
+    @exit_cmd = @cmds['exit']
+    @exit_subcmd = Trepan::Subcommand.new(@exit_cmd)
+    def @exit_subcmd.msg(message)
+      $msgs << message
+    end
+    def @exit_subcmd.errmsg(message)
+      $errors << message
+    end
+  end
+
+  def test_base_subcommand
+    assert @exit_subcmd
+    assert_raises RuntimeError do 
+      @exit_subcmd.run
+    end
+    assert_equal([], $errors)
+    @exit_subcmd.run_set_int('', 'testing 1 2 3')
+    assert_equal(1, $errors.size)
+    assert_equal(Fixnum, @exit_subcmd.settings[:maxwidth].class)
+    @cmds.each do |cmd_name, cmd_obj|
+      next unless cmd_obj.is_a?(Trepan::SubcommandMgr)
+      cmd_obj.subcmds.subcmds.each do |subcmd_name, subcmd_obj|
+        %w(HELP NAME PREFIX).each do |attr|
+          assert_equal(true, subcmd_obj.class.constants.member?(attr),
+                       "Constant #{attr} should be defined in \"#{cmd_obj.name} #{subcmd_obj.class::NAME}\"")
+        end
+      end
+        
+    end
+  end
+
+  def test_show_on_off
+    assert_equal('on', @exit_subcmd.show_onoff(true))
+    assert_equal('off', @exit_subcmd.show_onoff(false))
+    assert_equal('unset', @exit_subcmd.show_onoff(nil))
+    assert_equal('??', @exit_subcmd.show_onoff(5))
+  end
+end