rbx-trepanning 0.2.0-universal-rubinius-2.0

data/test/functional/test-list.rb

@@ -0,0 +1,56 @@
+#!/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.",
+           " 31  ->\t    foo",
+           " 32    \t    ##############################",
+           "Set temporary breakpoint 1: foo.rb:55 (@3)",
+           "x1 ",
+           "a = 5      # line +  5",
+           " 27  ->\t      a = 5      # line +  5",
+           " 28    \t      b = 6      # line +  6",
+           "--> #1 TestBreak#test_list_frame_change at test-list.rb:31",
+           "   ",
+           "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-recursive-bt.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestRecursiveBt < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def test_recursive_backtrace
+
+    cmds = [
+            'set basename on',
+            'next',
+            'bt 1',
+            'step',
+            'step',
+            'bt 2',
+            'step',
+            'step',
+            'bt 3',
+            'step',
+            'step',
+            'step',
+            'bt 5',
+            'step',
+            'step',
+            'step',
+            'bt 7',
+            'continue'
+            ]
+    d = strarray_setup(cmds)
+    d.start
+    ##############################
+    def factorial(n)
+      if n > 0
+        return n * factorial(n-1)
+      else
+        return 1
+      end
+    end
+    z = factorial(5)
+    ##############################
+    d.stop
+    out = 
+      ["-- ",
+       "def factorial(n)",
+       "basename is on.",
+       "-- ",
+       "z = factorial(5)",
+       "--> #0 TestRecursiveBt#test_recursive_backtrace at test-recursive-bt.rb:42",
+       "(More stack frames follow...)",
+       "-> ",
+       "if n > 0",
+       "-- ",
+       "return n * factorial(n-1)",
+       "--> #0 TestRecursiveBt#factorial(n) at test-recursive-bt.rb:37",
+       "    #1 TestRecursiveBt#test_recursive_backtrace at test-recursive-bt.rb:42",
+       "(More stack frames follow...)",
+       "-> ",
+       "if n > 0",
+       "-- ",
+       "return n * factorial(n-1)",
+       "--> #0 TestRecursiveBt#factorial(n) at test-recursive-bt.rb:37",
+       "    #1 TestRecursiveBt#factorial(n) at test-recursive-bt.rb:37",
+       "    #2 TestRecursiveBt#test_recursive_backtrace at test-recursive-bt.rb:42",
+       "(More stack frames follow...)",
+       "-> ",
+       "if n > 0",
+       "-- ",
+       "return n * factorial(n-1)",
+       "-> ",
+       "if n > 0",
+       "--> #0 TestRecursiveBt#factorial(n) at test-recursive-bt.rb:36",
+       "    #1 TestRecursiveBt#factorial(n) at test-recursive-bt.rb:37",
+       "... above line repeated 2 times",
+       "    #4 TestRecursiveBt#test_recursive_backtrace at test-recursive-bt.rb:42",
+       "(More stack frames follow...)",
+       "-- ",
+       "return n * factorial(n-1)",
+       "-> ",
+       "if n > 0",
+       "-- ",
+       "return n * factorial(n-1)",
+       "--> #0 TestRecursiveBt#factorial(n) at test-recursive-bt.rb:37",
+       "    #1 TestRecursiveBt#factorial(n) at test-recursive-bt.rb:37",
+       "... above line repeated 3 times",
+       "    #5 TestRecursiveBt#test_recursive_backtrace at test-recursive-bt.rb:42",
+       "    #6 Test::Unit::TestCase(TestRecursiveBt)#run(result) at testcase.rb:78",
+       "(More stack frames follow...)"]
+    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

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/.gitignore

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