rbx-trepanning 0.2.0-universal-rubinius-2.0

data/test/unit/test-app-method.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/method'
+
+class TestAppMethod < Test::Unit::TestCase
+
+  def test_find_method_with_line
+    method = Rubinius::VM.backtrace(0, true)[0].method
+    line = __LINE__
+    ##############################
+    def foo                        # line +  2
+      a = 5                        # line +  3
+      b = 6                        # line +  4
+    end                            # line +  5
+    1.times do                     # line +  6 
+      1.times do                   # line +  7
+        x = 11                     # line +  8
+        foo                        # line +  9
+      end                          # line + 10
+      c = 14                       # line + 11
+    end                            # line + 12
+    ################################################
+    meths = []                     # line + 14
+    expect = Array.new(22, true)  # line + 15
+    [5, 10, 12, 13, 18].each do |i|
+      expect[i] = false             # line + 17
+    end                            # line + 18
+    (2..21).each do |l|            # line + 19
+      meth = Trepanning::Method.find_method_with_line(method, line+l)
+      meths << meth                # line + 21
+      assert_equal(expect[l], !!meth, "Mismatched line #{line+l}")
+    end
+    pairs = [[1,2], [0,4], [5,9], [6,7], [14,15], [20,21]]
+    pairs.each do |pair|
+      assert_equal(meths[pair[0]].inspect, meths[pair[1]].inspect, 
+                   "Method compare")
+    end
+  end
+  def test_valid_ip?
+    meth = Rubinius::VM.backtrace(0, true)[0].method
+    ip = Trepanning::Method.locate_line( __LINE__, meth)[1]
+    assert_equal(true, ip.kind_of?(Fixnum), 
+                 "locate line of #{__LINE__} should have gotten an IP;" +
+                 " got: #{ip.inspect}")
+    [[-1, false],
+     [ 0, true], 
+     [ip, true], 
+     [100000, false]].each do |ip, expect|
+      assert_equal expect, Trepanning::Method.valid_ip?(meth, ip)
+    end
+  end
+
+end

data/test/unit/test-app-options.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'stringio'
+require 'tempfile'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/options'
+
+# To have something to work with.
+load 'tmpdir.rb'
+
+class TestAppOptions < Test::Unit::TestCase
+
+  def setup
+    @options = Trepan::DEFAULT_CMDLINE_SETTINGS.clone
+    @stderr  = StringIO.new
+    @stdout  = StringIO.new
+    @options = Trepan::copy_default_options
+    @opts    = Trepan::setup_options(@options, @stdout, @stderr)
+  end
+
+  def test_cd
+    rest = @opts.parse(['--cd', Dir.tmpdir])
+    assert_equal(Dir.tmpdir, @options[:chdir])
+    assert_equal('', @stderr.string)
+    assert_equal('', @stdout.string)
+
+    setup
+    tf    = Tempfile.new("delete-me")
+    orig_cd = @options[:chdir]
+    rest = @opts.parse(['--cd', tf.path])
+    assert_equal(orig_cd, @options[:chdir])
+    assert_not_equal('', @stderr.string)
+    assert_equal('', @stdout.string)
+    File.unlink tf.path
+    # FIXME: add test where directory isn't executable.
+  end
+
+  def test_binary_opts
+    %w(nx readline).each do |name|
+      setup
+      o    = ["--#{name}"]
+      rest = @opts.parse o
+      assert_equal('', @stderr.string)
+      assert_equal(true, @options[name.to_sym])
+    end
+    # --no- options
+    %w(readline).each do |name|
+      o    = ["--no-#{name}"]
+      rest = @opts.parse o
+      assert_equal('', @stderr.string)
+      assert_equal(false, @options[name.to_sym])
+    end
+  end
+
+  def test_help_and_version_opts
+    omit unless Process.respond_to?(:fork) 
+    Process.fork {
+      %w(help version).each do |name|
+        setup
+        o    = ["--#{name}"]
+        rest = @opts.parse o
+        assert_not_equal('', @stdout.string)
+        assert_equal('', @stderr.string)
+        assert_equal(true, @options[name.to_sym])
+        other_sym = 'help' == name ? :version : :help
+        assert_equal(false, @options.member?(other_sym))
+      end
+    }
+    Process.wait
+  end
+
+  def test_both_client_server_opts
+    # Try each of --client and --server options separately
+    %w(client server).each do |name|
+      setup
+      o    = ["--#{name}"]
+      rest = @opts.parse o
+      assert_equal('', @stdout.string)
+      assert_equal('', @stderr.string)
+      assert_equal(true, @options[name.to_sym])
+    end
+
+    # Try both --client and --server together. Should give a warning
+    setup
+    o    = %w(--client  --server)
+    rest = @opts.parse o
+    assert_not_equal('', @stderr.string)
+    assert_equal('', @stdout.string)
+    assert_equal(true, @options[:client])
+    assert_equal(false, @options[:server])
+    
+  end
+
+end

