trepanning 0.0.4

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

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+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-cmd-quit.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../processor/mock'
+require_relative '../../processor/command/quit'
+
+class TestCommandQuit < 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-step.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative 'cmd-helper'
+require_relative '../../processor/command/step'
+
+class TestCommandStep < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    common_setup
+    @name     = File.basename(__FILE__, '.rb').split(/-/)[2]
+    @my_cmd   = @cmds[@name]
+  end
+
+  def reset_cmdproc_vars
+    @cmdproc.instance_variable_set('@msgs', [])
+    @cmdproc.instance_variable_set('@errmsgs', [])
+    @cmdproc.leave_cmd_loop = false
+  end
+  
+  def test_step_command
+    @my_cmd.run([@name, 'foo'])
+    assert_equal(false,  @cmdproc.leave_cmd_loop)
+
+    reset_cmdproc_vars
+    @my_cmd.run([@name, '5'])
+    assert_equal(true,  @cmdproc.leave_cmd_loop)
+    assert_equal(4,  @core.step_count)
+
+    reset_cmdproc_vars
+    @my_cmd.run([@name])
+    assert_equal(true,  @cmdproc.leave_cmd_loop)
+    assert_equal(0,  @core.step_count)
+
+    reset_cmdproc_vars
+    @my_cmd.run([@name, '1+(2*3)'])
+    assert_equal(true,  @cmdproc.leave_cmd_loop)
+    assert_equal(6,  @core.step_count)
+
+    reset_cmdproc_vars
+    @my_cmd.run([@name, '1+foo'])
+    assert_equal(false,  @cmdproc.leave_cmd_loop)
+  end
+
+end

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

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# Unit test for trepan.interface.user
+
+require 'test/unit'
+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,26 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+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,26 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+require_relative '../../processor/eval'
+require_relative '../../app/mock'
+
+# Test Trepan::CmdProcessor Eval portion
+class TestProcEval < Test::Unit::TestCase
+
+  def test_basic
+    cmdp = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+    assert_equal('(eval "x = 1; y = 2")',
+                 cmdp.fake_eval_filename('x = 1; y = 2'))
+    assert_equal('(eval "x = 1;"...)',
+                 cmdp.fake_eval_filename('x = 1; y = 2', 7))
+    x = 1
+    require 'thread_frame'
+    cmdp.instance_variable_set('@frame', RubyVM::ThreadFrame.current)
+    cmdp.instance_variable_set('@settings', {:stack_trace_on_error => true})
+    assert_equal('1', cmdp.debug_eval('x = "#{x}"'))
+    x = 2
+    assert_equal('2', cmdp.debug_eval_no_errmsg('x = "#{x}"'))
+    assert_equal(nil, cmdp.debug_eval_no_errmsg('x+'))
+  end
+end

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

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'thread_frame'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+require_relative '../../processor/frame'
+require_relative '../../app/mock'
+
+$errors = []
+$msgs   = []
+
+# Test Trepan::CmdProcessor Frame portion
+class TestCmdProcessorFrame < Test::Unit::TestCase
+
+  def setup
+    $errors = []
+    $msgs   = []
+    @proc    = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+    @proc.frame_index = 0
+    class << @proc
+      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
+
+  # See that we have can load up commands
+  def test_basic
+    @proc.frame_setup(RubyVM::ThreadFrame.current)
+    @proc.hidelevels = {}
+
+    # Test absolute positioning. Should all be okay
+    0.upto(@proc.top_frame.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.top_frame.stack_size-1, true)
+    assert_equal(1, $errors.size, $errors)
+    assert_equal(frame_index, @proc.frame_index)
+
+    setup
+    @proc.top_frame  = @proc.frame = RubyVM::ThreadFrame.current
+    @proc.hidelevels = {}
+    @proc.adjust_frame(0, true)
+
+    @proc.top_frame.stack_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,15 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+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,29 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+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,40 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../processor/load_cmds'
+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-main.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../processor/main'
+require_relative '../../app/core'
+
+# Mock debugger stub. FIXME: put in comment helper routine.
+class Trepan
+end
+
+# Test Trepan:CmdProcessor
+class TestCmdProcessor < Test::Unit::TestCase
+
+  def setup
+    @dbg     = Trepan.new
+    @core    = Trepan::Core.new(@dbg)
+    @cmdproc = @core.processor = Trepan::CmdProcessor.new(@core)
+    @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 test_compute_prompt
+    assert_equal('(trepan): ', @cmdproc.compute_prompt)
+    Thread.new{ assert_equal('(trepan@55): ', @cmdproc.compute_prompt.gsub(/@\d+/, '@55'))}.join
+    x = Thread.new{ Thread.pass; x = 1 }
+    assert_equal('(trepan@main): ', @cmdproc.compute_prompt)
+    x.join
+    @cmdproc.debug_nest += 1
+    assert_equal('((trepan)): ', @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 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)
+      $msgs << "#{mess}"
+    end
+    def @cmdproc.errmsg(mess)
+      $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,90 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../processor/main' # Have to include before validate!
+                                        # FIXME
+require_relative '../../processor/validate'
+require_relative '../../app/mock'
+
+$errors = []
+$msgs   = []
+
+# Test Trepan::CmdProcessor Validation portion
+class TestValidate < Test::Unit::TestCase
+
+  def setup
+    $errors = []
+    $msgs   = []
+    @proc    = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+
+    class << @proc
+      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
+
+  # See that we have can load up commands
+  def test_basic
+    onoff = 
+    [['1', true],  ['on', true],
+     ['0', false], ['off', false]].each do |arg, expected|
+      assert_equal(expected, @proc.get_onoff(arg))
+    end
+    [['1', 1],  ['1E', nil], ['bad', nil], ['1+1', 2], ['-5', -5]].each do 
+      |arg, expected|
+      assert_equal(expected, @proc.get_int_noerr(arg))
+    end
+  end
+
+  def test_breakpoint_position
+    require 'thread_frame'
+    tf = RubyVM::ThreadFrame.current
+    @proc.frame_setup(tf)
+
+    def munge(args)
+      args[1] = 'bogus'
+      args
+    end
+
+    assert_equal([0, 'bogus', true, 'true', nil],
+                 munge(@proc.breakpoint_position(%w(O0))))
+    assert_equal([1, 'bogus', false, 'true', nil], 
+                 munge(@proc.breakpoint_position(%w(1))))
+    assert_equal([2, 'bogus', false, 'a > b', nil],
+                 munge(@proc.breakpoint_position(%w(2 if a > b))))
+  end
+
+  def test_int_list
+    assert_equal([1,2,3], @proc.get_int_list(%w(1+0 3-1 3)))
+    assert_equal(0, $errors.size)
+    assert_equal([2,3], @proc.get_int_list(%w(a 2 3)))
+    assert_equal(1, $errors.size)
+  end
+
+  def test_method?
+    def foo; 5 end
+    
+    # require_relative '../../lib/trepan'
+    # dbgr = Trepan.new(:set_restart => true)
+    # FIXME: 'foo', 'errmsg'
+    ['Array#map', 'Trepan::CmdProcessor.new'
+    ].each do |str|
+      # dbgr.debugger if 'foo' == str
+      assert_equal(true, @proc.method?(str),
+                   "#{str} should be known as a method")
+    end
+    ['food', '.errmsg'
+    ].each do |str|
+      # dbgr.debugger if 'foo' == str
+      assert_equal(false, @proc.method?(str),
+                   "#{str} should be known as a method")
+    end
+
+  end
+
+end

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

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../processor/main'
+require_relative '../../app/core'
+
+# Mock debugger stub. FIXME: put in comment helper routine.
+class Trepan
+end
+
+# Test Trepan::CmdProcessor
+class TestSubCmdHelp < Test::Unit::TestCase
+
+  def setup
+    @dbg     = Trepan.new
+    @core    = Trepan::Core.new(@dbg)
+    @cmdproc = @core.processor = Trepan::CmdProcessor.new(@core)
+    @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