rbx-trepanning 0.0.3-universal-rubinius-1.2 → 0.0.4-universal-rubinius-1.2

data/sample/rocky-dot-trepanrc.rej

@@ -0,0 +1,11 @@
+--- sample/rocky-dot-trepanrc
++++ sample/rocky-dot-trepanrc
+@@ -4,7 +4,7 @@
+ dir /home/rocky-rvm/.rvm/src/rbx-head/
+ 
+ set autoeval on   # Is default, but just in case
+-# set terminal on   # turn on syntax highlight by default
++# set highlight on   # turn on syntax highlight by default
+ 
+ # My customization to the default syntax coloring
+ load "#{ENV['HOME']}/.trepanx-colors.rb"

data/sample/rocky-dot-trepanxrc

@@ -0,0 +1,14 @@
+# Rocky's trepanx profile for Rubinius.
+
+# Place where I have Rubinius source (in rvm)
+dir /home/rocky-rvm/.rvm/src/rbx-head/
+
+set autoeval on   # Is default, but just in case
+# set terminal on   # turn on syntax highlight by default
+
+# My customization to the default syntax coloring
+load "#{ENV['HOME']}/.trepanx-colors.rb"
+
+# let me know that this ran...
+puts "Rocky's .trepanxrc loaded"
+

data/sample/rocky-trepanx-colors.rb

@@ -0,0 +1,39 @@
+# Terminal color settings I use. I doubt terminal colors are
+# standardized let alone what colors you want for the various
+# syntax elements. So you should adjust as desired.
+
+# Values are either a number string, e.g. '36' or a pair of number
+# semicolon and number, e.g. '3;36'.
+#
+# The first number before a semicolon is a font modifier from the
+# following table:
+#
+#    1 - bold 
+#    3 - italic
+#    4 - underline 
+
+require 'rubygems'
+require 'coderay'
+require 'coderay/encoders/term'
+TERM_TOKEN_COLORS = {
+  :comment => '3;36',        # italic yellow brownish
+  :constant => '1;34',       # bold blue
+  :global_variable => '36',  # yellow brownish 
+  :integer => '34',          # blue
+  :label => '4',             # black underline
+  :regexp => {
+    :content => '33',        # light turquoise (from red)
+    :delimiter => '1;29',
+    :modifier => '35',
+    :function => '1;29'
+  },
+  :reserved => '1;32',       # bold green (from red)
+  :symbol   => '35',         # purple
+}
+module CodeRay::Encoders
+  class Term < Encoder
+    TERM_TOKEN_COLORS.each_pair do |key, value|
+      TOKEN_COLORS[key] = value
+    end
+  end
+end

data/test/data/fname-with-blank.right

@@ -1 +1,4 @@
+-> (fname with blank.rb:1 @0)
+puts "Ha!"
+basename is off.
 Ha!

data/test/data/inline-call.cmd

@@ -0,0 +1,6 @@
+# ***************************************************
+# This calling the debugger from inside the source
+# ***************************************************
+set basename off
+list
+q!

data/test/data/inline-call.right

@@ -0,0 +1,13 @@
+-- (inline-call.rb:11 @12)
+if a > b
+basename is off.
+  6   	$dbgr = Trepan.new(:nx => true, :cmdfiles => [cmdfile])
+  7   	# GCD. We assume positive numbers
+  8   	def gcd(a, b)
+  9   	  $dbgr.debugger
+ 10   	  # Make: a <= b
+ 11 ->	  if a > b
+ 12   	    a, b = [b, a]
+ 13   	  end
+ 14   	
+ 15   	  return nil if a <= 0

data/test/data/quit.right

@@ -0,0 +1,2 @@
+-> (null.rb:1 @0)
+# Nothing here. Move along.

data/test/example/{gcd1.rb → gcd-server.rb}

@@ -1,12 +1,10 @@
 #!/usr/bin/env ruby
-require 'thread_frame'
-tf = RubyVM::ThreadFrame.current
-iseq = tf.iseq
-p iseq.child_iseqs
-puts iseq.disassemble
-
 # GCD. We assume positive numbers
+require 'rubygems'; require 'require_relative'
+require_relative '../../lib/trepanning.rb'
+$dbgr = Trepan.new(:server => true)
 def gcd(a, b)
+  $dbgr.debugger
   # Make: a <= b
   if a > b
     a, b = [b, a]

