rbx-trepanning 0.2.0-universal-rubinius-2.0

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,81 @@
+require 'rubygems'; require 'require_relative'
+require 'diff/lcs'
+require 'fileutils'
+require_relative '../../app/run' # for RbConfig.ruby
+
+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     = opts[: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 = opts[:feed_input] ? "#{opts[:feed_input]} |" : ''
+  cmd +=
+    if opts[:xdebug]
+    "%s -Xdebug '%s' %s >%s 2>&1 <%s" %
+        [RbConfig.ruby, programfile, opts[:args], outfile, cmdfile]
+    elsif opts[:standalone]
+      "%s %s %s >%s 2>&1" %
+        [RbConfig.ruby, programfile, opts[:args], outfile]
+    else
+      "%s %s --nx --command %s %s '%s' %s >%s 2>&1" %
+        [RbConfig.ruby, dbgr_path, cmdfile, opts[:dbgr],
+         programfile, opts[:args], outfile]
+    end
+  puts cmd # if opts[:verbose]
+  system(cmd)
+  return false unless 0 == $?.exitstatus
+  if opts[:do_diff]
+    expected_lines = File.open(rightfile).readlines()
+    got_lines      = File.open(outfile).readlines()
+    opts[:filter].call(got_lines, expected_lines) if opts[:filter]
+    # puts "=" * 80
+    # got_lines.map{|line| puts line}
+
+    # Seems to be a bug in LCS in that it will return a diff even if two
+    # files are the same.
+    return true if expected_lines == got_lines
+
+    sdiffs = Diff::LCS.sdiff(expected_lines, got_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,16 @@
+#!/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
+    opts = {}
+    opts[:filter] = Proc.new{|got_lines, correct_lines|
+      got_lines[0] = "-> (fname with blank.rb:1 @0)\n"
+    }
+    assert_equal(true, run_debugger(@@NAME, 'fname with blank.rb', opts))
+  end
+end

data/test/integration/test-inline-call.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'helper'
+
+class TestInlineCall < Test::Unit::TestCase
+  @@NAME = File.basename(__FILE__, '.rb')[5..-1]
+  def test_inline_call
+    opts = {
+      :short_cmd => @@NAME, :do_diff => true,
+      :standalone => true
+    }
+    opts[:filter] = Proc.new{|got_lines, correct_lines|
+      got_lines[0] = "-- (inline-call.rb:11 @12)\n"
+    }
+
+    no_error = run_debugger(@@NAME, @@NAME + '.rb', opts)
+    assert_equal(true, no_error)
+  end
+end

data/test/integration/test-quit.rb

@@ -0,0 +1,47 @@
+#!/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]
+
+  # FIXME: causes rubinius to hang. Use
+  #   rbx -Xagent.start -S rake
+  # to see backtrace
+  # def test_trepanx_set_confirm_off
+  #   opts = {}
+  #   opts[:filter] = Proc.new{|got_lines, correct_lines|
+  #     got_lines[0] = "-> (null.rb:1 @0)\n"
+  #   }
+  #   assert_equal(true, run_debugger('quit2', 'null.rb', opts))
+  # end
+
+  def test_trepanx_call
+    opts = {}
+    opts[:filter] = Proc.new{|got_lines, correct_lines|
+      got_lines[0] = "-> (null.rb:1 @0)\n"
+    }
+    assert_equal(true, run_debugger(@@NAME, 'null.rb', opts))
+  end
+
+  def test_xcode_call
+    startup_file = File.join(ENV['HOME'], '.rbxrc')
+    lines = File.open(startup_file).readlines.grep(/Trepan\.start/)
+    if lines && lines.any?{|line| line.grep(/:Xdebug/)}
+      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
+    else
+      puts "Trepan.start(:skip_loader=>:Xdebug) is not in ~.rbxrc. Skipping."
+      assert true
+    end
+  end
+end

data/test/unit/.gitignore

@@ -0,0 +1,3 @@
+/*.rbc
+/*~
+

data/test/unit/cmd-helper.rb

@@ -0,0 +1,50 @@
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/mock'
+require_relative '../../processor/frame'
+
+module UnitHelper
+
+  module_function
+  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.errmsg(message, opts={})
+      @errmsgs << message
+    end
+    def @cmdproc.errmsgs
+      @errmsgs
+    end
+    def @cmdproc.msg(message, opts={})
+      @msgs << message
+    end
+    def @cmdproc.msgs
+      @msgs
+    end
+    def @cmdproc.section(message, opts={})
+      @msgs << message
+    end
+    reset_cmdproc_vars
+  end
+
+  def common_teardown
+    @cmdproc.finalize
+  end
+  
+  def reset_cmdproc_vars
+    @cmdproc.instance_variable_set('@msgs', [])
+    @cmdproc.instance_variable_set('@errmsgs', [])
+  end
+
+end
+
+if __FILE__ == $0
+  include UnitHelper
+  common_setup
+  p @cmdproc.msgs
+  p @dbg
+end

data/test/unit/mock-helper.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/mock'
+
+module MockUnitHelper
+  def common_setup(name)
+    @dbg, @cmd = MockDebugger::setup(name, false)
+  end
+end
+

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

@@ -0,0 +1,31 @@
+#!/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 = Trepan::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?(binding))
+    assert_equal(1, b1.hits)
+    b1.enabled = false
+    assert_equal(false, b1.active?)
+    assert_equal('b', b1.icon_char)
+    assert_raises ArgumentError do 
+      b1.activate
+    end
+
+    b2 = Trepan::Breakpoint.new('<start>', method, 0, 2, 0)
+    b2.activate
+    assert_equal(true, b2.active?)
+    b2.remove!
+    assert_equal(false, b2.active?)
+    b3 = Trepan::Breakpoint.new('temp brkpt', method, 2, 3, 0, :temp => true)
+    assert_equal('t', b3.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 = Trepan::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 << Trepan::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-cmd_parse.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/cmd_parse'
+
+class TestCmdParse < Test::Unit::TestCase
+
+  # require_relative '../../lib/trepanning'
+  def test_parse_location
+    [['fn', [:fn, nil, nil]],
+     ['fn 2', [:fn, :line, 2]],
+     ['fn @5', [:fn, :offset, 5]],
+     ['@3',   [nil, :offset, 3]],
+     ['fn:6', [:fn, :line, 6]],
+     ["#{__FILE__}:5", [:file, :line, 5]],
+     ['fn:@15', [:fn, :offset, 15]],
+    ].each do |location, expect|
+      cp = parse_location(location)
+      assert cp, "should be able to parse #{location} as a location"
+      assert_equal(expect[0], cp.container_type, 
+                   "mismatch container_type on #{location}")
+      assert_equal(expect[1], cp.position_type, 
+                   "mismatch position_type on #{location}")
+      assert_equal(expect[2], cp.position, 
+                   "mismatch position on #{location}")
+    end
+    
+    # %w(0 1e10 a.b).each do |location|
+    #   begin
+    #     cp = CmdParse.new(name)
+    #     assert_equal nil cp._location, 
+    #     "should be able to parse #{name} as a location"
+    #   end
+    # end
+  end
+  
+  module Testing
+    def testing; 5 end
+    module_function :testing
+  end
+
+  def test_parse_identifier
+    %w(a a1 $global __FILE__ Constant).each do |name|
+      cp = CmdParse.new(name)
+      assert cp._identifier, "should be able to parse #{name} as an identifier"
+    end
+    %w(0 1e10 @10).each do |name|
+      cp = CmdParse.new(name)
+      assert_equal(true, !cp._identifier, 
+                   "should not have been able to parse of #{name}")
+    end
+  end
+
+  def test_parse_method
+    [['Object', 0], ['A::B', 1], ['A::B::C', 2],
+     ['A::B::C::D', 3], ['A::B.c', 2], ['A.b.c.d', 3]].each do |name, count|
+      cp = CmdParse.new(name)
+      assert cp._class_module_chain, "should be able to parse of #{name}"
+      m = cp.result
+      count.times do |i|
+        assert m, "Chain item #{i} of #{name} should not be nil"
+        m = m.chain[1]
+      end
+      assert_nil m.chain, "#{count} chain item in #{cp.result} should be nil"
+    end
+    ['A(5)'].each do |name|
+      cp = CmdParse.new(name)
+      cp._class_module_chain
+      assert_not_equal(name, cp.result.name,
+                   "should not have been able to parse of #{name}")
+    end
+  end
+
+  include Trepan::CmdParser
+  def test_method_name
+    def five; 5 end
+    %w(five Rubinius::VM.backtrace Kernel.eval
+        Testing.testing Kernel::eval File.basename).each do |str|
+      meth = meth_for_string(str, binding)
+      assert meth.kind_of?(Method), "#{str} method's class should be Method, not #{meth.class}"
+    end
+    x = File
+    def x.five; 5; end
+    %w(x.basename x.five).each do |str|
+      meth = meth_for_string(str, binding)
+      assert meth.kind_of?(Method), "#{str} method's class should be Method, not #{meth.class}"
+    end
+    %w(Array.map).each do |str|
+      meth = meth_for_string(str, binding)
+      assert meth.kind_of?(UnboundMethod), "#{meth.class}"
+    end
+    %w(O5).each do |str|
+      meth = meth_for_string(str, binding)
+      assert_equal nil, meth, "should have found a method for #{str}"
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/cmd_parser'
+
+class TestAppCmdParser < Test::Unit::TestCase
+  def setup
+    @cp = CmdParse.new('', :debug=>true)
+  end
+
+  def test_parse_filename
+    [
+     ['filename', 'filename'],
+     ['"this is a filename"', 'this is a filename'],
+     ['this\ is\ another\ filename', 'this is another filename'],
+     ['C\:filename', 'C:filename']
+    ].each do |name, expect|
+      @cp.setup_parser(name, :debug => true)
+      res = @cp._filename
+      assert_equal(expect, @cp.result)
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/complete'
+
+class TestAppUtil < Test::Unit::TestCase
+  include Trepan::Complete
+  def test_complete
+    hash = {'ab' => 1, 'aac' => 2, 'aa' => 3, 'a' => 4}
+    ary = hash.keys.sort
+    [[[], 'b'], [ary, 'a'], [%w(aa aac), 'aa'], 
+     [ary, ''], [['ab'], 'ab'], [[], 'abc']].each do |result, prefix|
+      assert_equal(result, complete_token(ary, prefix),
+                   "Trouble matching #{ary}.inspect on #{prefix.inspect}")
+    end
+    [[ary, 'a'], [%w(aa aac), 'aa'], 
+     [['ab'], 'ab'], [[], 'abc']].each do |result_keys, prefix|
+      result = result_keys.map {|key| [key, hash[key]]}
+      assert_equal(result, complete_token_with_next(hash, prefix),
+                   "Trouble matching #{hash}.inspect on #{prefix.inspect}")
+    end
+    
+  end
+
+  def test_next_token
+    x = '  now is  the  time'
+    [[0, [ 5, 'now']], 
+     [2, [ 5, 'now']],
+     [5, [ 8, 'is']], 
+     [8, [13, 'the']],
+     [9, [13, 'the']],
+     [13, [19, 'time']],
+     [19, [19, '']],
+    ].each do |pos, expect|
+      assert_equal expect, next_token(x, pos)
+    end
+  end
+
+end

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

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'stringio'
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/condition'
+
+class TestAppCondition < Test::Unit::TestCase
+  include Trepan::Condition
+  
+  def test_basic
+    assert valid_condition?('1+2')
+    old_stderr = $stderr
+    new_stdout = StringIO.new
+    $stderr = new_stdout
+    assert_equal nil, valid_condition?('1+')
+    $stderr = old_stderr
+  end
+end

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

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require 'test/unit'
+require_relative '../../app/display'
+require_relative '../../app/frame'
+
+class TestLibAppBrkptMgr < Test::Unit::TestCase
+
+  def test_basic
+    mgr = DisplayMgr.new
+#    frame = Trepan::Frame.new(self, 0, Rubinius::VM.backtrace(0)[1])
+    assert_equal(0, mgr.size)
+#    disp = mgr.add(frame, '3 > 1')
+#    assert_equal(1, mgr.max)
+#    assert_equal(true, disp.enabled?)
+    
+#    mgr.enable_disable(disp.number, false)
+#    assert_equal(false, disp.enabled?)
+#    mgr.enable_disable(disp.number, true)
+#    assert_equal(true, disp.enabled?)
+  end
+end

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

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/iseq'
+
+class TestAppISeq < Test::Unit::TestCase
+
+  def test_disasm_prefix
+    meth = Rubinius::VM.backtrace(0, true)[0].method
+    assert_equal(' -->', Trepan::ISeq.disasm_prefix(0, 0, meth))
+    assert_equal('    ', Trepan::ISeq.disasm_prefix(0, 1, meth))
+    meth.set_breakpoint(0, nil)
+    assert_equal('B-->', Trepan::ISeq.disasm_prefix(0, 0, meth))
+    assert_equal('B   ', Trepan::ISeq.disasm_prefix(0, 1, meth))
+  end
+
+  def test_basic
+
+    def single_return
+      cm = Rubinius::VM.backtrace(0, true)[0].method
+      last = cm.lines.last
+      first = 0
+      0.upto((cm.lines.last+1)/2) do |i|
+        first = cm.lines[i*2]
+        break if -1 != first
+      end
+      [last, Trepan::ISeq.yield_or_return_between(cm, first, last)]
+    end
+
+    def branching(bool)
+      cm = Rubinius::VM.backtrace(0, true)[0].method
+      last = cm.lines.last
+      first = nil
+      0.upto((cm.lines.last+1)/2) do |i|
+        first = cm.lines[i*2]
+        break if -1 != first
+      end
+
+      if bool
+        x = 5
+      else
+        x = 6
+      end
+      Trepan::ISeq.goto_between(cm, first, last)
+    end
+
+    def no_branching
+      cm = Rubinius::VM.backtrace(0, true)[0].method
+      last = cm.lines.last
+      first = 0
+      0.upto((cm.lines.last+1)/2) do |i|
+        first = cm.lines[i*2]
+        break if -1 != first
+      end
+      Trepan::ISeq.goto_between(cm, 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