rbx-trepanning 0.0.5-universal-rubinius-1.2.1

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    = Trepan.new
+    @cmdproc = Trepan::CmdProcessor.new(@dbgr)
+    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-frame.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+require_relative '../../processor/frame'
+require_relative '../../processor/mock'
+
+$errors = []
+$msgs   = []
+
+# Test Trepan::CmdProcessor Frame portion
+class TestCmdProcessorFrame < Test::Unit::TestCase
+
+  def setup
+    $errors = []
+    $msgs   = []
+    @dbgr = MockDebugger::MockDebugger.new
+    @proc = Trepan::CmdProcessor.new(@dbgr)
+    @proc.frame_index = 0
+    @proc.frame_initialize
+    class << @proc
+      def errmsg(msg)
+        $errors << msg
+      end
+      def print_location
+        # $msgs << "#{@frame.source_container} #{@frame.source_location[0]}"
+        $msgs << File.basename(@frame.file)
+        # puts $msgs
+      end
+    end
+  end
+
+  # See that we have can load up commands
+  def test_basic
+    @proc.frame_setup
+
+    # Test absolute positioning. Should all be okay
+    0.upto(@proc.stack_size-1) do |i| 
+      @proc.adjust_frame(i, true) 
+      assert_equal(0, $errors.size)
+      assert_equal(i+1, $msgs.size)
+    end
+
+    # Test absolute before the beginning fo the stack
+    frame_index = @proc.frame_index
+    @proc.adjust_frame(-1, true)
+    assert_equal(0, $errors.size)
+    assert_equal(frame_index, @proc.frame_index)
+    @proc.adjust_frame(-@proc.stack_size-1, true)
+    assert_equal(1, $errors.size, $errors)
+    assert_equal(frame_index, @proc.frame_index)
+
+    ## FIXME: look over and reinstate this code...
+    # setup
+    # @proc.top_frame  = @proc.frame = @dbgr.vm_locations[0]
+    # @proc.adjust_frame(0, true)
+
+    # @dbgr.vm_locations.size-1.times do 
+    #   frame_index = @proc.frame_index
+    #   @proc.adjust_frame(1, false) 
+    #   assert_equal(0, $errors.size)
+    #   assert_not_equal(frame_index, @proc.frame_index,
+    #                    '@proc.frame_index should have moved')
+    # end
+
+    # FIXME: bug in threadframe top_frame.stack_size? 
+    # # Adjust relative beyond the end
+    # @proc.adjust_frame(1, false) 
+    # assert_equal(1, $errors.size)
+
+    # Should have stayed at the end
+    # proc.adjust_frame(proc.top_frame.stack_size-1, true)
+    # proc.top_frame.stack_size.times { proc.adjust_frame(-1, false) }
+
+  end
+
+
+end

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

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative '../../processor/help'
+
+# Test Trepan::CmdProcessor
+class TestCmdProcessor < Test::Unit::TestCase
+
+  include Trepan::Help
+  # See that we have can load up commands
+  def test_abbrev_stringify
+    assert_equal('(test)ing', 
+                 abbrev_stringify('testing', 'test'.size))
+  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 '../../processor/main'
+require_relative '../../app/mock'
+
+class TestCmdProcessorLoadCmds < Test::Unit::TestCase
+
+  def setup
+    @proc = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+    @proc.instance_variable_set('@settings', {})
+  end
+
+  # See that we have can load up commands
+  def test_basic
+    @proc.load_cmds_initialize
+    assert_equal(false, @proc.commands.empty?)
+    assert_equal(false, @proc.aliases.empty?)
+  end
+
+  def test_complete
+    assert_equal(%w(delete directory disassemble display down),
+                 @proc.complete("d"),
+                 "Failed completion of 'd' commands")
+    assert_equal(['show debug', 'show different'], @proc.complete("sho d"),
+                 "Failed completion of 'sho d' subcommands")
+    $errors = []
+  end
+
+  def test_run_cmd
+    $errors = []
+
+    def @proc.errmsg(mess)
+      $errors << mess
+    end
+
+    def test_it(size, *args)
+      @proc.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,53 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require 'linecache'
+require_relative '../../processor/main' # Have to include before frame!
+                                        # FIXME
+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)
+    @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
+    @proc.frame_setup
+    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 
+    # FIXME test that filename remapping works.
+  end
+
+end