rb8-trepanning 0.1.3

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

data/test/unit/test-io-input.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../io/input'
+
+# Test Trepan::UserInput
+class TestIOInput < Test::Unit::TestCase
+
+  def test_UserInput
+    inp = Trepan::UserInput.open(__FILE__)
+    assert inp, 'Should have gotten a Trepan::UserInput object back'
+    line = inp.readline.chomp
+    assert_equal '#!/usr/bin/env ruby', line
+    assert_equal false, inp.eof?
+    inp.close
+    assert_equal true, inp.closed?
+    inp = Trepan::UserInput.open(__FILE__)
+    while not inp.eof?
+      begin
+        inp.readline
+      rescue EOFError
+        assert_equal(true, inp.eof?, 
+                     'EOF should be true after EOFError')
+      end
+    end
+  end
+end

data/test/unit/test-io-tcp.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+
+# Unit test for io/tcpclient.rb and io/tcpserver.rb together
+require_relative '../../io/tcpfns'
+require_relative '../../io/tcpclient'
+require_relative '../../io/tcpserver'
+
+# Tests TCPServer together with and TCPClient
+class TestTCPClientServer < Test::Unit::TestCase
+
+  def test_client_server
+    server = Trepan::TCPDbgServer.new({ :open => true,
+                                        :port => 1028,
+                                        :host => 'localhost'
+                                      })
+    client = Trepan::TCPDbgClient.new({ :open => true,
+                                        :port => 1028,
+                                        :host => 'localhost'
+                                      })
+    %w(one, two, three).each do |line|
+      server.writeline(line)
+      assert_equal line, client.read_msg.chomp
+    end
+    %w(four, five, six).each do |line|
+      client.writeline(line)
+      assert_equal line, server.read_msg.chomp
+    end
+    client.close
+    server.close
+  end
+end

data/test/unit/test-io-tcpclient.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+
+# Unit test for io/tcpclient.rb
+require_relative '../../io/tcpfns'
+require_relative '../../io/tcpclient'
+
+class TestTCPDbgClient < Test::Unit::TestCase
+
+  include Trepanning::TCPPacking
+
+  def test_basic
+    client = Trepan::TCPDbgClient.new({ :open => false,
+                                        :port => 1027,
+                                        :host => 'localhost'
+                                      })
+    threads = []
+    Thread.new do
+      server = TCPServer.new('localhost', 1027)
+      session = server.accept
+      while 'quit' != (line = session.gets)
+        session.puts line 
+      end
+      session.close
+    end
+    threads << Thread.new do 
+      3.times do 
+        begin
+          client.open
+        rescue IOError
+        end
+        break
+      end
+      assert client
+      msgs = %w(four five six)
+      msgs.each do |mess|
+        begin
+          break if client.disconnected?
+          client.writeline(mess)
+          assert_equal mess, client.read_msg.chomp
+        rescue EOFError
+          puts "In client: got EOF"
+          break
+        rescue Exception => e
+          puts "In client: got #{e}"
+          break
+        end
+      end
+      client.close
+    end
+    threads.each {|t| t.join }
+  end
+end

data/test/unit/test-io-tcpfns.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+
+# Unit test for io/tcpfns.rb
+
+require_relative '../../io/tcpfns'
+
+class TestTCPPacking < Test::Unit::TestCase
+
+  include Trepanning::TCPPacking
+
+  def test_pack_unpack
+    msg = "Hi there!"
+    assert_equal unpack_msg(pack_msg(msg))[1], msg
+  end
+end

data/test/unit/test-io-tcpserver.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+
+# Unit test for io/tcpserver.rb
+require_relative '../../io/tcpfns'
+require_relative '../../io/tcpserver'
+
+class TestTCPDbgServer < Test::Unit::TestCase
+
+  include Trepanning::TCPPacking
+
+  def test_basic
+    server = Trepan::TCPDbgServer.new
+    server.open({ :open => false,
+                  :port => 1027,
+                  :host => '127.0.0.1'
+                })
+    threads = []
+    msgs = %w(one two three)
+    Thread.new do
+      msgs.each do |msg|
+        begin
+          line = server.read_msg.chomp
+          assert_equal(msg, line)
+        rescue EOFError
+          puts 'Got EOF'
+          break
+        end
+      end
+    end
+    threads << Thread.new do 
+      t = TCPSocket.new('127.0.0.1', 1027)
+      msgs.each do |msg|
+        begin
+          t.puts(pack_msg(msg))
+        rescue EOFError
+          puts "Got EOF"
+          break
+        rescue Exception => e
+          puts "Got #{e}"
+          break
+        end
+      end
+      t.close
+    end
+    threads.each {|t| t.join }
+    server.close
+  end
+end