data/test/unit/test-app-run.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/run'
+
+class TestAppRun < Test::Unit::TestCase
+  include Trepanning
+  def test_basic
+    assert_equal(true, File.executable?(whence_file('irb')))
+    ng = whence_file('probably-does-not-exist')
+    assert_equal(true, File.executable?(ng) || ng == 'probably-does-not-exist')
+  end
+
+end

data/test/unit/test-app-util.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/util'
+
+class TestAppUtil < Test::Unit::TestCase
+  include Trepan::Util
+  def test_safe_repr
+    string = 'The time has come to talk of many things.'
+    assert_equal(string, safe_repr(string, 50))
+    assert_equal('The time...  things.', safe_repr(string, 17))
+    assert_equal('"The tim... things."', safe_repr(string.inspect, 17))
+    string = "'The time has come to talk of many things.'"
+    assert_equal("'The tim... things.'", safe_repr(string, 17))
+  end
+
+  def test_find_main_script
+    locs = Rubinius::VM.backtrace(0, true)
+    i = find_main_script(locs)
+    assert_equal(true, !!i)
+    assert_equal(false, !!find_main_script(locs[0..i]))
+  end
+
+  def test_abbrev
+    list = %w(disassemble disable distance up)
+    [['dis', 'dis'],
+     ['disas', 'disassemble'],
+     ['u', 'up'],
+     ['upper', 'upper'],
+     ['foo', 'foo']].each do |name, expect|
+      assert_equal expect, uniq_abbrev(list, name)
+    end
+  end
+
+  def test_extract_expression
+    [['if condition("if")',        'condition("if")'],
+     ['until until_termination',   'until_termination'],
+     ['return return_value',       'return_value'],
+     ['nothing_to_be.done',         'nothing_to_be.done'],
+    ].each do |stmt, expect|
+      assert_equal expect, extract_expression(stmt)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/validate'
+
+class TestAppValidate < Test::Unit::TestCase
+  include Trepan::Validate
+  def test_line_or_ip
+    [
+     ['@2',   [2, nil]],
+     ['oink', [nil, nil]],
+     ['1'   , [nil, 1]],
+     ['12',   [nil, 12]],
+     ['-12',  [nil, -12]]].each do |arg, expect|
+      assert_equal(line_or_ip(arg), expect)
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/command'
+
+class Trepan::Command::Test < Trepan::Command
+  NAME = 'test'
+  CATEGORY = 'testcategory'
+  completion %w(a aa ab ba aac)
+end
+
+class TestBaseCommand < Test::Unit::TestCase
+
+  class MockCmdProcessor
+    # The below functions aren't tested/called, but they are the
+    # methods required by a command and are placeholders for when we
+    # do start testing.
+    def initialize(dbgr)
+    end
+    def confirm(message, default)
+      p ['confirm: ', message, default]
+    end
+    def errmsg(message, opts)
+      p ['err:', message, opts]
+    end
+    def msg(message, opts)
+      p [message, opts]
+    end
+    def msg_nocr(message, opts)
+      p ['nocr: ', message, opts]
+    end
+    def section(message, opts)
+      p ['section: ', message, opts]
+    end
+  end
+
+  def setup
+    @proc = MockCmdProcessor.new(nil)
+    @cmd = Trepan::Command::Test.new(@proc)
+  end
+
+  def test_base_completion
+    assert_equal(%w(aa aac), @cmd.complete('aa'))
+  end
+end

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

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+# require_relative '../../app/core'
+require_relative '../../processor'
+require_relative '../../processor/command/exit'
+require_relative '../../processor/command/base/subcmd'
+
+$errors = []
+class TestBaseSubCommand < Test::Unit::TestCase
+
+  Trepan::Subcommand.const_set(:NAME, 'bogus')
+  def setup
+    $errors   = []
+    $msgs     = []
+    @dbgr     = Trepan.new
+    # @core     = Trepan::Core.new(@dbgr)
+    @cmdproc  = Trepan::CmdProcessor.new(@dbgr)
+    @cmds     = @cmdproc.instance_variable_get('@commands')
+    @exit_cmd = @cmds['exit']
+    @exit_subcmd = Trepan::Subcommand.new(@exit_cmd)
+    def @exit_subcmd.msg(message)
+      $msgs << message
+    end
+    def @exit_subcmd.errmsg(message)
+      $errors << message
+    end
+  end
+
+  def test_base_subcommand
+    assert @exit_subcmd
+    assert_raises RuntimeError do 
+      @exit_subcmd.run
+    end
+    assert_equal([], $errors)
+    @exit_subcmd.run_set_int('', 'testing 1 2 3')
+    assert_equal(1, $errors.size)
+    assert_equal(Fixnum, @exit_subcmd.settings[:maxwidth].class)
+    @cmds.each do |cmd_name, cmd_obj|
+      next unless cmd_obj.is_a?(Trepan::SubcommandMgr)
+      cmd_obj.subcmds.subcmds.each do |subcmd_name, subcmd_obj|
+        %w(HELP NAME PREFIX).each do |attr|
+          assert_equal(true, subcmd_obj.class.constants.member?(attr),
+                       "Constant #{attr} should be defined in \"#{cmd_obj.name} #{subcmd_obj.class::NAME}\"")
+        end
+      end
+      
+    end
+  end
+
+  def test_show_on_off
+    assert_equal('on', @exit_subcmd.show_onoff(true))
+    assert_equal('off', @exit_subcmd.show_onoff(false))
+    assert_equal('unset', @exit_subcmd.show_onoff(nil))
+    assert_equal('??', @exit_subcmd.show_onoff(5))
+  end
+end

