rbx-trepanning 0.2.0-universal-rubinius-2.0

data/test/unit/test-proc-frame.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor'
+require_relative '../../processor/frame'
+require_relative '../../processor/mock'
+
+$errors = []
+$msgs   = []
+
+# Test Trepan::CmdProcessor Frame portion
+class TestCmdProcessorFrame < Test::Unit::TestCase
+
+  def setup
+    $errors = []
+    $msgs   = []
+    @dbgr = MockDebugger::MockDebugger.new
+    @proc = Trepan::CmdProcessor.new(@dbgr)
+    @proc.frame_index = 0
+    @proc.frame_initialize
+    class << @proc
+      def msg(msg)
+        $msgs << msg
+      end
+      def errmsg(msg)
+        $errors << msg
+      end
+      def print_location
+        # $msgs << "#{@frame.source_container} #{@frame.source_location[0]}"
+        $msgs << File.basename(@frame.file)
+        # puts $msgs
+      end
+    end
+  end
+
+  # See that we have can load up commands
+  def test_basic
+    @proc.frame_setup
+
+    # Test absolute positioning. Should all be okay
+    0.upto(@proc.stack_size-1) do |i| 
+      @proc.adjust_frame(i, true) 
+      assert_equal(0, $errors.size)
+      assert_equal(true, $msgs.size >= i+1)
+    end
+
+    # Test absolute before the beginning fo the stack
+    frame_index = @proc.frame_index
+    @proc.adjust_frame(-1, true)
+    assert_equal(0, $errors.size)
+    assert_equal(frame_index, @proc.frame_index)
+    @proc.adjust_frame(-@proc.stack_size-1, true)
+    assert_equal(1, $errors.size, $errors)
+    assert_equal(frame_index, @proc.frame_index)
+
+    ## FIXME: look over and reinstate this code...
+    # setup
+    # @proc.top_frame  = @proc.frame = @dbgr.vm_locations[0]
+    # @proc.adjust_frame(0, true)
+
+    # @dbgr.vm_locations.size-1.times do 
+    #   frame_index = @proc.frame_index
+    #   @proc.adjust_frame(1, false) 
+    #   assert_equal(0, $errors.size)
+    #   assert_not_equal(frame_index, @proc.frame_index,
+    #                    '@proc.frame_index should have moved')
+    # end
+
+    # FIXME: bug in threadframe top_frame.stack_size? 
+    # # Adjust relative beyond the end
+    # @proc.adjust_frame(1, false) 
+    # assert_equal(1, $errors.size)
+
+    # Should have stayed at the end
+    # proc.adjust_frame(proc.top_frame.stack_size-1, true)
+    # proc.top_frame.stack_size.times { proc.adjust_frame(-1, false) }
+
+  end
+
+
+end

data/test/unit/test-proc-help.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/help'
+
+# Test Trepan::CmdProcessor
+class TestCmdProcessor < Test::Unit::TestCase
+
+  include Trepan::Help
+  # See that we have can load up commands
+  def test_abbrev_stringify
+    assert_equal('(test)ing', 
+                 abbrev_stringify('testing', 'test'.size))
+  end
+
+end

data/test/unit/test-proc-hook.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/hook'
+
+# Test Debugger:CmdProcessor Hook portion
+class TestProcHook < Test::Unit::TestCase
+
+  def test_basic
+    @args = []
+    hook1 = Proc.new {|name, a| @args << [name, a]}
+    hooks = Trepan::CmdProcessor::Hook.new()
+    assert_equal(true, hooks.empty?)
+    hooks.insert(-1, 'hook1', hook1)
+    hooks.run
+    assert_equal([['hook1', nil]], @args)
+    hooks.insert_if_new(-1, 'hook1', hook1)
+    assert_equal([['hook1', nil]], @args)
+    
+    @args = []
+    hooks.insert_if_new(-1, 'hook2', hook1)
+    hooks.run(10)
+    assert_equal([['hook1', 10], ['hook2', 10]], @args)
+
+    @args = []
+    hooks.delete_by_name('hook2')
+    hooks.run(30)
+    assert_equal([['hook1', 30]], @args)
+  end
+end

