rb-threadframe 0.39 → 0.40

data/test/unit/test-iseq.rb

@@ -1,11 +1,11 @@
 require 'test/unit'
-require_relative '../../ext/thread_frame'
+require_relative '../../ext/thread_frame' if '1.9.2' == RUBY_VERSION
 
 class TestISeq < Test::Unit::TestCase
 
   class C
     def initialize(test_obj, optional=true)
-      iseq = RubyVM::ThreadFrame::current.iseq
+      iseq = RubyVM::Frame::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)
@@ -15,7 +15,7 @@ class TestISeq < Test::Unit::TestCase
   
   def test_fields
     start_lineno = __LINE__ - 1;
-    iseq = RubyVM::ThreadFrame::current.iseq
+    iseq = RubyVM::Frame::current.iseq
     assert iseq
     assert_equal('test_fields', iseq.name)
     ## FIXME: Why does this fail? 
@@ -26,7 +26,7 @@ class TestISeq < Test::Unit::TestCase
     assert_equal(0, iseq.arg_opts)
     assert_equal(4, iseq.local_table_size)
     x  = lambda do |x,y| 
-      iseq = RubyVM::ThreadFrame::current.iseq
+      iseq = RubyVM::Frame::current.iseq
       assert iseq
       assert_equal(2, iseq.arity)
       assert_equal(-1, iseq.arg_block)
@@ -45,7 +45,7 @@ class TestISeq < Test::Unit::TestCase
     x.call(1,2)
 
     x  = Proc.new do |a|
-      iseq = RubyVM::ThreadFrame::current.iseq
+      iseq = RubyVM::Frame::current.iseq
       assert iseq
       assert_equal(1, iseq.arity)
       assert_equal(-1, iseq.arg_block)
@@ -70,8 +70,8 @@ class TestISeq < Test::Unit::TestCase
   end
 
   def test_iseq_equal
-    tf = RubyVM::ThreadFrame.current
-    tf2 = RubyVM::ThreadFrame.current
+    tf = RubyVM::Frame.current
+    tf2 = RubyVM::Frame.current
     while !tf.iseq do
       tf = tf.prev
       tf2 = tf2.prev
@@ -90,7 +90,8 @@ class TestISeq < Test::Unit::TestCase
   # FIXME: killcache interface will probably change. Try make less sensitive
   # to compile sequence
   def test_iseq_killcache
