rb-threadframe 0.32

data/lib/thread_frame.rb

@@ -0,0 +1,3 @@
+# Boilerplate to pull shared object and helper routines.
+require_relative '../ext/thread_frame'
+require_relative 'iseq_extra'

data/test/unit/cfunc-use.rb

@@ -0,0 +1,11 @@
+def cfunc_loc
+  ftype, file = [nil, nil]
+  1.times do
+    1.times do
+      f = RubyVM::ThreadFrame::current.prev
+      ftype = f.type 
+      file  = f.source_container[1]
+    end
+  end
+  return [ftype, file]
+end

data/test/unit/test-argc.rb

@@ -0,0 +1,45 @@
+require 'test/unit'
+require_relative '../../ext/thread_frame'
+
+class TestARGC < Test::Unit::TestCase
+
+  def setup
+    @original_compile_option = RubyVM::InstructionSequence.compile_option
+    RubyVM::InstructionSequence.compile_option = {
+      :trace_instruction => false,
+      :specialized_instruction => false
+    }
+  end
+
+  def teardown
+    set_trace_func(nil)
+    RubyVM::InstructionSequence.compile_option = @original_compile_option
+  end
+
+  def test_C_argc
+    cmd='File.basename("/tmp/foo.rb");File.basename("/tmp/foo.rb",".rb")'
+    iseq = RubyVM::InstructionSequence.compile(cmd)
+    events = []
+    all_events = []
+    eval <<-EOF.gsub(/^.*?: /, "")
+     1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+     2:   tf = RubyVM::ThreadFrame.current.prev(1)
+     3:   all_events << [tf.argc, tf.arity, tf.type, mid]
+     4:   if :basename == mid 
+     5:     events << [tf.argc, tf.arity, tf.type, mid]
+     6:   end
+     7: })
+     8: iseq.eval
+     9: set_trace_func(nil)
+    EOF
+    # p all_events
+    assert_equal([[1, -1, "CFUNC", :basename],  # 1-arg c-call
+                  [1, -1, "CFUNC", :basename],  # 1-arg c-return
+                  [2, -1, "CFUNC", :basename],  # 2-arg c-call
+                  [2, -1, "CFUNC", :basename]   # 2-arg c-return
+                 ], events)
+  end
+end
+
+# We want to double-check we didn't mess up any pointers somewhere.
+at_exit { GC.start  }

data/test/unit/test-binding.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require_relative '../../ext/thread_frame'
+
+def outside(a)
+    return eval('a', RubyVM::ThreadFrame.new(Thread::current).binding)
+end
+
+$a = 10
+
+class TestBinding < Test::Unit::TestCase
+  def test_basic
+    a = 1
+    c = 0
+    assert_equal(5, outside(5))
+    tf = RubyVM::ThreadFrame.new(Thread::current)
+    b  = tf.binding
+    assert_equal(1, eval('a', b))
+    assert_equal(10, eval('$a', b))
+    assert_equal(self, tf.self)
+    1.times do |i;a| 
+      tf2 = Thread::current.threadframe()
+      b2  = tf2.binding
+      a = 2
+      assert_equal(2, eval('a', b2))
+      assert_equal(0, eval('c', b2))
+
+      # Times is C inline so prev we can't get a binding for it
+      # But we can for use the instruction sequence before that.
+      assert_equal(1, eval('a', tf2.prev(2).binding))
+    end
+    def inner(a)
+      tf3 = Thread::current.threadframe()
+      b3  = tf3.binding
+      if a == 4
+        assert_equal(4, eval('a', b3))
+        inner(a-1)
+      else
+        assert_equal(3, eval('a', b3))
+        assert_equal(4, eval('a', tf3.prev.binding))
+      end
+    end
+    inner(4)
+  end
+end