data/test/unit/test-proc-list.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor'
+require_relative '../../processor/frame'
+require_relative '../../processor/list'
+require_relative '../../processor/mock'
+
+# Test Trepan::CmdProcessor List portion
+class TestProcList < Test::Unit::TestCase
+
+  def setup
+    $errors = []
+    $msgs   = []
+    @dbgr = MockDebugger::MockDebugger.new
+    @proc = Trepan::CmdProcessor.new(@dbgr)
+    @proc.frame_index = 0
+    @proc.frame_initialize
+    class << @proc
+      def msg(msg)
+        $msgs << msg
+      end
+      def errmsg(msg)
+        $errors << msg
+      end
+      def print_location
+        # $msgs << "#{@frame.source_container} #{@frame.source_location[0]}"
+        $msgs << "#{@frame.source_container} "
+        # puts $msgs
+      end
+    end
+  end
+
+  def test_basic
+    @proc.frame_setup
+
+    def foo; 5 end
+    def check(cmdp, arg, last=10)
+      r =  cmdp.parse_list_cmd('.', last)
+      assert r[1]
+      assert r[2]
+      assert r[3]
+    end
+    check(@proc, '-')
+    check(@proc, 'foo')
+    check(@proc, '@0')
+    check(@proc, "#{__LINE__}")
+    check(@proc, "#{__FILE__}   @0")
+    check(@proc, "#{__FILE__}:#{__LINE__}")
+    check(@proc, "#{__FILE__} #{__LINE__}")
+    check(@proc, "#{__FILE__} #{__LINE__}", -10)
+    check(@proc, "@proc.errmsg")
+    check(@proc, "@proc.errmsg:@0")
+  end
+end

data/test/unit/test-proc-load_cmds.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor'
+require_relative '../../app/mock'
+
+class TestCmdProcessorLoadCmds < Test::Unit::TestCase
+
+  def setup
+    @proc = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+    @proc.instance_variable_set('@settings', {})
+  end
+
+  # See that we have can load up commands
+  def test_basic
+    @proc.load_cmds_initialize
+    assert_equal(false, @proc.commands.empty?)
+    assert_equal(false, @proc.aliases.empty?)
+  end
+
+  def test_complete
+    assert_equal(%w(delete directory disable disassemble display down),
+                 @proc.complete('d', 'd'),
+                 "Failed completion of 'd' commands")
+    assert_equal(['debug', 'different', 'directories'], 
+                 @proc.complete('sho d', 'd'),
+                 "Failed completion of 'sho d' subcommands")
+    $errors = []
+  end
+
+  def test_run_cmd
+    $errors = []
+
+    def @proc.errmsg(mess)
+      $errors << mess
+    end
+
+    def test_it(size, *args)
+      @proc.run_cmd(*args)
+      assert_equal(size, $errors.size, $errors)
+    end
+    test_it(1, 'foo')
+    test_it(2, [])
+    test_it(3, ['list', 5])
+    # See that we got different error messages
+    assert_not_equal($errors[0], $errors[1], $errors)
+    assert_not_equal($errors[1], $errors[2], $errors)
+    assert_not_equal($errors[2], $errors[0], $errors)
+  end
+
+end

