summaryrefslogtreecommitdiff
path: root/test/ruby/test_settracefunc.rb
diff options
context:
space:
mode:
Diffstat (limited to 'test/ruby/test_settracefunc.rb')
-rw-r--r--test/ruby/test_settracefunc.rb1016
1 files changed, 933 insertions, 83 deletions
diff --git a/test/ruby/test_settracefunc.rb b/test/ruby/test_settracefunc.rb
index 0599ea2022..73d8aee6a2 100644
--- a/test/ruby/test_settracefunc.rb
+++ b/test/ruby/test_settracefunc.rb
@@ -3,17 +3,21 @@ 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
- }
+ if defined?(RubyVM)
+ @original_compile_option = RubyVM::InstructionSequence.compile_option
+ RubyVM::InstructionSequence.compile_option = {
+ :trace_instruction => true,
+ :specialized_instruction => false
+ }
+ end
@target_thread = Thread.current
end
def teardown
set_trace_func(nil)
- RubyVM::InstructionSequence.compile_option = @original_compile_option
+ if defined?(RubyVM)
+ RubyVM::InstructionSequence.compile_option = @original_compile_option
+ end
@target_thread = nil
end
@@ -46,6 +50,29 @@ class TestSetTraceFunc < Test::Unit::TestCase
assert_equal([], events)
end
+ def test_c_call_removed_method
+ # [Bug #19305]
+ klass = Class.new do
+ attr_writer :bar
+ alias_method :set_bar, :bar=
+ remove_method :bar=
+ end
+
+ obj = klass.new
+ method_id = nil
+ parameters = nil
+
+ TracePoint.new(:c_call) { |tp|
+ method_id = tp.method_id
+ parameters = tp.parameters
+ }.enable {
+ obj.set_bar(1)
+ }
+
+ assert_equal(:bar=, method_id)
+ assert_equal([[:req]], parameters)
+ end
+
def test_call
events = []
name = "#{self.class}\##{__method__}"
@@ -137,6 +164,10 @@ class TestSetTraceFunc < Test::Unit::TestCase
assert_equal(["c-call", 9, :set_trace_func, Kernel],
events.shift)
assert_equal([], events)
+
+ self.class.class_eval do
+ remove_const :Foo
+ end
end
def test_return # [ruby-dev:38701]
@@ -239,8 +270,6 @@ class TestSetTraceFunc < Test::Unit::TestCase
EOF
assert_equal(["c-return", 1, :set_trace_func, Kernel],
events.shift)
- assert_equal(["line", 4, __method__, self.class],
- events.shift)
assert_equal(["line", 5, __method__, self.class],
events.shift)
assert_equal(["c-call", 5, :raise, Kernel],
@@ -289,8 +318,8 @@ class TestSetTraceFunc < Test::Unit::TestCase
["line", 4, __method__, self.class],
["c-return", 4, :any?, Array],
["line", 5, __method__, self.class],
- ["c-call", 5, :set_trace_func, Kernel]].each{|e|
- assert_equal(e, events.shift)
+ ["c-call", 5, :set_trace_func, Kernel]].each.with_index{|e, i|
+ assert_equal(e, events.shift, "mismatch on #{i}th trace")
}
end
@@ -364,6 +393,11 @@ class TestSetTraceFunc < Test::Unit::TestCase
end
assert_equal([], events[:set])
assert_equal([], events[:add])
+
+ # cleanup
+ self.class.class_eval do
+ remove_const :ThreadTraceInnerClass
+ end
end
def test_trace_defined_method
@@ -382,7 +416,7 @@ class TestSetTraceFunc < Test::Unit::TestCase
[["c-return", 3, :set_trace_func, Kernel],
["line", 6, __method__, self.class],
["call", 1, :foobar, FooBar],
- ["return", 6, :foobar, FooBar],
+ ["return", 1, :foobar, FooBar],
["line", 7, __method__, self.class],
["c-call", 7, :set_trace_func, Kernel]].each{|e|
assert_equal(e, events.shift)
@@ -470,13 +504,10 @@ class TestSetTraceFunc < Test::Unit::TestCase
answer_events = [
#
- [:c_return, 1, "xyzzy", TracePoint, :trace, TracePoint, :outer, trace],
[:line, 4, 'xyzzy', self.class, method, self, :outer, :nothing],
[:c_call, 4, 'xyzzy', Integer, :times, 1, :outer, :nothing],
[:line, 4, 'xyzzy', self.class, method, self, nil, :nothing],
[:line, 5, 'xyzzy', self.class, method, self, :inner, :nothing],
- [:c_call, 5, 'xyzzy', Kernel, :tap, self, :inner, :nothing],
- [:c_return, 5, "xyzzy", Kernel, :tap, self, :inner, self],
[:c_return, 4, "xyzzy", Integer, :times, 1, :outer, 1],
[:line, 7, 'xyzzy', self.class, method, self, :outer, :nothing],
[:c_call, 7, "xyzzy", Class, :inherited, Object, :outer, :nothing],
@@ -502,8 +533,6 @@ class TestSetTraceFunc < Test::Unit::TestCase
[:call, 13, "xyzzy", xyzzy.class, :bar, xyzzy, nil, :nothing],
[:line, 14, "xyzzy", xyzzy.class, :bar, xyzzy, nil, :nothing],
[:line, 15, "xyzzy", xyzzy.class, :bar, xyzzy, :XYZZY_bar, :nothing],
- [:c_call, 15, "xyzzy", Kernel, :tap, xyzzy, :XYZZY_bar, :nothing],
- [:c_return,15, "xyzzy", Kernel, :tap, xyzzy, :XYZZY_bar, xyzzy],
[:return, 16, "xyzzy", xyzzy.class, :bar, xyzzy, :XYZZY_bar, xyzzy],
[:return, 12, "xyzzy", xyzzy.class, :foo, xyzzy, :XYZZY_foo, xyzzy],
[:line, 20, "xyzzy", TestSetTraceFunc, method, self, :outer, :nothing],
@@ -519,12 +548,55 @@ class TestSetTraceFunc < Test::Unit::TestCase
[:c_call, 20, "xyzzy", Module, :===, RuntimeError,:outer, :nothing],
[:c_return,20, "xyzzy", Module, :===, RuntimeError,:outer, true],
[:line, 21, "xyzzy", TestSetTraceFunc, method, self, :outer, :nothing],
- [:c_call, 21, "xyzzy", TracePoint, :disable, trace, :outer, :nothing],
]
return events, answer_events
end
+ def test_tracepoint
+ events1, answer_events = *trace_by_tracepoint(:line, :class, :end, :call, :return, :c_call, :c_return, :raise)
+
+ ms = [events1, answer_events].map{|evs|
+ evs.map{|e|
+ "#{e[0]} - #{e[2]}:#{e[1]} id: #{e[4]}"
+ }
+ }
+
+ if false # show all events
+ printf(" %-60s | %-60s\n", "actual", "expected")
+ ms[0].zip(ms[1]){|a, b|
+ printf("%s%-60s | %-60s\n", a==b ? ' ' : '!', a, b)
+ }
+ end
+
+ mesg = ms[0].zip(ms[1]).map{|a, b|
+ if a != b
+ "actual: #{a} <-> expected: #{b}"
+ end
+ }.compact.join("\n")
+
+ answer_events.zip(events1){|answer, event|
+ assert_equal answer, event, mesg
+ }
+
+ [:line, :class, :end, :call, :return, :c_call, :c_return, :raise].each{|event|
+ events1, answer_events = *trace_by_tracepoint(event)
+ answer_events.find_all{|e| e[0] == event}.zip(events1){|answer_line, event_line|
+ assert_equal answer_line, event_line
+ }
+ }
+ end
+
+ # Bug #18264
+ def test_tracepoint_memory_leak
+ assert_no_memory_leak([], <<-PREP, <<-CODE, rss: true)
+code = proc { TracePoint.new(:line) { } }
+1_000.times(&code)
+PREP
+1_000_000.times(&code)
+CODE
+ end
+
def trace_by_set_trace_func
events = []
trace = nil
@@ -532,6 +604,9 @@ class TestSetTraceFunc < Test::Unit::TestCase
xyzzy = nil
xyzzy = xyzzy
_local_var = :outer
+ method = :trace_by_set_trace_func
+ raised_exc = nil
+
eval <<-EOF.gsub(/^.*?: /, ""), nil, 'xyzzy'
1: set_trace_func(lambda{|event, file, line, id, binding, klass|
2: events << [event, line, file, klass, id, binding.eval('self'), binding.eval("_local_var")] if file == 'xyzzy'
@@ -556,44 +631,69 @@ class TestSetTraceFunc < Test::Unit::TestCase
21: set_trace_func(nil)
EOF
self.class.class_eval{remove_const(:XYZZY)}
- return events
- end
-
- def test_tracepoint
- events1, answer_events = *trace_by_tracepoint(:line, :class, :end, :call, :return, :c_call, :c_return, :raise)
-
- ms = [events1, answer_events].map{|evs|
- evs.map{|e|
- "#{e[0]} - #{e[2]}:#{e[1]} id: #{e[4]}"
- }
- }
-
- mesg = ms[0].zip(ms[1]).map{|a, b|
- if a != b
- "#{a} <-> #{b}"
- end
- }.compact.join("\n")
- answer_events.zip(events1){|answer, event|
- assert_equal answer, event, mesg
- }
+ answer_events = [
+ #
+ [:c_return, 1, "xyzzy", TracePoint, :trace, TracePoint, :outer, trace],
+ [:line, 4, 'xyzzy', self.class, method, self, :outer, :nothing],
+ [:c_call, 4, 'xyzzy', Integer, :times, 1, :outer, :nothing],
+ [:line, 4, 'xyzzy', self.class, method, self, nil, :nothing],
+ [:line, 5, 'xyzzy', self.class, method, self, :inner, :nothing],
+ [:c_return, 4, "xyzzy", Integer, :times, 1, :outer, 1],
+ [:line, 7, 'xyzzy', self.class, method, self, :outer, :nothing],
+ [:c_call, 7, "xyzzy", Class, :inherited, Object, :outer, :nothing],
+ [:c_return, 7, "xyzzy", Class, :inherited, Object, :outer, nil],
+ [:class, 7, "xyzzy", nil, nil, xyzzy.class, nil, :nothing],
+ [:line, 8, "xyzzy", nil, nil, xyzzy.class, nil, :nothing],
+ [:line, 9, "xyzzy", nil, nil, xyzzy.class, :XYZZY_outer, :nothing],
+ [:c_call, 9, "xyzzy", Module, :method_added, xyzzy.class, :XYZZY_outer, :nothing],
+ [:c_return, 9, "xyzzy", Module, :method_added, xyzzy.class, :XYZZY_outer, nil],
+ [:line, 13, "xyzzy", nil, nil, xyzzy.class, :XYZZY_outer, :nothing],
+ [:c_call, 13, "xyzzy", Module, :method_added, xyzzy.class, :XYZZY_outer, :nothing],
+ [:c_return,13, "xyzzy", Module, :method_added, xyzzy.class, :XYZZY_outer, nil],
+ [:end, 17, "xyzzy", nil, nil, xyzzy.class, :XYZZY_outer, :nothing],
+ [:line, 18, "xyzzy", TestSetTraceFunc, method, self, :outer, :nothing],
+ [:c_call, 18, "xyzzy", Class, :new, xyzzy.class, :outer, :nothing],
+ [:c_call, 18, "xyzzy", BasicObject, :initialize, xyzzy, :outer, :nothing],
+ [:c_return,18, "xyzzy", BasicObject, :initialize, xyzzy, :outer, nil],
+ [:c_return,18, "xyzzy", Class, :new, xyzzy.class, :outer, xyzzy],
+ [:line, 19, "xyzzy", TestSetTraceFunc, method, self, :outer, :nothing],
+ [:call, 9, "xyzzy", xyzzy.class, :foo, xyzzy, nil, :nothing],
+ [:line, 10, "xyzzy", xyzzy.class, :foo, xyzzy, nil, :nothing],
+ [:line, 11, "xyzzy", xyzzy.class, :foo, xyzzy, :XYZZY_foo, :nothing],
+ [:call, 13, "xyzzy", xyzzy.class, :bar, xyzzy, nil, :nothing],
+ [:line, 14, "xyzzy", xyzzy.class, :bar, xyzzy, nil, :nothing],
+ [:line, 15, "xyzzy", xyzzy.class, :bar, xyzzy, :XYZZY_bar, :nothing],
+ [:return, 16, "xyzzy", xyzzy.class, :bar, xyzzy, :XYZZY_bar, xyzzy],
+ [:return, 12, "xyzzy", xyzzy.class, :foo, xyzzy, :XYZZY_foo, xyzzy],
+ [:line, 20, "xyzzy", TestSetTraceFunc, method, self, :outer, :nothing],
+ [:c_call, 20, "xyzzy", Kernel, :raise, self, :outer, :nothing],
+ [:c_call, 20, "xyzzy", Exception, :exception, RuntimeError, :outer, :nothing],
+ [:c_call, 20, "xyzzy", Exception, :initialize, raised_exc, :outer, :nothing],
+ [:c_return,20, "xyzzy", Exception, :initialize, raised_exc, :outer, raised_exc],
+ [:c_return,20, "xyzzy", Exception, :exception, RuntimeError, :outer, raised_exc],
+ [:c_return,20, "xyzzy", Kernel, :raise, self, :outer, nil],
+ [:c_call, 20, "xyzzy", Exception, :backtrace, raised_exc, :outer, :nothing],
+ [:c_return,20, "xyzzy", Exception, :backtrace, raised_exc, :outer, nil],
+ [:raise, 20, "xyzzy", TestSetTraceFunc, :trace_by_tracepoint, self, :outer, raised_exc],
+ [:c_call, 20, "xyzzy", Module, :===, RuntimeError,:outer, :nothing],
+ [:c_return,20, "xyzzy", Module, :===, RuntimeError,:outer, true],
+ [:line, 21, "xyzzy", TestSetTraceFunc, method, self, :outer, :nothing],
+ [:c_call, 21, "xyzzy", TracePoint, :disable, trace, :outer, :nothing],
+ ]
+ return events, answer_events
+ end
- events2 = trace_by_set_trace_func
- events1.zip(events2){|ev1, ev2|
- ev2[0] = ev2[0].sub('-', '_').to_sym
- assert_equal ev1[0..2], ev2[0..2], ev1.inspect
+ def test_set_trace_func
+ actual_events, expected_events = trace_by_set_trace_func
+ expected_events.zip(actual_events){|e, a|
+ a[0] = a[0].to_s.sub('-', '_').to_sym
+ assert_equal e[0..2], a[0..2], a.inspect
# event, line, file, klass, id, binding.eval('self'), binding.eval("_local_var")
- assert_equal ev1[3].nil?, ev2[3].nil? # klass
- assert_equal ev1[4].nil?, ev2[4].nil? # id
- assert_equal ev1[6], ev2[6] # _local_var
- }
-
- [:line, :class, :end, :call, :return, :c_call, :c_return, :raise].each{|event|
- events1, answer_events = *trace_by_tracepoint(event)
- answer_events.find_all{|e| e[0] == event}.zip(events1){|answer_line, event_line|
- assert_equal answer_line, event_line
- }
+ assert_equal e[3].nil?, a[3].nil? # klass
+ assert_equal e[4].nil?, a[4].nil? # id
+ assert_equal e[6], a[6] # _local_var
}
end
@@ -678,7 +778,7 @@ class TestSetTraceFunc < Test::Unit::TestCase
}
foo
trace.disable
- assert_equal([:foo, :foo], ary)
+ assert_equal([:foo, :disable, :foo, :disable], ary)
assert_equal([], args)
trace = TracePoint.new{}
@@ -705,6 +805,45 @@ class TestSetTraceFunc < Test::Unit::TestCase
assert_equal(false, trace.enabled?)
end
+ def parameter_test(a, b, c)
+ yield
+ end
+
+ def test_tracepoint_parameters
+ trace = TracePoint.new(:line, :class, :end, :call, :return, :b_call, :b_return, :c_call, :c_return, :raise){|tp|
+ next if !target_thread?
+ next if tp.path != __FILE__
+ case tp.event
+ when :call, :return
+ assert_equal([[:req, :a], [:req, :b], [:req, :c]], tp.parameters)
+ when :b_call, :b_return
+ next if tp.parameters == []
+ if tp.parameters.first == [:opt, :x]
+ assert_equal([[:opt, :x], [:opt, :y], [:opt, :z]], tp.parameters)
+ else
+ assert_equal([[:req, :p], [:req, :q], [:req, :r]], tp.parameters)
+ end
+ when :c_call, :c_return
+ assert_equal([[:req]], tp.parameters) if tp.method_id == :getbyte
+ when :line, :class, :end, :raise
+ assert_raise(RuntimeError) { tp.parameters }
+ end
+ }
+ obj = Object.new
+ trace.enable{
+ parameter_test(1, 2, 3) {|x, y, z|
+ }
+ lambda {|p, q, r| }.call(4, 5, 6)
+ "".getbyte(0)
+ class << obj
+ end
+ begin
+ raise
+ rescue
+ end
+ }
+ end
+
def method_test_tracepoint_return_value obj
obj
end
@@ -725,19 +864,69 @@ class TestSetTraceFunc < Test::Unit::TestCase
}
end
+ def test_tracepoint_attr
+ c = Class.new do
+ attr_accessor :x
+ alias y x
+ alias y= x=
+ end
+ obj = c.new
+
+ ar_meth = obj.method(:x)
+ aw_meth = obj.method(:x=)
+ aar_meth = obj.method(:y)
+ aaw_meth = obj.method(:y=)
+ events = []
+ trace = TracePoint.new(:c_call, :c_return){|tp|
+ next if !target_thread?
+ next if tp.path != __FILE__
+ next if tp.method_id == :call
+ case tp.event
+ when :c_call
+ assert_raise(RuntimeError) {tp.return_value}
+ events << [tp.event, tp.method_id, tp.callee_id]
+ when :c_return
+ events << [tp.event, tp.method_id, tp.callee_id, tp.return_value]
+ end
+ }
+ test_proc = proc do
+ obj.x = 1
+ obj.x
+ obj.y = 2
+ obj.y
+ aw_meth.call(1)
+ ar_meth.call
+ aaw_meth.call(2)
+ aar_meth.call
+ end
+ test_proc.call # populate call caches
+ trace.enable(&test_proc)
+ expected = [
+ [:c_call, :x=, :x=],
+ [:c_return, :x=, :x=, 1],
+ [:c_call, :x, :x],
+ [:c_return, :x, :x, 1],
+ [:c_call, :x=, :y=],
+ [:c_return, :x=, :y=, 2],
+ [:c_call, :x, :y],
+ [:c_return, :x, :y, 2],
+ ]
+ assert_equal(expected*2, events)
+ end
+
class XYZZYException < Exception; end
def method_test_tracepoint_raised_exception err
raise err
end
def test_tracepoint_raised_exception
- trace = TracePoint.new(:call, :return){|tp|
+ trace = TracePoint.new(:call, :return, :raise){|tp|
next if !target_thread?
case tp.event
when :call, :return
assert_raise(RuntimeError) { tp.raised_exception }
when :raise
- assert_equal(XYZZYError, tp.raised_exception)
+ assert_kind_of(XYZZYException, tp.raised_exception)
end
}
trace.enable{
@@ -814,14 +1003,16 @@ class TestSetTraceFunc < Test::Unit::TestCase
def test_tracepoint_inspect
events = []
+ th = nil
trace = TracePoint.new{|tp|
- next if !target_thread?
+ next if !target_thread? && th != Thread.current
events << [tp.event, tp.inspect]
}
assert_equal("#<TracePoint:disabled>", trace.inspect)
trace.enable{
assert_equal("#<TracePoint:enabled>", trace.inspect)
- Thread.new{}.join
+ th = Thread.new{}
+ th.join
}
assert_equal("#<TracePoint:disabled>", trace.inspect)
events.each{|(ev, str)|
@@ -829,9 +1020,9 @@ class TestSetTraceFunc < Test::Unit::TestCase
when :line
assert_match(/ in /, str)
when :call, :c_call
- assert_match(/call \`/, str) # #<TracePoint:c_call `inherited'@../trunk/test.rb:11>
+ assert_match(/call \`/, str) # #<TracePoint:c_call `inherited' ../trunk/test.rb:11>
when :return, :c_return
- assert_match(/return \`/, str) # #<TracePoint:return `m'@../trunk/test.rb:3>
+ assert_match(/return \`/, str) # #<TracePoint:return `m' ../trunk/test.rb:3>
when /thread/
assert_match(/\#<Thread:/, str) # #<TracePoint:thread_end of #<Thread:0x87076c0>>
else
@@ -857,22 +1048,41 @@ class TestSetTraceFunc < Test::Unit::TestCase
end
end
+ def test_tracepoint_exception_at_c_return
+ assert_nothing_raised(Timeout::Error, 'infinite trace') do
+ assert_normal_exit %q{
+ begin
+ TracePoint.new(:c_return){|tp|
+ raise
+ }.enable{
+ tap{ itself }
+ }
+ rescue
+ end
+ }, '', timeout: 3
+ end
+ end
+
def test_tracepoint_with_multithreads
assert_nothing_raised do
- TracePoint.new{
+ TracePoint.new(:line){
10.times{
Thread.pass
}
}.enable do
(1..10).map{
Thread.new{
- 1000.times{
+ 1_000.times{|i|
+ _a = i
}
}
}.each{|th|
th.join
}
end
+ _a = 1
+ _b = 2
+ _c = 3 # to make sure the deletion of unused TracePoints
end
end
@@ -1013,7 +1223,7 @@ class TestSetTraceFunc < Test::Unit::TestCase
}.enable{
3.times{
next
- } # 3 times b_retun
+ } # 3 times b_return
} # 1 time b_return
assert_equal 4, n
@@ -1431,11 +1641,10 @@ class TestSetTraceFunc < Test::Unit::TestCase
end
def test_throwing_return_with_finish_frame
- target_th = Thread.current
evs = []
TracePoint.new(:call, :return){|tp|
- return if Thread.current != target_th
+ next unless target_thread?
evs << tp.event
}.enable{
Bug10724.new
@@ -1471,6 +1680,33 @@ class TestSetTraceFunc < Test::Unit::TestCase
assert_equal ev, :fiber_switch
}
+ # test for raise into resumable fiber
+ evs = []
+ f = nil
+ TracePoint.new(:raise, :fiber_switch){|tp|
+ next unless target_thread?
+ evs << [tp.event, Fiber.current]
+ }.enable{
+ f = Fiber.new{
+ Fiber.yield # will raise
+ Fiber.yield # unreachable
+ }
+ begin
+ f.resume
+ f.raise StopIteration
+ rescue StopIteration
+ evs << :rescued
+ end
+ }
+ assert_equal [:fiber_switch, f], evs[0], "initial resume"
+ assert_equal [:fiber_switch, Fiber.current], evs[1], "Fiber.yield"
+ assert_equal [:fiber_switch, f], evs[2], "fiber.raise"
+ assert_equal [:raise, f], evs[3], "fiber.raise"
+ assert_equal [:fiber_switch, Fiber.current], evs[4], "terminated with raise"
+ assert_equal [:raise, Fiber.current], evs[5], "terminated with raise"
+ assert_equal :rescued, evs[6]
+ assert_equal 7, evs.size
+
# test for transfer
evs = []
TracePoint.new(:fiber_switch){|tp|
@@ -1493,11 +1729,47 @@ class TestSetTraceFunc < Test::Unit::TestCase
evs.each{|ev|
assert_equal ev, :fiber_switch
}
+
+ # test for raise and from transferring fibers
+ evs = []
+ f1 = f2 = nil
+ TracePoint.new(:raise, :fiber_switch){|tp|
+ next unless target_thread?
+ evs << [tp.event, Fiber.current]
+ }.enable{
+ f1 = Fiber.new{
+ f2.transfer
+ f2.raise ScriptError
+ Fiber.yield :ok
+ }
+ f2 = Fiber.new{
+ f1.transfer
+ f1.transfer
+ }
+ begin
+ f1.resume
+ rescue ScriptError
+ evs << :rescued
+ end
+ }
+ assert_equal [:fiber_switch, f1], evs[0], "initial resume"
+ assert_equal [:fiber_switch, f2], evs[1], "f2.transfer"
+ assert_equal [:fiber_switch, f1], evs[2], "f1.transfer"
+ assert_equal [:fiber_switch, f2], evs[3], "f2.raise ScriptError"
+ assert_equal [:raise, f2], evs[4], "f2.raise ScriptError"
+ assert_equal [:fiber_switch, f1], evs[5], "f2 unhandled exception"
+ assert_equal [:raise, f1], evs[6], "f2 unhandled exception"
+ assert_equal [:fiber_switch, Fiber.current], evs[7], "f1 unhandled exception"
+ assert_equal [:raise, Fiber.current], evs[8], "f1 unhandled exception"
+ assert_equal :rescued, evs[9], "rescued everything"
+ assert_equal 10, evs.size
+
end
def test_tracepoint_callee_id
events = []
capture_events = Proc.new{|tp|
+ next unless target_thread?
events << [tp.event, tp.method_id, tp.callee_id]
}
@@ -1554,7 +1826,7 @@ class TestSetTraceFunc < Test::Unit::TestCase
TracePoint.new(:return, &capture_events).enable{
o.alias_m
}
- assert_equal [[:return, :m, :alias_m]], events
+ assert_equal [[:return, :tap, :tap], [:return, :m, :alias_m]], events
events.clear
o = Class.new{
@@ -1578,13 +1850,13 @@ class TestSetTraceFunc < Test::Unit::TestCase
events.clear
o = Class.new{
- alias alias_tap tap
- define_method(:m){alias_tap{return}}
+ alias alias_singleton_class singleton_class
+ define_method(:m){alias_singleton_class}
}.new
TracePoint.new(:c_return, &capture_events).enable{
o.m
}
- assert_equal [[:c_return, :tap, :alias_tap]], events
+ assert_equal [[:c_return, :singleton_class, :alias_singleton_class]], events
events.clear
c = Class.new{
@@ -1610,13 +1882,32 @@ class TestSetTraceFunc < Test::Unit::TestCase
def tp_return_value mid
ary = []
- TracePoint.new(:return, :b_return){|tp| ary << [tp.event, tp.method_id, tp.return_value]}.enable{
+ TracePoint.new(:return, :b_return){|tp| next if !target_thread?; ary << [tp.event, tp.method_id, tp.return_value]}.enable{
send mid
}
ary.pop # last b_return event is not required.
ary
end
+ def test_single_raise_inside_load
+ events = []
+ tmpdir = Dir.mktmpdir
+ path = "#{tmpdir}/hola.rb"
+ File.open(path, "w") { |f| f.write("raise") }
+ tp = TracePoint.new(:raise) {|tp| events << [tp.event] if target_thread?}
+ tp.enable{
+ load path rescue nil
+ }
+ assert_equal [[:raise]], events
+ events.clear
+ tp.enable{
+ require path rescue nil
+ }
+ assert_equal [[:raise]], events
+ ensure
+ FileUtils.rmtree(tmpdir)
+ end
+
def f_raise
raise
rescue
@@ -1683,23 +1974,19 @@ class TestSetTraceFunc < Test::Unit::TestCase
end
define_method(:f_break_defined) do
- return :f_break_defined
+ break :f_break_defined
end
define_method(:f_raise_defined) do
- begin
- raise
- rescue
- return :f_raise_defined
- end
+ raise
+ rescue
+ return :f_raise_defined
end
define_method(:f_break_in_rescue_defined) do
- begin
- raise
- rescue
- break :f_break_in_rescue_defined
- end
+ raise
+ rescue
+ break :f_break_in_rescue_defined
end
def test_return_value_with_rescue_and_defined_methods
@@ -1708,27 +1995,44 @@ class TestSetTraceFunc < Test::Unit::TestCase
tp_return_value(:f_last_defined),
'[Bug #13369]'
- assert_equal [[:b_return, :f_return_defined, nil], # current limitation
+ assert_equal [[:b_return, :f_return_defined, :f_return_defined],
[:return, :f_return_defined, :f_return_defined]],
tp_return_value(:f_return_defined),
'[Bug #13369]'
- assert_equal [[:b_return, :f_break_defined, nil],
+ assert_equal [[:b_return, :f_break_defined, :f_break_defined],
[:return, :f_break_defined, :f_break_defined]],
tp_return_value(:f_break_defined),
'[Bug #13369]'
- assert_equal [[:b_return, :f_raise_defined, nil],
+ assert_equal [[:b_return, :f_raise_defined, f_raise_defined],
[:return, :f_raise_defined, f_raise_defined]],
tp_return_value(:f_raise_defined),
'[Bug #13369]'
- assert_equal [[:b_return, :f_break_in_rescue_defined, nil],
+ assert_equal [[:b_return, :f_break_in_rescue_defined, f_break_in_rescue_defined],
[:return, :f_break_in_rescue_defined, f_break_in_rescue_defined]],
tp_return_value(:f_break_in_rescue_defined),
'[Bug #13369]'
end
+ define_method(:just_yield) do |&block|
+ block.call
+ end
+
+ define_method(:unwind_multiple_bmethods) do
+ just_yield { return :unwind_multiple_bmethods }
+ end
+
+ def test_non_local_return_across_multiple_define_methods
+ assert_equal [[:b_return, :unwind_multiple_bmethods, nil],
+ [:b_return, :just_yield, nil],
+ [:return, :just_yield, nil],
+ [:b_return, :unwind_multiple_bmethods, :unwind_multiple_bmethods],
+ [:return, :unwind_multiple_bmethods, :unwind_multiple_bmethods]],
+ tp_return_value(:unwind_multiple_bmethods)
+ end
+
def f_iter
yield
end
@@ -1772,4 +2076,550 @@ class TestSetTraceFunc < Test::Unit::TestCase
end
}, bug13705
end
+
+ def test_trace_point_require_block
+ assert_raise(ArgumentError) { TracePoint.new(:return) }
+ end
+
+ def method_for_test_thread_add_trace_func
+
+ end
+
+ def test_thread_add_trace_func
+ events = []
+ base_line = __LINE__
+ q = Thread::Queue.new
+ t = Thread.new{
+ Thread.current.add_trace_func proc{|ev, file, line, *args|
+ events << [ev, line]
+ } # do not stop trace. They will be stopped at Thread termination.
+ q.push 1
+ _x = 1
+ method_for_test_thread_add_trace_func
+ _y = 2
+ }
+ q.pop
+ method_for_test_thread_add_trace_func
+ t.join
+ assert_equal ["c-return", base_line + 3], events[0]
+ assert_equal ["line", base_line + 6], events[1]
+ assert_equal ["c-call", base_line + 6], events[2]
+ assert_equal ["c-return", base_line + 6], events[3]
+ assert_equal ["line", base_line + 7], events[4]
+ assert_equal ["line", base_line + 8], events[5]
+ assert_equal ["call", base_line + -6], events[6]
+ assert_equal ["return", base_line + -4], events[7]
+ assert_equal ["line", base_line + 9], events[8]
+ assert_equal nil, events[9]
+
+ # other thread
+ events = []
+ m2t_q = Thread::Queue.new
+
+ t = Thread.new{
+ Thread.current.abort_on_exception = true
+ assert_equal 1, m2t_q.pop
+ _x = 1
+ method_for_test_thread_add_trace_func
+ _y = 2
+ Thread.current.set_trace_func(nil)
+ method_for_test_thread_add_trace_func
+ }
+ # it is dirty hack. usually we shouldn't use such technique
+ Thread.pass until t.status == 'sleep'
+ # When MJIT thread exists, t.status becomes 'sleep' even if it does not reach m2t_q.pop.
+ # This sleep forces it to reach m2t_q.pop for --jit-wait.
+ sleep 1 if defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled?
+
+ t.add_trace_func proc{|ev, file, line, *args|
+ if file == __FILE__
+ events << [ev, line]
+ end
+ }
+
+ method_for_test_thread_add_trace_func
+
+ m2t_q.push 1
+ t.join
+
+ assert_equal ["c-return", base_line + 31], events[0]
+ assert_equal ["line", base_line + 32], events[1]
+ assert_equal ["line", base_line + 33], events[2]
+ assert_equal ["call", base_line + -6], events[3]
+ assert_equal ["return", base_line + -4], events[4]
+ assert_equal ["line", base_line + 34], events[5]
+ assert_equal ["line", base_line + 35], events[6]
+ assert_equal ["c-call", base_line + 35], events[7] # Thread.current
+ assert_equal ["c-return", base_line + 35], events[8] # Thread.current
+ assert_equal ["c-call", base_line + 35], events[9] # Thread#set_trace_func
+ assert_equal nil, events[10]
+ end
+
+ def test_lineno_in_optimized_insn
+ assert_separately([], "#{<<~"begin;"}\n#{<<~'end;'}")
+ begin;
+ $loc = nil
+ class String
+ undef -@
+ def -@
+ $loc = caller_locations(1, 1)[0].lineno
+ end
+ end
+
+ assert_predicate(-"", :frozen?)
+ assert_equal(__LINE__-1, $loc, '[Bug #14809]')
+ end;
+ end
+
+ def method_for_enable_target1
+ a = 1
+ b = 2
+ 1.times{|i|
+ _x = i
+ }
+ _c = a + b
+ end
+
+ def method_for_enable_target2
+ a = 1
+ b = 2
+ 1.times{|i|
+ _x = i
+ }
+ _c = a + b
+ end
+
+ def check_with_events *trace_events
+ all_events = [[:call, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:b_call, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:b_return, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:return, :method_for_enable_target1],
+ # repeat
+ [:call, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:b_call, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:b_return, :method_for_enable_target1],
+ [:line, :method_for_enable_target1],
+ [:return, :method_for_enable_target1],
+ ]
+ events = []
+ TracePoint.new(*trace_events) do |tp|
+ next unless target_thread?
+ events << [tp.event, tp.method_id]
+ end.enable(target: method(:method_for_enable_target1)) do
+ method_for_enable_target1
+ method_for_enable_target2
+ method_for_enable_target1
+ end
+ assert_equal all_events.find_all{|(ev)| trace_events.include? ev}, events
+ end
+
+ def test_tracepoint_enable_target
+ check_with_events :line
+ check_with_events :call, :return
+ check_with_events :line, :call, :return
+ check_with_events :call, :return, :b_call, :b_return
+ check_with_events :line, :call, :return, :b_call, :b_return
+ end
+
+ def test_tracepoint_nested_enabled_with_target
+ code1 = proc{
+ _a = 1
+ }
+ code2 = proc{
+ _b = 2
+ }
+
+ ## error
+
+ # targeted TP and targeted TP
+ ex = assert_raise(ArgumentError) do
+ tp = TracePoint.new(:line){}
+ tp.enable(target: code1){
+ tp.enable(target: code2){}
+ }
+ end
+ assert_equal "can't nest-enable a targeting TracePoint", ex.message
+
+ # global TP and targeted TP
+ ex = assert_raise(ArgumentError) do
+ tp = TracePoint.new(:line){}
+ tp.enable{
+ tp.enable(target: code2){}
+ }
+ end
+ assert_equal "can't nest-enable a targeting TracePoint", ex.message
+
+ # targeted TP and global TP
+ ex = assert_raise(ArgumentError) do
+ tp = TracePoint.new(:line){}
+ tp.enable(target: code1){
+ tp.enable{}
+ }
+ end
+ assert_equal "can't nest-enable a targeting TracePoint", ex.message
+
+ # targeted TP and disable
+ ex = assert_raise(ArgumentError) do
+ tp = TracePoint.new(:line){}
+ tp.enable(target: code1){
+ tp.disable{}
+ }
+ end
+ assert_equal "can't disable a targeting TracePoint in a block", ex.message
+
+ ## success with two nesting targeting tracepoints
+ events = []
+ tp1 = TracePoint.new(:line){|tp| events << :tp1}
+ tp2 = TracePoint.new(:line){|tp| events << :tp2}
+ tp1.enable(target: code1) do
+ tp2.enable(target: code1) do
+ code1.call
+ events << :___
+ end
+ end
+ assert_equal [:tp2, :tp1, :___], events
+
+ # success with two tracepoints (global/targeting)
+ events = []
+ tp1 = TracePoint.new(:line){|tp| events << :tp1}
+ tp2 = TracePoint.new(:line){|tp| events << :tp2}
+ tp1.enable do
+ tp2.enable(target: code1) do
+ code1.call
+ events << :___
+ end
+ end
+ assert_equal [:tp1, :tp1, :tp1, :tp1, :tp2, :tp1, :___], events
+
+ # success with two tracepoints (targeting/global)
+ events = []
+ tp1 = TracePoint.new(:line){|tp| events << :tp1}
+ tp2 = TracePoint.new(:line){|tp| events << :tp2}
+ tp1.enable(target: code1) do
+ tp2.enable do
+ code1.call
+ events << :___
+ end
+ end
+ assert_equal [:tp2, :tp2, :tp1, :tp2, :___], events
+ end
+
+ def test_tracepoint_enable_with_target_line
+ events = []
+ line_0 = __LINE__
+ code1 = proc{
+ events << 1
+ events << 2
+ events << 3
+ }
+ tp = TracePoint.new(:line) do |tp|
+ events << :tp
+ end
+ tp.enable(target: code1, target_line: line_0 + 3) do
+ code1.call
+ end
+ assert_equal [1, :tp, 2, 3], events
+
+
+ e = assert_raise(ArgumentError) do
+ TracePoint.new(:line){}.enable(target_line: 10){}
+ end
+ assert_equal 'only target_line is specified', e.message
+
+ e = assert_raise(ArgumentError) do
+ TracePoint.new(:call){}.enable(target: code1, target_line: 10){}
+ end
+ assert_equal 'target_line is specified, but line event is not specified', e.message
+ end
+
+ def test_tracepoint_enable_with_target_line_two_times
+ events = []
+ line_0 = __LINE__
+ code1 = proc{
+ events << 1 # tp1
+ events << 2
+ events << 3 # tp2
+ }
+
+ tp1 = TracePoint.new(:line) do |tp|
+ events << :tp1
+ end
+ tp2 = TracePoint.new(:line) do |tp|
+ events << :tp2
+ end
+
+ tp1.enable(target: code1, target_line: line_0 + 2) do
+ tp2.enable(target: code1, target_line: line_0 + 4) do
+ # two hooks
+ code1.call
+ end
+ end
+ assert_equal [:tp1, 1, 2, :tp2, 3], events
+ end
+
+ def test_script_compiled
+ events = []
+ tp = TracePoint.new(:script_compiled){|tp|
+ next unless target_thread?
+ events << [tp.instruction_sequence.path,
+ tp.eval_script]
+ }
+
+ eval_script = 'a = 1'
+ tp.enable{
+ eval(eval_script, nil, __FILE__+"/eval")
+ nil.instance_eval(eval_script, __FILE__+"/instance_eval")
+ Object.class_eval(eval_script, __FILE__+"/class_eval")
+ }
+ assert_equal [[__FILE__+"/eval", eval_script],
+ [__FILE__+"/instance_eval", eval_script],
+ [__FILE__+"/class_eval", eval_script],
+ ], events
+
+ events.clear
+ tp.enable{
+ begin
+ eval('a=')
+ rescue SyntaxError
+ end
+ }
+ assert_equal [], events, 'script_compiled event should not be invoked on compile error'
+
+ skip "TODO: test for requires"
+
+ events.clear
+ tp.enable{
+ require ''
+ require_relative ''
+ load ''
+ }
+ assert_equal [], events
+ end
+
+ def test_enable_target_thread
+ events = []
+ TracePoint.new(:line) do |tp|
+ events << Thread.current
+ end.enable(target_thread: Thread.current) do
+ _a = 1
+ Thread.new{
+ _b = 2
+ _c = 3
+ }.join
+ _d = 4
+ end
+ assert_equal Array.new(3){Thread.current}, events
+
+ events = []
+ tp = TracePoint.new(:line) do |tp|
+ events << Thread.current
+ end
+
+ q1 = Thread::Queue.new
+ q2 = Thread::Queue.new
+
+ th = Thread.new{
+ q1 << :ok; q2.pop
+ _t1 = 1
+ _t2 = 2
+ }
+ q1.pop
+ tp.enable(target_thread: th) do
+ q2 << 1
+ _a = 1
+ _b = 2
+ th.join
+ end
+
+ assert_equal Array.new(2){th}, events
+ end
+
+ def test_return_bmethod_location
+ bug13392 = "[ruby-core:80515] incorrect bmethod return location"
+ actual = nil
+ obj = Object.new
+ expected = __LINE__ + 1
+ obj.define_singleton_method(:t){}
+ tp = TracePoint.new(:return) do
+ next unless target_thread?
+ actual = tp.lineno
+ end
+ tp.enable {obj.t}
+ assert_equal(expected, actual, bug13392)
+ end
+
+ def test_b_tracepoints_going_away
+ # test that call and return TracePoints continue to work
+ # when b_call and b_return TracePoints stop
+ events = []
+ record_events = ->(tp) do
+ next unless target_thread?
+ events << [tp.event, tp.method_id]
+ end
+
+ call_ret_tp = TracePoint.new(:call, :return, &record_events)
+ block_call_ret_tp = TracePoint.new(:b_call, :b_return, &record_events)
+
+ obj = Object.new
+ obj.define_singleton_method(:foo) {} # a bmethod
+
+ foo = obj.method(:foo)
+ call_ret_tp.enable(target: foo) do
+ block_call_ret_tp.enable(target: foo) do
+ obj.foo
+ end
+ obj.foo
+ end
+
+ assert_equal(
+ [
+ [:call, :foo],
+ [:b_call, :foo],
+ [:b_return, :foo],
+ [:return, :foo],
+ [:call, :foo],
+ [:return, :foo],
+ ],
+ events,
+ )
+ end
+
+ def test_target_different_bmethod_same_iseq
+ # make two bmethods that share the same block iseq
+ block = Proc.new {}
+ obj = Object.new
+ obj.define_singleton_method(:one, &block)
+ obj.define_singleton_method(:two, &block)
+
+ events = []
+ record_events = ->(tp) do
+ next unless target_thread?
+ events << [tp.event, tp.method_id]
+ end
+ tp_one = TracePoint.new(:call, :return, &record_events)
+ tp_two = TracePoint.new(:call, :return, &record_events)
+
+ tp_one.enable(target: obj.method(:one)) do
+ obj.one
+ obj.two # not targeted
+ end
+ assert_equal([[:call, :one], [:return, :one]], events)
+ events.clear
+
+ tp_one.enable(target: obj.method(:one)) do
+ obj.one
+ tp_two.enable(target: obj.method(:two)) do
+ obj.two
+ end
+ obj.two
+ obj.one
+ end
+ assert_equal(
+ [
+ [:call, :one],
+ [:return, :one],
+ [:call, :two],
+ [:return, :two],
+ [:call, :one],
+ [:return, :one],
+ ],
+ events
+ )
+ end
+
+ def test_return_event_with_rescue
+ obj = Object.new
+ def obj.example
+ 1 if 1 == 1
+ rescue
+ end
+ ok = false
+ tp = TracePoint.new(:return) {ok = true}
+ tp.enable {obj.example}
+ assert ok, "return event should be emitted"
+ end
+
+ def test_disable_local_tracepoint_in_trace
+ assert_normal_exit <<-EOS
+ def foo
+ trace = TracePoint.new(:b_return){|tp|
+ tp.disable
+ }
+ trace.enable(target: method(:bar))
+ end
+ def bar
+ 100.times{|i|
+ foo; foo
+ }
+ end
+ bar
+ EOS
+ end
+
+ def test_stat_exists
+ assert_instance_of Hash, TracePoint.stat
+ end
+
+ def test_tracepoint_opt_invokebuiltin_delegate_leave
+ code = 'puts RubyVM::InstructionSequence.of("\x00".method(:unpack)).disasm'
+ out = EnvUtil.invoke_ruby(['-e', code], '', true).first
+ assert_match(/^0000 opt_invokebuiltin_delegate_leave /, out)
+
+ event = eval(EnvUtil.invoke_ruby(['-e', <<~'EOS'], '', true).first)
+ TracePoint.new(:return) do |tp|
+ p [tp.event, tp.method_id]
+ end.enable do
+ "\x00".unpack("c")
+ end
+ EOS
+ assert_equal [:return, :unpack], event
+ end
+
+ def test_while_in_while
+ lines = []
+
+ TracePoint.new(:line){|tp|
+ next unless target_thread?
+ lines << tp.lineno
+ }.enable{
+ n = 3
+ while n > 0
+ n -= 1 while n > 0
+ end
+ }
+ assert_equal [__LINE__ - 5, __LINE__ - 4, __LINE__ - 3], lines, 'Bug #17868'
+ end
+
+ def test_allow_reentry
+ event_lines = []
+ _l1 = _l2 = _l3 = _l4 = nil
+ TracePoint.new(:line) do |tp|
+ next unless target_thread?
+
+ event_lines << tp.lineno
+ next if (__LINE__ + 2 .. __LINE__ + 4).cover?(tp.lineno)
+ TracePoint.allow_reentry do
+ _a = 1; _l3 = __LINE__
+ _b = 2; _l4 = __LINE__
+ end
+ end.enable do
+ _c = 3; _l1 = __LINE__
+ _d = 4; _l2 = __LINE__
+ end
+
+ assert_equal [_l1, _l3, _l4, _l2, _l3, _l4], event_lines
+
+ assert_raise RuntimeError do
+ TracePoint.allow_reentry{}
+ end
+ end
end
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-08 12:25:07 +0000