rbx-trepanning 0.0.5-universal-rubinius-1.2.1

data/test/functional/test-step2.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestStep2 < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def test_step_out_of_fn
+
+    # See that handle stepping out of a function properly.
+    cmds = ['step', 'step', 'continue']
+    d = strarray_setup(cmds)
+
+    def echo(x)
+      return x
+    end
+
+    d.start
+    ########### t1 ###############
+    x = echo("hi")
+    y = 3
+    ##############################
+    d.stop
+    out = ['-- ', 
+           'x = echo("hi")', 
+           '-> ', 
+           'return x', 
+           '-- ', 
+           'x = echo("hi")']
+    compare_output(out, d, cmds)
+  end
+
+end

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     = 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 = 
+    if opts[:xdebug]
+    "%s -Xdebug '%s' %s >%s 2>&1 <%s" %
+        [Trepanning::ruby_path, programfile, opts[:args], outfile, cmdfile]
+    elsif opts[:standalone]
+      "%s %s %s >%s 2>&1" %
+        [Trepanning::ruby_path, programfile, opts[:args], outfile]
+    else
+      "%s %s --nx --command %s %s '%s' %s >%s 2>&1" %
+        [Trepanning::ruby_path, dbgr_path, cmdfile, opts[:dbgr], 
+         programfile, opts[:args], outfile]
+    end
+  
+  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]
+    
+    # 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/skip-test-step-bug.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'helper'
+
+class TestQuit < Test::Unit::TestCase
+
+  def NO__test_it
+    name = File.basename(__FILE__, '.rb')[5..-1]
+    no_error = run_debugger(name, 'step-bug.rb')
+    assert_equal(true, no_error)
+    if no_error
+      outfile = File.join(File.dirname(__FILE__), 'step-bug.out')
+      FileUtils.rm(outfile)
+    end
+  end
+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/cmd-helper.rb

@@ -0,0 +1,50 @@
+require 'test/unit'
+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.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
+  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/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,29 @@
+#!/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?)
+    # 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 
+    #   Trepan::Breakpoint.new(iseq, iseq.iseq_size, :temp => true)
+    # end
+    # assert_raises TypeError do 
+    #   Trepan::Breakpoint.new(0, 5)
+    # end
+    # require_relative '../../lib/trepanning.rb'
+    b2 = Trepan::Breakpoint.new('temp brkpt', method, 2, 3, 0, :temp => true)
+    assert_equal('t', b2.icon_char)
+  end
+end