data/test/unit/test-invalid.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require_relative '../../ext/thread_frame'
+
+class TestProc < Test::Unit::TestCase
+  def test_basic
+    @tf = RubyVM::ThreadFrame::current
+    assert_equal(false, @tf.invalid?, 
+                 'Frame should be valid right after ThreadFrame::current')
+    def notgood(test_tf=nil)
+      # FIXME
+      # if test_tf
+      #   assert_equal(test_tf != @tf, test_tf.invalid?)
+      # end
+      return RubyVM::ThreadFrame::current
+    end
+
+    def inner_fn(tf)
+      tf.invalid?
+    end
+      
+    invalid_tf = notgood
+    # FIXME:
+    # assert_equal(true, invalid_tf.invalid?,
+    #             'current thread frame should not be returned from a fn')
+    # begin
+    #   b = invalid_tf.binding
+    #   assert false, 'Should have raised an ThreadFrameError'
+    # rescue ThreadFrameError
+    #   assert true
+    # end
+    # Add a new local variable
+    x = 5
+    assert_equal(false, @tf.invalid?, 
+                 'Frame should still be valid after adding more locals')
+    assert_equal(false, inner_fn(@tf),
+                 'outer thread frame should ok inside a called fn')
+    notgood(invalid_tf)
+    notgood(@tf)
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'test/unit'
+require_relative '../../ext/thread_frame'
+
+class TestISeqBrkpt < Test::Unit::TestCase
+
+  def test_iseq_brkpt
+    iseq = RubyVM::ThreadFrame.current.iseq
+    assert iseq
+    assert_equal(nil, iseq.brkpts)
+    assert_equal(true, iseq.brkpt_alloc)
+    assert_equal([], iseq.brkpts)
+    assert_equal(false, iseq.brkpt_alloc)
+
+    offlines  = iseq.offsetlines
+    offsets   = offlines.values
+    [offsets.min[0], offsets.max[0]].each do |offset|
+      assert_equal(true, iseq.brkpt_set(offset))
+      assert_equal(true, iseq.brkpt_set(offset))
+      assert_equal(true, iseq.brkpt_get(offset),
+                   "Offset %d should be set" % offset)
+      assert_equal(true, iseq.brkpt_unset(offset),
+                   "Offset %d should be unset" % offset)
+      assert_equal(false, iseq.brkpt_get(offset),
+                   "Offset %d should be unset now" % offset)
+      assert_equal(true, iseq.brkpt_unset(offset),
+                   "Offset %d should be unset again" % offset)
+      iseq.brkpt_set(offset) # For test below
+    end
+    assert_equal(2, iseq.brkpts.size)
+    
+    max_offset = offsets.max[0]
+
+    assert_raises TypeError do iseq.brkpt_get(iseq.iseq_size) end
+
+    assert_equal(true, iseq.brkpt_dealloc)
+    assert_equal(false, iseq.brkpt_dealloc)
+    assert_equal(true, iseq.brkpt_unset(max_offset),
+                 "Offset %d should be unset even when deallocated" % max_offset)
+
+    assert_raises TypeError do iseq.brkpt_set('a') end
+  end
+
+  def test_iseq_brkpt_set
+    add_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+                     if 'brkpt' == event
+                       $saw_brkpt = true
+                     end
+                    })
+
+    $saw_brkpt = false
+    tf = RubyVM::ThreadFrame.current
+    tf.iseq.offsetlines.keys.each do |offset|
+      tf.iseq.brkpt_set(offset)
+    end
+    assert_equal(true, $saw_brkpt)
+    clear_trace_func
+  end
+end
+
+# We want to double-check we didn't mess up any pointers somewhere.
+at_exit { GC.start  }

data/test/unit/test-iseq.rb

