rb-threadframe 0.32

data/test/unit/test-proc.rb

@@ -0,0 +1,23 @@
+# Test of additional proc and method
+require 'test/unit'
+require_relative '../../ext/thread_frame'
+
+class TestProcAndMethod < Test::Unit::TestCase
+  def test_proc_iseq
+    assert_equal(true, 
+                 Proc.new{|x,y| x+y}.iseq.is_a?(RubyVM::InstructionSequence))
+  end
+  def test_method_extra
+    m = self.method :test_method_extra
+    assert_equal(1, m.alias_count)
+    assert_equal(:test_method_extra, m.original_id)
+    self.instance_eval { assert_equal(1, m.alias_count) }
+    assert_equal(1, m.alias_count)
+    self.instance_eval { alias :two :test_method_extra }
+    assert_equal(2, m.alias_count)
+    assert_equal(3, self.method(:test_method_extra).alias_count)
+    assert_equal(3, m.alias_count)
+    assert_equal(4, self.method(:two).alias_count)
+    assert_equal(:test_method_extra, self.method(:two).original_id)
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'test/unit'
+
+# require 'thread_frame'  # To compare with previous version
+require_relative '../../ext/thread_frame'
+
+# Test source_location and source_container.
+class TestReturnStop < Test::Unit::TestCase
+
+  def setup
+    @tuples = []
+    @p = Proc.new { |event, file, lineno, mid, binding, klass|
+      # RubyVM::ThreadFrame.current.trace_off = true
+      @tuples << [event, lineno, mid, klass]
+      # p [event, lineno, mid, klass]
+    }
+  end
+
+  # Another method to call used to make sure we have turned off
+  # tracing.
+  def five; 5 end
+
+  def recurse(a, trace_off)
+    tf = RubyVM::ThreadFrame::current
+    if a==1
+      assert_equal false, tf.return_stop?
+      tf.return_stop=trace_off
+      assert_equal trace_off, tf.return_stop?
+      tf.trace_off=true
+      assert_equal true, tf.trace_off?
+      set_trace_func(@p)
+      return recurse(2, trace_off)
+    else
+      five
+    end
+  end
+
+  def tup_to_s(tuples)
+    tuples.map do |t| 
+      '[' + t.map{|t2| t2.inspect}.join(', ') + ']'
+    end.join("\n")
+  end
+
+  def test_return_stop
+    recurse(1, true)
+    set_trace_func(nil)
+    first = @tuples.dup
+    assert_equal('return', @tuples[0][0],
+                 "First tuple recorded should have been a return event," + 
+                 "got: #{ tup_to_s(@tuples)}")
+    recurse(1, false)
+    set_trace_func(nil)
+
+    assert_equal(true, @tuples.size > first.size,
+                 'should have gotten more tuples recorded')
+    assert_equal(true, @tuples.member?(first[0]),
+                 'should find "return" event in longer trace')
+    # puts tup_to_s(first)
+    # puts '-' * 30
+    # puts tup_to_s(@tuples)
+    # assert_equal(true, @tuples.index(first[0]) > 0,
+    #              'should not find "return" event as the first event')
+  end
+
+end

data/test/unit/test-settracefunc.rb

