rbx-trepanning 0.0.2-universal-rubinius-1.2

data/test/functional/test-break.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestBreak < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def test_line_only_break
+    # Check that we can set breakpoints in parent, sibling and children
+    # of sibling returns. We have one more 'continue' than we need
+    # just in case something goes wrong.
+    cmds_pat = ((['break %d'] * 4) + (%w(continue) * 4)).join("\n")
+    line = __LINE__
+    cmds = (cmds_pat % [line, line+6, line+11, line+14]).split(/\n/)
+    d = strarray_setup(cmds)
+    ##############################
+    def foo      # line +  4  
+      a = 5      # line +  5
+      b = 6      # line +  6
+    end          # line +  7
+    1.times do   # line +  8 
+      d.start    # line +  9
+      1.times do # line + 10
+        x = 11   # line + 11
+        foo      # line + 12
+      end        # line + 13
+      c = 14     # line + 14
+    end
+    ##############################
+    d.stop # ({:remove => true})
+    out = ["-- ",
+           '1.times do # line + 10',
+           'Set breakpoint 1: foo.rb:55 (@3)',
+           'Set breakpoint 2: foo.rb:55 (@3)',
+           'Set breakpoint 3: foo.rb:55 (@3)',
+           'Set breakpoint 4: foo.rb:55 (@3)',
+           'xx ',
+           'x = 11   # line + 11',
+           'xx ',
+           'b = 6      # line +  6',
+           'xx ',
+           'c = 14     # line + 14'
+          ]
+    compare_output(out, d, cmds)
+  end
+
+end
+
+

data/test/functional/test-finish.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestFinish < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def test_finish_between_fn
+    # "Finish" over a recursive function. We use a recursive function
+    # so that we check that the temporary breakpoint created in the
+    # implementation is specific to the frame. See Rubinius issue
+    # #558.
+    def fact(x)
+      return 1 if x <= 1
+      x = x * fact(x-1)
+      return x
+    end
+    # An extra 'continue' added in case something goes wrong.
+    cmds = %w(step finish) + ['pr x', 'continue', 'continue'] 
+    d = strarray_setup(cmds)
+    d.start
+    ##############################
+    x = fact(4)
+    y = 5
+    ##############################
+    d.stop # ({:remove => true})
+    out = ['-- ',
+           'x = fact(4)',
+           '-> ',
+           'return 1 if x <= 1',
+           '<- ',
+           'return x',
+           '24']
+    compare_output(out, d, cmds)
+  end
+  
+  def test_finish_between_fn_simple
+    
+    # Finish over functions
+    def five; 5 end
+    def something(x)
+      return 1 if x <= 1
+      x = 
+        if five > 5
+          24
+        else
+          22
+        end
+    end
+    cmds = %w(step finish) + ['pr x', 'continue'] 
+    d = strarray_setup(cmds)
+    d.start
+    ##############################
+    x = something(4)
+    y = 5
+    ##############################
+    d.stop # ({:remove => true})
+    out = [
+           '-- ', 
+           'x = something(4)', 
+           '-> ',
+           'return 1 if x <= 1',
+           '<- ',
+           '22', '22']
+    compare_output(out, d, cmds)
+  end
+  
+end

data/test/functional/test-fn_helper.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestFnTestHelper < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def test_basic
+    assert_equal(__LINE__, get_lineno, 'get_lineno()')
+    assert_equal(0,
+                 '-- (/tmp/trepan/tmp/gcd.rb:4)' =~ TREPAN_LOC)
+    assert_equal(0, '(trepanx): exit' =~ TREPAN_PROMPT)
+
+    output='
+-- (/tmp/trepan/tmp/gcd.rb:4)
+(trepanx): s
+-- (/tmp/trepan/tmp/gcd.rb:18)
+(trepanx): s
+-- (/tmp/trepan/tmp/gcd.rb:19)
+(trepanx): s
+.. (/tmp/trepan/tmp/gcd.rb:0)
+(trepanx): s
+-> (/tmp/trepan/tmp/gcd.rb:4)
+'.split(/\n/)
+   expect='
+-- (/tmp/trepan/tmp/gcd.rb:4)
+-- (/tmp/trepan/tmp/gcd.rb:18)
+-- (/tmp/trepan/tmp/gcd.rb:19)
+.. (/tmp/trepan/tmp/gcd.rb:0)
+-> (/tmp/trepan/tmp/gcd.rb:4)
+'.split(/\n/)
+  assert_equal(expect, filter_line_cmd(output))
+  end
+  
+end
+
+
+
+
+
+