@@ -0,0 +1,121 @@
+require 'test/unit'
+require_relative '../../ext/thread_frame'
+
+class TestISeq < Test::Unit::TestCase
+
+  class C
+    def initialize(test_obj, optional=true)
+      iseq = RubyVM::ThreadFrame::current.iseq
+      test_obj.assert_equal('test_obj', iseq.local_name(0))
+      test_obj.assert_equal(1, iseq.arity)
+      test_obj.assert_equal(-1, iseq.arg_block)
+      test_obj.assert_equal(1, iseq.argc)
+    end
+  end
+  
+  def test_fields
+    start_lineno = __LINE__ - 1;
+    iseq = RubyVM::ThreadFrame::current.iseq
+    assert iseq
+    assert_equal('test_fields', iseq.name)
+    ## FIXME: Why does this fail? 
+    ## assert_equal(start_lineno, iseq.lineno, 'iseq.lineno')
+    assert_equal(0, iseq.arity)
+    assert_equal(-1, iseq.arg_block)
+    assert_equal(0, iseq.argc)
+    assert_equal(0, iseq.arg_opts)
+    assert_equal(4, iseq.local_table_size)
+    x  = lambda do |x,y| 
+      iseq = RubyVM::ThreadFrame::current.iseq
+      assert iseq
+      assert_equal(2, iseq.arity)
+      assert_equal(-1, iseq.arg_block)
+      assert_equal(2, iseq.argc)
+      assert_equal(0, iseq.arg_opts)
+      assert_equal(3, iseq.local_table_size)
+      ['x', 'y'].each_with_index do |expect, i|
+        assert_equal(expect, iseq.local_name(i))
+      end
+      
+      assert_equal('x', iseq.local_name(-1))
+      assert_raise IndexError do
+        x = iseq.local_name(10)
+      end
+    end
+    x.call(1,2)
+
+    x  = Proc.new do |a|
+      iseq = RubyVM::ThreadFrame::current.iseq
+      assert iseq
+      assert_equal(1, iseq.arity)
+      assert_equal(-1, iseq.arg_block)
+      assert_equal(1, iseq.argc)
+      assert_equal(0, iseq.arg_opts)
+      assert_equal(1, iseq.local_table_size)
+      ['a'].each_with_index do |expect, i|
+        assert_equal(expect, iseq.local_name(i))
+      end
+      assert_raises IndexError do
+        x = iseq.local_name(100)
+      end
+      assert_raises TypeError do 
+        p iseq.local_name('a')
+      end
+    end
+    x.call(1,2)
+    C.new(self, 5)
+    end_lineno = __LINE__ + 3
+    assert_equal((start_lineno..end_lineno), 
+                 method(:test_fields).iseq.line_range, 'line range')
+  end
+
+  def test_iseq_equal
+    tf = RubyVM::ThreadFrame.current
+    tf2 = RubyVM::ThreadFrame.current
+    while !tf.iseq do
+      tf = tf.prev
+      tf2 = tf2.prev
+    end
+    assert_equal(false, tf.iseq.equal?(nil))
+    assert_equal(true,  tf.iseq.equal?(tf.iseq))
+    assert_equal(true,  tf.iseq.equal?(tf2.iseq))
+    tf2 = tf2.prev 
+    while !tf2.iseq do tf2 = tf2.prev end
+    assert_equal(false, tf.iseq.equal?(tf2.iseq))
+    assert_raises TypeError do
+      tf.iseq.equal?(tf)
+    end
+  end
+
+  # FIXME: killcache interface will probably change. Try make less sensitive
+  # to compile sequence
+  def test_iseq_killcache
+    iseq = RubyVM::ThreadFrame.current.iseq
+    count = iseq.killcache
+    if 0 != count
+      assert_equal(0, iseq.killcache, 
+                 'Doing killcache a second time should do nothing')
+    end
+  end
+
+  def test_offsetlines
+    start     = __LINE__ - 1
+    tf        = RubyVM::ThreadFrame::current
+    iseq      = tf.iseq
+    offlines  = iseq.offsetlines
+    pc        = tf.pc_offset
+    assert_equal(__LINE__, offlines[pc][0]+1)
+    offlines.values.each do |value|
+      assert(value[0] >= start, "#{value[0]} should be not less than starting line #{start}")
+      # Rough count of # of lines is less than 20
+      assert(value[0] < start + 20, "#{value[0]} should be less than starting line #{start}")
+    end
+    offlines.keys.each do |offset|
+      assert_equal offlines[offset][0], iseq.offset2lines(offset)[0]
+    end
+  end
+
+end
+
+# We want to double-check we didn't mess up any pointers somewhere.
+at_exit { GC.start  }