-    iseq = RubyVM::ThreadFrame.current.iseq
+    skip "killcache doesn't work on 1.9.3" if '1.9.3' == RUBY_VERSION
+    iseq = RubyVM::Frame.current.iseq
     count = iseq.killcache
     if 0 != count
       assert_equal(0, iseq.killcache, 
@@ -100,7 +101,7 @@ class TestISeq < Test::Unit::TestCase
 
   def test_offsetlines
     start     = __LINE__ - 1
-    tf        = RubyVM::ThreadFrame::current
+    tf        = RubyVM::Frame::current
     iseq      = tf.iseq
     offlines  = iseq.offsetlines
     pc        = tf.pc_offset

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

@@ -4,7 +4,7 @@ require_relative '../../lib/iseq_extra'
 class TestLibISeqExtra < Test::Unit::TestCase
 
   def test_basic
-    tf = RubyVM::ThreadFrame.current
+    tf = RubyVM::Frame.current
     iseq = tf.iseq
     # See that we get the same line numbers
     assert_equal(iseq.offsetlines.values.flatten.uniq.sort, 
@@ -17,8 +17,6 @@ class TestLibISeqExtra < Test::Unit::TestCase
                  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...
@@ -37,6 +35,17 @@ class TestLibISeqExtra < Test::Unit::TestCase
     end
   end
 
+  def test_iseq_type
+    tf = RubyVM::Frame.current
+    top_iseq = tf.prev(-1).iseq
+    if '1.9.3' == RUBY_VERSION 
+      assert_equal('METHOD', tf.prev.type)
+    else
+      assert_equal('method', 
+                   RubyVM::InstructionSequence::TYPE2STR[top_iseq.type])
+    end
+  end
+
   def test_format_args
     # These prototypes are from IRB
     def evaluate(context, statements, file = __FILE__, line = __LINE__); end
@@ -55,9 +64,9 @@ class TestLibISeqExtra < Test::Unit::TestCase
   end
 
   def test_iseq_parent
-    parent_iseq = RubyVM::ThreadFrame::current.iseq
+    parent_iseq = RubyVM::Frame::current.iseq
     1.times do 
-      tf = RubyVM::ThreadFrame::current
+      tf = RubyVM::Frame::current
       assert_equal(true, tf.iseq.parent.equal?(parent_iseq))
     end
   end

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

@@ -1,6 +1,7 @@
 require 'test/unit'
-require_relative '../../ext/thread_frame'
-require_relative '../../lib/thread_frame'
+require_relative '../../ext/thread_frame' if '1.9.2' == RUBY_VERSION
+require_relative '../../lib/thread_frame' if '1.9.2' == RUBY_VERSION
+require_relative '../../lib/iseq_extra'
 
 $global_test_line = __LINE__
 
@@ -9,22 +10,22 @@ class TestLibISeq < Test::Unit::TestCase
   TEST_LINE = __LINE__
 
   def test_sha1
-    iseq1 = RubyVM::ThreadFrame::current.iseq
-    iseq2 = RubyVM::ThreadFrame::current.iseq
+    iseq1 = RubyVM::Frame::current.iseq
+    iseq2 = RubyVM::Frame::current.iseq
     assert_equal(iseq1.sha1, iseq2.sha1, 
                  "SHA1 for same threadframe should match")
   end
 
   def test_lines
     line = __LINE__
-    iseq = RubyVM::ThreadFrame::current.iseq
+    iseq = RubyVM::Frame::current.iseq
     assert_equal((line-1..__LINE__+2).to_a, iseq.lines,
                  "lines of test_lines() don't match")
   end
 
   def test_locate_line
     line = __LINE__
-    iseq = RubyVM::ThreadFrame::current.iseq
+    iseq = RubyVM::Frame::current.iseq
     assert iseq.locate_line(line)
     assert_nil iseq.locate_line(line - 2)
   end
@@ -34,11 +35,11 @@ class TestLibISeq < Test::Unit::TestCase
     # It is lame how little we can do here.
     line = __LINE__
     def find_line(line) # :nodoc
-      tf = RubyVM::ThreadFrame.current
+      tf = RubyVM::Frame.current
       assert(tf.iseq.find_iseq_with_line(line), 
              "should have found line #{line}")
     end
-    tf = RubyVM::ThreadFrame.current
+    tf = RubyVM::Frame.current
     find_line(line+2)
     # line2 = nil
     # 1.times do 

data/test/unit/test-prev.rb

@@ -1,9 +1,9 @@
 require 'test/unit'
-require_relative '../../ext/thread_frame'
+require_relative '../../ext/thread_frame' if '1.9.2' == RUBY_VERSION
 
 class TestThread < Test::Unit::TestCase
   def test_stack_size_with_prev
-    tf = RubyVM::ThreadFrame.new(Thread::current)
+    tf = RubyVM::Frame.new(Thread::current)
 
     # valid prev counts are -stack_size .. stack_size-1
     n = tf.stack_size
@@ -21,26 +21,26 @@ class TestThread < Test::Unit::TestCase
 
   def test_prev
 
-    assert RubyVM::ThreadFrame::prev(Thread::current, 1),
+    assert RubyVM::Frame::prev(Thread::current, 1),
                                      'should allow 2-arg prev'
-    assert RubyVM::ThreadFrame::prev(Thread::current),
+    assert RubyVM::Frame::prev(Thread::current),
                                      'should allow 1-arg thread prev'
-    assert(RubyVM::ThreadFrame::prev(2),
+    assert(RubyVM::Frame::prev(2),
            'There should be at least two prior frames in single Fixnum prev')
 
-    top_frame = RubyVM::ThreadFrame::prev(Thread::current, -1)
+    top_frame = RubyVM::Frame::prev(Thread::current, -1)
     assert(top_frame, 'Should give back the top frame for two arg and -1')
     assert_equal('TOP', top_frame.type,
                  'The type of the top frame should be "TOP"')
 
-    top_frame = RubyVM::ThreadFrame::prev(-1)
+    top_frame = RubyVM::Frame::prev(-1)
     assert(top_frame, 'Should give back the top frame for one arg and -1')
     assert_equal('TOP', top_frame.type,
                  'The type of the top frame should be "TOP"')
 
-    assert_equal(nil, RubyVM::ThreadFrame::prev(Thread::current, 1000))
+    assert_equal(nil, RubyVM::Frame::prev(Thread::current, 1000))
 
-    tf = RubyVM::ThreadFrame.prev
+    tf = RubyVM::Frame.prev
 
     assert tf.prev(2)
     assert_equal(tf,  tf.prev(0), 
@@ -52,13 +52,13 @@ class TestThread < Test::Unit::TestCase
       tf.prev('a')
     end
     assert_raises ArgumentError do
-      tf.prev(RubyVM::ThreadFrame::current, 1, 'bad_arg')
+      tf.prev(RubyVM::Frame::current, 1, 'bad_arg')
     end
     assert_raises TypeError do
-      RubyVM::ThreadFrame::prev([1])
+      RubyVM::Frame::prev([1])
     end
     assert_raises TypeError do
-      RubyVM::ThreadFrame::prev(RubyVM::ThreadFrame::current, [1])
+      RubyVM::Frame::prev(RubyVM::Frame::current, [1])
     end
 
   end

data/test/unit/test-proc.rb

@@ -1,6 +1,7 @@
 # Test of additional proc and method
 require 'test/unit'
-require_relative '../../ext/thread_frame'
+
+require_relative '../../ext/thread_frame' if '1.9.2' == RUBY_VERSION
 
 class TestProcAndMethod < Test::Unit::TestCase
   def test_proc_iseq
@@ -8,6 +9,8 @@ class TestProcAndMethod < Test::Unit::TestCase
                  Proc.new{|x,y| x+y}.iseq.is_a?(RubyVM::InstructionSequence))
   end
   def test_method_extra
+    # skip "Figure out what's up with on 1.9.3" if 
+    #  '1.9.3' == RUBY_VERSION
     m = self.method :test_method_extra
     assert_equal(1, m.alias_count)
     assert_equal(:test_method_extra, m.original_id)

data/test/unit/test-return-stop.rb

@@ -1,7 +1,6 @@
 require 'test/unit'
 
-# require 'thread_frame'  # To compare with previous version
-require_relative '../../ext/thread_frame'
+require_relative '../../ext/thread_frame' if '1.9.2' == RUBY_VERSION
 
 # Test source_location and source_container.
 class TestReturnStop < Test::Unit::TestCase
@@ -9,7 +8,7 @@ class TestReturnStop < Test::Unit::TestCase
   def setup
     @tuples = []
     @p = Proc.new { |event, file, lineno, mid, binding, klass|
-      # RubyVM::ThreadFrame.current.trace_off = true
+      # RubyVM::Frame.current.trace_off = true
       @tuples << [event, lineno, mid, klass]
       # p [event, lineno, mid, klass]
     }
@@ -20,7 +19,7 @@ class TestReturnStop < Test::Unit::TestCase
   def five; 5 end
 
   def recurse(a, trace_off)
-    tf = RubyVM::ThreadFrame::current
+    tf = RubyVM::Frame::current
     if a==1
       assert_equal false, tf.return_stop?
       tf.return_stop=trace_off

data/test/unit/test-settracefunc.rb

@@ -45,14 +45,18 @@ class TestSetTraceFunc < Test::Unit::TestCase
      5: set_trace_func(nil)
     EOF
 
-    expected = [
-                [4, 'line',     __method__, self.class],
-                [4, 'send',     __method__, self.class],
-                [4, "c-call",   :+,         Fixnum],
-                [4, "c-return", :+,         Fixnum],
-                [5, "line",     __method__, self.class],
-                [5, "send",     __method__, self.class],
-                [5, "c-call",   :set_trace_func, Kernel]]
+    expected = 
+      [
+       [4, 'line',     __method__, self.class],
+       [4, 'send',     __method__, self.class],
+       [4, "c-call",   :+,         Fixnum],
+       [4, "c-return", :+,         Fixnum],
+       [5, "line",     __method__, self.class],
+       [5, "send",     __method__, self.class],
+       [5, "c-call",   :set_trace_func, Kernel]
+      ]
+    expected.unshift [5, 'c-return', :set_trace_func, Kernel] if 
+      '1.9.3' == RUBY_VERSION
     checkit(@events, expected)
   end
 
@@ -87,6 +91,9 @@ class TestSetTraceFunc < Test::Unit::TestCase
        [8, 'send',      __method__,   self.class],
        [8, 'c-call',   :set_trace_func, Kernel]
       ]
+    expected.unshift [3, 'c-return', :set_trace_func, Kernel] if 
+      '1.9.3' == RUBY_VERSION
+
     checkit(@events, expected)
   end
 
@@ -102,29 +109,34 @@ class TestSetTraceFunc < Test::Unit::TestCase
      8: x = Foo.new.bar
      9: clear_trace_func()
     EOF
-    expected = [[4, 'line',     __method__,   self.class],
-                [4, 'c-call',   :inherited,   Class],
-                [4, 'c-return', :inherited,   Class],
-                [4, 'class',    nil,           nil],
-                [5, 'line',     nil,           nil],
-                [5, 'send',     nil,           nil],
-                [5, 'c-call',   :method_added, Module],
-                [5, 'c-return', :method_added, Module],
-                [7, 'end',      nil,           nil],
-                [7, 'leave',    nil,           nil],
-                [8, 'line',     __method__,    self.class],
-                [8, 'send',     __method__,    self.class],
-                [8, 'c-call',   :new,          Class],
-                [8, 'c-call',   :initialize,   BasicObject],
-                [8, 'c-return', :initialize,   BasicObject],
-                [8, 'c-return', :new,          Class],
-                [8, 'send',     __method__,          Class],
-                [5, 'call',     :bar,          Foo],
-                [6, 'return',   :bar,          Foo],
-                [6, 'leave',    :bar,          Foo],
-                [9, 'line',     __method__,    self.class],
-                [9, 'send',     __method__,    self.class],
-                [9, 'c-call',   :clear_trace_func, Kernel]]
+    expected = 
+      [
+       [4, 'line',     __method__,   self.class],
+       [4, 'c-call',   :inherited,   Class],
+       [4, 'c-return', :inherited,   Class],
+       [4, 'class',    nil,           nil],
+       [5, 'line',     nil,           nil],
+       [5, 'send',     nil,           nil],
+       [5, 'c-call',   :method_added, Module],
+       [5, 'c-return', :method_added, Module],
+       [7, 'end',      nil,           nil],
+       [7, 'leave',    nil,           nil],
+       [8, 'line',     __method__,    self.class],
+       [8, 'send',     __method__,    self.class],
+       [8, 'c-call',   :new,          Class],
+       [8, 'c-call',   :initialize,   BasicObject],
+       [8, 'c-return', :initialize,   BasicObject],
+       [8, 'c-return', :new,          Class],
+       [8, 'send',     __method__,          Class],
+       [5, 'call',     :bar,          Foo],
+       [6, 'return',   :bar,          Foo],
+       [6, 'leave',    :bar,          Foo],
+       [9, 'line',     __method__,    self.class],
+       [9, 'send',     __method__,    self.class],
+       [9, 'c-call',   :clear_trace_func, Kernel]
+      ]
+    expected.unshift [3, 'c-return', :set_trace_func, Kernel] if 
+      '1.9.3' == RUBY_VERSION
     checkit(@events, expected)
   end
 
@@ -194,6 +206,9 @@ class TestSetTraceFunc < Test::Unit::TestCase
        [9, 'line',     :test_return2, self.class],
        [9, 'send',     :test_return2, self.class],
        [9, 'c-call',   :set_trace_func, Kernel]]
+    expected.unshift [3, 'c-return', :set_trace_func, Kernel] if 
+      '1.9.3' == RUBY_VERSION
+
     @events.each_with_index{|e, i|
       assert_equal(e, @events[i], showit(@events, expected))}
     assert_equal(expected.size, @events.size, showit(@events, expected))
@@ -236,6 +251,9 @@ class TestSetTraceFunc < Test::Unit::TestCase
        [8, 'send',     __method__,     self.class],
        [8, 'c-call',   :set_trace_func, Kernel]
       ]