@@ -0,0 +1,315 @@
+#!/usr/bin/env ruby
+
+# This program is from Ruby 1.9. We run it here (again) just in case we didn't
+# run as part of checking Ruby 1.9 sanity.
+
+require 'test/unit'
+
+class TestSetTraceFunc < Test::Unit::TestCase
+  def setup
+    @original_compile_option = RubyVM::InstructionSequence.compile_option
+    RubyVM::InstructionSequence.compile_option = {
+      :trace_instruction => true,
+      :specialized_instruction => false
+    }
+    @events = []
+  end
+
+  def teardown
+    set_trace_func(nil)
+    RubyVM::InstructionSequence.compile_option = @original_compile_option
+  end
+
+  def chunk(list, char='-')
+    sep = char * 30 + "\n"
+    sep + list.map{|e| e.join(' ')}.join("\n") + "\n"
+  end
+
+  def showit(actual, expected)
+    chunk(actual, '-') + chunk(expected, '=')
+  end
+
+  def checkit(actual, expected)
+    actual.each_with_index do |e, i|
+      assert_equal(e, actual[i], showit(actual, expected))
+    end
+    assert_equal(expected.size, actual.size, showit(actual, expected))
+  end
+
+  def test_c_call
+    eval <<-EOF.gsub(/^.*?: /, '')
+     1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+     2:   @events << [lineno, event, mid, klass]
+     3: })
+     4: x = 1 + 1
+     5: set_trace_func(nil)
+    EOF
+
+    expected = [[4, 'line',     __method__, self.class],
+                [4, "c-call",   :+,         Fixnum],
+                [4, "c-return", :+,         Fixnum],
+                [5, "line",     __method__, self.class],
+                [5, "c-call",   :set_trace_func, Kernel]]
+    checkit(@events, expected)
+  end
+
+  def test_call
+    eval <<-EOF.gsub(/^.*?: /, '')
+     1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+     2:   @events << [lineno, event, mid, klass]
+     3: })
+     4: def add(x, y)
+     5:   x + y
+     6: end
+     7: x = add(1, 1)
+     8: set_trace_func(nil)
+    EOF
+
+    expected = [[4, 'line',     __method__,    self.class],
+                [4, 'c-call',   :method_added, Module],
+                [4, 'c-return', :method_added, Module],
+                [7, 'line',     __method__,    self.class],
+                [4, 'call',     :add,          self.class],
+                [5, 'line',     :add,          self.class],
+                [5, 'c-call',   :+,            Fixnum],
+                [5, 'c-return', :+,            Fixnum],
+                [6, 'return',   :add,          self.class],
+                [8, 'line',      __method__,   self.class],
+                [8, 'c-call',   :set_trace_func, Kernel]]
+    checkit(@events, expected)
+  end
+
+  def test_class
+    eval <<-EOF.gsub(/^.*?: /, '')
+     1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+     2:   @events << [lineno, event, mid, klass]
+     3: })
+     4: class Foo
+     5:   def bar
+     6:   end
+     7: end
+     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, 'c-call',   :method_added, Module],
+                [5, 'c-return', :method_added, Module],
+                [7, 'end',      nil,           nil],
+                [8, 'line',     __method__,    self.class],
+                [8, 'c-call',   :new,          Class],
+                [8, 'c-call',   :initialize,   BasicObject],
+                [8, 'c-return', :initialize,   BasicObject],
+                [8, 'c-return', :new,          Class],
+                [5, 'call',     :bar,          Foo],
+                [6, 'return',   :bar,          Foo],
+                [9, 'line',     __method__,    self.class],
+                [9, 'c-call',   :clear_trace_func, Kernel]]
+    checkit(@events, expected)
+  end
+
+  def test_return # [ruby-dev:38701]
+    eval <<-EOF.gsub(/^.*?: /, '')
+     1: add_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+     2:   @events << [lineno, event, mid, klass]
+     3: })
+     4: def foo(a)
+     5:   return if a
+     6:   return
+     7: end
+     8: foo(true)
+     9: foo(false)
+    10: set_trace_func(nil)
+    EOF
+    expected = [[ 4, 'line',     __method__,   self.class],
+                [ 4, 'c-call',   :method_added, Module],
+                [ 4, 'c-return', :method_added, Module],
+                [ 8, 'line',     __method__,   self.class],
+                [ 4, 'call',     :foo,         self.class],
+                [ 5, 'line',     :foo,         self.class],
+                [ 5, 'return',   :foo,         self.class],
+                [ 9, 'line',     :test_return, self.class],
+                [ 4, 'call',     :foo,         self.class],
+                [ 5, 'line',     :foo,         self.class],
+                [ 7, 'return',   :foo,         self.class],
+                [10, 'line',     :test_return, self.class],
+                [10, 'c-call',   :set_trace_func, Kernel]]
+    checkit(@events, expected)
+  end
+
+  def test_return2 # [ruby-core:24463]
+    eval <<-EOF.gsub(/^.*?: /, '')
+     1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+     2:   @events << [lineno, event, mid, klass]
+     3: })
+     4: def foo
+     5:   a = 5
+     6:   return a
+     7: end
+     8: foo
+     9: set_trace_func(nil)
+    EOF
+
+    expected = [[4, 'line',     __method__, self.class],
+                [4, 'c-call',   :method_added, Module],
+                [4, 'c-return', :method_added, Module],
+                [8, 'line',     __method__, self.class],
+                [4, 'call',     :foo, self.class],
+                [5, 'line',     :foo, self.class],
+                [6, 'line',     :foo, self.class],
+                [7, 'return',   :foo, self.class],
+                [9, 'line',     :test_return2, self.class],
+                [9, 'c-call',   :set_trace_func, Kernel]]
+    @events.each_with_index{|e, i|
+      assert_equal(e, @events[i], showit(@events, expected))}
+    assert_equal(expected.size, @events.size, showit(@events, expected))
+  end
+
+  def test_raise
+    events = []
+    eval <<-EOF.gsub(/^.*?: /, '')
+     1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+     2:   events << [event, lineno, mid, klass]
+     3: })
+     4: begin
+     5:   raise TypeError, 'error'
+     6: rescue TypeError => $e
+     7: end
+     8: set_trace_func(nil)
+    EOF
+    
+    expected = [[4, 'line',     __method__,     self.class],
+                [5, 'line',     __method__,     self.class],
+                [5, 'c-call',   :raise,         Kernel],
+                [5, 'c-call',   :exception,     Exception],
+                [5, 'c-call',   :initialize,    Exception],
+                [5, 'c-return', :initialize,    Exception],
+                [5, 'c-return', :exception,     Exception],
+                [5, 'c-call',   :backtrace,     Exception],
+                [5, 'c-return', :backtrace,     Exception],
+                [5, 'c-call',   :set_backtrace, Exception],
+                [5, 'c-return', :set_backtrace, Exception],
+                [5, 'raise',    :test_raise,    $e], 
+                [5, 'c-return', :raise,         Kernel],
+                [6, 'c-call',   :===,           Module],
+                [6, 'c-return', :===,           Module],
+                [8, 'line',     __method__,     self.class],
+                [8, 'c-call',   :set_trace_func, Kernel]]
+    checkit(events, expected)
+  end
+
+  def test_break # [ruby-core:27606] [Bug #2610]
+    events = []
+    eval <<-EOF.gsub(/^.*?: /, '')
+     1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
+     2:   events << [lineno, event, mid, klass]
+     3: })
+     4: [1,2,3].any? {|n| n}
+     8: set_trace_func(nil)
+    EOF
+
+    expected = [[4, 'line',     __method__, self.class],
+                [4, 'c-call',   :any?,      Enumerable],
+                [4, 'c-call',   :each,      Array],
+                [4, 'line',     __method__, self.class],
+                [4, 'c-return', :each,      Array],
+                [4, 'c-return', :any?,      Enumerable],
+                [5, 'line',     __method__, self.class],
+                [5, 'c-call',   :set_trace_func, Kernel]]
+    checkit(events, expected)
+  end
+
+  def test_invalid_proc
+      assert_raise(TypeError) { set_trace_func(1) }
+  end
+
+  def test_raise_in_trace
+    set_trace_func proc {raise rescue nil}
+    assert_equal(42, (raise rescue 42), '[ruby-core:24118]')
+  end
+
+  def test_thread_trace
+    events = {:set => [], :add => []}
+    prc = Proc.new { |event, file, lineno, mid, binding, klass|
+      events[:set] << [lineno, event, mid, klass, :set]
+    }
+    prc2 = Proc.new { |event, file, lineno, mid, binding, klass|
+      events[:add] << [lineno, event, mid, klass, :add]
+    }
+
+    th = Thread.new do
+      th = Thread.current
+      eval <<-EOF.gsub(/^.*?: /, '')
+       1: th.set_trace_func(prc)
+       2: th.add_trace_func(prc2)
+       3: class ThreadTraceInnerClass
+       4:   def foo
+       5:     x = 1 + 1
+       6:   end
+       7: end
+       8: ThreadTraceInnerClass.new.foo
+       9: th.set_trace_func(nil)
+      EOF
+    end
+    th.join
+
+    expected = [[1, 'c-return', :set_trace_func, Thread, :set],
+                [2, 'line',     __method__, self.class, :set],
+                [2, 'c-call',   :add_trace_func, Thread, :set]]
+    expected.each do |e|
+      assert_equal(e, events[:set].shift, showit(events, expected))
+    end
+
+    [[2, 'c-return', :add_trace_func, Thread],
+     [3, 'line',     __method__, self.class],
+     [3, 'c-call',   :inherited, Class],
+     [3, 'c-return', :inherited, Class],
+     [3, 'class',    nil, nil],
+     [4, 'line',     nil, nil],
+     [4, 'c-call',   :method_added, Module],
+     [4, 'c-return', :method_added, Module],
+     [7, 'end',      nil, nil],
+     [8, 'line',     __method__, self.class],
+     [8, 'c-call',   :new, Class],
+     [8, 'c-call',   :initialize, BasicObject],
+     [8, 'c-return', :initialize, BasicObject],
+     [8, 'c-return', :new, Class],
+     [4, 'call',     :foo, ThreadTraceInnerClass],
+     [5, 'line',     :foo, ThreadTraceInnerClass],
+     [5, 'c-call',   :+, Fixnum],
+     [5, 'c-return', :+, Fixnum],
+     [6, 'return',   :foo, ThreadTraceInnerClass],
+     [9, 'line',     __method__, self.class],
+     [9, 'c-call',   :set_trace_func, Thread]].each do |e|
+      [:set, :add].each do |type|
+        assert_equal(e + [type], events[type].shift)
+      end
+    end
+    assert_equal([], events[:set])
+    assert_equal([], events[:add])
+  end
+
+  def test_trace_proc_that_raises_exception_recovery
+    $first_time = true
+    $traced = []
+    s = Proc.new {|event|
+      if $first_time
+        $first_time = false
+        raise RuntimeError
+      end
+      $traced << event
+    }
+    begin
+      set_trace_func(s)
+      assert_equal(false, 'hook should have raised error')
+    rescue RuntimeError
+      x = 1
+      set_trace_func(nil)
+      assert_equal(false, $traced.empty?, $traced)
+    end
+  end
+
+end