data/test/unit/test-proc-location.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require 'linecache'
+require_relative '../../processor/location'
+require_relative 'cmd-helper'
+
+# Test Trepan::CmdProcessor location portion
+class TestCmdProcessorLocation < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    common_setup
+    @file ||= File.basename(__FILE__)
+  end
+
+  # Test resolve_file_with_dir() and line_at()
+  def test_line_at
+    @cmdproc.settings[:directory] = ''
+    assert_equal(nil, @cmdproc.resolve_file_with_dir(@file))
+    if File.expand_path(Dir.pwd) == File.expand_path(File.dirname(__FILE__))
+      line = @cmdproc.line_at(@file, __LINE__)
+      assert_match(/line = @cmdproc.line_at/, line)
+    else
+      assert_equal(nil, @cmdproc.line_at(@file, __LINE__))
+    end
+    dir = @cmdproc.settings[:directory] = File.dirname(__FILE__)
+    assert_equal(File.join(dir, @file), 
+                 @cmdproc.resolve_file_with_dir('test-proc-location.rb'))
+    test_line = 'test_line'
+    line = @cmdproc.line_at(@file, __LINE__-1)
+    assert_match(/#{line}/, line)
+  end
+
+  def test_loc_and_text
+    @cmdproc.frame_index = 0
+    @cmdproc.frame_initialize
+    @cmdproc.frame_setup
+    LineCache::clear_file_cache
+    dir = @cmdproc.settings[:directory] = File.dirname(__FILE__)
+    loc, line_no, text = @cmdproc.loc_and_text('hi')
+    assert loc and line_no.is_a?(Fixnum) and text 
+    assert @cmdproc.current_source_text
+    # FIXME test that filename remapping works.
+  end
+
+  def test_canonic_file
+    @cmdproc.settings[:basename] = false
+    assert_equal __FILE__, @cmdproc.canonic_file(__FILE__)
+    assert @cmdproc.canonic_file('lib/compiler/ast.rb')
+    @cmdproc.settings[:basename] = true
+    assert_equal File.basename(__FILE__), @cmdproc.canonic_file(__FILE__)
+    assert_equal 'ast.rb', @cmdproc.canonic_file('lib/compiler/ast.rb')
+  end
+
+
+  def test_eval_current_source_text
+    eval <<-EOE
+      @cmdproc.frame_index = 0
+      @cmdproc.frame_initialize
+      @cmdproc.frame_setup
+      LineCache::clear_file_cache
+      assert @cmdproc.current_source_text
+    EOE
+  end
+
+end

data/test/unit/test-proc-main.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+require_relative '../../processor'
+## require_relative '../../app/core'
+
+# Test Trepan:CmdProcessor
+class TestCmdProcessor < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    common_setup
+    @cmds = @cmdproc.instance_variable_get('@commands')
+  end
+
+  # See that we have can load up commands
+  def test_command_load
+    assert @cmds.is_a?(Hash), 'Should have gotten a command hash'
+    assert @cmds.keys.size > 0, 'Should have found at least one command'
+    cmd_name, cmd_obj = @cmds.first
+    assert cmd_name.is_a?(String), 'Should have string name for a command'
+    assert(cmd_obj.kind_of?(Trepan::Command), 
+           'Command should be a Trapan::Command')
+    assert cmd_obj.respond_to?(:run), 'Command should have a run method'
+  end
+
+  def no_test_compute_prompt
+    assert_equal('(rbdbgr): ', @cmdproc.compute_prompt)
+    Thread.new{ assert_equal('(rbdbgr@55): ', @cmdproc.compute_prompt.gsub(/@\d+/, '@55'))}.join
+    x = Thread.new{ Thread.pass; x = 1 }
+    assert_equal('(rbdbgr@main): ', @cmdproc.compute_prompt)
+    x.join
+    @cmdproc.debug_nest += 1
+    assert_equal('((rbdbgr)): ', @cmdproc.compute_prompt)
+    @cmdproc.debug_nest -= 1
+  end
+
+  # See that each command has required constants defined.  Possibly in
+  # a strongly-typed language we wouldn't need to do much of this.
+  def test_command_class_vars
+    @cmds.each do |cmd_name, cmd|
+      %w(HELP CATEGORY NAME SHORT_HELP).each do
+        |const|
+        value = cmd.class.const_get(const)
+        assert(value.is_a?(String),
+               "#{const} in command #{cmd_name} should be a String; got #{value}.")
+      end
+      %w(MIN_ARGS MAX_ARGS).each do
+        |const|
+        value = cmd.class.const_get(const)
+        assert(value.is_a?(Fixnum) || value.nil?,
+               "#{const} in command #{cmd_name} should be a Fixnum or nil; got #{value}.")
+      end
+      %w(ALIASES).each do
+        |const|
+        next unless cmd.class.constants.member?(:ALIASES)
+        ary = cmd.class.const_get(const)
+        assert(ary.is_a?(Array),
+               "#{const} in command #{cmd_name} should be an Array")
+
+        ary.each do |v| 
+          assert(v.is_a?(String),
+                 "#{const} in command #{cmd_name} should be Array of Strings; got #{v}.")
+        end
+      end
+    end
+  end
+
+  def no__test_run_command
+    def run_and_check(cmd, expect_msgs, expect_errmsgs, add_msg)
+      $errs = []; $msgs = []
+      @cmdproc.run_command(cmd)
+      assert_equal(expect_msgs, $msgs, 
+                   "#{add_msg}: mismatched messages from #{caller[0]}")
+      assert_equal(expect_errmsgs, $errs, 
+                   "Mismatched error messages from #{caller[0]}")
+    end
+    def @cmdproc.msg(mess, opts={})
+      $msgs << "#{mess}"
+    end
+    def @cmdproc.errmsg(mess, opts={})
+      $errs << "#{mess}"
+    end
+    run_and_check('!s=1', ['D=> 1'], [], "! evaluation")
+    run_and_check('print "foo"', ['foo'], [], "print command")
+    run_and_check('set autoeval off', 
+                  ['Evaluation of unrecognized debugger commands is off.'], [], 
+                  "autoeval set")
+    run_and_check('asdf', [], 
+                  ['Undefined command: "asdf". Try "help".'], 
+                  "invalid command")
+    
+  end
+
+end

data/test/unit/test-proc-validate.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor'
+require_relative '../../processor/validate'
+require_relative '../../app/mock'
+require_relative 'cmd-helper'
+
+$errors = []
+$msgs   = []
+
+# Test Trepan::CmdProcessor Validation portion
+class TestValidate < Test::Unit::TestCase
+
+  def setup
+    $errors  = []
+    $msgs    = []
+    @dbg   ||= MockDebugger::MockDebugger.new(:nx => true)
+    @cmdproc = Trepan::CmdProcessor.new(@dbg)
+
+    class << @cmdproc
+      def errmsg(msg)
+        $errors << msg
+      end
+      def print_location
+        # $msgs << "#{@frame.source_container} #{@frame.source_location[0]}"
+        $msgs << "#{@frame.source_container} "
+        # puts $msgs
+      end
+    end
+  end
+
+  def test_get_int
+    [['1', 1],  ['1E', nil], ['bad', nil], ['1+1', 2], ['-5', -5]].each do 
+      |arg, expected|
+      assert_equal(expected, @cmdproc.get_int_noerr(arg))
+    end
+  end
+
+  def test_get_on_off
+    onoff = 
+    [['1', true],  ['on', true],
+     ['0', false], ['off', false]].each do |arg, expected|
+      assert_equal(expected, @cmdproc.get_onoff(arg))
+    end
+  end
+
+  include UnitHelper
+  def outer_line
+    @line = __LINE__
+  end
+
+  def test_parse_position
+    common_setup
+    outer_line
+    @dbg.instance_variable_set('@current_frame',
+                               Trepan::Frame.new(self, 0,
+                                                 Rubinius::VM.backtrace(0, true)[0]))
+    @cmdproc.frame_setup
+    file = File.basename(__FILE__)
+    [
+     [__FILE__, [true, file, nil, nil]],
+     ['@8', [true, file, 8, :offset]],
+     [@line.to_s , [true, file, @line, :line]],
+     ['2' , [true, file, 2, :line]],
+     ["#{__FILE__}:#{__LINE__}" , [true, file, __LINE__, :line]],
+     ["#{__FILE__} #{__LINE__}" , [true, file, __LINE__, :line]]
+    ].each do |pos_str, expected|
+      result = @cmdproc.parse_position(pos_str)
+      result[1] = File.basename(result[1])
+      result[0] = !!result[0]
+      assert_equal(expected, result, "parsing position #{pos_str}")
+    end
+  end
+
+  def test_file_exists_proc
+    load 'tmpdir.rb'
+    # %W(#{__FILE__} tmpdir.rb mock.rb).each do |name|
+    %W(#{__FILE__}).each do |name|
+      assert_equal true, @cmdproc.file_exists_proc.call(name), "Should find #{name}"
+    end
+    %W(#{File.dirname(__FILE__)} tmpdir).each do |name|
+      assert_equal false, !!@cmdproc.file_exists_proc.call(name), "Should not find #{name}"
+    end
+  end
+
+  def test_breakpoint_position
+    start_line = __LINE__
+    common_setup
+    outer_line
+    @dbg.instance_variable_set('@current_frame',
+                               Trepan::Frame.new(self, 0,
+                                                 Rubinius::VM.backtrace(0, true)[0]))
+    @cmdproc.frame_setup
+
+    def munge(args)
+      args[0] = args[0].class
+      args
+    end
+
+    assert_equal([Rubinius::CompiledMethod, start_line, 0, 'true', false],
+                 munge(@cmdproc.breakpoint_position('@0', false)))
+    result = @cmdproc.breakpoint_position("outer_line:#{@line}", true)
+    result[0] = result[0].name
+    assert_equal([:outer_line, @line, 0, 'true', false], result)
+    result = @cmdproc.breakpoint_position("#{@line} unless 1 == 2", true)
+    result[0] = result[0].name
+    assert_equal([:outer_line, @line, 0, '1 == 2', true], result)
+  end
+
+  def test_int_list
+    assert_equal([1,2,3], @cmdproc.get_int_list(%w(1+0 3-1 3)))
+    assert_equal(0, $errors.size)
+    assert_equal([2,3], @cmdproc.get_int_list(%w(a 2 3)))
+    assert_equal(1, $errors.size)
+  end
+
+  def test_method?
+    def foo; 5 end
+    
+    # require_relative '../../lib/rbdbgr'
+    # dbgr = Trepan.new(:set_restart => true)
+    # FIXME: 'foo',
+    ['Array.map', 'Trepan::CmdProcessor.new',
+     'errmsg'
+    ].each do |str|
+      # dbgr.debugger if 'foo' == str
+      assert @cmdproc.method?(str), "#{str} should be known as a method"
+    end
+    ['food', '.errmsg'
+    ].each do |str|
+      # dbgr.debugger if 'foo' == str
+      assert_equal(false, !!@cmdproc.method?(str),
+                   "#{str} should not be known as a method")
+    end
+
+  end
+
+end

data/test/unit/test-subcmd-help.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor'
+
+# Test Trepan::CmdProcessor
+class TestSubCmdHelp < Test::Unit::TestCase
+
+  def setup
+    @dbg     = Trepan.new
+    @cmdproc = Trepan::CmdProcessor.new(@dbg)
+    @cmds    = @cmdproc.instance_variable_get('@commands')
+  end
+
+  # See that subcommand class constants exist.
+  def test_required_class_constants
+    @cmds.each do |cmd_name, cmd|
+      if cmd.is_a?(Trepan::SubcommandMgr)
+        cmd.subcmds.subcmds.each do |subcmd_name, subcmd|
+          where = "of subcommand #{subcmd_name} in command #{cmd_name}"
+          %w(HELP NAME SHORT_HELP).each do
+            |const|
+            value = subcmd.my_const(const)
+            assert_equal(true, value.is_a?(String),
+                         "#{const} #{where} should be a String; got #{value}.")
+          end
+          value = subcmd.my_const('MIN_ABBREV')
+          assert(value.is_a?(Fixnum),
+                 "MIN_ABBREV #{where} should be a Fixnum; got #{value}.")
+
+          if 'show' == cmd_name
+            short_help = subcmd.my_const('SHORT_HELP')
+            needed_start = 'Show '
+            assert_equal(needed_start, short_help[0..needed_start.size-1],
+                         "Short help #{where} should start: \"#{needed_start}\"; got #{short_help}")
+          end
+        end
+      end
+    end
+  end
+
+
+end