data/test/unit/test-lib-iseq-extra.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require_relative '../../lib/iseq_extra'
+
+class TestLibISeqExtra < Test::Unit::TestCase
+
+  def test_basic
+    tf = RubyVM::ThreadFrame.current
+    iseq = tf.iseq
+    # See that we get the same line numbers
+    assert_equal(iseq.offsetlines.values.flatten.uniq.sort, 
+                 iseq.lineoffsets.keys.sort)
+    # See that we get the same offsets
+    assert_equal(iseq.lineoffsets.values.flatten.uniq.sort, 
+                 iseq.offsetlines.keys.sort)
+
+    assert_equal(iseq.lineoffsets[__LINE__].sort, 
+                 iseq.line2offsets(__LINE__-1).sort)
+
+    assert_equal([], iseq.line2offsets(__LINE__+100))
+    top_iseq = tf.prev(-1).iseq
+    assert_equal('method', RubyVM::InstructionSequence::TYPE2STR[top_iseq.type])
+
+    iseq2 = tf.iseq
+    # Different object ids...
+    assert_not_equal(iseq.object_id, iseq2.object_id)
+    #    but same SHA1s..
+    assert_equal(iseq.sha1, iseq2.sha1)
+    #    and equal instruction sequences
+    assert_equal(true, iseq.equal?(iseq2))
+    
+    # Now try two different iseqs
+    tf2 = tf.prev
+    tf2 = tf2.prev until !tf2.prev || tf2.prev.iseq
+    if tf2
+      assert_not_equal(iseq.sha1, tf2.iseq.sha1) 
+      assert_equal(false, iseq.equal?(tf2.iseq))
+    end
+  end
+
+  def test_format_args
+    # These prototypes are from IRB
+    def evaluate(context, statements, file = __FILE__, line = __LINE__); end
+    def def_extend_command(cmd_name, load_file, *aliases); end
+
+    assert_equal('context, statements; file, line', 
+                 method(:evaluate).iseq.format_args)
+    assert_equal('cmd_name, load_file; aliases',
+                 method(:def_extend_command).iseq.format_args)
+  end
+
+  def test_sha1
+    sha1 = proc{ 5 }.iseq.sha1
+    assert_equal(40, sha1.size)
+    assert_equal(0, sha1 =~ /^[0-9a-f]+$/)
+  end
+
+end

data/test/unit/test-prev.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require_relative '../../ext/thread_frame'
+
+class TestThread < Test::Unit::TestCase
+  def test_stack_size_with_prev
+    tf = RubyVM::ThreadFrame.new(Thread::current)
+
+    # valid prev counts are -stack_size .. stack_size-1
+    n = tf.stack_size
+    assert_equal(nil, tf.prev(n), 
+                 'Should have accessed past the top of the stack')
+    top_frame = tf.prev(n-1)
+    assert(top_frame, 
+           'Should have gotten the top frame')
+    assert_equal(tf, tf.prev(-n),
+                 'tf.prev(tf.stack_size) == tf')
+    assert(top_frame)
+    assert_equal('TOP', top_frame.type,
+                 'The type of the top frame should be "TOP"')
+  end
+
+  def test_prev
+
+    assert RubyVM::ThreadFrame::prev(Thread::current, 0)
+    assert(RubyVM::ThreadFrame::prev(Thread::current, 2),
+           'There should be at least two prior frames')
+
+    top_frame = RubyVM::ThreadFrame::prev(Thread::current, -1)
+    assert(top_frame, 'Should give back the top frame')
+    assert_equal('TOP', top_frame.type,
+                 'The type of the top frame should be "TOP"')
+
+    assert_equal(nil, RubyVM::ThreadFrame::prev(Thread::current, 1000))
+
+    tf = RubyVM::ThreadFrame::current.prev
+
+    assert tf.prev(2)
+    assert_equal(tf,  tf.prev(0), 
+                 'tf.prev(0) is defined as be tf')
+    assert tf.prev(-1)
+    assert_equal(nil, tf.prev(1000))
+
+    assert_raises TypeError do
+      tf.prev('a')
+    end
+    assert_raises TypeError do
+      RubyVM::ThreadFrame::prev([1])
+    end
+    assert_raises TypeError do
+      RubyVM::ThreadFrame::prev(RubyVM::ThreadFrame::current, [1])
+    end
+
+  end
+end