data/test/functional/test-list.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestBreak < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def test_list_frame_change
+    # Check that list update the frame position
+    # of sibling returns. We have one more 'continue' than we need
+    # just in case something goes wrong.
+    cmds_pat = [
+                'set max list 2',
+                'list', 
+                "continue %d", 
+                'list',
+                'up',
+                'list', 
+                'continue'].join("\n")
+    line = __LINE__
+    cmds = (cmds_pat % (line+5)).split(/\n/)
+    d = strarray_setup(cmds)
+    ##############################
+    def foo      # line +  4  
+      a = 5      # line +  5
+      b = 6      # line +  6
+    end          # line +  7
+    d.start      # line +  8
+    foo
+    ##############################
+    d.stop # ({:remove => true})
+    out = [
+           "-- ",
+           "foo",
+           "max list is 2.",
+           " 30   \t    d.start      # line +  8",
+           " 31 ->\t    foo",
+           "Set temporary breakpoint 1: foo.rb:55 (@3)",
+           "x1 ",
+           "a = 5      # line +  5",
+           " 26   \t    def foo      # line +  4  ",
+           " 27 ->\t      a = 5      # line +  5",
+           "   ",
+           "foo",
+           " 31 ->\t    foo",
+           " 32   \t    ##############################"
+          ]
+    compare_output(out, d, cmds)
+  end
+
+end
+
+

data/test/functional/test-next-bug.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+def discontinuous(obj)
+  if klass = obj.class and klass.kind_of?(String)
+    return true
+  end
+  return nil
+end
+
+class TestNextBug < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  # Sometimes a line may have a disconnected set of IP. For example
+  # Rubinius::VariableScope#method_visibility which has these
+  # offset/lines
+  #
+  # ... 0, 126, 22, 127, 29, 128, 43, 130, 48, 126, 50, ...
+  #        ^^^                                 ^^^
+  #
+  # Make sure when can "next" when we are stopped at the 2nd part of
+  # line 126 (offset 50). 
+  # 
+  def test_next_on_line_with_discontinuous_ips
+    lines = method(:discontinuous).executable.lines
+    unless lines.at(3) == lines.at(7) 
+      puts("Skipping #{__FILE__} test because code generated is not " +
+           "what we need to test here. Please fix.")
+    end
+    cmds = %w(step next continue)
+    d = strarray_setup(cmds)
+    d.start
+    discontinuous(4)
+    d.stop
+    out = ['-- ',
+           'discontinuous(4)',
+           '-> ',
+           'if klass = obj.class and klass.kind_of?(String)',
+           '-- ',
+           'return nil'
+          ]
+    compare_output(out, d, cmds)
+  end
+end
+
+

data/test/functional/test-next.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestNext < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def test_next_same_level
+
+    # See that we can next with parameter which is the same as 'next 1'
+    cmds = %w(next next continue)
+    d = strarray_setup(cmds)
+    d.start
+    x = 5
+    y = 6
+    d.stop
+    out = ['-- ', 'x = 5', '-- ', 'y = 6', '-- ', 'd.stop']
+    compare_output(out, d, cmds)
+    
+    # See that we can next with a computed count value
+    cmds = ['step', 'next 5-3', 'continue']
+    d = strarray_setup(cmds)
+    d.start
+    ########### t1 ###############
+    x = 5
+    y = 6
+    z = 7
+    ##############################
+    d.stop
+    out = ['-- ', 'x = 5', '-- ', 'y = 6', '-- ', 'd.stop']
+    compare_output(out, d, cmds)
+  end
+    
+  def test_next_between_fn
+    
+    # Next over functions
+    cmds = ['next 2', 'continue']
+    d = strarray_setup(cmds)
+    d.start
+    ########### t2 ###############
+    def fact(x)
+      return 1 if x <= 1
+      return fact(x-1)
+    end
+    x = fact(4)
+    y = 5
+    ##############################
+    d.stop # ({:remove => true})
+    out = ['-- ', 'def fact(x)', '-- ', 'y = 5']
+    compare_output(out, d, cmds)
+  end
+  
+  def test_scoped_next
+    # "Next" over a recursive function. We use a recursive function so
+    # that we check that the temporary breakpoint created in the
+    # implementation is specific to the frame. See Rubinius issue
+    # #558.
+    def fact(x)
+      return 1 if x <= 1
+      x = x * fact(x-1)
+      return x
+    end
+    cmds = ['step', 'next 3', 'pr x', 'continue'] 
+    d = strarray_setup(cmds)
+    d.start
+    ##############################
+    x = fact(4)
+    y = 5
+    ##############################
+    d.stop # ({:remove => true})
+    out = ['-- ',
+           'x = fact(4)',
+           '-> ',
+           'return 1 if x <= 1',
+           '-- ',
+           'return x',
+           '24']
+    compare_output(out, d, cmds)
+  end
+
+  # def test_next_in_exception
+  #   cmds = %w(next! continue)
+  #   d = strarray_setup(cmds)
+  #   d.start
+  #   ########### t2 ###############
+  #   begin
+  #     got_boom = false
+  #     x = 4/0
+  #   rescue
+  #     got_boom = true
+  #   end
+  #   ##############################
+  #   d.stop # ({:remove => true})
+  #   out = ['-- ', 'begin']
+  #   compare_output(out, d, cmds)
+  # end
+end
+
+

data/test/functional/test-step.rb

@@ -0,0 +1,272 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestStep < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  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.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 no_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 no_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 no_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 no_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-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