trepanning 0.1.0 → 0.1.1

data/test/functional/test-raise.rb

@@ -34,7 +34,7 @@ class TestRaise < Test::Unit::TestCase
            '-- ', 'x = 1',
            '-- ', 'y = 2',
            '-- ', 'd.stop',
-           'hi']
+           '"hi"']
     compare_output(out, d, cmds)
 
     # Try with explicit Exception name

data/test/functional/test-return.rb

@@ -93,7 +93,7 @@ class TestRaise < Test::Unit::TestCase
            "\tbrkpt, line",
            "-- ",
            "d.stop # ({:remove => true})",
-           "abc"]
+           '"abc"']
     compare_output(out, d, cmds)
   end
   

data/test/integration/.gitignore

@@ -0,0 +1,2 @@
+/*~
+/*.out

data/test/integration/helper.rb

@@ -25,14 +25,15 @@ def run_debugger(testname, ruby_file, opts={})
   rightfile  = File.join(datadir, short_right)
 
   short_cmd   = "#{opts[:short_cmd] || testname}.cmd"
-  cmdfile     = File.join(datadir, short_cmd)
+  cmdfile     = opts[:cmdfile] || File.join(datadir, short_cmd)
   outfile     = opts[:outfile] ||
     File.join(srcdir,  "#{testname}.out")
   programfile = ruby_file ? File.join(progdir, ruby_file) : ''
 
   FileUtils.rm(outfile) if File.exist?(outfile)
 
-  cmd = 
+  cmd = opts[:feed_input] ? "#{opts[:feed_input]} |" : ''
+  cmd += 
     if opts[:standalone]
       "%s %s %s >%s 2>&1" %
         [Trepanning::ruby_path, programfile, opts[:args], outfile]
@@ -41,13 +42,15 @@ def run_debugger(testname, ruby_file, opts={})
         [Trepanning::ruby_path, dbgr_path, cmdfile, opts[:dbgr], 
          programfile, opts[:args], outfile]
     end
-  
+  puts cmd if opts[:verbose]
   system(cmd)
   return false unless 0 == $?.exitstatus 
   if opts[:do_diff]
     expected_lines = File.open(rightfile).readlines()
     got_lines      = File.open(outfile).readlines()
     opts[:filter].call(got_lines, expected_lines) if opts[:filter]
+    # puts "=" * 80
+    # got_lines.map{|line| puts line}
     
     # Seems to be a bug in LCS in that it will return a diff even if two
     # files are the same.

data/test/integration/test-debugger-stop.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative 'helper'
+
+class TestDebuggerStop < Test::Unit::TestCase
+  @@NAME = File.basename(__FILE__, '.rb')[5..-1]
+
+  def test_it
+    opts = {}
+    opts[:feed_input] = "echo 'info program ;; continue ;; quit!' "
+    opts[:filter] = Proc.new{|got_lines, correct_lines|
+      got_lines[0].gsub!(/\(.*debugger-stop.rb[:]\d+ @\d+/, 
+                         'debugger-stop.rb:14 @1955')
+      # require_relative '../../lib/trepanning'; debugger
+      got_lines[2].gsub!(/PC offset \d+ .*<top .+debugger-stop.rb/, 
+                         "PC offset 100 <top debugger-stop.rb")
+      got_lines[3].gsub!(/\(.*debugger-stop.rb[:]\d+ @\d+/, 
+                         'debugger-stop.rb:10 @1954')
+    }
+    assert_equal(true, run_debugger(@@NAME, @@NAME + '.rb', opts))
+  end
+end

data/test/integration/test-quit.rb

@@ -5,6 +5,14 @@ require_relative 'helper'
 class TestQuit < Test::Unit::TestCase
   @@NAME = File.basename(__FILE__, '.rb')[5..-1]
 
+  # def test_trepanx_set_confirm_off
+  #   opts = {}
+  #   opts[:filter] = Proc.new{|got_lines, correct_lines|
+  #     got_lines[0] = "-> (null.rb:1 @0)\n"
+  #   }
+  #   assert_equal(true, run_debugger('quit2', 'null.rb', opts))
+  # end
+
   def test_trepan_call
     opts = {}
     opts[:filter] = Proc.new{|got_lines, correct_lines|

data/test/unit/.gitignore

@@ -0,0 +1 @@
+/*~

data/test/unit/Makefile

@@ -0,0 +1,7 @@
+# Whatever it is you want to do, it should be forwarded to the 
+# to top-level irectories
+PHONY=check all
+all: check
+
+%: 
+	$(MAKE) -C ../.. $@

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

@@ -23,7 +23,6 @@ class TestAppBrkpt < Test::Unit::TestCase
     assert_raises TypeError do 
       Trepan::Breakpoint.new(0, 5)
     end
-    require_relative '../../lib/trepanning.rb'
     b2 = Trepan::Breakpoint.new(iseq, 0, :temp => true)
     assert_equal('t', b2.icon_char)
   end

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

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../app/cmd_parse'
+
+class TestCmdParse < Test::Unit::TestCase
+
+  def no__test_parse_location
+    ['fn', 'fn 5', 'fn @5', '@5', '5', 'fn:5', 'fn:@5'].each do |location|
+      begin
+        match = MethodName.parse(location, :root => :location)
+        assert_equal location, match.to_s, "should be able to parse of #{location}"
+      rescue Citrus::ParseError
+        assert false, "should be able to parse of #{location}"
+      end
+    end
+    
+    # Check actual values
+    [['@5', 5, :vm_offset], ['10', 10, :line_number]].each do 
+      |position, expect, symbol|
+      match = MethodName.parse(position, :root => symbol)
+      assert_equal(expect, match.value.value, 
+                   "should be able to get value of location #{position}")
+    end
+    # %w(0 1e10 a.b).each do |location|
+    #   begin
+    #     match = MethodName.parse(location, :root => :identifier)
+    #     assert false, "should not have been able to parse of #{location}"
+    #   rescue Citrus::ParseError
+    #     assert true, "should not have been able to parse of #{location}"
+    #   end
+    # end
+  end
+  
+  module Testing
+    def testing; 5 end
+    module_function :testing
+  end
+
+  def test_parse_identifier
+    %w(a a1 $global __FILE__ Constant).each do |name|
+      cp = CmdParse.new(name)
+      assert cp._identifier, "should be able to parse of #{name}"
+    end
+    %w(0 1e10 @10).each do |name|
+      cp = CmdParse.new(name)
+      assert_equal(true, !cp._identifier, 
+                   "should not have been able to parse of #{name}")
+    end
+  end
+
+  def test_parse_method
+    [['Object', [:constant]], 
+     ['AA::B', [:constant] * 2], 
+     ['Aa::Bb::C', [:constant] * 3],
+     ['A::B::C::D', [:constant] * 4], 
+     ['A::B.c', [:constant, :constant, :variable]], 
+     ['A.b.c.d', [:constant] + [:variable] * 3],
+     ['@ivar', [:instance]],
+     ['@@classvar', [:classvar]],
+     ['$global', [:global]],
+     ['$global.meth', [:global, :variable]],
+     ['@ivar.meth', [:instance, :variable]],
+    ].each do |name, types|
+      cp = CmdParse.new(name)
+      assert cp._class_module_chain, "should be able to parse of #{name}"
+      m = cp.result
+      assert_equal m.type, types[0], "parse type of #{name}"
+      1.upto(types.size-1) do |i|
+        assert m, "Chain item #{i} of #{name} should not be nil"
+        m = m.chain[1]
+        assert_equal m.type, types[i], "parse type of #{name}"
+      end
+      assert_nil m.chain, "chain item #{types.size} in #{cp.result} should be nil"
+    end
+    ['A(5)'].each do |name|
+      cp = CmdParse.new(name)
+      cp._class_module_chain
+      assert_not_equal(name, cp.result.name,
+                   "should not have been able to parse of #{name}")
+    end
+  end
+
+  include Trepan::CmdParser
+  def test_method_name
+    # require_relative '../../lib/trepanning'
+    def five; 5 end
+    %w(five RubyVM::InstructionSequence.new Kernel.eval
+        Testing.testing Kernel::eval File.basename).each do |str|
+      meth = meth_for_string(str, binding)
+      assert meth.kind_of?(Method), "#{str} method's class should be Method, not #{meth.class}"
+    end
+    x = File
+    def x.five; 5; end
+    %w(x.basename x.five).each do |str|
+      meth = meth_for_string(str, binding)
+      assert meth.kind_of?(Method), "#{str} method's class should be Method, not #{meth.class}"
+    end
+    %w(Array.map).each do |str|
+      meth = meth_for_string(str, binding)
+      assert meth.kind_of?(UnboundMethod), "#{meth.class}"
+    end
+    %w(O5).each do |str|
+      meth = meth_for_string(str, binding)
+      assert_equal nil, meth, "should have found a method for #{str}"
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../app/cmd_parser'
+
+class TestAppCmdParser < Test::Unit::TestCase
+  def setup
+    @cp = CmdParse.new('', true)
+  end
+
+  def test_parse_filename
+    [
+     ['filename', 'filename'],
+     ['"this is a filename"', 'this is a filename'],
+     ['this\ is\ another\ filename', 'this is another filename'],
+     ['C\:filename', 'C:filename']
+    ].each do |name, expect|
+      @cp.setup_parser(name, true)
+      res = @cp._filename
+      assert_equal(expect, @cp.result)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../app/complete'
+
+class TestAppUtil < Test::Unit::TestCase
+  include Trepan::Complete
+  def test_complete
+    hash = {'ab' => 1, 'aac' => 2, 'aa' => 3, 'a' => 4}
+    ary = hash.keys.sort
+    [[[], 'b'], [ary, 'a'], [%w(aa aac), 'aa'], 
+     [ary, ''], [['ab'], 'ab'], [[], 'abc']].each do |result, prefix|
+      assert_equal(result, complete_token(ary, prefix),
+                   "Trouble matching #{ary}.inspect on #{prefix.inspect}")
+    end
+    [[ary, 'a'], [%w(aa aac), 'aa'], 
+     [['ab'], 'ab'], [[], 'abc']].each do |result_keys, prefix|
+      result = result_keys.map {|key| [key, hash[key]]}
+      assert_equal(result, complete_token_with_next(hash, prefix),
+                   "Trouble matching #{hash}.inspect on #{prefix.inspect}")
+    end
+    
+  end
+
+  def test_next_token
+    x = '  now is  the  time'
+    [[0, [ 5, 'now']], 
+     [2, [ 5, 'now']],
+     [5, [ 8, 'is']], 
+     [8, [13, 'the']],
+     [9, [13, 'the']],
+     [13, [19, 'time']],
+     [19, [19, '']],
+    ].each do |pos, expect|
+      assert_equal expect, next_token(x, pos)
+    end
+  end
+
+end

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

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'stringio'
+require_relative '../../app/condition'
+
+class TestAppCondition < Test::Unit::TestCase
+  include Trepan::Condition
+  
+  def test_basic
+    assert valid_condition?('1+2')
+    old_stderr = $stderr
+    new_stdout = StringIO.new
+    $stderr = new_stdout
+    assert_equal(nil, valid_condition?('1+'), 
+                 "Should have not been able to parse 1+")
+    $stderr = old_stderr
+    assert_equal(false, new_stdout.string.empty?, 
+                 "Should have gotten some sort of compile error on stderr")
+  end
+end

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

@@ -0,0 +1,31 @@
+#!/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 TestAppISEQ < Test::Unit::TestCase
+  include Trepanning
+
+  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
+
+end

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

@@ -30,17 +30,25 @@ class TestAppOptions < Test::Unit::TestCase
     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).each do |name|
+    %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

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

@@ -12,5 +12,4 @@ class TestAppUtil < Test::Unit::TestCase
     string = "'The time has come to talk of many things.'"
     assert_equal("'The tim... things.'", safe_repr(string, 17))
   end
-
 end

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

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative '../../processor/command/base/cmd'
+
+class Trepan
+  class Command::Test < Trepan::Command
+    NAME = 'test'
+    CATEGORY = 'testcategory'
+    completion %w(a aa ab ba aac)
+  end
+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

@@ -5,12 +5,12 @@ require_relative '../../processor/main'
 require_relative '../../processor/command/exit'
 require_relative '../../processor/command/base/subcmd'
 
-# Mock debugger stub. FIXME: put in comment helper routine.
+# Mock debugger stub. FIXME: put in common helper routine.
 class Trepan
 end
 
 $errors = []
-class TestBaseCommandHelp < Test::Unit::TestCase
+class TestBaseSubCommand < Test::Unit::TestCase
 
   def setup
     $errors   = []
@@ -56,4 +56,13 @@ class TestBaseCommandHelp < Test::Unit::TestCase
     assert_equal('unset', @exit_subcmd.show_onoff(nil))
     assert_equal('??', @exit_subcmd.show_onoff(5))
   end
+
+  def test_prefix_set
+    Trepanning::Subcommand.set_name_prefix('/tmp/show_subcmd/foo.rb', 
+                                           self.class)
+    assert_equal('foo', NAME, "should have set NAME")
+    assert_equal('show foo', CMD)
+    assert_equal(%w(show foo), PREFIX)
+  end
+
 end