data/test/example/inline-call.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative '../../lib/trepanning.rb'
+DATA_DIR = File.join(File.dirname(RequireRelative::abs_file), %w(.. data))
+cmdfile = File.join(DATA_DIR, 'inline-call.cmd')
+$dbgr = Trepan.new(:nx => true, :cmdfiles => [cmdfile])
+# GCD. We assume positive numbers
+def gcd(a, b)
+  $dbgr.debugger
+  # Make: a <= b
+  if a > b
+    a, b = [b, a]
+  end
+
+  return nil if a <= 0
+
+  if a == 1 or b-a == 0
+    return a
+  end
+end
+
+a, b = ARGV[0..1].map {|arg| arg.to_i}
+puts "The GCD of %d and %d is %d" % [a, b, gcd(a, b)]

data/test/integration/helper.rb

@@ -37,6 +37,9 @@ def run_debugger(testname, ruby_file, opts={})
     if opts[:xdebug]
     "%s -Xdebug '%s' %s >%s 2>&1 <%s" %
         [Trepanning::ruby_path, programfile, opts[:args], outfile, cmdfile]
+    elsif opts[:standalone]
+      "%s %s %s >%s 2>&1" %
+        [Trepanning::ruby_path, programfile, opts[:args], outfile]
     else
       "%s %s --nx --command %s %s '%s' %s >%s 2>&1" %
         [Trepanning::ruby_path, dbgr_path, cmdfile, opts[:dbgr], 
@@ -46,18 +49,15 @@ def run_debugger(testname, ruby_file, opts={})
   system(cmd)
   return false unless 0 == $?.exitstatus 
   if opts[:do_diff]
-    from_file  = rightfile
-    # fromdate  = time.ctime(os.stat(fromfile).st_mtime)
-    from_lines = File.open(from_file).readlines()
-    to_file    = outfile
-    # todate    = time.ctime(os.stat(tofile).st_mtime)
-    to_lines   = File.open(to_file).readlines()
+    expected_lines = File.open(rightfile).readlines()
+    got_lines      = File.open(outfile).readlines()
+    opts[:filter].call(got_lines, expected_lines) if opts[:filter]
     
     # Seems to be a bug in LCS in that it will return a diff even if two
     # files are the same.
-    return true if from_lines == to_lines
+    return true if expected_lines == got_lines
     
-    sdiffs = Diff::LCS.sdiff(from_lines, to_lines)
+    sdiffs = Diff::LCS.sdiff(expected_lines, got_lines)
     
     if sdiffs.empty?
       FileUtils.rm(outfile)

data/test/integration/test-fname-with-blank.rb

@@ -7,6 +7,10 @@ class TestFnameWithBlank < Test::Unit::TestCase
   @@NAME = File.basename(__FILE__, '.rb')[5..-1]
 
   def test_it
-    assert_equal(true, run_debugger(@@NAME, 'fname with blank.rb'))
+    opts = {}
+    opts[:filter] = Proc.new{|got_lines, correct_lines|
+      got_lines[0] = "-> (fname with blank.rb:1 @0)\n"
+    }
+    assert_equal(true, run_debugger(@@NAME, 'fname with blank.rb', opts))
   end
 end

data/test/integration/test-inline-call.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'helper'
+
+class TestInlineCall < Test::Unit::TestCase
+  @@NAME = File.basename(__FILE__, '.rb')[5..-1]
+  def test_inline_call
+    opts = {
+      :short_cmd => @@NAME, :do_diff => true,
+      :standalone => true
+    }
+    opts[:filter] = Proc.new{|got_lines, correct_lines|
+      got_lines[0] = "-- (inline-call.rb:11 @12)\n"
+    }
+
+    no_error = run_debugger(@@NAME, @@NAME + '.rb', opts)
+    assert_equal(true, no_error)
+  end
+end

data/test/integration/test-quit.rb

@@ -7,7 +7,11 @@ class TestQuit < Test::Unit::TestCase
   @@NAME = File.basename(__FILE__, '.rb')[5..-1]
 
   def test_trepanx_call
-    assert_equal(true, run_debugger(@@NAME, 'null.rb'))
+    opts = {}
+    opts[:filter] = Proc.new{|got_lines, correct_lines|
+      got_lines[0] = "-> (null.rb:1 @0)\n"
+    }
+    assert_equal(true, run_debugger(@@NAME, 'null.rb', opts))
   end
 
   def test_xcode_call

data/test/unit/cmd-helper.rb

@@ -16,18 +16,21 @@ module UnitHelper
     @cmdproc.dbgr  = @dbg
     @cmds     = @cmdproc.commands
 
-    def @cmdproc.msg(message)
-      @msgs << message
-    end
-    def @cmdproc.errmsg(message)
+    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
   module_function :common_setup

data/test/unit/mock-helper.rb

@@ -1,4 +1,5 @@
 require 'test/unit'
+require 'rubygems'; require 'require_relative'
 require_relative '../../processor/mock'
 
 module MockUnitHelper

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

@@ -7,7 +7,7 @@ class TestAppBrkpt < Test::Unit::TestCase
 
   def test_basic
     method = Rubinius::CompiledMethod.of_sender
-    b1 = Trepanning::Breakpoint.new('<start>', method, 1, 2, 0)
+    b1 = Trepan::Breakpoint.new('<start>', method, 1, 2, 0)
     assert_equal(false, b1.temp?)
     assert_equal(0, b1.hits)
     assert_equal('B', b1.icon_char)
@@ -17,14 +17,13 @@ class TestAppBrkpt < Test::Unit::TestCase
     b1.enabled = false
     assert_equal('b', b1.icon_char)
     # assert_raises TypeError do 
-    #   Trepanning::Breakpoint.new(iseq, iseq.iseq_size, :temp => true)
+    #   Trepan::Breakpoint.new(iseq, iseq.iseq_size, :temp => true)
     # end
     # assert_raises TypeError do 
-    #   Trepanning::Breakpoint.new(0, 5)
+    #   Trepan::Breakpoint.new(0, 5)
     # end
     # require_relative '../../lib/trepanning.rb'
-    b2 = Trepanning::Breakpoint.new('temp brkpt', method, 2, 3, 0, 
-                                    :temp => true)
+    b2 = Trepan::Breakpoint.new('temp brkpt', method, 2, 3, 0, :temp => true)
     assert_equal('t', b2.icon_char)
   end
 end

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

@@ -8,7 +8,7 @@ class TestLibAppBrkptMgr < Test::Unit::TestCase
 
   def setup
     @meth = Rubinius::CompiledMethod.of_sender
-    @brkpts = BreakpointMgr.new
+    @brkpts = Trepan::BreakpointMgr.new
     @offset = 0
   end
 
@@ -23,7 +23,7 @@ class TestLibAppBrkptMgr < Test::Unit::TestCase
     assert_equal(0, @brkpts.size)
 
     # Try adding via << rather than .add
-    b2 = @brkpts << Trepanning::Breakpoint.new(@meth, 5, nil, :temp => true)
+    b2 = @brkpts << Trepan::Breakpoint.new(@meth, 5, nil, :temp => true)
 
     assert_equal(nil, @brkpts.find(@meth, 6))
     @brkpts.reset

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

@@ -4,40 +4,55 @@ require 'rubygems'; require 'require_relative'
 require_relative '../../app/iseq'
 
 class TestAppISeq < Test::Unit::TestCase
-  include Trepanning::ISeq
 
   def test_disasm_prefix
     meth = Rubinius::VM.backtrace(0, true)[0].method
-    assert_equal(' -->', disasm_prefix(0, 0, meth))
-    assert_equal('    ', disasm_prefix(0, 1, meth))
+    assert_equal(' -->', Trepan::ISeq.disasm_prefix(0, 0, meth))
+    assert_equal('    ', Trepan::ISeq.disasm_prefix(0, 1, meth))
     meth.set_breakpoint(0, nil)
-    assert_equal('B-->', disasm_prefix(0, 0, meth))
-    assert_equal('B   ', disasm_prefix(0, 1, meth))
+    assert_equal('B-->', Trepan::ISeq.disasm_prefix(0, 0, meth))
+    assert_equal('B   ', Trepan::ISeq.disasm_prefix(0, 1, meth))
   end
 
   def test_basic
 
     def single_return
-      meth = Rubinius::VM.backtrace(0, true)[0].method
-      first, last = [meth.lines.first, meth.lines.last]
-      [last, yield_or_return_between(meth, first, last)]
+      cm = Rubinius::VM.backtrace(0, true)[0].method
+      last = cm.lines.last
+      first = 0
+      0.upto((cm.lines.last+1)/2) do |i|
+        first = cm.lines[i*2]
+        break if -1 != first
+      end
+      [last, Trepan::ISeq.yield_or_return_between(cm, first, last)]
     end
 
     def branching(bool)
-      meth = Rubinius::VM.backtrace(0, true)[0].method
-      first, last = [meth.lines.first, meth.lines.last]
+      cm = Rubinius::VM.backtrace(0, true)[0].method
+      last = cm.lines.last
+      first = nil
+      0.upto((cm.lines.last+1)/2) do |i|
+        first = cm.lines[i*2]
+        break if -1 != first
+      end
+
       if bool
         x = 5
       else
         x = 6
       end
-      goto_between(meth, first, last)
+      Trepan::ISeq.goto_between(cm, first, last)
     end
 
     def no_branching
-      meth = Rubinius::VM.backtrace(0, true)[0].method
-      first, last = [meth.lines.first, meth.lines.last]
-      goto_between(meth, first, last)
+      cm = Rubinius::VM.backtrace(0, true)[0].method
+      last = cm.lines.last
+      first = 0
+      0.upto((cm.lines.last+1)/2) do |i|
+        first = cm.lines[i*2]
+        break if -1 != first
+      end
+      Trepan::ISeq.goto_between(cm, first, last)
     end
 
     last, return_ips = single_return

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

@@ -8,15 +8,14 @@ require_relative '../../app/options'
 # To have something to work with.
 load 'tmpdir.rb'
 
-class TestAppStringIO < Test::Unit::TestCase
-  include Trepanning
+class TestAppOptions < Test::Unit::TestCase
 
   def setup
-    @options = DEFAULT_CMDLINE_SETTINGS.clone
+    @options = Trepan::DEFAULT_CMDLINE_SETTINGS.clone
     @stderr  = StringIO.new
     @stdout  = StringIO.new
-    @options = copy_default_options
-    @opts = setup_options(@options, @stdout, @stderr)
+    @options = Trepan::copy_default_options
+    @opts    = Trepan::setup_options(@options, @stdout, @stderr)
   end
 
   def test_cd
@@ -58,4 +57,26 @@ class TestAppStringIO < Test::Unit::TestCase
     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])
