1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
ruby--ruby/spec/ruby/core/tracepoint/enable_spec.rb

552 lines
14 KiB
Ruby
Raw Normal View History

require_relative '../../spec_helper'
2020-05-31 12:22:49 -04:00
require_relative 'fixtures/classes'
describe 'TracePoint#enable' do
describe 'without a block' do
2020-05-31 12:22:49 -04:00
it 'returns false if trace was disabled' do
called = false
trace = TracePoint.new(:line) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
called = true
end
line_event = true
called.should == false
2020-05-31 12:22:49 -04:00
ret = trace.enable
begin
2020-05-31 12:22:49 -04:00
ret.should == false
line_event = true
called.should == true
ensure
trace.disable
end
end
2020-05-31 12:22:49 -04:00
it 'returns true if trace was already enabled' do
called = false
trace = TracePoint.new(:line) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
called = true
end
line_event = true
called.should == false
2020-05-31 12:22:49 -04:00
ret = trace.enable
begin
2020-05-31 12:22:49 -04:00
ret.should == false
trace.enable.should == true
line_event = true
called.should == true
ensure
trace.disable
2020-05-31 12:22:49 -04:00
trace.should_not.enabled?
end
end
end
describe 'with a block' do
it 'enables the trace object within a block' do
event_name = nil
TracePoint.new(:line) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
event_name = tp.event
end.enable { event_name.should equal(:line) }
end
2020-05-31 12:22:49 -04:00
it 'enables the trace object for any thread' do
threads = []
trace = TracePoint.new(:line) do |tp|
# Runs on purpose on any Thread
threads << Thread.current
end
thread = nil
trace.enable do
line_event = true
thread = Thread.new do
event_in_other_thread = true
end
thread.join
end
threads = threads.uniq
threads.should.include?(Thread.current)
threads.should.include?(thread)
end
2019-04-27 12:53:23 -04:00
it 'can accept arguments within a block but it should not yield arguments' do
event_name = nil
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:line) do |tp|
next unless TracePointSpec.target_thread?
event_name = tp.event
end
2019-04-27 12:53:23 -04:00
trace.enable do |*args|
event_name.should equal(:line)
args.should == []
end
2020-05-03 06:28:29 -04:00
trace.should_not.enabled?
end
it 'enables trace object on calling with a block if it was already enabled' do
enabled = nil
trace = TracePoint.new(:line) {}
trace.enable
begin
trace.enable { enabled = trace.enabled? }
enabled.should == true
ensure
trace.disable
end
end
it 'returns the return value of the block' do
trace = TracePoint.new(:line) {}
trace.enable { 42 }.should == 42
end
it 'disables the trace object outside the block' do
called = false
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:line) do
next unless TracePointSpec.target_thread?
called = true
end
trace.enable {
line_event = true
}
called.should == true
2020-05-03 06:28:29 -04:00
trace.should_not.enabled?
end
end
2020-05-31 12:22:49 -04:00
describe "when nested" do
before do
2020-09-15 15:54:31 -04:00
ruby_version_is ""..."3.0" do
@path_prefix = '@'
end
2020-09-15 15:54:31 -04:00
ruby_version_is "3.0" do
@path_prefix = ' '
end
end
2020-05-31 12:22:49 -04:00
it "enables both TracePoints but only calls the respective callbacks" do
called = false
first = TracePoint.new(:line) do |tp|
next unless TracePointSpec.target_thread?
called = true
end
all = []
inspects = []
second = TracePoint.new(:line) { |tp|
next unless TracePointSpec.target_thread?
all << tp
inspects << tp.inspect
}
line = nil
first.enable do
second.enable do
line = __LINE__
end
end
all.uniq.should == [second]
inspects.uniq.should == ["#<TracePoint:line#{@path_prefix}#{__FILE__}:#{line}>"]
2020-05-31 12:22:49 -04:00
called.should == true
end
end
ruby_version_is "2.6" do
describe 'target: option' do
before :each do
ScratchPad.record []
end
it 'enables trace point for specific location' do
trace = TracePoint.new(:call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.method_id
end
obj = Object.new
def obj.foo; end
def obj.bar; end
trace.enable(target: obj.method(:foo)) do
obj.foo
obj.bar
end
ScratchPad.recorded.should == [:foo]
end
it 'traces all the events triggered in specified location' do
trace = TracePoint.new(:line, :call, :return, :b_call, :b_return) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.event
end
obj = Object.new
def obj.foo
bar
-> {}.call
end
def obj.bar; end
trace.enable(target: obj.method(:foo)) do
obj.foo
end
ScratchPad.recorded.uniq.sort.should == [:call, :return, :b_call, :b_return, :line].sort
end
it 'does not trace events in nested locations' do
trace = TracePoint.new(:call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.method_id
end
obj = Object.new
def obj.foo
bar
end
def obj.bar
baz
end
def obj.baz
end
trace.enable(target: obj.method(:foo)) do
obj.foo
end
ScratchPad.recorded.should == [:foo]
end
it "traces some events in nested blocks" do
klass = Class.new do
def foo
1.times do
1.times do
bar do
end
end
end
end
def bar(&blk)
blk.call
end
end
trace = TracePoint.new(:b_call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.lineno
end
obj = klass.new
_, lineno = obj.method(:foo).source_location
trace.enable(target: obj.method(:foo)) do
obj.foo
end
ScratchPad.recorded.should == (lineno+1..lineno+3).to_a
end
describe 'option value' do
2019-04-27 12:53:23 -04:00
it 'accepts Method' do
trace = TracePoint.new(:call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.method_id
end
obj = Object.new
def obj.foo; end
trace.enable(target: obj.method(:foo)) do
obj.foo
end
ScratchPad.recorded.should == [:foo]
end
2019-04-27 12:53:23 -04:00
it 'accepts UnboundMethod' do
trace = TracePoint.new(:call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.method_id
end
klass = Class.new do
def foo; end
end
unbound_method = klass.instance_method(:foo)
trace.enable(target: unbound_method) do
klass.new.foo
end
ScratchPad.recorded.should == [:foo]
end
2019-04-27 12:53:23 -04:00
it 'accepts Proc' do
trace = TracePoint.new(:b_call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.lineno
end
block = proc {}
_, lineno = block.source_location
trace.enable(target: block) do
block.call
end
ScratchPad.recorded.should == [lineno]
lineno.should be_kind_of(Integer)
end
end
it "raises ArgumentError if target object cannot trigger specified event" do
trace = TracePoint.new(:call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.method_id
end
block = proc {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target: block) do
block.call # triggers :b_call and :b_return events
end
}.should raise_error(ArgumentError, /can not enable any hooks/)
end
2019-04-27 12:53:23 -04:00
it "raises ArgumentError if passed not Method/UnboundMethod/Proc" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:call) {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target: Object.new) do
end
}.should raise_error(ArgumentError, /specified target is not supported/)
end
context "nested enabling and disabling" do
it "raises ArgumentError if trace point already enabled with target is re-enabled with target" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:b_call) {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target: -> {}) do
trace.enable(target: -> {}) do
end
end
}.should raise_error(ArgumentError, /can't nest-enable a targett?ing TracePoint/)
end
it "raises ArgumentError if trace point already enabled without target is re-enabled with target" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:b_call) {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable do
trace.enable(target: -> {}) do
end
end
}.should raise_error(ArgumentError, /can't nest-enable a targett?ing TracePoint/)
end
it "raises ArgumentError if trace point already enabled with target is re-enabled without target" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:b_call) {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target: -> {}) do
trace.enable do
end
end
}.should raise_error(ArgumentError, /can't nest-enable a targett?ing TracePoint/)
end
it "raises ArgumentError if trace point already enabled with target is disabled with block" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:b_call) {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target: -> {}) do
trace.disable do
end
end
}.should raise_error(ArgumentError, /can't disable a targett?ing TracePoint in a block/)
end
it "traces events when trace point with target is enabled in another trace point enabled without target" do
trace_outer = TracePoint.new(:b_call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << :outer
end
trace_inner = TracePoint.new(:b_call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << :inner
end
target = -> {}
trace_outer.enable do
trace_inner.enable(target: target) do
target.call
end
end
ScratchPad.recorded.should == [:outer, :outer, :outer, :inner]
end
it "traces events when trace point with target is enabled in another trace point enabled with target" do
trace_outer = TracePoint.new(:b_call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << :outer
end
trace_inner = TracePoint.new(:b_call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << :inner
end
target = -> {}
trace_outer.enable(target: target) do
trace_inner.enable(target: target) do
target.call
end
end
ScratchPad.recorded.should == [:inner, :outer]
end
it "traces events when trace point without target is enabled in another trace point enabled with target" do
trace_outer = TracePoint.new(:b_call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << :outer
end
trace_inner = TracePoint.new(:b_call) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << :inner
end
target = -> {}
trace_outer.enable(target: target) do
trace_inner.enable do
target.call
end
end
ScratchPad.recorded.should == [:inner, :inner, :outer]
end
end
end
describe 'target_line: option' do
before :each do
ScratchPad.record []
end
it "traces :line events only on specified line of code" do
trace = TracePoint.new(:line) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.lineno
end
target = -> {
x = 1
y = 2 # <= this line is target
z = x + y
}
_, lineno = target.source_location
target_line = lineno + 2
trace.enable(target_line: target_line, target: target) do
target.call
end
ScratchPad.recorded.should == [target_line]
end
it "raises ArgumentError if :target option isn't specified" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:line) {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target_line: 67) do
end
}.should raise_error(ArgumentError, /only target_line is specified/)
end
it "raises ArgumentError if :line event isn't registered" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:call) {}
target = -> {
x = 1
y = 2 # <= this line is target
z = x + y
}
_, lineno = target.source_location
target_line = lineno + 2
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target_line: target_line, target: target) do
end
}.should raise_error(ArgumentError, /target_line is specified, but line event is not specified/)
end
it "raises ArgumentError if :target_line value is out of target code lines range" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:line) {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target_line: 1, target: -> { }) do
end
}.should raise_error(ArgumentError, /can not enable any hooks/)
end
it "raises TypeError if :target_line value couldn't be coerced to Integer" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:line) {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target_line: Object.new, target: -> { }) do
end
}.should raise_error(TypeError, /no implicit conversion of \w+? into Integer/)
end
it "raises ArgumentError if :target_line value is negative" do
2020-05-31 12:22:49 -04:00
trace = TracePoint.new(:line) {}
2019-07-27 06:40:09 -04:00
-> {
trace.enable(target_line: -2, target: -> { }) do
end
}.should raise_error(ArgumentError, /can not enable any hooks/)
end
2019-04-27 12:53:23 -04:00
it "accepts value that could be coerced to Integer" do
trace = TracePoint.new(:line) do |tp|
2020-05-31 12:22:49 -04:00
next unless TracePointSpec.target_thread?
ScratchPad << tp.lineno
end
target = -> {
x = 1 # <= this line is target
}
_, lineno = target.source_location
target_line = lineno + 1
trace.enable(target_line: target_line.to_r, target: target) do
target.call
end
ScratchPad.recorded.should == [target_line]
end
end
end
end