rbx-trepanning 0.0.5-universal-rubinius-1.2.1

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,48 @@
+#!/usr/bin/env ruby
+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,22 @@
+#!/usr/bin/env ruby
+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 './mock-helper'
+require_relative '../../processor/command/exit'
+
+class TestCommandExit < Test::Unit::TestCase
+  include MockUnitHelper
+  def setup
+    @name      = File.basename(__FILE__, '.rb').split(/-/)[2]
+    common_setup(@name)
+  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-finish.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+
+class TestCommandFinish < 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
+    [
+     [%W(#{@name}), 'finish', -1],
+     [%W(#{@name} 2-1), 'finish', -1],
+    ].each do |c, rtp, count|
+      @cmdproc.instance_variable_set('@return_to_program', false)
+      @my_cmd.run(c)
+      assert_equal(rtp, @cmdproc.instance_variable_get('@return_to_program'))
+      assert_equal(count, @cmdproc.instance_variable_get('@step_count'))
+    end
+  end
+
+end

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

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+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
+
+  def test_help_complete
+    assert_equal(%w(break breakpoints), @my_cmd.complete('br'))
+    assert_equal(%w(unalias undisplay), @my_cmd.complete('un'))
+  end
+end

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

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative './mock-helper'
+require_relative '../../processor/command/kill'
+
+class TestCommandKill < Test::Unit::TestCase
+  include MockUnitHelper
+  def setup
+    @name = File.basename(__FILE__, '.rb').split(/-/)[2]
+    common_setup(@name)
+    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-source.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative './mock-helper'
+require_relative '../../processor/command/source'
+
+# Test command source
+class TestCommandSource < Test::Unit::TestCase
+
+  include MockUnitHelper
+  def setup
+    @name = File.basename(__FILE__, '.rb').split(/-/)[2]
+    common_setup(@name)
+  end
+
+  def test_source_opts
+
+  [['--quiet',       :verbose, false],
+   ['-q',            :quiet, true],
+   ['--no-quiet',    :quiet, false],
+   ['--continue',    :abort_on_error, false],
+   ['--no-continue', :abort_on_error, true],
+   ['-c',            :abort_on_error, false],
+   ['-v',            :verbose, true],
+   ['--verbose',     :verbose, true],
+   ['--no-verbose',  :verbose, false]
+  ].each do |opt, key, expect|
+      options = 
+        @cmd.parse_options(Trepan::Command::SourceCommand::DEFAULT_OPTIONS.dup,
+                           opt)
+      assert_equal(expect, options[key], 
+                   "Option #{opt} using key #{key} failure")
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+
+class TestCommandStep < 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
+    [
+     [%W(#{@name}), 'step', 1],
+     [%W(#{@name} 2), 'step', 2],
+     [%W(#{@name} into 1+2),  'step', 3],
+     [%W(#{@name} over), 'next', 1]
+    ].each do |c, rtp, count|
+      @cmdproc.instance_variable_set('@return_to_program', false)
+      @my_cmd.run(c)
+      assert_equal(rtp, @cmdproc.instance_variable_get('@return_to_program'))
+      assert_equal(count, @cmdproc.instance_variable_get('@step_count'))
+    end
+  end
+
+end

data/test/unit/test-completion.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../lib/trepanning'
+
+# We don't want to do completion or save history.
+# This is one hacky way to make sure this doesn't happen
+def Trepan::GNU_readline?
+  false
+end
+
+# Test commands completion
+class TestCompletion < Test::Unit::TestCase
+  def test_completion
+    dbgr = Trepan.new
+    [
+     ['sh', 'sh', ['show']],  # Simple single completion
+     ['se', 'se', ['server', 'set']],  # Simple multiple completion
+     ['show', 'show', ['show ']], # Add a space because there is more
+     ['irb ', 'irb ', []],        # Don't add anything - no more
+     # ['irb ', 'irb', []],         # Don't add anything - no more
+     ['set au', 'au', ['auto']],  # Single completion when there are two words
+     ['set auto', 'auto', ['auto ']], # Add a space because there is more
+     ['set auto ', '', ['dis', 'eval', 'irb', 'list']], # Many two-word completions
+     ['set auto e', 'e', ['eval']],
+     ['disas', 'disas ', ['disassemble']], # Another single completion
+     ['help syn', 'syn', ['syntax']],
+     ['help br', 'br', ['break', 'breakpoints']],
+     ['set basename o', 'o', ['off', 'on']],
+    ].each do |line, token, expect_completion|
+      assert_equal(expect_completion, 
+                   dbgr.completion_method(token, line),
+                   "Bad completion of #{token.inspect} with #{line.inspect}")
+    end
+    assert(dbgr.completion_method('', '').size > 30, 
+           'Initial completion should return more than 30 commands')
+  end
+end

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

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# Unit test for 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(nil, nil, {:history_save => false})
+    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