trepanning 0.0.4

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

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../app/disassemble'
+
+# Test Trepan::CmdProcessor
+class TestAppDisassemble < Test::Unit::TestCase
+
+  include Trepan::Disassemble
+
+  def setup
+    @dis_string='
+local table (size: 6, argc: 1 [opts: 0, rest: -1, post: 0, block: -1] s1)
+[ 6] relative_feature<Arg>[ 5] c          [ 4] e          [ 3] file       [ 2] absolute_feature
+0000 trace            8                                               (  26)
+0002 trace            1                                               (  27)
+0004 putnil           
+'
+  end
+
+  def test_mark_dissassembly
+    # Check marking pc offset.
+    [[-1, -1], [1, -1], [2, 4], [10, -1]].each do |pc_offset, pos|
+      ary = mark_disassembly(@dis_string, true, pc_offset)
+      selected = ary.select{|line| line =~ /\d{4} / && line !~ /^    /}
+      if pos == -1
+        assert_equal([], selected,
+                     'All lines should not be marked')
+      else
+        assert_equal(1, selected.size,
+                     "Should have found exectly one PC mark at #{pos}" +
+                     "\n%s" % ary.join("\n"))
+        assert_equal(0, ary[pos] =~ /^ --> /,
+                     "Should have marked PC at position #{pos}" + 
+                     "\n%s" % ary.join("\n"))
+      end
+    end
+
+    # Check marking breakpoints.
+
+    [[2, []], [2, [2]], [10, [0, 4]]].each do |pc_offset, brkpts|
+      ary = mark_disassembly(@dis_string, true, pc_offset, brkpts)
+      selected = ary.select{|line| line =~ /\d{4} / && line !~ /^ /}
+      assert_equal(brkpts.size, selected.size,
+                   "Should have found #{brkpts.size} lines " + 
+                   "at #{brkpts.join(',')}" + 
+                   ("\n%s" % ary.join("\n")))
+    end
+  end
+
+  def test_disassemble_split
+    expect = {
+      0=>
+      "0000 trace            8                                               (  26)",
+      2=>
+      "0002 trace            1                                               (  27)",
+      4=>"0004 putnil           "
+    }
+    assert_equal(expect, disassemble_split(@dis_string))
+  end
+end

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

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../app/file'
+
+if defined?(SCRIPT_ISEQS__) && SCRIPT_ISEQS__.is_a?(Hash)
+  SCRIPT_ISEQS__.clear
+else
+  SCRIPT_ISEQS__ = {} 
+end
+if defined?(ISEQS__) && ISEQS__.is_a?(Hash)
+  ISEQS__.clear
+else  
+  ISEQS__ = {}
+end
+
+# To have something to work with.
+load 'tmpdir.rb'
+
+class TestAppFile < Test::Unit::TestCase
+  include Trepanning
+
+  def test_file_match_pat
+    assert_equal('(?:^|[/])abc\.rb$', file_match_pat('abc.rb'))
+    assert_equal('^/a/abc\.rb$', file_match_pat('/a/abc.rb'))
+  end
+
+  def test_find_iseqs
+    iseqs = find_iseqs(ISEQS__, "tmpdir")
+    assert_equal(false, iseqs.empty?)
+    iseqs = find_iseqs(ISEQS__, "tmpdir@#{__FILE__}")
+    assert_equal(true, iseqs.empty?)
+    iseqs = find_iseqs(ISEQS__, "tmpdir@tmpdir.rb")
+    assert_equal(false, iseqs.empty?)
+  end
+
+  def test_find_scripts
+    [['tmpdir.rb', true], ['/tmpdir.rb', false],
+     ['sometmpdir.rb', false]].each do 
+      |filename, expected|
+      found = find_scripts(filename)
+      assert_equal(expected, !found.empty?,
+                   "Should %shave found %s; got %s" % 
+                   [expected ? '' : 'not ', filename, found.inspect])
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../app/frame'
+require 'thread_frame'
+
+class TestAppFrame < Test::Unit::TestCase
+
+  include Trepan::Frame
+
+  def test_app_frame
+    frame = RubyVM::ThreadFrame.current
+    base_count = frame.stack_size
+    s = format_stack_entry(frame)
+    pat = /^METHOD .*#test_app_frame\(\) in file .*test-app-frame.rb at line \d+/
+    assert(s =~ pat, "got #{s}, expected pat #{pat}")
+    1.times do 
+      assert_equal(base_count+2, RubyVM::ThreadFrame.current.stack_size)
+      s = format_stack_entry(frame)
+      assert(s =~ pat, "got #{s}, expected pat #{pat}")
+    end
+
+    def inner_test(count)
+      frame = RubyVM::ThreadFrame.current
+      assert_equal(count, frame.stack_size)
+
+      s = format_stack_entry(frame)
+      pat = /^METHOD .*#inner_test\(count\) in file .*test-app-frame.rb at line \d+/
+      assert(s =~ pat, "got: #{s.inspect},\nexpected: pat #{pat}")
+
+      s = format_stack_entry(frame, :basename => true)
+      pat = /^METHOD .*#inner_test\(count\) in file test-app-frame.rb at line \d+/
+      assert(s =~ pat, "got: #{s.inspect},\nexpected: pat #{pat}")
+
+      s = format_stack_entry(frame, :basename => true, :show_pc => true)
+      pat = /^METHOD .*#inner_test\(count\) in file test-app-frame.rb at line \d+, pc: \d+/
+      assert(s =~ pat, "got: #{s.inspect},\nexpected: pat #{pat}")
+    end
+    inner_test(base_count+1)
+  end
+
+  def test_return
+    assert_equal(1, offset_for_return('return'))
+    assert_equal(2, offset_for_return('c-return'))
+    assert_raises RuntimeError do
+      offset_for_return('c-call')
+    end
+  end
+
+end

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

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'stringio'
+require 'tempfile'
+require_relative '../../app/options'
+
+# To have something to work with.
+load 'tmpdir.rb'
+
+class TestAppStringIO < Test::Unit::TestCase
+  include Trepanning
+
+  def setup
+    @options = DEFAULT_CMDLINE_SETTINGS.clone
+    @stderr  = StringIO.new
+    @stdout  = StringIO.new
+    @options = copy_default_options
+    @opts = 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)
+    # FIXME: add test where directory isn't executable.
+  end
+
+  def test_binary_opts
+    %w(nx).each do |name|
+      setup
+      o    = ["--#{name}"]
+      rest = @opts.parse o
+      assert_equal('', @stderr.string)
+      assert_equal(true, @options[name.to_sym])
+    end
+  end
+
+  def test_help_and_version_opts
+    %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
+  end
+
+end

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

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+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')
+    rp = ruby_path
+    assert_equal(true, File.executable?(rp))
+    tup = explicit_restart_argv(ARGV)
+    assert_equal(rp, tup[0])
+    assert_equal(true, File.readable?(tup[1]))
+    assert_equal(ARGV.size + 2, tup.size)
+  end
+
+end

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../app/thread'
+
+class TestAppThread < Test::Unit::TestCase
+  include Trepan::ThreadHelper
+
+  def test_basic
+    Object::Thread.new do 
+      th_main = Thread.main
+      th_current = Thread.current
+      [[ 0, th_main],   
+       [ 1, th_current], 
+       [-1, th_current],
+       [-2, th_main],
+       [2, nil], [-3, nil],
+       [Thread.main.object_id, th_main],
+       [Thread.current.object_id, th_current]].each do 
+         |th_num, expected_th|
+         assert_equal(expected_th, get_thread(th_num),
+                      "get_thread(#{th_num}) should be expected")
+       end
+     end.join
+  end
+end

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

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+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 has come...', safe_repr(string, 17))
+    assert_equal('The time has come', safe_repr(string, 17, ''))
+    assert_equal('"The time has co"...', safe_repr(string.inspect, 17))
+    string = "'The time has come to talk of many things.'"
+    assert_equal("'The time has co'...", safe_repr(string, 17))
+  end
+
+end

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

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../app/core'
+require_relative '../../processor/main'
+require_relative '../../processor/command/exit'
+require_relative '../../processor/command/base/subcmd'
+
+# Mock debugger stub. FIXME: put in comment helper routine.
+class Trepan
+end
+
+$errors = []
+class TestBaseCommandHelp < Test::Unit::TestCase
+
+  def setup
+    $errors   = []
+    $msgs     = []
+    @dbg      = Trepan.new
+    @core     = Trepan::Core.new(@dbg)
+    @cmdproc  = @core.processor = Trepan::CmdProcessor.new(@core)
+    @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.to_sym),
+                       "Constant #{attr} should be defined in \"#{cmd_obj.name} #{subcmd_obj.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-bin-trepan.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rbconfig'
+load File.join(File.dirname(__FILE__), %w(.. .. bin trepan))
+
+# 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.pretty_inspect}
+expected: 
+#{RbConfig::CONFIG.pretty_inspect}
+")
+  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,50 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+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,80 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'thread_frame'
+require_relative 'cmd-helper'
+
+class TestCommandBreak < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    common_setup
+    @name   = File.basename(__FILE__, '.rb').split(/-/)[2]
+    @my_cmd = @cmds[@name]
+  end
+  
+  def test_basic
+    tf = RubyVM::ThreadFrame.current
+    @cmdproc.frame_setup(tf)
+    [
+     [@name,  __LINE__.to_s],
+    ].each_with_index do |args, i|
+      @my_cmd.run(args)
+      assert_equal(true, @cmdproc.errmsgs.empty?, @cmdproc.errmsgs)
+      assert_equal(0, 
+                   @cmdproc.msgs[0] =~ /^Breakpoint \d+ set at line \d+ in file #{__FILE__},\n\tVM offset \d+ of instruction sequence \"test_basic\"\.$/,
+                   @cmdproc.msgs[0])
+      reset_cmdproc_vars
+    end
+    pc_offset = tf.pc_offset
+    [[@name],
+     [@name, "O#{pc_offset}"],
+    ].each_with_index do |args, i|
+      @my_cmd.run(args)
+      assert_equal(true, @cmdproc.errmsgs.empty?, @cmdproc.errmsgs)
+      assert_equal(0, 
+                   @cmdproc.msgs[0] =~ /^Breakpoint \d+ set at VM offset \d+ of instruction sequence \"test_basic\",\n\tline \d+ in file .+\.$/,
+                   @cmdproc.msgs[0])
+      reset_cmdproc_vars
+    end
+
+    def foo
+      5 
+    end
+    [[@name, 'foo', (__LINE__-3).to_s]].each_with_index do |args, i|
+      @my_cmd.run(args)
+      assert_equal(true, @cmdproc.errmsgs.empty?,
+                   @cmdproc.errmsgs)
+      assert_equal(0, 
+                   @cmdproc.msgs[0] =~ /^Breakpoint \d+ set at line \d+ in file #{__FILE__},\n\tVM offset \d+ of instruction sequence \"foo\"\.$/,
+                   @cmdproc.msgs[0])
+      reset_cmdproc_vars
+    end
+    [[@name, 'foo']].each_with_index do |args, i|
+      @my_cmd.run(args)
+      assert_equal(true, @cmdproc.errmsgs.empty?,
+                   @cmdproc.errmsgs)
+      assert_equal(0, 
+                   @cmdproc.msgs[0] =~ /Breakpoint \d+ set at line \d+ in file #{__FILE__},\n\tVM offset \d+/,
+                   @cmdproc.msgs[0])
+      reset_cmdproc_vars
+    end
+  end
+
+  # Test setting a breakpoint at a line that can only be found using
+  # the parent instruction sequence, i.e. the line is not in the
+  # current instruction sequence.
+  def test_parent_breakpoint
+    xx = 5  # This is the line we set the breakpoint for.
+    1.times do
+      tf = RubyVM::ThreadFrame.current  
+      @cmdproc.frame_setup(tf)
+      @my_cmd.run([@name, (__LINE__-4).to_s])
+      assert_equal(true, @cmdproc.errmsgs.empty?, @cmdproc.errmsgs)
+      assert_equal(0, 
+                   @cmdproc.msgs[0] =~ /^Breakpoint \d+ set at line \d+ in file .+\n\tVM offset \d+ of instruction sequence \"test_parent_breakpoint\"\.$/,
+                   @cmdproc.msgs[0])
+      reset_cmdproc_vars
+    end
+  end
+
+end

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

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative 'cmd-helper'
+require_relative '../../app/breakpoint'
+
+class TestCommandEnableDisable < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    Trepanning::Breakpoint::reset
+    common_setup
+    @break_cmd   = @cmds['break']
+    @disable_cmd = @cmds['disable']
+    @enable_cmd  = @cmds['enable']
+  end
+
+  def test_basic
+
+    # Some simple errors in running enable/disable commands
+    [[@enable_cmd, ['enable', '1'], 0, 1],
+     [@disable_cmd, ['disable', '1'], 0, 1]].each do 
+      |cmd, args, nmsgs, nerrs|
+      # No breakpoint number given
+      cmd.run(args[0..0])
+      assert_equal(nmsgs, @cmdproc.msgs.size, 
+                   "#{args} - msgs: #{@cmdproc.msgs.inspect}")
+      assert_equal(nerrs, @cmdproc.errmsgs.size, 
+                   "#{args} - errmsgs: #{@cmdproc.errmsgs.inspect}")
+      reset_cmdproc_vars
+
+      # Non-existent breakpoint
+      cmd.run(args)
+      assert_equal(true, @cmdproc.msgs.empty?)
+      assert_equal(1, @cmdproc.errmsgs.size)
+      reset_cmdproc_vars
+    end
+
+    require 'thread_frame'
+    tf = RubyVM::ThreadFrame.current
+    @cmdproc.frame_setup(tf)
+    pc_offset = tf.pc_offset
+    @break_cmd.run(['break'])
+    assert_equal(true, @cmdproc.errmsgs.empty?)
+    assert_equal(1, @cmdproc.msgs.size)
+    reset_cmdproc_vars
+
+    @disable_cmd.run(['disable', '1'])
+    assert_equal(0, 
+                 @cmdproc.msgs[0] =~ /^Breakpoint 1 disabled./,
+                 @cmdproc.msgs)
+    reset_cmdproc_vars
+
+    @enable_cmd.run(['enable', '1'])
+    assert_equal(0, 
+                 @cmdproc.msgs[0] =~ /^Breakpoint 1 enabled./,
+                 @cmdproc.msgs)
+  end
+
+end

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

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+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 #{arg_str}.\n Got #{msgs}" %
+                 shoulda[0])
+    assert_equal(!should_not_have, errmsgs.empty?,
+                 "Expecting %serror for #{arg_str}.\n Got #{errmsgs}" %
+                 shoulda[1])
+  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(step n help).each do |cmd_pat|
+      check_help(false, cmd_pat)
+    end
+
+    # Test patterns
+    %w(* s.* ste).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