trepanning 0.0.4

data/test/functional/test-step.rb

@@ -0,0 +1,274 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'trace'
+require_relative 'fn_helper'
+
+class TestStep < Test::Unit::TestCase
+
+  include FnTestHelper
+  include Trace
+
+  def test_step_same_level
+
+    # See that we can step with parameter which is the same as 'step 1'
+    cmds = ['step', 'continue']
+    d = strarray_setup(cmds)
+    d.core.step_events = TEST_STEP_EVENT_MASK
+
+    d.start
+    ########### t1 ###############
+    x = 5
+    y = 6
+    ##############################
+    d.stop
+    out = ['-- ', 'x = 5', '-- ', 'y = 6']
+    compare_output(out, d, cmds)
+
+    # See that we can step with a computed count value
+    cmds = ['step 5-3', 'continue']
+    d = strarray_setup(cmds)
+    d.start
+    ########### t2 ###############
+    x = 5
+    y = 6
+    z = 7
+    ##############################
+    d.stop # ({:remove => true})
+    out = ['-- ', 'x = 5', '-- ', 'z = 7']
+    compare_output(out, d, cmds)
+    
+    # Test step>
+    cmds = ['step>', 'continue']
+    d = strarray_setup(cmds)
+    d.start
+    ########### t3 ###############
+    x = 5
+    def foo()
+    end
+    y = 6
+    foo
+    ##############################
+    d.stop  # {:remove => true})
+    out = ['-- ', 'x = 5', 'METHOD TestStep#foo()', '-> ', 'def foo()']
+    compare_output(out, d, cmds)
+    
+    # Test step!
+    cmds = ['step!', 'continue']
+    d = strarray_setup(cmds)
+    d.start()
+    ########### t4 ###############
+    x = 5
+    begin
+      y = 2
+      z = 1/0
+    rescue
+    end
+    ##############################
+    d.stop # ({:remove => true})
+    out = ['-- ', 'x = 5', 
+           '#<ZeroDivisionError: divided by 0>', 
+           '!! ', 'z = 1/0']
+    compare_output(out, d, cmds)
+    
+    # Test "step" with sets of events. Part 1
+    cmds = ['set events call raise',
+            'step', 's!']
+    d = strarray_setup(cmds)
+    d.start()
+    ########### t5 ###############
+    x = 5
+    def foo1
+      y = 2
+      raise Exception
+    rescue Exception
+    end
+    foo1()
+    z = 1
+    ##############################
+    d.stop # ({:remove => true})
+    out = ['-- ',
+           'x = 5',
+           'Trace events we may stop on:',
+           "\tbrkpt, call, raise",
+           'METHOD TestStep#foo1()',
+           '-> ',
+           'def foo1',
+           '#<Exception: Exception>',
+           '!! ',
+           'raise Exception']
+
+    got = filter_line_cmd(d.intf[-1].output.output)
+    out.pop if got.size+1 == out.size
+    compare_output(out, d, cmds)
+    
+    # Test "step" will sets of events. Part 2
+    cmds = ['step> 1+0',
+            'step! 1', 'continue']
+    d = strarray_setup(cmds)
+    d.start()
+    ########### t6 ###############
+    x = 5
+    begin
+      def foo2()
+        y = 2
+        raise Exception
+      end
+      foo2()
+    rescue Exception
+    end
+    z = 1
+    ##############################
+    d.stop({:remove => true})
+    out = ['-- ',
+           'x = 5',
+           'METHOD TestStep#foo2()',
+           '-> ',
+           'def foo2()',
+           'TestStep',
+           '!! ',
+           'raise Exception']
+    
+  end
+
+  def test_step_between_fn
+
+    # Step into and out of a function
+    def sqr(x)
+      y = x * x
+    end
+    cmds = %w(step) * 4 + %w(continue)
+    out =  ['-- ',
+            'x = sqr(4)',
+            'METHOD TestStep#sqr(x)',
+            '-> ',
+            'def sqr(x)',
+            '-- ',
+            'y = x * x',
+            '<- ',
+            'R=> 16',
+            'end',
+            '-- ',
+            'y = 5']
+    d = strarray_setup(cmds)
+    d.start
+    ########### t7 ###############
+    x = sqr(4)
+    y = 5
+    ##############################
+    d.stop # ({:remove => true})
+    compare_output(out, d, cmds)
+
+    cmds = ['set events call return',
+            'step', 'step', 'continue']
+    out =  ['-- ',
+            'x = sqr(4)',
+            'Trace events we may stop on:',
+            "\tbrkpt, call, return",
+            'METHOD TestStep#sqr(x)',
+            '-> ',
+            'def sqr(x)',
+            '<- ',
+            'R=> 16',
+            'end']
+    d = strarray_setup(cmds)
+    d.start
+    ########### t8 ###############
+    x = sqr(4)
+    y = 5
+    ##############################
+    d.stop # ({:remove => true})
+    compare_output(out, d, cmds)
+  end
+
+  def test_step_in_exception
+    def boom(x)
+      y = 0/x
+    end
+    def bad(x)
+      boom(x)
+      y = x * x
+    end
+    cmds = %w(step! continue)
+    d = strarray_setup(cmds)
+    begin 
+      d.start()
+      x = bad(0)
+      assert_equal(false, true, 'should have raised an exception')
+    rescue ZeroDivisionError
+      assert true, 'Got the exception'
+    ensure
+      d.stop({:remove => true})
+    end
+    
+    out = ['-- ', 
+           'x = bad(0)', # line event
+           '#<ZeroDivisionError: divided by 0>',
+           '!! ',        # exception event
+           'y = 0/x']
+
+    compare_output(out, d, cmds)
+  end
+
+  def test_step_event
+
+    def fact(x)
+      return 1 if x <= 1
+      x = x * fact(x-1)
+      return x
+    end
+    cmds = ['step<', '1 == x', 'continue'] 
+    d = strarray_setup(cmds)
+    d.start
+    ########### t9 ###############
+    x = fact(4)
+    y = 5
+    ##############################
+    d.stop # ({:remove => true})
+    out = ['-- ', 
+           'x = fact(4)', 
+           '<- ', 
+           'R=> 1', 
+           'return 1 if x <= 1', 
+           'D=> true']
+    compare_output(out, d, cmds)
+  end
+
+  def test_step_into_fun
+
+    # Bug was that we were stopping at a VM instruction before the fn
+    # call proper ('bar' below), and not getting a line number for it.
+    # So a subsequent 'step' when 'set different' in effect was to stay
+    # at the same place at the function call.
+    cmds = ['set different', 'set events call, class, line, return',
+            'step', 'step', 'step', 'step', 'continue'] 
+    d = strarray_setup(cmds)
+    d.start
+    ########### t10 ###############
+    def bar
+      return 1
+    end
+
+    def foo
+      bar
+      return 5
+    end
+    foo
+    ##############################
+    d.stop # ({:remove => true})
+    out = ['-- ',
+           'def bar',
+           'different is on.',
+           'Trace events we may stop on:',
+           "\tbrkpt, call, class, line, return",
+           '-- ',
+           'def foo',
+           '-- ',
+           'foo',
+           'METHOD TestStep#foo()',
+           '-> ',
+           'def foo',
+           '-- ',
+           'bar']
+    compare_output(out, d, cmds)
+  end
+end

