rbx-trepanning 0.0.2-universal-rubinius-1.2

data/test/unit/test-bin-trepanx.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rbconfig'
+load File.join(File.dirname(__FILE__), %w(.. .. bin trepanx))
+
+# Test bin/trepan Module methods
+class TestBinTrepan < Test::Unit::TestCase
+
+  include Trepanning
+
+  def test_ruby_path
+    rb_path = ruby_path
+    assert_equal(true, File.executable?(rb_path),
+                 "#{rb_path} should be an executable Ruby interpreter")
+
+    # Let us test that we get *exactly* the same configuration as we
+    # have in this. I'm a ball buster.
+    cmd = "#{rb_path} -rrbconfig -e 'puts Marshal.dump(RbConfig::CONFIG)'"
+    rb_config = Marshal.load(`#{cmd}`)
+    assert_equal(RbConfig::CONFIG, rb_config,
+                 "#{rb_path} config doesn't match got:
+#{rb_config}
+expected: 
+#{RbConfig::CONFIG}
+")
+  end
+
+  def test_whence_file
+    abs_path_me = File.expand_path(__FILE__)
+    assert_equal(abs_path_me, whence_file(abs_path_me),
+                 "whence_file should have just returned #{abs_path_me}")
+
+    basename_me = File.basename(__FILE__)
+    dirname_me  = File.dirname(__FILE__)
+
+    # Add my directory onto the beginning of PATH
+    path_dirs = ENV['PATH'].split(File::PATH_SEPARATOR)
+    path_dirs.unshift(dirname_me)
+    ENV['PATH'] = path_dirs.join(File::PATH_SEPARATOR)
+
+    assert_equal(File.join(dirname_me, basename_me), 
+                 whence_file(basename_me),
+                 "whence_file should have found me")
+    # Restore old path
+    path_dirs.shift 
+    ENV['PATH'] = path_dirs.join(File::PATH_SEPARATOR)
+  end
+end

data/test/unit/test-cmd-alias.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+require_relative '../../processor/command/alias'
+require_relative '../../processor/command/unalias'
+
+# Test commands alias and unalias
+class TestCommandAliasUnalias < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    common_setup
+    @name = File.basename(__FILE__, '.rb').split(/-/)[2]
+  end
+
+  def check_alias(should_not_have, cmd_name, *args)
+    @cmdproc.instance_variable_set('@msgs', [])
+    @cmdproc.instance_variable_set('@errmsgs', [])
+    arg_str = args.join(' ')
+    my_cmd   = @cmds[cmd_name]
+    my_cmd.run([cmd_name] + args)
+    shoulda = should_not_have ? ['no ', ''] : ['', 'no ']
+    msgs = @cmdproc.instance_variable_get('@msgs')
+    errmsgs = @cmdproc.instance_variable_get('@errmsgs')
+    assert_equal(should_not_have, msgs.empty?,
+                 "Expecting %s%s for #{arg_str}.\n Got #{msgs}" %
+                 [shoulda[0], cmd_name])
+    assert_equal(!should_not_have, errmsgs.empty?,
+                 "Expecting %serror for #{arg_str}.\n Got #{errmsgs}" %
+                 shoulda[1])
+  end
+
+  def alias_defined?(alias_name)
+    @cmdproc.aliases.member?(alias_name)
+  end
+  
+  def test_alias_command
+
+    assert_equal(false, @cmdproc.aliases.empty?,
+                 'There should be some aliases defined')
+
+    assert_equal(false, alias_defined?('ki'))
+    check_alias(false, 'alias', 'ki', 'kill')
+    assert_equal(true, alias_defined?('ki'))
+    check_alias(false, 'unalias', 'ki')
+    assert_equal(false, alias_defined?('ki'))
+  end
+end

data/test/unit/test-cmd-break.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+
+class TestCommandBreak < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    common_setup
+    @cmdproc.frame_setup
+    @name   = File.basename(__FILE__, '.rb').split(/-/)[2]
+    @my_cmd = @cmds[@name]
+  end
+  
+  def test_basic
+    place = "#{self.class}#test_basic:#{__LINE__}"
+    @my_cmd.run([@name, place])
+    assert_equal(true, @cmdproc.errmsgs.empty?,
+                 @cmdproc.errmsgs)
+  end
+
+end

data/test/unit/test-cmd-exit.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/mock'
+require_relative '../../processor/command/exit'
+
+class TestCommandExit < Test::Unit::TestCase
+
+  def setup
+    @name      = File.basename(__FILE__, '.rb').split(/-/)[2]
+    @dbg, @cmd = MockDebugger::setup(@name, false)
+  end
+
+  def test_basic
+    pid = fork { @cmd.run([@name, '10']) }
+    Process.wait
+    assert_equal(10, $?.exitstatus)
+    pid = fork { @cmd.run([@name]) }
+    Process.wait
+    assert_equal(0, $?.exitstatus)
+    # FIXME: should test that finalization routines get run;
+    # should test 'confirm' gets run; and should test that
+    # 'unconditional' is handled correctly.
+  end
+  
+
+end

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

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+require_relative '../../processor/command/help'
+
+class TestCommandHelp < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    common_setup
+    @name     = File.basename(__FILE__, '.rb').split(/-/)[2]
+    @my_cmd   = @cmds[@name]
+  end
+
+  def check_help(should_not_have, *args)
+    @cmdproc.instance_variable_set('@msgs', [])
+    @cmdproc.instance_variable_set('@errmsgs', [])
+    arg_str = args.join(' ')
+    @my_cmd.run([@name] + args)
+    shoulda = should_not_have ? ['no ', ''] : ['', 'no ']
+    msgs = @cmdproc.instance_variable_get('@msgs')
+    errmsgs = @cmdproc.instance_variable_get('@errmsgs')
+    assert_equal(should_not_have, msgs.empty?,
+                 "Expecting %shelp for %s.\n Got %s" %
+                 [shoulda[0], arg_str, msgs])
+    assert_equal(!should_not_have, errmsgs.empty?,
+                 "Expecting %serror for %s.\n Got %s" %
+                 [shoulda[1], arg_str, msgs])
+  end
+  
+  def test_help_command
+
+    # Test we can run 'help *cmd* for each command
+    @cmds.keys.each do |cmd_name| 
+      check_help(false, cmd_name) 
+    end
+
+    # Test we can run 'help *alias* for each alias
+    @cmdproc.aliases.keys.each do |alias_name| 
+      check_help(false, alias_name)
+    end
+
+    # double-check specific commands and aliases
+    %w(kill n help).each do |cmd_pat|
+      check_help(false, cmd_pat)
+    end
+
+    # Test patterns
+    %w(* k.* ki).each do |cmd_pat|
+      check_help(false, cmd_pat)
+    end
+
+    # Test categories
+    %w(running stack).each do |cmd_pat|
+      check_help(false, cmd_pat)
+    end
+
+    # # Test sub help and subhelp patterns
+    # [%w(info file), %w(show *)].each do |args|
+    #   check_help(false, args)
+    # end
+
+    # Test invalid commands
+    %w(bogus abcd.*).each do |cmd_pat|
+      check_help(true, cmd_pat)
+    end
+
+    # invalid help subcommands
+    [%w(info fdafds), %w(fedafdsa *)].each do |args|
+      check_help(true, *args)
+    end
+
+    # screwball error
+    check_help(true, '["info",')
+
+  end
+
+  # FIXME: Do better than this.
+  def check_subcmd_help(cmd_name, subcmd, *args)
+    def subcmd.msg(mess)
+      @msgs << mess
+    end
+    subcmd.instance_variable_set('@msgs', [])
+    subcmd.instance_variable_set('@errmsgs', [])
+    subcmd.help(cmd_name)
+    assert subcmd.instance_variable_get('@msgs')
+    # subcmd.help
+  end
+
+  def test_help_subcommand
+    # Get list of commands with subcmds
+    cmd_names = @cmds.values.map do |c| 
+      c.instance_variable_defined?(:@subcmds) ? c.name : nil
+    end.compact
+    cmd_names.each do |cmd_name|
+      check_subcmd_help(cmd_name, @cmds[cmd_name].subcmds)
+    end
+  end
+
+end

data/test/unit/test-cmd-kill.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/mock'
+require_relative '../../processor/command/kill'
+
+class TestCommandKill < Test::Unit::TestCase
+
+  def setup
+    @name      = File.basename(__FILE__, '.rb').split(/-/)[2]
+    @dbg, @cmd = MockDebugger::setup(@name, false)
+    def @cmd.msg(message)
+      @msgs << message
+    end
+    def @cmd.errmsg(message)
+      @errmsgs << message
+    end
+    reset_cmdproc_vars
+  end
+
+  def reset_cmdproc_vars
+    @cmd.instance_variable_set('@msgs', [])
+    @cmd.instance_variable_set('@errmsgs', [])
+    @cmd.proc.leave_cmd_loop = false
+  end
+  
+  def test_kill_command
+      @cmd.run([@name, 'foo'])
+      assert_equal(false,  @cmd.proc.leave_cmd_loop)
+      assert_equal(1, @cmd.instance_variable_get('@errmsgs').size)
+      
+    if false
+      save_trap = Signal.trap(10) {
+        @success = true
+      }
+      
+      @success = false
+      @cmd.run([@name, '10'])
+      #  assert_equal(true,  @success, 
+      #             'Should have run the handler')
+    end
+
+  ensure
+    # restore old trap if any
+    trap(10, save_trap)
+  end
+
+end

data/test/unit/test-intf-user.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# Unit test for rbdbgr.interface.user
+
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../interface/user'
+
+# Tests Trepan::UserInterface
+class TestInterfaceUser < Test::Unit::TestCase
+
+  # Test UserInterface.confirm()
+  def test_confirm
+    
+    user_intf = Trepan::UserInterface.new
+    def user_intf.readline(prompt)
+      $response_answer
+    end
+
+    ['y', 'Y', 'Yes', '  YES  '].each do |s|
+      $response_answer = s
+      ans = user_intf.confirm('Testing', true)
+      assert_equal(true, ans)
+    end
+    
+    ['n', 'N', 'No', '  NO  '].each do |s|
+      $response_answer = s
+      ans = user_intf.confirm('Testing', true)
+      assert_equal(false, ans)
+    end
+
+    def user_intf.readline(prompt)
+      raise EOFError
+    end
+
+    [true, false].each do |tf|
+      assert_equal(tf, user_intf.confirm('default testing', tf))
+    end
+
+    # Ok, we'll throw in one test of EOFError
+    assert_raises EOFError do 
+      user_intf.readline('')
+    end
+
+  end
+  # FIXME: more thorough testing of other routines in user.
+end

data/test/unit/test-io-input.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../io/input'
+
+# Test Trepan::UserInput
+class TestIOInput < Test::Unit::TestCase
+
+  def test_UserInput
+    inp = Trepan::UserInput.open(__FILE__)
+    assert inp, 'Should have gotten a Trepan::UserInput object back'
+    line = inp.readline.chomp
+    assert_equal '#!/usr/bin/env ruby', line
+    assert_equal false, inp.eof?
+    inp.close
+    assert_equal true, inp.closed?
+    inp = Trepan::UserInput.open(__FILE__)
+    while not inp.eof?
+      begin
+        inp.readline
+      rescue EOFError
+        assert_equal(true, inp.eof?, 
+                     'EOF should be true after EOFError')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+require_relative '../../app/frame'
+require_relative '../../processor/eval'
+require_relative '../../processor/mock'
+
+# Test Trepan::CmdProcessor Eval portion
+class TestProcEval < Test::Unit::TestCase
+
+  include UnitHelper
+  def test_basic
+    common_setup
+    @dbgr    = Trepan.new
+    @cmdproc = Trepan::CmdProcessor.new(@dbgrr)
+    assert_equal('(eval "x = 1; y = 2")',
+
+                 @cmdproc.fake_eval_filename('x = 1; y = 2'))
+    assert_equal('(eval "x = 1;"...)',
+                 @cmdproc.fake_eval_filename('x = 1; y = 2', 7))
+
+    @cmdproc.instance_variable_set('@settings', {:stack_trace_on_error => true})
+    # x = 1
+    # vm_locations = Rubinius::VM.backtrace(0, true)
+    # @dbgr.instance_variable_set('@vm_locations', vm_locations)
+    # @cmdproc.instance_variable_set('@current_frame', 
+    #                                Trepan::Frame.new(self, 0, vm_locations[0]))
+    # @cmdproc.instance_variable_set('@settings', {:stack_trace_on_error => true})
+    # assert_equal('1', @cmdproc.debug_eval('x = "#{x}"'))
+    # x = 2
+    # assert_equal('2', @cmdproc.debug_eval_no_errmsg('x = "#{x}"'))
+    # assert_equal(nil, @cmdproc.debug_eval_no_errmsg('x+'))
+  end
+end

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

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+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 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(i+1, $msgs.size)
+    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-load_cmds.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/main'
+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_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,48 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require 'linecache'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+require_relative '../../processor/location'
+require_relative '../../processor/mock'
+
+$errors = []
+$msgs   = []
+
+# Test Trepan::CmdProcessor location portion
+class TestCmdProcessorLocation < Test::Unit::TestCase
+
+  def setup
+    $errors = []
+    $msgs   = []
+    @dbgr = MockDebugger::MockDebugger.new
+    @proc = Trepan::CmdProcessor.new(@dbgr)
+    @file = File.basename(__FILE__)
+  end
+
+  # Test resolve_file_with_dir() and line_at()
+  def test_line_at
+    @proc.settings[:directory] = ''
+    assert_equal(nil, @proc.resolve_file_with_dir(@file))
+    assert_equal(nil, @proc.line_at(@file, __LINE__))
+    dir = @proc.settings[:directory] = File.dirname(__FILE__)
+    assert_equal(File.join(dir, @file), 
+                 @proc.resolve_file_with_dir('test-proc-location.rb'))
+    test_line = 'test_line'
+    line = @proc.line_at(@file, __LINE__-1)
+    assert_match(/#{line}/, line)
+  end
+
+  def test_loc_and_text
+    @proc.frame_index = 0
+    @proc.frame_initialize
+    @proc.frame_setup
+    LineCache::clear_file_cache
+    dir = @proc.settings[:directory] = File.dirname(__FILE__)
+    loc, line_no, text = @proc.loc_and_text('hi')
+    assert loc and line_no.is_a?(Fixnum) and text 
+    # FIXME test that filename remapping works.
+  end
+
+end