diff options
Diffstat (limited to 'spec/ruby/core/tracepoint')
20 files changed, 654 insertions, 373 deletions
diff --git a/spec/ruby/core/tracepoint/allow_reentry_spec.rb b/spec/ruby/core/tracepoint/allow_reentry_spec.rb new file mode 100644 index 0000000000..475cca29a9 --- /dev/null +++ b/spec/ruby/core/tracepoint/allow_reentry_spec.rb @@ -0,0 +1,30 @@ +require_relative '../../spec_helper' +require_relative 'fixtures/classes' + +describe 'TracePoint.allow_reentry' do + it 'allows the reentrance in a given block' do + event_lines = [] + l1 = l2 = l3 = l4 = nil + TracePoint.new(:line) do |tp| + next unless TracePointSpec.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 + + event_lines.should == [l1, l3, l4, l2, l3, l4] + end + + it 'raises RuntimeError when not called inside a TracePoint' do + -> { + TracePoint.allow_reentry{} + }.should.raise(RuntimeError) + end +end diff --git a/spec/ruby/core/tracepoint/binding_spec.rb b/spec/ruby/core/tracepoint/binding_spec.rb index f37753602e..6de6e47d7d 100644 --- a/spec/ruby/core/tracepoint/binding_spec.rb +++ b/spec/ruby/core/tracepoint/binding_spec.rb @@ -1,4 +1,5 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint#binding' do def test @@ -8,12 +9,13 @@ describe 'TracePoint#binding' do it 'return the generated binding object from event' do bindings = [] TracePoint.new(:return) { |tp| + next unless TracePointSpec.target_thread? bindings << tp.binding }.enable { test } bindings.size.should == 1 - bindings[0].should be_kind_of(Binding) + bindings[0].should.is_a?(Binding) bindings[0].local_variables.should == [:secret] end end diff --git a/spec/ruby/core/tracepoint/callee_id_spec.rb b/spec/ruby/core/tracepoint/callee_id_spec.rb index d340290d8b..cc08a45504 100644 --- a/spec/ruby/core/tracepoint/callee_id_spec.rb +++ b/spec/ruby/core/tracepoint/callee_id_spec.rb @@ -7,6 +7,7 @@ describe "TracePoint#callee_id" do obj = TracePointSpec::ClassWithMethodAlias.new TracePoint.new(:call) do |tp| + next unless TracePointSpec.target_thread? a << tp.callee_id end.enable do obj.m_alias diff --git a/spec/ruby/core/tracepoint/defined_class_spec.rb b/spec/ruby/core/tracepoint/defined_class_spec.rb index 72536e6a56..53c86a8210 100644 --- a/spec/ruby/core/tracepoint/defined_class_spec.rb +++ b/spec/ruby/core/tracepoint/defined_class_spec.rb @@ -5,22 +5,23 @@ describe 'TracePoint#defined_class' do it 'returns class or module of the method being called' do last_class_name = nil TracePoint.new(:call) do |tp| + next unless TracePointSpec.target_thread? last_class_name = tp.defined_class end.enable do TracePointSpec::B.new.foo - last_class_name.should equal(TracePointSpec::B) + last_class_name.should.equal?(TracePointSpec::B) TracePointSpec::B.new.bar - last_class_name.should equal(TracePointSpec::A) + last_class_name.should.equal?(TracePointSpec::A) c = TracePointSpec::C.new - last_class_name.should equal(TracePointSpec::C) + last_class_name.should.equal?(TracePointSpec::C) c.foo - last_class_name.should equal(TracePointSpec::B) + last_class_name.should.equal?(TracePointSpec::B) c.bar - last_class_name.should equal(TracePointSpec::A) + last_class_name.should.equal?(TracePointSpec::A) end end end diff --git a/spec/ruby/core/tracepoint/disable_spec.rb b/spec/ruby/core/tracepoint/disable_spec.rb index 612ca3c25a..73a31b3b81 100644 --- a/spec/ruby/core/tracepoint/disable_spec.rb +++ b/spec/ruby/core/tracepoint/disable_spec.rb @@ -1,9 +1,11 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint#disable' do it 'returns true if trace was enabled' do called = false trace = TracePoint.new(:line) do |tp| + next unless TracePointSpec.target_thread? called = true end @@ -25,6 +27,7 @@ describe 'TracePoint#disable' do it 'returns false if trace was disabled' do called = false trace = TracePoint.new(:line) do |tp| + next unless TracePointSpec.target_thread? called = true end @@ -41,7 +44,7 @@ describe 'TracePoint#disable' do begin trace.disable { enabled = trace.enabled? } enabled.should == false - trace.enabled?.should == true + trace.should.enabled? ensure trace.disable end @@ -52,7 +55,7 @@ describe 'TracePoint#disable' do trace.enable begin trace.disable { 42 }.should == 42 - trace.enabled?.should == true + trace.should.enabled? ensure trace.disable end @@ -65,7 +68,7 @@ describe 'TracePoint#disable' do trace.disable do |*args| args.should == [] end - trace.enabled?.should == true + trace.should.enabled? ensure trace.disable end diff --git a/spec/ruby/core/tracepoint/enable_spec.rb b/spec/ruby/core/tracepoint/enable_spec.rb index b0fe38c559..bf61c35154 100644 --- a/spec/ruby/core/tracepoint/enable_spec.rb +++ b/spec/ruby/core/tracepoint/enable_spec.rb @@ -1,20 +1,21 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint#enable' do - # def test; end - describe 'without a block' do - it 'returns true if trace was enabled' do + it 'returns false if trace was disabled' do called = false trace = TracePoint.new(:line) do |tp| + next unless TracePointSpec.target_thread? called = true end line_event = true called.should == false - trace.enable + ret = trace.enable begin + ret.should == false line_event = true called.should == true ensure @@ -22,30 +23,27 @@ describe 'TracePoint#enable' do end end - it 'returns false if trace was disabled' do + it 'returns true if trace was already enabled' do called = false trace = TracePoint.new(:line) do |tp| + next unless TracePointSpec.target_thread? called = true end - trace.enable.should == false - begin - line_event = true - called.should == true - ensure - trace.disable - end - - called = false line_event = true called.should == false - trace.enable.should == false + ret = trace.enable begin + ret.should == false + + trace.enable.should == true + line_event = true called.should == true ensure trace.disable + trace.should_not.enabled? end end end @@ -54,18 +52,43 @@ describe 'TracePoint#enable' do it 'enables the trace object within a block' do event_name = nil TracePoint.new(:line) do |tp| + next unless TracePointSpec.target_thread? event_name = tp.event - end.enable { event_name.should equal(:line) } + end.enable { event_name.should.equal?(:line) } + end + + it 'enables the trace object only for the current 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_not.include?(thread) end it 'can accept arguments within a block but it should not yield arguments' do event_name = nil - trace = TracePoint.new(:line) { |tp| event_name = tp.event } + trace = TracePoint.new(:line) do |tp| + next unless TracePointSpec.target_thread? + event_name = tp.event + end trace.enable do |*args| - event_name.should equal(:line) + event_name.should.equal?(:line) args.should == [] end - trace.enabled?.should == false + trace.should_not.enabled? end it 'enables trace object on calling with a block if it was already enabled' do @@ -87,394 +110,434 @@ describe 'TracePoint#enable' do it 'disables the trace object outside the block' do called = false - trace = TracePoint.new(:line) { called = true } + trace = TracePoint.new(:line) do + next unless TracePointSpec.target_thread? + called = true + end trace.enable { line_event = true } called.should == true - trace.enabled?.should == false + trace.should_not.enabled? end end - ruby_version_is "2.6" do - describe 'target: option' do - before :each do - ScratchPad.record [] + describe "when nested" do + before do + @path_prefix = ' ' + end + + 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 - it 'enables trace point for specific location' do - trace = TracePoint.new(:call) do |tp| - ScratchPad << tp.method_id + 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 - obj = Object.new - def obj.foo; end - def obj.bar; end + all.uniq.should == [second] + inspects.uniq.should == ["#<TracePoint:line#{@path_prefix}#{__FILE__}:#{line}>"] + called.should == true + end + end - trace.enable(target: obj.method(:foo)) do - obj.foo - obj.bar - end + describe 'target: option' do + before :each do + ScratchPad.record [] + end - ScratchPad.recorded.should == [:foo] + it 'enables trace point for specific location' do + trace = TracePoint.new(:call) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << tp.method_id end - it 'traces all the events triggered in specified location' do - trace = TracePoint.new(:line, :call, :return, :b_call, :b_return) do |tp| - ScratchPad << tp.event - end + obj = Object.new + def obj.foo; end + def obj.bar; end - obj = Object.new - def obj.foo - bar - -> {}.call - end - def obj.bar; end + trace.enable(target: obj.method(:foo)) do + obj.foo + obj.bar + end - trace.enable(target: obj.method(:foo)) do - obj.foo - end + ScratchPad.recorded.should == [:foo] + end - ScratchPad.recorded.uniq.sort.should == [:call, :return, :b_call, :b_return, :line].sort + it 'traces all the events triggered in specified location' do + trace = TracePoint.new(:line, :call, :return, :b_call, :b_return) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << tp.event end - it 'does not trace events in nested locations' do - trace = TracePoint.new(:call) do |tp| - ScratchPad << tp.method_id - end + obj = Object.new + def obj.foo + bar + -> {}.call + end + def obj.bar; 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 - trace.enable(target: obj.method(:foo)) do - obj.foo - end + ScratchPad.recorded.uniq.sort.should == [:call, :return, :b_call, :b_return, :line].sort + end - ScratchPad.recorded.should == [:foo] + it 'does not trace events in nested locations' do + trace = TracePoint.new(:call) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << tp.method_id end - it "traces some events in nested blocks" do - klass = Class.new do - def foo + 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 - 1.times do - bar do - end + bar do end end end + end - def bar(&blk) - blk.call - end + def bar(&blk) + blk.call end + end - trace = TracePoint.new(:b_call) do |tp| - ScratchPad << tp.lineno + trace = TracePoint.new(:b_call) do |tp| + 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 + it 'accepts Method' do + trace = TracePoint.new(:call) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << tp.method_id end - obj = klass.new - _, lineno = obj.method(:foo).source_location + obj = Object.new + def obj.foo; end trace.enable(target: obj.method(:foo)) do obj.foo end - ScratchPad.recorded.should == (lineno+1..lineno+3).to_a + ScratchPad.recorded.should == [:foo] end - describe 'option value' do - it 'accepts Method' do - trace = TracePoint.new(:call) do |tp| - ScratchPad << tp.method_id - end - - obj = Object.new - def obj.foo; end + it 'accepts UnboundMethod' do + trace = TracePoint.new(:call) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << tp.method_id + end - trace.enable(target: obj.method(:foo)) do - obj.foo - end + klass = Class.new do + def foo; end + end - ScratchPad.recorded.should == [:foo] + unbound_method = klass.instance_method(:foo) + trace.enable(target: unbound_method) do + klass.new.foo end - it 'accepts UnboundMethod' do - trace = TracePoint.new(:call) do |tp| - ScratchPad << tp.method_id - end + ScratchPad.recorded.should == [:foo] + end - klass = Class.new do - def foo; end - end + it 'accepts Proc' do + trace = TracePoint.new(:b_call) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << tp.lineno + end - unbound_method = klass.instance_method(:foo) - trace.enable(target: unbound_method) do - klass.new.foo - end + block = proc {} + _, lineno = block.source_location - ScratchPad.recorded.should == [:foo] + trace.enable(target: block) do + block.call end - it 'accepts Proc' do - trace = TracePoint.new(:b_call) do |tp| - ScratchPad << tp.lineno - end + ScratchPad.recorded.should == [lineno] + lineno.should.is_a?(Integer) + end + end - block = proc {} - _, lineno = block.source_location + it "raises ArgumentError if target object cannot trigger specified event" do + trace = TracePoint.new(:call) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << tp.method_id + end - trace.enable(target: block) do - block.call - end + block = proc {} - ScratchPad.recorded.should == [lineno] - lineno.should be_kind_of(Integer) + -> { + trace.enable(target: block) do + block.call # triggers :b_call and :b_return events end - end + }.should.raise(ArgumentError, /can not enable any hooks/) + end - it "raises ArgumentError if target object cannot trigger specified event" do - trace = TracePoint.new(:call) do |tp| - ScratchPad << tp.method_id + it "raises ArgumentError if passed not Method/UnboundMethod/Proc" do + trace = TracePoint.new(:call) {} + + -> { + trace.enable(target: Object.new) do end + }.should.raise(ArgumentError, /specified target is not supported/) + end - block = proc {} + context "nested enabling and disabling" do + it "raises ArgumentError if trace point already enabled with target is re-enabled with target" do + trace = TracePoint.new(:b_call) {} -> { - trace.enable(target: block) do - block.call # triggers :b_call and :b_return events + trace.enable(target: -> {}) do + trace.enable(target: -> {}) do + end end - }.should raise_error(ArgumentError, /can not enable any hooks/) + }.should.raise(ArgumentError, /can't nest-enable a targett?ing TracePoint/) end - it "raises ArgumentError if passed not Method/UnboundMethod/Proc" do - trace = TracePoint.new(:call) do |tp| - end + it "raises ArgumentError if trace point already enabled without target is re-enabled with target" do + trace = TracePoint.new(:b_call) {} -> { - trace.enable(target: Object.new) do + trace.enable do + trace.enable(target: -> {}) do + end end - }.should raise_error(ArgumentError, /specified target is not supported/) + }.should.raise(ArgumentError, /can't nest-enable a targett?ing TracePoint/) end - context "nested enabling and disabling" do - it "raises ArgumentError if trace point already enabled with target is re-enabled with target" do - trace = TracePoint.new(:b_call) do - end + it "raises ArgumentError if trace point already enabled with target is re-enabled without target" do + trace = TracePoint.new(:b_call) {} - -> { - trace.enable(target: -> {}) do - trace.enable(target: -> {}) do - end + -> { + trace.enable(target: -> {}) do + trace.enable do 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 - trace = TracePoint.new(:b_call) do end + }.should.raise(ArgumentError, /can't nest-enable a targett?ing TracePoint/) + end - -> { - 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 disabled with block" do + trace = TracePoint.new(:b_call) {} - it "raises ArgumentError if trace point already enabled with target is re-enabled without target" do - trace = TracePoint.new(:b_call) do + -> { + trace.enable(target: -> {}) do + trace.disable do + end end + }.should.raise(ArgumentError, /can't disable a targett?ing TracePoint in a block/) + end - -> { - trace.enable(target: -> {}) do - trace.enable do - end - end - }.should raise_error(ArgumentError, /can't nest-enable a targett?ing TracePoint/) + 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| + next unless TracePointSpec.target_thread? + ScratchPad << :outer end - it "raises ArgumentError if trace point already enabled with target is disabled with block" do - trace = TracePoint.new(:b_call) do - end - - -> { - trace.enable(target: -> {}) do - trace.disable do - end - end - }.should raise_error(ArgumentError, /can't disable a targett?ing TracePoint in a block/) + trace_inner = TracePoint.new(:b_call) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << :inner 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| - ScratchPad << :outer - end + target = -> {} - trace_inner = TracePoint.new(:b_call) do |tp| - ScratchPad << :inner + trace_outer.enable do + trace_inner.enable(target: target) do + target.call end + end - target = -> {} + ScratchPad.recorded.should == [:outer, :outer, :outer, :inner] + end - trace_outer.enable do - trace_inner.enable(target: target) do - target.call - end - 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| + next unless TracePointSpec.target_thread? + ScratchPad << :outer + end - ScratchPad.recorded.should == [:outer, :outer, :outer, :inner] + trace_inner = TracePoint.new(:b_call) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << :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| - ScratchPad << :outer - end + target = -> {} - trace_inner = TracePoint.new(:b_call) do |tp| - ScratchPad << :inner + trace_outer.enable(target: target) do + trace_inner.enable(target: target) do + target.call end + end - target = -> {} - - trace_outer.enable(target: target) do - trace_inner.enable(target: target) do - target.call - end - end + ScratchPad.recorded.should == [:inner, :outer] + end - ScratchPad.recorded.should == [:inner, :outer] + 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| + next unless TracePointSpec.target_thread? + ScratchPad << :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| - ScratchPad << :outer - end - - trace_inner = TracePoint.new(:b_call) do |tp| - ScratchPad << :inner - end + trace_inner = TracePoint.new(:b_call) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << :inner + end - target = -> {} + target = -> {} - trace_outer.enable(target: target) do - trace_inner.enable do - target.call - end + trace_outer.enable(target: target) do + trace_inner.enable do + target.call end - - ScratchPad.recorded.should == [:inner, :inner, :outer] end - end - end - describe 'target_line: option' do - before :each do - ScratchPad.record [] + ScratchPad.recorded.should == [:inner, :inner, :outer] end + end + end - it "traces :line events only on specified line of code" do - trace = TracePoint.new(:line) do |tp| - ScratchPad << tp.lineno - end + describe 'target_line: option' do + before :each do + ScratchPad.record [] + end - target = -> { - x = 1 - y = 2 # <= this line is target - z = x + y - } - _, lineno = target.source_location - target_line = lineno + 2 + it "traces :line events only on specified line of code" do + trace = TracePoint.new(:line) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << tp.lineno + end - trace.enable(target_line: target_line, target: target) do - target.call - end + target = -> { + x = 1 + y = 2 # <= this line is target + z = x + y + } + _, lineno = target.source_location + target_line = lineno + 2 - ScratchPad.recorded.should == [target_line] + trace.enable(target_line: target_line, target: target) do + target.call end - it "raises ArgumentError if :target option isn't specified" do - trace = TracePoint.new(:line) do |tp| - end + ScratchPad.recorded.should == [target_line] + end - -> { - trace.enable(target_line: 67) do - end - }.should raise_error(ArgumentError, /only target_line is specified/) - end + it "raises ArgumentError if :target option isn't specified" do + trace = TracePoint.new(:line) {} - it "raises ArgumentError if :line event isn't registered" do - trace = TracePoint.new(:call) do |tp| + -> { + trace.enable(target_line: 67) do end + }.should.raise(ArgumentError, /only target_line is specified/) + end - target = -> { - x = 1 - y = 2 # <= this line is target - z = x + y - } - _, lineno = target.source_location - target_line = lineno + 2 + it "raises ArgumentError if :line event isn't registered" do + trace = TracePoint.new(:call) {} - -> { - 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 + target = -> { + x = 1 + y = 2 # <= this line is target + z = x + y + } + _, lineno = target.source_location + target_line = lineno + 2 - it "raises ArgumentError if :target_line value is out of target code lines range" do - trace = TracePoint.new(:line) do |tp| + -> { + trace.enable(target_line: target_line, target: target) do end + }.should.raise(ArgumentError, /target_line is specified, but line event is not specified/) + end - -> { - trace.enable(target_line: 1, target: -> { }) do - end - }.should raise_error(ArgumentError, /can not enable any hooks/) - end + it "raises ArgumentError if :target_line value is out of target code lines range" do + trace = TracePoint.new(:line) {} - it "raises TypeError if :target_line value couldn't be coerced to Integer" do - trace = TracePoint.new(:line) do |tp| + -> { + trace.enable(target_line: 1, target: -> { }) do end + }.should.raise(ArgumentError, /can not enable any hooks/) + end - -> { - trace.enable(target_line: Object.new, target: -> { }) do - end - }.should raise_error(TypeError, /no implicit conversion of \w+? into Integer/) - end + it "raises TypeError if :target_line value couldn't be coerced to Integer" do + trace = TracePoint.new(:line) {} - it "raises ArgumentError if :target_line value is negative" do - trace = TracePoint.new(:line) do |tp| + -> { + trace.enable(target_line: Object.new, target: -> { }) do end + }.should.raise(TypeError, /no implicit conversion of \w+? into Integer/) + end - -> { - trace.enable(target_line: -2, target: -> { }) do - end - }.should raise_error(ArgumentError, /can not enable any hooks/) - end + it "raises ArgumentError if :target_line value is negative" do + trace = TracePoint.new(:line) {} - it "accepts value that could be coerced to Integer" do - trace = TracePoint.new(:line) do |tp| - ScratchPad << tp.lineno + -> { + trace.enable(target_line: -2, target: -> { }) do end + }.should.raise(ArgumentError, /can not enable any hooks/) + end - target = -> { - x = 1 # <= this line is target - } - _, lineno = target.source_location - target_line = lineno + 1 + it "accepts value that could be coerced to Integer" do + trace = TracePoint.new(:line) do |tp| + next unless TracePointSpec.target_thread? + ScratchPad << tp.lineno + end - trace.enable(target_line: target_line.to_r, target: target) do - target.call - end + target = -> { + x = 1 # <= this line is target + } + _, lineno = target.source_location + target_line = lineno + 1 - ScratchPad.recorded.should == [target_line] + trace.enable(target_line: target_line.to_r, target: target) do + target.call end + + ScratchPad.recorded.should == [target_line] end end end diff --git a/spec/ruby/core/tracepoint/enabled_spec.rb b/spec/ruby/core/tracepoint/enabled_spec.rb index 0167d32fb0..0e9566a02c 100644 --- a/spec/ruby/core/tracepoint/enabled_spec.rb +++ b/spec/ruby/core/tracepoint/enabled_spec.rb @@ -1,14 +1,15 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint#enabled?' do it 'returns true when current status of the trace is enable' do trace = TracePoint.new(:line) {} trace.enable do - trace.enabled?.should == true + trace.should.enabled? end end it 'returns false when current status of the trace is disabled' do - TracePoint.new(:line) {}.enabled?.should == false + TracePoint.new(:line) {}.should_not.enabled? end end diff --git a/spec/ruby/core/tracepoint/eval_script_spec.rb b/spec/ruby/core/tracepoint/eval_script_spec.rb index 1d8e425a9a..7ec53e7094 100644 --- a/spec/ruby/core/tracepoint/eval_script_spec.rb +++ b/spec/ruby/core/tracepoint/eval_script_spec.rb @@ -1,24 +1,23 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' -ruby_version_is "2.6" do - describe "TracePoint#eval_script" do - it "is the evald source code" do - ScratchPad.record [] +describe "TracePoint#eval_script" do + it "is the evald source code" do + ScratchPad.record [] - script = <<-CODE - def foo - p :hello - end - CODE - - TracePoint.new(:script_compiled) do |e| - ScratchPad << e.eval_script - end.enable do - eval script + script = <<-CODE + def foo + p :hello end + CODE - ScratchPad.recorded.should == [script] + TracePoint.new(:script_compiled) do |e| + next unless TracePointSpec.target_thread? + ScratchPad << e.eval_script + end.enable do + eval script end + + ScratchPad.recorded.should == [script] end end diff --git a/spec/ruby/core/tracepoint/event_spec.rb b/spec/ruby/core/tracepoint/event_spec.rb index 019d0c3253..58017dc98d 100644 --- a/spec/ruby/core/tracepoint/event_spec.rb +++ b/spec/ruby/core/tracepoint/event_spec.rb @@ -5,16 +5,17 @@ describe 'TracePoint#event' do it 'returns the type of event' do event_name = nil TracePoint.new(:end, :call) do |tp| + next unless TracePointSpec.target_thread? event_name = tp.event end.enable do TracePointSpec.test - event_name.should equal(:call) + event_name.should.equal?(:call) TracePointSpec::B.new.foo - event_name.should equal(:call) + event_name.should.equal?(:call) class TracePointSpec::B; end - event_name.should equal(:end) + event_name.should.equal?(:end) end end diff --git a/spec/ruby/core/tracepoint/fixtures/classes.rb b/spec/ruby/core/tracepoint/fixtures/classes.rb index 49c70e1915..3ab1b00b16 100644 --- a/spec/ruby/core/tracepoint/fixtures/classes.rb +++ b/spec/ruby/core/tracepoint/fixtures/classes.rb @@ -1,4 +1,10 @@ module TracePointSpec + @thread = Thread.current + + def self.target_thread? + Thread.current == @thread + end + class ClassWithMethodAlias def m end diff --git a/spec/ruby/core/tracepoint/inspect_spec.rb b/spec/ruby/core/tracepoint/inspect_spec.rb index 9ff1653ae8..6cc2ebe243 100644 --- a/spec/ruby/core/tracepoint/inspect_spec.rb +++ b/spec/ruby/core/tracepoint/inspect_spec.rb @@ -2,27 +2,140 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' describe 'TracePoint#inspect' do + before do + @path_prefix = ' ' + end + it 'returns a string containing a human-readable TracePoint status' do - TracePoint.new(:line) {}.inspect.should == - '#<TracePoint:disabled>' + TracePoint.new(:line) {}.inspect.should == '#<TracePoint:disabled>' + end + + it "shows only whether it's enabled when outside the TracePoint handler" do + trace = TracePoint.new(:line) {} + trace.enable + + trace.inspect.should == '#<TracePoint:enabled>' + + trace.disable end it 'returns a String showing the event, path and line' do inspect = nil - line = __LINE__ - TracePoint.new(:line) { |tp| inspect = tp.inspect }.enable do - inspect.should == "#<TracePoint:line@#{__FILE__}:#{line+2}>" + line = nil + TracePoint.new(:line) { |tp| + next unless TracePointSpec.target_thread? + next unless tp.path == __FILE__ + + inspect ||= tp.inspect + }.enable do + line = __LINE__ + end + + inspect.should == "#<TracePoint:line#{@path_prefix}#{__FILE__}:#{line}>" + end + + it 'returns a String showing the event, method, path and line for a :call event' do + inspect = nil + line = nil + TracePoint.new(:call) { |tp| + next unless TracePointSpec.target_thread? + next unless tp.path == __FILE__ + + inspect ||= tp.inspect + }.enable do + line = __LINE__ + 1 + def trace_point_spec_test_call; end + trace_point_spec_test_call + end + + inspect.should =~ /\A#<TracePoint:call [`']trace_point_spec_test_call'#{@path_prefix}#{__FILE__}:#{line}>\z/ + end + + it 'returns a String showing the event, method, path and line for a :return event' do + inspect = nil + line = nil + TracePoint.new(:return) { |tp| + next unless TracePointSpec.target_thread? + next unless tp.path == __FILE__ + + inspect ||= tp.inspect + }.enable do + line = __LINE__ + 4 + def trace_point_spec_test_return + a = 1 + return a + end + trace_point_spec_test_return + end + ruby_version_is("3.4") { line -= 1 } + + inspect.should =~ /\A#<TracePoint:return [`']trace_point_spec_test_return'#{@path_prefix}#{__FILE__}:#{line}>\z/ + end + + it 'returns a String showing the event, method, path and line for a :c_call event' do + inspect = nil + tracepoint = TracePoint.new(:c_call) { |tp| + next unless TracePointSpec.target_thread? + next unless tp.path == __FILE__ + + inspect ||= tp.inspect + } + line = __LINE__ + 2 + tracepoint.enable do + [0, 1].max end + + inspect.should =~ /\A#<TracePoint:c_call [`']max'#{@path_prefix}#{__FILE__}:#{line}>\z/ end it 'returns a String showing the event, path and line for a :class event' do inspect = nil - line = __LINE__ - TracePoint.new(:class) { |tp| inspect = tp.inspect }.enable do + line = nil + TracePoint.new(:class) { |tp| + next unless TracePointSpec.target_thread? + next unless tp.path == __FILE__ + + inspect ||= tp.inspect + }.enable do + line = __LINE__ + 1 class TracePointSpec::C end end - inspect.should == "#<TracePoint:class@#{__FILE__}:#{line+2}>" + inspect.should == "#<TracePoint:class#{@path_prefix}#{__FILE__}:#{line}>" + end + + it 'returns a String showing the event and thread for :thread_begin event' do + inspect = nil + thread = nil + thread_inspection = nil + TracePoint.new(:thread_begin) { |tp| + next unless Thread.current == thread + + inspect ||= tp.inspect + }.enable(target_thread: nil) do + thread = Thread.new {} + thread_inspection = thread.inspect + thread.join + end + + inspect.should == "#<TracePoint:thread_begin #{thread_inspection}>" + end + + it 'returns a String showing the event and thread for :thread_end event' do + inspect = nil + thread = nil + thread_inspection = nil + TracePoint.new(:thread_end) { |tp| + next unless Thread.current == thread + + inspect ||= tp.inspect + }.enable(target_thread: nil) do + thread = Thread.new {} + thread_inspection = thread.inspect + thread.join + end + + inspect.should == "#<TracePoint:thread_end #{thread_inspection}>" end end diff --git a/spec/ruby/core/tracepoint/lineno_spec.rb b/spec/ruby/core/tracepoint/lineno_spec.rb index a4d7e77e8d..7c46d5222b 100644 --- a/spec/ruby/core/tracepoint/lineno_spec.rb +++ b/spec/ruby/core/tracepoint/lineno_spec.rb @@ -1,10 +1,20 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint#lineno' do it 'returns the line number of the event' do lineno = nil - TracePoint.new(:line) { |tp| lineno = tp.lineno }.enable do - lineno.should == 7 + TracePoint.new(:line) { |tp| + next unless TracePointSpec.target_thread? + lineno = tp.lineno + }.enable do + line_event = true end + lineno.should == __LINE__ - 2 + end + + it 'raises RuntimeError if accessed from outside' do + tp = TracePoint.new(:line) {} + -> { tp.lineno }.should.raise(RuntimeError, 'access from outside') end end diff --git a/spec/ruby/core/tracepoint/method_id_spec.rb b/spec/ruby/core/tracepoint/method_id_spec.rb index 82254d1299..67740f2d7d 100644 --- a/spec/ruby/core/tracepoint/method_id_spec.rb +++ b/spec/ruby/core/tracepoint/method_id_spec.rb @@ -1,13 +1,15 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint#method_id' do - def test; end - it 'returns the name at the definition of the method being called' do method_name = nil - TracePoint.new(:call) { |tp| method_name = tp.method_id}.enable do - test - method_name.should equal(:test) + TracePoint.new(:call) { |tp| + next unless TracePointSpec.target_thread? + method_name = tp.method_id + }.enable do + TracePointSpec.test + method_name.should.equal?(:test) end end end diff --git a/spec/ruby/core/tracepoint/new_spec.rb b/spec/ruby/core/tracepoint/new_spec.rb index 916d826fdf..763b35292b 100644 --- a/spec/ruby/core/tracepoint/new_spec.rb +++ b/spec/ruby/core/tracepoint/new_spec.rb @@ -3,21 +3,24 @@ require_relative 'fixtures/classes' describe 'TracePoint.new' do it 'returns a new TracePoint object, not enabled by default' do - TracePoint.new(:line) {}.enabled?.should be_false + TracePoint.new(:line) {}.enabled?.should == false end it 'includes :line event when event is not specified' do event_name = nil - TracePoint.new() { |tp| event_name = tp.event }.enable do - event_name.should equal(:line) + TracePoint.new { |tp| + next unless TracePointSpec.target_thread? + event_name = tp.event + }.enable do + event_name.should.equal?(:line) event_name = nil TracePointSpec.test - event_name.should equal(:line) + event_name.should.equal?(:line) event_name = nil TracePointSpec::B.new.foo - event_name.should equal(:line) + event_name.should.equal?(:line) end end @@ -25,7 +28,10 @@ describe 'TracePoint.new' do event_name = nil (o = mock('line')).should_receive(:to_sym).and_return(:line) - TracePoint.new(o) { |tp| event_name = tp.event }.enable do + TracePoint.new(o) { |tp| + next unless TracePointSpec.target_thread? + event_name = tp.event + }.enable do line_event = true event_name.should == :line end @@ -34,34 +40,33 @@ describe 'TracePoint.new' do it 'includes multiple events when multiple event names are passed as params' do event_name = nil TracePoint.new(:end, :call) do |tp| + next unless TracePointSpec.target_thread? event_name = tp.event end.enable do TracePointSpec.test - event_name.should equal(:call) + event_name.should.equal?(:call) TracePointSpec::B.new.foo - event_name.should equal(:call) + event_name.should.equal?(:call) class TracePointSpec::B; end - event_name.should equal(:end) + event_name.should.equal?(:end) end end it 'raises a TypeError when the given object is not a string/symbol' do o = mock('123') - -> { TracePoint.new(o) {}}.should raise_error(TypeError) + -> { TracePoint.new(o) {} }.should.raise(TypeError) o.should_receive(:to_sym).and_return(123) - -> { TracePoint.new(o) {}}.should raise_error(TypeError) + -> { TracePoint.new(o) {} }.should.raise(TypeError) end - ruby_version_is "2.5" do - it 'expects to be called with a block' do - -> { TracePoint.new(:line) }.should raise_error(ArgumentError, "must be called with a block") - end + it 'expects to be called with a block' do + -> { TracePoint.new(:line) }.should.raise(ArgumentError, "must be called with a block") end it "raises a Argument error when the given argument doesn't match an event name" do - -> { TracePoint.new(:test) }.should raise_error(ArgumentError, "unknown event: test") + -> { TracePoint.new(:test) }.should.raise(ArgumentError, "unknown event: test") end end diff --git a/spec/ruby/core/tracepoint/parameters_spec.rb b/spec/ruby/core/tracepoint/parameters_spec.rb index f901c184f4..82aee3caa4 100644 --- a/spec/ruby/core/tracepoint/parameters_spec.rb +++ b/spec/ruby/core/tracepoint/parameters_spec.rb @@ -1,23 +1,28 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' -ruby_version_is "2.6" do - describe 'TracePoint#parameters' do - it 'returns the parameters of block' do - f = proc {|x, y, z| } - parameters = nil - TracePoint.new(:b_call) {|tp| parameters = tp.parameters }.enable do - f.call - parameters.should == [[:opt, :x], [:opt, :y], [:opt, :z]] - end +describe 'TracePoint#parameters' do + it 'returns the parameters of block' do + f = proc {|x, y, z| } + parameters = nil + TracePoint.new(:b_call) { |tp| + next unless TracePointSpec.target_thread? + parameters = tp.parameters + }.enable do + f.call + parameters.should == [[:opt, :x], [:opt, :y], [:opt, :z]] end + end - it 'returns the parameters of lambda block' do - f = -> x, y, z { } - parameters = nil - TracePoint.new(:b_call) {|tp| parameters = tp.parameters }.enable do - f.call(1, 2, 3) - parameters.should == [[:req, :x], [:req, :y], [:req, :z]] - end + it 'returns the parameters of lambda block' do + f = -> x, y, z { } + parameters = nil + TracePoint.new(:b_call) { |tp| + next unless TracePointSpec.target_thread? + parameters = tp.parameters + }.enable do + f.call(1, 2, 3) + parameters.should == [[:req, :x], [:req, :y], [:req, :z]] end end end diff --git a/spec/ruby/core/tracepoint/path_spec.rb b/spec/ruby/core/tracepoint/path_spec.rb index 1e31c1bb68..aa6868ead2 100644 --- a/spec/ruby/core/tracepoint/path_spec.rb +++ b/spec/ruby/core/tracepoint/path_spec.rb @@ -1,18 +1,26 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint#path' do it 'returns the path of the file being run' do path = nil - TracePoint.new(:line) { |tp| path = tp.path }.enable do - path.should == "#{__FILE__}" + TracePoint.new(:line) { |tp| + next unless TracePointSpec.target_thread? + path = tp.path + }.enable do + line_event = true end + path.should == "#{__FILE__}" end - it 'equals (eval) inside an eval for :end event' do + it 'equals "(eval at __FILE__:__LINE__)" inside an eval for :end event' do path = nil - TracePoint.new(:end) { |tp| path = tp.path }.enable do + TracePoint.new(:end) { |tp| + next unless TracePointSpec.target_thread? + path = tp.path + }.enable do eval("module TracePointSpec; end") - path.should == '(eval)' end + path.should == "(eval at #{__FILE__}:#{__LINE__ - 2})" end end diff --git a/spec/ruby/core/tracepoint/raised_exception_spec.rb b/spec/ruby/core/tracepoint/raised_exception_spec.rb index 450717b958..b1199902f2 100644 --- a/spec/ruby/core/tracepoint/raised_exception_spec.rb +++ b/spec/ruby/core/tracepoint/raised_exception_spec.rb @@ -1,16 +1,36 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint#raised_exception' do it 'returns value from exception raised on the :raise event' do raised_exception, error_result = nil - trace = TracePoint.new(:raise) { |tp| raised_exception = tp.raised_exception } + trace = TracePoint.new(:raise) { |tp| + next unless TracePointSpec.target_thread? + raised_exception = tp.raised_exception + } trace.enable do begin raise StandardError rescue => e error_result = e end - raised_exception.should equal(error_result) + raised_exception.should.equal?(error_result) + end + end + + it 'returns value from exception rescued on the :rescue event' do + raised_exception, error_result = nil + trace = TracePoint.new(:rescue) { |tp| + next unless TracePointSpec.target_thread? + raised_exception = tp.raised_exception + } + trace.enable do + begin + raise StandardError + rescue => e + error_result = e + end + raised_exception.should.equal?(error_result) end end end diff --git a/spec/ruby/core/tracepoint/return_value_spec.rb b/spec/ruby/core/tracepoint/return_value_spec.rb index f0ed86bd00..e84c7dd762 100644 --- a/spec/ruby/core/tracepoint/return_value_spec.rb +++ b/spec/ruby/core/tracepoint/return_value_spec.rb @@ -1,11 +1,15 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint#return_value' do def test; 'test' end it 'returns value from :return event' do trace_value = nil - TracePoint.new(:return) { |tp| trace_value = tp.return_value}.enable do + TracePoint.new(:return) { |tp| + next unless TracePointSpec.target_thread? + trace_value = tp.return_value + }.enable do test trace_value.should == 'test' end diff --git a/spec/ruby/core/tracepoint/self_spec.rb b/spec/ruby/core/tracepoint/self_spec.rb index 8bfd09301e..bf9a2b6a45 100644 --- a/spec/ruby/core/tracepoint/self_spec.rb +++ b/spec/ruby/core/tracepoint/self_spec.rb @@ -4,17 +4,23 @@ require_relative 'fixtures/classes' describe 'TracePoint#self' do it 'return the trace object from event' do trace = nil - TracePoint.new(:line) { |tp| trace = tp.self }.enable do - trace.equal?(self).should be_true + TracePoint.new(:line) { |tp| + next unless TracePointSpec.target_thread? + trace = tp.self + }.enable do + trace.equal?(self).should == true end end it 'return the class object from a class event' do trace = nil - TracePoint.new(:class) { |tp| trace = tp.self }.enable do + TracePoint.new(:class) { |tp| + next unless TracePointSpec.target_thread? + trace = tp.self + }.enable do class TracePointSpec::C end end - trace.should equal TracePointSpec::C + trace.should.equal? TracePointSpec::C end end diff --git a/spec/ruby/core/tracepoint/trace_spec.rb b/spec/ruby/core/tracepoint/trace_spec.rb index ea6c85bcc5..167f594bb9 100644 --- a/spec/ruby/core/tracepoint/trace_spec.rb +++ b/spec/ruby/core/tracepoint/trace_spec.rb @@ -1,9 +1,10 @@ require_relative '../../spec_helper' +require_relative 'fixtures/classes' describe 'TracePoint.trace' do it 'activates the trace automatically' do trace = TracePoint.trace(:line) {} - trace.enabled?.should == true + trace.should.enabled? trace.disable end end |