rtinspect 0.0.1 → 0.0.19

data/test/test.rb

@@ -1,9 +1,42 @@
+# Contains the TestRuntimeInspectionThread.
+#
+# Copyright (c) 2006-2007 Brad Robel-Forrest.
+#
+# This software can be distributed under the terms of the Ruby license
+# as detailed in the accompanying LICENSE[link:files/LICENSE.html]
+# file.
+
+require 'thread'
+
+# Extend the Thread class so we can know exactly where a given thread
+# was created to validate that there aren't any leftover in various
+# spots.
+class Thread
+    alias orig_initialize initialize
+    def initialize( *args, &block )
+        orig_initialize( *args, &block )
+        self[:caller] = caller
+    end
+end
+
 require 'timeout'
 require 'expect'
 require 'test/unit'
 
 require 'rtinspect'
 
+if ARGV.include?( '-show_trace' )
+    RuntimeInspection.show_trace = true
+end
+
+$mybp_line = __LINE__ + 2
+class MyBreakpoint
+    def mybreakpoint( i )
+        a = 1
+        b = 2
+    end
+end
+
 class TestRuntimeInspectionThread < Test::Unit::TestCase
 
     class Tracker
@@ -11,12 +44,13 @@ class TestRuntimeInspectionThread < Test::Unit::TestCase
             @@assert_equal = block
         end
 
-        def initialize( &assert_block )
+        def initialize
             $expect_verbose = $DEBUG
             @sock = TCPSocket.new( 'localhost', 56789 )
             @cmd_count = 1
             @block_count = 0
             @at_prompt = false
+            @prompt_name = File.basename( $0, '.rb' )
         end
 
         def assert( cmd=nil, *expected )
@@ -38,7 +72,7 @@ class TestRuntimeInspectionThread < Test::Unit::TestCase
                 timeout( 5 ) do
                     out += @sock.expect( prompt ).first
                 end