data/test/unit/test-proc-eval.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+require_relative '../../app/frame'
+require_relative '../../processor/eval'
+require_relative '../../processor/mock'
+
+# Test Trepan::CmdProcessor Eval portion
+class TestProcEval < Test::Unit::TestCase
+
+  include UnitHelper
+  def test_basic
+    common_setup
+    @dbgr = MockDebugger::MockDebugger.new
+    @cmdproc = Trepan::CmdProcessor.new(@dbgr.intf)
+    assert_equal('(eval "x = 1; y = 2")',
+
+                 @cmdproc.fake_eval_filename('x = 1; y = 2'))
+    assert_equal('(eval "x = 1;"...)',
+                 @cmdproc.fake_eval_filename('x = 1; y = 2', 7))
+
+    @cmdproc.instance_variable_set('@settings', {:stack_trace_on_error => true})
+    # x = 1
+    # vm_locations = Rubinius::VM.backtrace(0, true)
+    # @dbgr.instance_variable_set('@vm_locations', vm_locations)
+    # @cmdproc.instance_variable_set('@current_frame', 
+    #                                Trepan::Frame.new(self, 0, vm_locations[0]))
+    # @cmdproc.instance_variable_set('@settings', {:stack_trace_on_error => true})
+    # assert_equal('1', @cmdproc.debug_eval('x = "#{x}"'))
+    # x = 2
+    # assert_equal('2', @cmdproc.debug_eval_no_errmsg('x = "#{x}"'))
+    # assert_equal(nil, @cmdproc.debug_eval_no_errmsg('x+'))
+  end
+end

data/test/unit/test-proc-hook.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/hook'
+
+# Test Debugger:CmdProcessor Hook portion
+class TestProcHook < Test::Unit::TestCase
+
+  def test_basic
+    @args = []
+    hook1 = Proc.new {|name, a| @args << [name, a]}
+    hooks = Trepan::CmdProcessor::Hook.new()
+    assert_equal(true, hooks.empty?)
+    hooks.insert(-1, 'hook1', hook1)
+    hooks.run
+    assert_equal([['hook1', nil]], @args)
+    hooks.insert_if_new(-1, 'hook1', hook1)
+    assert_equal([['hook1', nil]], @args)
+    
+    @args = []
+    hooks.insert_if_new(-1, 'hook2', hook1)
+    hooks.run(10)
+    assert_equal([['hook1', 10], ['hook2', 10]], @args)
+
+    @args = []
+    hooks.delete_by_name('hook2')
+    hooks.run(30)
+    assert_equal([['hook1', 30]], @args)
+  end
+end

data/test/unit/test-proc-load_cmds.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd-helper'
+
+class TestCmdProcessorLoadCmds < Test::Unit::TestCase
+
+  include UnitHelper
+  def setup
+    common_setup
+  end
+
+  # See that we have can load up commands
+  def test_basic
+    @cmdproc.load_cmds_initialize
+    assert_equal(false, @cmdproc.commands.empty?)
+    assert_equal(false, @cmdproc.aliases.empty?)
+  end
+
+  def test_complete
+    assert_equal(%w(directory disable display down),
+                 @cmdproc.complete('d', 'd'),
+                 "Failed completion of 'd' commands")
+    assert_equal(['debug', 'different', 'directories'], 
+                 @cmdproc.complete('sho d', 'd'),
+                 "Failed completion of 'sho d' subcommands")
+    $errors = []
+  end
+
+  def test_run_cmd
+    $errors = []
+
+    def @cmdproc.errmsg(mess)
+      $errors << mess
+    end
+
+    def test_it(size, *args)
+      @cmdproc.run_cmd(*args)
+      assert_equal(size, $errors.size, $errors)
+    end
+    test_it(1, 'foo')
+    test_it(2, [])
+    test_it(3, ['list', 5])
+    # See that we got different error messages
+    assert_not_equal($errors[0], $errors[1], $errors)
+    assert_not_equal($errors[1], $errors[2], $errors)
+    assert_not_equal($errors[2], $errors[0], $errors)
+  end
+
+end