+    assert_equal(false, @options[:server])
+    
+  end
+
 end

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

@@ -48,7 +48,7 @@ class TestBaseCommandHelp < Test::Unit::TestCase
                        "Constant #{attr} should be defined in \"#{cmd_obj.name} #{subcmd_obj.class::NAME}\"")
         end
       end
-        
+      
     end
   end
 

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require 'rubygems'; require 'require_relative'
+require_relative './mock-helper'
+require_relative '../../processor/command/source'
+
+# Test command source
+class TestCommandSource < Test::Unit::TestCase
+
+  include MockUnitHelper
+  def setup
+    @name = File.basename(__FILE__, '.rb').split(/-/)[2]
+    common_setup(@name)
+  end
+
+  def test_source_opts
+
+  [['--quiet',       :verbose, false],
+   ['-q',            :quiet, true],
+   ['--no-quiet',    :quiet, false],
+   ['--continue',    :abort_on_error, false],
+   ['--no-continue', :abort_on_error, true],
+   ['-c',            :abort_on_error, false],
+   ['-v',            :verbose, true],
+   ['--verbose',     :verbose, true],
+   ['--no-verbose',  :verbose, false]
+  ].each do |opt, key, expect|
+      options = 
+        @cmd.parse_options(Trepan::Command::SourceCommand::DEFAULT_OPTIONS.dup,
+                           opt)
+      assert_equal(expect, options[key], 
+                   "Option #{opt} using key #{key} failure")
+    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,53 @@
+#!/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
+          client.writeline(mess)
+          assert_equal mess, client.read_msg.chomp
+        rescue EOFError
+          puts "Got EOF"
+          break
+        rescue Exception => e
+          puts "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-main.rb

@@ -4,6 +4,10 @@ require_relative 'cmd-helper'
 require_relative '../../processor/main'
 ## require_relative '../../app/core'
 
+# Mock debugger stub. FIXME: put in comment helper routine.
+class Trepan
+end
+
 # Test Trepan:CmdProcessor
 class TestCmdProcessor < Test::Unit::TestCase
 
@@ -75,10 +79,10 @@ class TestCmdProcessor < Test::Unit::TestCase
       assert_equal(expect_errmsgs, $errs, 
                    "Mismatched error messages from #{caller[0]}")
     end
-    def @cmdproc.msg(mess)
+    def @cmdproc.msg(mess, opts={})
       $msgs << "#{mess}"
     end
-    def @cmdproc.errmsg(mess)
+    def @cmdproc.errmsg(mess, opts={})
       $errs << "#{mess}"
     end
     run_and_check('!s=1', ['D=> 1'], [], "! evaluation")