-                out.sub!( /test:\d+:\d> $/, '' )
+                out.sub!( /#{@prompt_name}:\d+:\d> $/, '' )
             end
 
             if @block_count > 0
@@ -48,13 +82,23 @@ class TestRuntimeInspectionThread < Test::Unit::TestCase
                 timeout( 5 ) do
                     out += @sock.expect( prompt ).first
                 end
-                out.sub!( /test:\d+:\d> $/, '' )
+                out.sub!( /#{@prompt_name}:\d+:\d> $/, '' )
             end
 
             @at_prompt = true
 
             out.chomp!
-            @@assert_equal.call( expected.join("\n") + "\n", out )
+            if expected.empty?
+                return out
+            else
+                if expected.last == :no_newline
+                    expected.pop
+                    nl = ''
+                else
+                    nl = "\n"
+                end
+                @@assert_equal.call( expected.join("\n") + nl, out )
+            end
         end
 
         def puts( msg )
@@ -86,7 +130,7 @@ class TestRuntimeInspectionThread < Test::Unit::TestCase
         private
 
         def prompt
-            "test:#{'%03d'%@cmd_count}:#{@block_count}> "
+            "#{@prompt_name}:#{'%03d'%@cmd_count}:#{@block_count}> "
         end
     end
 
@@ -96,9 +140,22 @@ class TestRuntimeInspectionThread < Test::Unit::TestCase
         end
     end
 
+    def teardown
+        # Ensure that the RTI is not running so if one test fails,
+        # future ones won't just because it can't take the port.
+        rti_th = nil
+        Thread.list.each do |th|
+            if th.kind_of?( RuntimeInspection::Thread )
+                rti_th = th
+                break
+            end
+        end
+        rti_th.kill if rti_th
+    end
+
     def test_prompt
         threads = Thread.list.dup
-        r = RuntimeInspectionThread.new
+        r = RuntimeInspection::Thread.new
         assert_not_equal( threads, Thread.list )
         t = Tracker.new
         t.assert
@@ -112,33 +169,37 @@ class TestRuntimeInspectionThread < Test::Unit::TestCase
     end
 
     def test_locals
-        r = RuntimeInspectionThread.new
+        r = RuntimeInspection::Thread.new
         t = Tracker.new
 
         t.assert( 'rti.state.use_yaml = true', "=> --- true" )
 
-        t.assert( 'local_variables',
-                  '=> --- ',
-                  '- rti' )
+        # As in the case of running within the GEM framework, the
+        # toplevel binding is not clean. Thus, we can only check that
+        # at least rti is around.
+        out = t.assert( 'local_variables' )
+        out.sub!( /^=> /, '' )
+        assert( YAML.load( out ).include?( 'rti' ), 'Missing rti local' )
 
         r.kill
     end
 
+    RTI_LIST = ["backtrace", "bp_add", "bp_attach", "bp_continue", "bp_delete",
+                "bp_finish", "bp_list", "bp_next", "bp_start", "bp_step",
+                "bp_stop", "get_object", "list", "name2class", "start_world",
+                "state", "stop_world", "threads"]
+
     def test_list
-        r = RuntimeInspectionThread.new
+        r = RuntimeInspection::Thread.new
         t = Tracker.new
 
-        t.assert( 'rti.list',
-                  '=> ["bp_add", "bp_continue", "bp_del", "bp_fin", "bp_list", ' +
-                  '"bp_next", "bp_start", "bp_step", "bp_stop", "get_object", ' +
-                  '"initialize", "list", "name2class", "start_world", "state", ' +
-                  '"stop_world"]' )
+        t.assert( 'rti.list', "=> #{RTI_LIST.inspect}" )
 
         r.kill
     end
 
     def test_lookup
-        r = RuntimeInspectionThread.new
+        r = RuntimeInspection::Thread.new
         t = Tracker.new
 
         Struct.new( 'Foo', :one, :two, :three )
@@ -159,4 +220,174 @@ class TestRuntimeInspectionThread < Test::Unit::TestCase
         r.kill
     end
 
+    def test_signal
+        assert_raise( Errno::ECONNREFUSED ) do
+            t = Tracker.new
+        end
+
+        RuntimeInspection.on_signal
+
+        Process.kill( 'USR1', $$ )
+        t = Tracker.new
+
+        t.assert( 'rti.list', "=> #{RTI_LIST.inspect}" )
+
+        Process.kill( 'USR1', $$ )
+
+        assert_raise( Errno::ECONNREFUSED ) do
+            t = Tracker.new
+        end
+    end
+
+    def test_breakpoints
+        r = RuntimeInspection::Thread.new
+        t = Tracker.new
+
+        # Try some invalid breakpoints.
+        t.assert( '.bp_add Foo#bar',
+                  '=> "Unable to find matching module or class for Foo"' )
+        t.assert( '.bp_add MyBreakpoint#doesnotexist',
+                  '=> "Unable to find doesnotexist method in MyBreakpoint"' )
+        t.assert( '.bp_add bar',
+                  '=> "Unable to find containing class or module for bar"' )
+
+        # Now let's run through a simple breakpoint analysis.
+        t.assert( '.bp_add MyBreakpoint#mybreakpoint',
+                  '=> "Added breakpoint 1"' )
+
+        line = __LINE__
+        th = Thread.new do
+            bp = MyBreakpoint.new
+            5.times do |i|
+                sleep 0.3
+                bp.mybreakpoint( i )
+            end
+        end
+
+        begin
+            t.assert( '.bp_start',
+                      '=> nil', '',
+                      'Breakpoint 1 in MyBreakpoint#mybreakpoint ' +
+                      "from #{__FILE__}:#{$mybp_line} (call) in #{th}",
+                      :no_newline )
+
+            t.assert( 'local_variables',
+                      '=> ["i", "a", "b", "rti"]', '',
+                      'Breakpoint 1 in MyBreakpoint#mybreakpoint ' +
+                      "from #{__FILE__}:#{$mybp_line} (call) in #{th}",
+                      :no_newline )
+
+            t.assert( '.bp_next',
+                      '=> nil', '',
+                      'Stopped in MyBreakpoint#mybreakpoint ' +
+                      "from #{__FILE__}:#{$mybp_line+1} (line) in #{th}",
+                      :no_newline )
+
+            t.assert( 'rti.backtrace',
+                      "=> [\"#{__FILE__}:#{$mybp_line+1}:in `mybreakpoint'\"," +
+                      " \"#{__FILE__}:#{line+5}:in `test_breakpoints'\", " +
+                      "\"#{__FILE__}:#{line+3}:in `test_breakpoints'\", " +
+                      "\"#{__FILE__}:17:in `initialize'\", " +
+                      "\"#{__FILE__}:#{line+1}:in `test_breakpoints'\"]",
+                      '',
+                      'Stopped in MyBreakpoint#mybreakpoint ' +
+                      "from #{__FILE__}:#{$mybp_line+1} (line) in #{th}",
+                      :no_newline )
+
+            out = t.assert( 'rti.threads' )
+            assert_match( / :main sleep/, out )
+            assert_no_match( /RuntimeInspection::Thread:/, out )
+            assert_no_match( /:rti_/, out )
+
+            t.assert( '.bp_continue',
+                      '=> nil', '',
+                      'Breakpoint 1 in MyBreakpoint#mybreakpoint ' +
+                      "from #{__FILE__}:#{$mybp_line} (call) in #{th}",
+                      :no_newline )
+        ensure
+            t.assert( '.bp_stop', '=> nil' )
+            th.kill
+        end
+
+        r.kill
+    end
+
+    def test_attach
+        r = RuntimeInspection::Thread.new
+        t = Tracker.new
+
+        line = __LINE__ + 4
+        th = Thread.new do
+            Thread.current[:thread_name] = :mybreakpoint
+            5.times do
+                sleep( 0.1 )
+            end
+        end
+
+        begin
+            t.assert( '.bp_attach :mybreakpoint',
+                      '=> nil', '',
+                      'Breakpoint 1 in TestRuntimeInspectionThread#test_attach ' +
+                      "from #{__FILE__}:#{line} (line) in #{th}",
+                      :no_newline )
+        ensure
+            t.assert( '.bp_stop', '=> nil' )
+            th.kill
+        end
+
+        r.kill
+    end
+
+    def test_client_close
+        r = RuntimeInspection::Thread.new
+        t = Tracker.new
+
+        # Have the client disconnect while waiting in the bp_start
+        # method.
+
+        t.assert( '.bp_add MyBreakpoint#mybreakpoint',
+                  '=> "Added breakpoint 1"' )
+
+        th = Thread.new do
+            t.assert( '.bp_start' )
+        end
+
+        sleep 0.2
+
+        th.kill
+        t.close
+
+        def r.breakpoints
+            @breakpoints
+        end
+
+        def r.clients
+            @clients
+        end
+
+        sleep 0.2
+
+        assert_equal( {}, r.breakpoints )
+        assert_equal( [], r.clients )
+
+        found = {}
+        Thread.list.each do |th|
+            if th.kind_of?( RuntimeInspection::Thread )
+                found[:rti] = true
+            elsif name = th[:thread_name]
+                if name == :rti_gc
+                    found[:rti_gc] = true
+                end
+            elsif th == Thread.main
+                found[:main] = true
+            else
+                flunk( "Found unknown thread (#{th.inspect}): " +
+                       "#{th[:caller].inspect}" )
+            end
+        end
+        assert_equal( {:rti=>true, :rti_gc=>true, :main=>true}, found )
+
+        r.kill
+    end
+
 end

metadata

@@ -3,19 +3,19 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: rtinspect
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-01-01 00:00:00 -08:00
+  version: 0.0.19
+date: 2007-01-09 00:00:00 -08:00
 summary: A thread that will enable remote access capabilities  in a running Ruby process for debugging and inspection.
 require_paths: 
 - lib
 email: bradrf@gigglewax.com
 homepage: http://rtinspect.rubyforge.org/
-rubyforge_project: 
+rubyforge_project: rtinspect
 description: This is a class that will enable remote access  capabilities in a running Ruby process, exposing the ability to  enable breakpoints, walk code (e.g. step/next/continue), inspect  variables, modify codepaths, and many other debugging actions.
 autorequire: 
 default_executable: 
 bindir: bin
-has_rdoc: false
+has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
   - - ">"
@@ -30,11 +30,17 @@ authors:
 - Brad Robel-Forrest
 files: 
 - lib/rtinspect.rb
+- lib/rti/manager.rb
+- lib/rti/redirect.rb
+- lib/rti/state.rb
+- lib/rti/thread.rb
+- lib/rti/tracer.rb
 - test/test.rb
 - README
 - LICENSE
 - COPYING
 - TODO
+- VERSION
 test_files: 
 - test/test.rb
 rdoc_options: []
@@ -44,8 +50,9 @@ extra_rdoc_files:
 - LICENSE
 - COPYING
 - TODO
-executables: []
-
+- VERSION
+executables: 
+- rti
 extensions: []
 
 requirements: []