data/test/unit/test-proc-location.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require 'ruby-debug'; 
+begin
+  require 'linecache'
+rescue LoadError
+  require 'linecache19'
+end
+require_relative '../../processor/location'
+require_relative '../../processor/mock'
+
+$errors = []
+$msgs   = []
+
+# Test Trepan::CmdProcessor location portion
+class TestCmdProcessorLocation < Test::Unit::TestCase
+
+  def setup
+    $errors = []
+    $msgs   = []
+    @dbgr = MockDebugger::MockDebugger.new
+    @proc = Trepan::CmdProcessor.new(@dbgr.intf)
+    @file = File.basename(__FILE__)
+  end
+
+  # Test resolve_file_with_dir() and line_at()
+  def test_line_at
+    @proc.settings[:directory] = ''
+    assert_equal(nil, @proc.resolve_file_with_dir(@file))
+    if File.expand_path(Dir.pwd) == File.expand_path(File.dirname(__FILE__))
+      line = @proc.line_at(@file, __LINE__)
+      assert_match(/line = @proc.line_at/, line)
+    else
+      assert_equal(nil, @proc.line_at(@file, __LINE__))
+    end
+    dir = @proc.settings[:directory] = File.dirname(__FILE__)
+    assert_equal(File.join(dir, @file), 
+                 @proc.resolve_file_with_dir('test-proc-location.rb'))
+    test_line = 'test_line'
+    line = @proc.line_at(@file, __LINE__-1)
+    assert_match(/#{line}/, line)
+  end
+
+  def test_loc_and_text
+    @proc.frame_index = 0
+    @proc.frame_initialize
+    Debugger.start
+    @proc.frame_setup(Debugger.current_context, nil)
+    LineCache::clear_file_cache
+    dir = @proc.settings[:directory] = File.dirname(__FILE__)
+    loc, line_no, text = @proc.loc_and_text('hi')
+    assert loc and line_no.is_a?(Fixnum) and text 
+    assert @proc.current_source_text
+    # FIXME test that filename remapping works.
+    Debugger.stop
+  end
+
+  def test_canonic_file
+    @proc.settings[:basename] = false
+    assert_equal File.expand_path(__FILE__), @proc.canonic_file(__FILE__)
+    @proc.settings[:basename] = true
+    assert_equal File.basename(__FILE__), @proc.canonic_file(__FILE__)
+  end
+
+
+  def test_eval_current_source_text
+    Debugger.start
+    eval <<-EOE
+      @proc.frame_index = 0
+      @proc.frame_initialize
+      @proc.frame_setup(Debugger.current_context, nil)
+      LineCache::clear_file_cache
+      assert @proc.current_source_text
+    EOE
+    Debugger.stop
+  end
+
+end

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

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/main'
+require_relative '../../processor/mock'
+
+# Test Trepan::CmdProcessor
+class TestSubCmdHelp < Test::Unit::TestCase
+
+  def setup
+    @dbgr = MockDebugger::MockDebugger.new
+    @cmdproc = Trepan::CmdProcessor.new(@dbgr.intf)
+    @cmds    = @cmdproc.instance_variable_get('@commands')
+  end
+
+  # See that subcommand class constants exist.
+  def test_required_class_constants
+    @cmds.each do |cmd_name, cmd|
+      if cmd.is_a?(Trepan::SubcommandMgr)
+        cmd.subcmds.subcmds.each do |subcmd_name, subcmd|
+          where = "of subcommand #{subcmd_name} in command #{cmd_name}"
+          %w(HELP NAME SHORT_HELP).each do
+            |const|
+            value = subcmd.my_const(const)
+            assert_equal(true, value.is_a?(String),
+                         "#{const} #{where} should be a String; got #{value}.")
+          end
+          value = subcmd.my_const('MIN_ABBREV')
+          assert(value.is_a?(Fixnum),
+                 "MIN_ABBREV #{where} should be a Fixnum; got #{value}.")
+
+          if 'show' == cmd_name
+            short_help = subcmd.my_const('SHORT_HELP')
+            needed_start = 'Show '
+            assert_equal(needed_start, short_help[0..needed_start.size-1],
+                         "Short help #{where} should start: \"#{needed_start}\"; got #{short_help}")
+          end
+        end
+      end
+    end
+  end
+
+
+end