data/test/unit/test-base-submgr.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+# We will use set as our canonical example
+require_relative '../../processor/command/set'
+
+class TestBaseSubcommandMgr < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    common_setup
+  end
+
+  def test_basic
+    my_cmd = @cmds['show']
+    # require 'trepanning'; debugger
+    assert_equal(%w(debug different directories), my_cmd.complete('d'),
+                 "Should be able to complete 'd'")
+    assert_equal(%w(show args), my_cmd.subcmds.lookup('ar').prefix,
+                 "Should be able to complete lookup('ar')")
+    assert_equal(nil, my_cmd.subcmds.lookup('a'), 
+                 "Shouldn't find since we have 'show args' and 'show auto'")
+  end
+end

data/test/unit/test-base-subsubcmd.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/command/base/subsubcmd'
+
+$errors = []
+class TestBaseSubCommand < Test::Unit::TestCase
+
+  def test_prefix_set
+    Trepanning::SubSubcommand.set_name_prefix('/tmp/show_subcmd/auto_subcmd/food.rb', 
+                                           self.class)
+    assert_equal('food', NAME, "should have set NAME")
+    assert_equal('show auto food', CMD)
+    assert_equal(%w(show auto food), PREFIX)
+  end
+
+end

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_RbConfig_ruby
+    rb_path = RbConfig.ruby
+    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,66 @@
+#!/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]
+    @brkpt_set_pat = /^Set breakpoint \d+: .*$/ 
+  end
+
+  def run_cmd(cmd, args) 
+    cmd.proc.instance_variable_set('@cmd_argstr', args[1..-1].join(' '))
+    cmd.run(args)
+  end
+
+  # require_relative '../../lib/trepanning'
+  def test_basic
+    assert true
+    return
+    # [
+    #  [@name,  __LINE__.to_s],
+    # ].each_with_index do |args, i|
+    #   run_cmd(@my_cmd, args)
+    #   assert_equal(true, @cmdproc.errmsgs.empty?, @cmdproc.errmsgs)
+    #   assert_equal(0, @cmdproc.msgs[0] =~ @brkpt_set_pat, @cmdproc.msgs[0])
+    #   reset_cmdproc_vars
+    # end
+
+    # pc_offset = tf.pc_offset
+    # [[@name],
+    #  [@name, "@#{pc_offset}"],
+    #  #[@name, 'FileUtils.cp']
+    # ].each_with_index do |args, i|
+    #   run_cmd(@my_cmd, args)
+    #   assert_equal(true, @cmdproc.errmsgs.empty?, @cmdproc.errmsgs)
+    #   assert_equal(0, @cmdproc.msgs[0] =~ @brkpt_set_pat, @cmdproc.msgs[0])
+    #   reset_cmdproc_vars
+    # end
+
+    common_setup
+    def foo
+      5 
+    end
+    [[@name, 'foo', (__LINE__-3).to_s]].each_with_index do |args, i|
+      run_cmd(@my_cmd, args)
+      assert_equal(true, @cmdproc.errmsgs.empty?,
+                   @cmdproc.errmsgs)
+      assert_equal(true, @cmdproc.errmsgs.empty?, @cmdproc.errmsgs)
+      reset_cmdproc_vars
+    end
+
+    # [[@name, 'foo']].each_with_index do |args, i|
+    #   run_cmd(@my_cmd, args)
+    #   assert_equal(true, @cmdproc.errmsgs.empty?,
+    #                @cmdproc.errmsgs)
+    #   assert_equal(0, @cmdproc.msgs[0] =~ @brkpt_set_pat, @cmdproc.msgs[0])
+    #   reset_cmdproc_vars
+    # end
+  end
+
+end

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative './mock-helper'
+require_relative './cmd-helper'
+require_relative '../../processor/command/edit'
+
+class TestCommandEdit < Test::Unit::TestCase
+  include MockUnitHelper
+  def setup
+    @name = File.basename(__FILE__, '.rb').split(/-/)[2]
+    $msgs = []
+    $errmsgs = []
+    common_setup(@name)
+    def @cmd.msg(message)
+      $msgs << message
+    end
+    def @cmd.errmsg(message)
+      $errmsgs << message
+    end
+  end
+
+  def test_basic
+    old_editor = ENV['EDITOR']
+    ENV['EDITOR'] = '#'
+    base_file = File.basename(__FILE__)
+    @cmd.proc.settings[:basename] = true
+    @cmd.run([@name])
+    assert_equal "Running # +7 \"mock-helper.rb\"...", $msgs[-1]
+    @cmd.run([@name, 8])
+    assert_equal "Running # +8 \"mock-helper.rb\"...", $msgs[-1]
+    @cmd.run([@name, __FILE__])
+    assert_equal "Running # +1 \"#{base_file}\"...", $msgs[-1]
+  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,31 @@
+#!/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 teardown
+    common_teardown
+  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