rb8-trepanning 0.1.3-universal-ruby-1.9.2

data/test/integration/test-source.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+# require_relative '../../lib/trepanning'
+require_relative 'helper'
+
+# Test 'source' command handling.
+class TestSource < Test::Unit::TestCase
+  include TestHelper
+  def test_basic
+    common_setup(__FILE__)
+    Dir.chdir(@srcdir) do 
+      assert_equal(true, 
+                   run_debugger(@testname, @prefix + '../example/gcd.rb 3 5'))
+    end
+  end
+end

data/test/integration/test-stepping.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+# require_relative '../../lib/trepanning'
+require_relative 'helper'
+
+# Test that step commands
+class TestStepping < Test::Unit::TestCase
+  include TestHelper
+  def test_basic
+    common_setup(__FILE__)
+    Dir.chdir(@srcdir) do 
+      if RUBY_VERSION =~ /1.9/      
+      else
+        rightfile = File.join(%W(.. data #{@testname}-1.9.right))
+        assert_equal(true,  
+                     run_debugger(@testname, 
+                                  @prefix + '../example/gcd.rb 3 5',
+                                  nil, false, 'tdebug.rb', rightfile))
+        assert_equal(true,  
+                     run_debugger(@testname, @prefix + '../example/gcd.rb 3 5'))
+      end
+    end
+  end
+end

data/test/unit/.gitignore

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

data/test/unit/cmd-helper.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+# require_relative '../../app/core'
+require_relative '../../processor/mock'
+require_relative '../../processor/frame'
+
+
+module UnitHelper
+
+  module_function
+  def common_setup
+    @dbg      ||= MockDebugger::MockDebugger.new(:nx => true)
+    @cmdproc  = Trepan::CmdProcessor.new(@dbg.intf)
+    @cmdproc.frame_initialize
+    @cmdproc.dbgr  = @dbg
+    @cmds     = @cmdproc.commands
+
+    def @cmdproc.errmsg(message, opts={})
+      @errmsgs << message
+    end
+    def @cmdproc.errmsgs
+      @errmsgs
+    end
+    def @cmdproc.msg(message, opts={})
+      @msgs << message
+    end
+    def @cmdproc.msgs
+      @msgs
+    end
+    def @cmdproc.section(message, opts={})
+      @msgs << message
+    end
+    reset_cmdproc_vars
+  end
+
+  def common_teardown
+    @cmdproc.finalize
+  end
+  
+  def reset_cmdproc_vars
+    @cmdproc.instance_variable_set('@msgs', [])
+    @cmdproc.instance_variable_set('@errmsgs', [])
+  end
+
+end
+
+if __FILE__ == $0
+  include UnitHelper
+  common_setup
+  p @cmdproc.msgs
+  p @dbg
+end

data/test/unit/mock-helper.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require 'ruby-debug-base'
+require_relative '../../processor/mock'
+
+module MockUnitHelper
+  def common_setup(name)
+    Debugger.start unless Debugger.started?
+    @dbg, @cmd = MockDebugger::setup(name, false)
+  end
+end
+

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

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/cmd_parse'
+
+class TestCmdParse < Test::Unit::TestCase
+
+  # require_relative '../../lib/trepanning'
+  def test_parse_location
+    [['fn', [:fn, nil, nil]],
+     ['fn 2', [:fn, :line, 2]],
+     ['fn @5', [:fn, :offset, 5]],
+     ['@3',   [nil, :offset, 3]],
+     ['fn:6', [:fn, :line, 6]],
+     ["#{__FILE__}:5", [:file, :line, 5]],
+     ['fn:@15', [:fn, :offset, 15]],
+    ].each do |location, expect|
+      cp = parse_location(location)
+      assert cp, "should be able to parse #{location} as a location"
+      assert_equal(expect[0], cp.container_type, 
+                   "mismatch container_type on #{location}")
+      assert_equal(expect[1], cp.position_type, 
+                   "mismatch position_type on #{location}")
+      assert_equal(expect[2], cp.position, 
+                   "mismatch position on #{location}")
+    end
+    
+    # %w(0 1e10 a.b).each do |location|
+    #   begin
+    #     cp = CmdParse.new(name)
+    #     assert_equal nil cp._location, 
+    #     "should be able to parse #{name} as a 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 #{name} as an identifier"
+    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', 0], ['A::B', 1], ['A::B::C', 2],
+     ['A::B::C::D', 3], ['A::B.c', 2], ['A.b.c.d', 3]].each do |name, count|
+      cp = CmdParse.new(name)
+      assert cp._class_module_chain, "should be able to parse of #{name}"
+      m = cp.result
+      count.times do |i|
+        assert m, "Chain item #{i} of #{name} should not be nil"
+        m = m.chain[1]
+      end
+      assert_nil m.chain, "#{count} chain item 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
+    def five; 5 end
+    %w(five 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.collect).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 not have found a method for #{str}"
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/cmd_parser'
+
+class TestAppCmdParser < Test::Unit::TestCase
+  def setup
+    @cp = CmdParse.new('', :debug=>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, :debug => true)
+      res = @cp._filename
+      assert_equal(expect, @cp.result)
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+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-frame.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../app/frame'
+
+class TestAppFrame < Test::Unit::TestCase
+  def test_basic
+    require 'rubygems'
+    require 'ruby-debug-base'; Debugger.start
+    skip "Things are different on an unpatched 1.9.2" if 
+      RUBY_VERSION =~ /1.9.2/
+    x = 1
+    Debugger.skip do 
+      frame = Trepan::Frame.new(Debugger.current_context)
+      assert_equal __LINE__-2, frame.line
+      assert frame.stack_size >= 2, "Frame size should be >= 2, is #{frame.stack_size}"
+      assert_equal 'skip', frame.method_name
+      assert_equal __FILE__, frame.file
+      assert_equal 0, frame.index
+      assert_equal Debugger, frame.klass
+      assert_equal 1, eval('x', frame.binding)
+      frame.index = 1
+      assert_equal 'test_basic', frame.method_name
+      assert_equal __FILE__, frame.file
+      assert_equal Thread.current, frame.thread
+      assert_equal self.class, frame.klass
+      assert_equal 1, eval('x', frame.binding)
+    end
+    Debugger.stop
+  end
+
+end

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

@@ -0,0 +1,92 @@
+#!/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
+
+  # FIXME: have to work around the fact that exit is called by help.
+  def no_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
+
+  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])
+    ## FIXME - reinstate
+    ## 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 Trepan
+  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