+    expected.unshift [3, 'c-return', :set_trace_func, Kernel] if 
+      '1.9.3' == RUBY_VERSION
+
     checkit(events, expected)
   end
 
@@ -249,18 +267,24 @@ class TestSetTraceFunc < Test::Unit::TestCase
      8: set_trace_func(nil)
     EOF
 
-    expected = [
-                [4, 'line',     __method__, self.class],
-                [4, 'send',     __method__, self.class],
-                [4, 'c-call',   :any?,      Enumerable],
-                [4, 'c-call',   :each,      Array],
-                [4, 'line',     __method__, self.class],
-                [4, 'leave',    __method__, self.class],
-                [4, 'c-return', :each,      Array],
-                [4, 'c-return', :any?,      Enumerable],
-                [5, 'line',     __method__, self.class],
-                [5, 'send',     __method__, self.class],
-                [5, 'c-call',   :set_trace_func, Kernel]]
+    expected = 
+      [
+       [4, 'line',     __method__, self.class],
+       [4, 'send',     __method__, self.class],
+       [4, 'c-call',   :any?,      Enumerable],
+       [4, 'c-call',   :each,      Array],
+       [4, 'line',     __method__, self.class],
+       [4, 'leave',    __method__, self.class],
+       [4, 'c-return', :each,      Array],
+       [4, 'c-return', :any?,      Enumerable],
+       [5, 'line',     __method__, self.class],
+       [5, 'send',     __method__, self.class],
+       [5, 'c-call',   :set_trace_func, Kernel]
+      ]
+    expected.unshift [3, 'c-return', :set_trace_func, Kernel] if 
+      '1.9.3' == RUBY_VERSION
+
+      
     checkit(events, expected)
   end
 