data/test/functional/test-stepbug.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'trace'
+require_relative 'fn_helper'
+
+class TestStep < Test::Unit::TestCase
+
+  include FnTestHelper
+  include Trace
+
+  def test_step_through_leave
+
+    # See that we can step with parameter which is the same as 'step 1'
+    cmds = ['step', 'step', 'step', 'step', 'step', 'step', 'continue']
+    d = strarray_setup(cmds)
+    d.core.step_events = TEST_STEP_EVENT_MASK 
+
+    d.start
+    ########### t1 ###############
+    x = 'class Foo
+           def bar
+             3
+           end
+         end'
+    eval(x)
+    f = Foo.new
+    # f.bar
+    ##############################
+    d.stop
+    out = ["-- x = 'class Foo", 
+           ".. eval(x)", 
+           ".. eval(x)", 
+           ":: eval(x)", 
+           "-- eval(x)"]
+    # compare_output(out, d, cmds)
+    assert true
+
+  end
+
+end

data/test/functional/test-trace-var.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'trace'
+require_relative 'fn_helper'
+
+# See that we hande "set trace var" properly
+class TestTraceVar < Test::Unit::TestCase
+
+  include FnTestHelper
+  include Trace
+
+  def test_basic
+
+    cmds = ['set trace var $my_var', 'continue', 'continue', 'continue']
+    d = strarray_setup(cmds)
+    d.core.step_events = TEST_STEP_EVENT_MASK
+
+    d.start
+    ########### t1 ###############
+    x = 1
+    $my_var = 5
+    y = 2
+    $my_var = 6
+    z = 3
+    ##############################
+    d.stop
+    out = ['-- ',
+           'x = 1',
+           'Tracing variable $my_var.',
+           '$V ',
+           '$my_var = 5',
+           'Note: we are stopped *after* the above location.',
+           '$V ',
+           '$my_var = 6',
+           'Note: we are stopped *after* the above location.',
+          ]
+    compare_output(out, d, cmds)
+    end
+
+end

data/test/functional/tmp/b1.rb

@@ -0,0 +1,5 @@
+    ########### b1 ###############
+    x = 5
+    y = 6
+    z = 7
+ k = 5