data/test/unit/test-source.rb

@@ -0,0 +1,104 @@
+require 'test/unit'
+
+# require 'thread_frame'  # To compare with previous version
+require_relative '../../ext/thread_frame'
+
+# Test source_location and source_container.
+class TestSource < Test::Unit::TestCase
+
+  def test_iseq_source_container
+    test_basic_lineno = __LINE__ - 1
+    tup = method(:test_iseq_source_container).iseq.source_container
+    tup[1] = File.basename(tup[1])
+    assert_equal(['file',  File.basename(__FILE__)], tup)
+
+    eval('def foo; 5 end')
+    tup = method(:foo).iseq.source_container    
+    assert_equal('string',  tup[0])
+    # puts tup[1]
+
+    iseq = RubyVM::InstructionSequence.compile("1+2")
+    assert_equal('string',  iseq.source_container[0])
+    # puts iseq.source_container[1]
+
+    eval_str = '  RubyVM::ThreadFrame.current.source_container # test'
+    tuple = eval(eval_str)
+    assert_equal('string',  tuple[0])
+    assert_equal(eval_str,  tuple[1])
+
+  end
+
+  def test_basic
+    tf = RubyVM::ThreadFrame::current
+    # Is this too specific to test/unit.rb implementation details? 
+    tup = tf.source_container
+    tup[1] = File.basename(tup[1])
+    assert_equal(['file',  File.basename(__FILE__)], tup)
+    assert_equal(__LINE__, tf.source_location[0])
+
+    # 1.times creates a C frame.
+    1.times do 
+      expect_line = __LINE__ - 1
+      tf = RubyVM::ThreadFrame::current
+      tup = tf.source_container
+      tup[1] = File.basename(tup[1])
+      assert_equal(['file',  File.basename(__FILE__)], tup)
+      assert_equal(tf.source_location[0], __LINE__)
+      tf = tf.prev
+      assert_equal('CFUNC', tf.type)
+      tup = tf.source_container
+      tup[1] = File.basename(tup[1])
+      assert_equal(expect_line, tf.source_location[0])
+    end
+
+    # 1.upto also creates a C frame.
+    1.upto(1) do 
+      expect_line = __LINE__ - 1
+      tf = RubyVM::ThreadFrame::current
+      assert_equal('BLOCK', tf.type)
+      tup = tf.source_container
+      tup[1] = File.basename(tup[1])
+      assert_equal(['file',  File.basename(__FILE__)], tup)
+      assert_equal(__LINE__, tf.source_location[0])
+      tf = tf.prev
+      assert_equal('CFUNC', tf.type)
+      tup = tf.source_container
+      tup[1] = File.basename(tup[1])
+      assert_equal(expect_line, tf.source_location[0])
+    end
+
+    x  = lambda do |expect_line| 
+      tf = RubyVM::ThreadFrame::current
+      assert_equal('LAMBDA', tf.type)
+      tup = tf.source_container
+      tup[1] = File.basename(tup[1])
+      assert_equal(['file',  File.basename(__FILE__)], tup)
+      assert_equal(__LINE__, tf.source_location[0])
+      tf = tf.prev
+      assert_equal('CFUNC', tf.type)
+      tup = tf.source_container
+      tup[1] = File.basename(tup[1])
+      assert_equal(expect_line, tf.source_location[0])
+    end
+    x.call(__LINE__)
+
+    x  = Proc.new do |expect_line|
+      tf = RubyVM::ThreadFrame::current
+      tup = tf.source_container
+      tup[1] = File.basename(tup[1])
+      assert_equal(['file',  File.basename(__FILE__)], tup)
+      assert_equal(__LINE__, tf.source_location[0])
+      tf = tf.prev
+      tup = tf.source_container
+      tup[1] = File.basename(tup[1])
+      # FIXME? 
+      # assert_equal(['file',  File.basename(__FILE__)], tup)
+      assert_equal(expect_line, tf.source_location[0])
+    end
+    x.call(__LINE__)
+  end
+end
+
+# We want to double-check we didn't mess up any pointers somewhere along
+# the line.
+at_exit { GC.start  }