data/test/unit/test-source.rb

@@ -1,7 +1,6 @@
 require 'test/unit'
 
-# require 'thread_frame'  # To compare with previous version
-require_relative '../../ext/thread_frame'
+require_relative '../../ext/thread_frame' if '1.9.2' == RUBY_VERSION
 
 # Test source_location and source_container.
 class TestSource < Test::Unit::TestCase
@@ -21,7 +20,7 @@ class TestSource < Test::Unit::TestCase
     assert_equal('string',  iseq.source_container[0])
     # puts iseq.source_container[1]
 
-    eval_str = '  RubyVM::ThreadFrame.current.source_container # test'
+    eval_str = '  RubyVM::Frame.current.source_container # test'
     tuple = eval(eval_str)
     assert_equal('string',  tuple[0])
     assert_equal(eval_str,  tuple[1])
@@ -29,7 +28,7 @@ class TestSource < Test::Unit::TestCase
   end
 
   def test_basic
-    tf = RubyVM::ThreadFrame::current
+    tf = RubyVM::Frame::current
     # Is this too specific to test/unit.rb implementation details? 
     tup = tf.source_container
     tup[1] = File.basename(tup[1])
@@ -39,7 +38,7 @@ class TestSource < Test::Unit::TestCase
     # 1.times creates a C frame.
     1.times do 
       expect_line = __LINE__ - 1