data/test/functional/tmp/s1.rb

@@ -0,0 +1,9 @@
+    x = 5
+    def foo1
+      y = 2
+      raise Exception
+    rescue Exception
+      puts 'hi'
+    end
+    foo1()
+    z = 1

data/test/functional/tmp/t2.rb

@@ -0,0 +1,6 @@
+    begin
+      got_boom = false
+      x = 4/0
+    rescue
+      got_boom = true
+    end

data/test/integration/file-diff.rb

@@ -0,0 +1,88 @@
+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,52 @@
+require 'diff/lcs'
+require 'fileutils'
+
+def run_debugger(testname, ruby_file, dbgr_opts='', args='', outfile=nil)
+
+  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 trepan))
+  dbgr_path  = File.join(dbgr_dir, dbgr_short)
+
+  rightfile  = File.join(datadir, "#{testname}.right")
+
+  cmdfile     = File.join(datadir, "#{testname}.cmd" % testname)
+  outfile     = File.join(srcdir,  "#{testname}.out" % testname)
+  programfile = ruby_file ? File.join(progdir, ruby_file) : ''
+
+  FileUtils.rm(outfile) if File.exist?(outfile)
+
+  cmd = "%s --nx --command %s %s '%s' %s >%s" %
+    [dbgr_path, cmdfile, dbgr_opts, programfile, args, outfile]
+  
+  system(cmd)
+  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?
+end
+    
+if __FILE__ == $0
+  run_debugger('testing', 'gcd1.rb')
+end

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+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,11 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative 'helper'
+
+class TestQuit < Test::Unit::TestCase
+  @@NAME = File.basename(__FILE__, '.rb')[5..-1]
+
+  def test_it
+    assert_equal(true, run_debugger(@@NAME, 'null.rb'))
+  end
+end

data/test/integration/try-test-enable.rb

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

data/test/unit/cmd-helper.rb

@@ -0,0 +1,44 @@
+require_relative '../../app/core'
+require_relative '../../app/mock'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+require_relative '../../processor/frame'
+
+
+module UnitHelper
+
+  def common_setup
+    @dbg      = Trepan::MockDebugger.new(:nx => true)
+    @core     = Trepan::Core.new(@dbg)
+    @cmdproc  = @core.processor = Trepan::CmdProcessor.new(@core)
+    @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_relative '../../app/breakpoint'
+require 'thread_frame'
+
+class TestAppBrkpt < Test::Unit::TestCase
+
+  def test_basic
+    tf = RubyVM::ThreadFrame.current
+    iseq = tf.iseq
+    b1 = Trepanning::Breakpoint.new(iseq, 0)
+    assert_equal(false, b1.temp?)
+    assert_equal(0, b1.hits)
+    assert_equal('B', b1.icon_char)
+    assert_equal(true, b1.condition?(tf.binding))
+    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(iseq, 0, :temp => true)
+    assert_equal('t', b2.icon_char)
+  end
+end

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

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../app/brkptmgr'
+require_relative '../../app/breakpoint'
+require 'thread_frame'
+
+class TestLibAppBrkptMgr < Test::Unit::TestCase
+
+  def setup
+    @brkpts = BreakpointMgr.new
+  end
+
+  def test_basic
+    tf = RubyVM::ThreadFrame.current
+    iseq = tf.iseq
+    offsets = iseq.offsetlines.keys
+    offset  = offsets[0]
+    assert_equal(0, @brkpts.size)
+    b1 = @brkpts.add(iseq, offset)
+    assert_equal(b1, @brkpts.find(iseq, offset, tf.binding))
+    assert_equal(1, @brkpts.size)
+    assert_equal(b1, @brkpts.find(iseq, offset, tf.binding))
+    assert_equal(b1, @brkpts.delete(b1.id))
+    assert_equal(0, @brkpts.size)
+
+    # Try adding via << rather than .add
+    b2 = @brkpts << Trepanning::Breakpoint.new(iseq, offsets[1], :temp => true)
+
+    assert_equal(nil, @brkpts.find(iseq, offset, tf.binding))
+    @brkpts.reset
+    assert_equal(0, @brkpts.size)
+  end
+
+  def test_multiple_brkpt_per_offset
+    tf = RubyVM::ThreadFrame.current
+    iseq = tf.iseq
+    offsets = iseq.offsetlines.keys
+    offset  = offsets[0]
+    b1 = @brkpts.add(iseq, offset)
+    b2 = @brkpts.add(iseq, offset)
+    assert_equal(2, @brkpts.size)
+    assert_equal(1, @brkpts.set.size, 
+                 'Two breakpoints but only one iseq/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 iseq/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 iseq/offset')
+  end
+
+end