-      tf = RubyVM::ThreadFrame::current
+      tf = RubyVM::Frame::current
       tup = tf.source_container
       tup[1] = File.basename(tup[1])
       assert_equal(['file',  File.basename(__FILE__)], tup)
@@ -54,7 +53,7 @@ class TestSource < Test::Unit::TestCase
     # 1.upto also creates a C frame.
     1.upto(1) do 
       expect_line = __LINE__ - 1
-      tf = RubyVM::ThreadFrame::current
+      tf = RubyVM::Frame::current
       assert_equal('BLOCK', tf.type)
       tup = tf.source_container
       tup[1] = File.basename(tup[1])
@@ -68,7 +67,7 @@ class TestSource < Test::Unit::TestCase
     end
 
     x  = lambda do |expect_line| 
-      tf = RubyVM::ThreadFrame::current
+      tf = RubyVM::Frame::current
       assert_equal('LAMBDA', tf.type)
       tup = tf.source_container
       tup[1] = File.basename(tup[1])
@@ -83,7 +82,7 @@ class TestSource < Test::Unit::TestCase
     x.call(__LINE__)
 
     x  = Proc.new do |expect_line|
-      tf = RubyVM::ThreadFrame::current
+      tf = RubyVM::Frame::current
       tup = tf.source_container
       tup[1] = File.basename(tup[1])
       assert_equal(['file',  File.basename(__FILE__)], tup)