newrelic_rpm 4.0.0.332 → 6.13.1

data/test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb

@@ -1,112 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
-
-require 'set'
-module NewRelic
-  module Agent
-    class Agent
-      module MethodTracer
-        module ClassMethods
-          class AddMethodTracerTest < Minitest::Test
-            #  require 'new_relic/agent/method_tracer'
-            include NewRelic::Agent::MethodTracer::ClassMethods::AddMethodTracer
-
-            def test_validate_options_nonhash
-              assert_raises(TypeError) do
-                validate_options(:fluttershy, [])
-              end
-            end
-
-            def test_validate_options_defaults
-              self.expects(:check_for_illegal_keys!)
-              self.expects(:check_for_push_scope_and_metric)
-              validate_options(:applejack, {})
-            end
-
-            def test_validate_options_override
-              opts = {:push_scope => false, :metric => false, :force => true}
-              self.expects(:check_for_illegal_keys!)
-              self.expects(:check_for_push_scope_and_metric)
-              val = validate_options(:pinkie_pie, opts)
-              assert val.is_a?(Hash)
-              assert (val[:push_scope] == false), val.inspect
-              assert (val[:metric] == false), val.inspect
-              assert (val[:force] == true), val.inspect
-            end
-
-            def test_default_metric_name_code
-              assert_equal "Custom/#{self.class.name}/test_method", self.class.default_metric_name_code('test_method')
-            end
-
-            def test_newrelic_method_exists_positive
-              self.expects(:method_defined?).returns(true)
-              assert newrelic_method_exists?('test_method')
-            end
-
-            def test_newrelic_method_exists_negative
-              self.class.expects(:method_defined?).returns(false)
-              self.class.expects(:private_method_defined?).returns(false)
-
-              assert !self.class.newrelic_method_exists?('test_method')
-            end
-
-            def test_check_for_illegal_keys_positive
-              assert_raises(RuntimeError) do
-                check_for_illegal_keys!(:twilight_sparkle, {:unknown_key => nil})
-              end
-            end
-
-            def test_check_for_illegal_keys_negative
-              test_keys = Hash[*ALLOWED_KEYS.map {|x| [x, nil]}.flatten]
-              check_for_illegal_keys!(:rainbow_dash, test_keys)
-            end
-
-            def test_traced_method_exists_positive
-              self.expects(:_traced_method_name)
-              self.expects(:method_defined?).returns(true)
-              assert traced_method_exists?('test_method', 'Custom/Test/test_method')
-            end
-
-            def test_traced_method_exists_negative
-              self.expects(:_traced_method_name)
-              self.expects(:method_defined?).returns(false)
-              assert !traced_method_exists?(nil, nil)
-            end
-
-            def test_assemble_code_header_unforced
-              self.expects(:_untraced_method_name).returns("method_name_without_tracing")
-              opts = {:force => false, :code_header => 'CODE HEADER'}
-              assert_equal "return method_name_without_tracing(*args, &block) unless NewRelic::Agent.tl_is_execution_traced?\nCODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
-            end
-
-            def test_check_for_push_scope_and_metric_positive
-              check_for_push_scope_and_metric({:push_scope => true})
-              check_for_push_scope_and_metric({:metric => true})
-            end
-
-            def test_check_for_push_scope_and_metric_negative
-              assert_raises(RuntimeError) do
-                check_for_push_scope_and_metric({:push_scope => false, :metric => false})
-              end
-            end
-
-            def test_code_to_eval_scoped
-              self.expects(:validate_options).returns({:push_scope => true})
-              self.expects(:method_with_push_scope).with('test_method', 'Custom/Test/test_method', {:push_scope => true})
-              code_to_eval('test_method', 'Custom/Test/test_method', {})
-            end
-
-            def test_code_to_eval_unscoped
-              self.expects(:validate_options).returns({:push_scope => false})
-              self.expects(:method_without_push_scope).with('test', 'Custom/Test/test', {:push_scope => false})
-              code_to_eval('test', 'Custom/Test/test', {})
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/test/new_relic/agent/method_tracer/instance_methods/trace_execution_scoped_test.rb

@@ -1,215 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
-class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
-  require 'new_relic/agent/method_tracer'
-  include NewRelic::Agent::MethodTracer
-
-  def setup
-    NewRelic::Agent.agent.stats_engine.clear_stats
-  end
-
-  def test_metric_recording_in_non_nested_transaction
-    in_transaction('outer') do
-      trace_execution_scoped(['foo', 'bar']) do
-        # erm
-      end
-    end
-
-    expected_values = { :call_count => 1 }
-    assert_metrics_recorded_exclusive(
-      ['foo', 'outer'] => expected_values,
-      'foo'            => expected_values,
-      'bar'            => expected_values,
-      'outer'          => expected_values
-    )
-  end
-
-  def test_metric_recording_in_nested_transactions
-    in_transaction('Controller/outer_txn') do
-      in_transaction('Controller/inner_txn') do
-        trace_execution_scoped(['foo', 'bar']) do
-          # erm
-        end
-      end
-    end
-
-    expected_values = { :call_count => 1 }
-    assert_metrics_recorded_exclusive(
-      'HttpDispatcher'                                    => expected_values,
-      'Controller/inner_txn'                              => expected_values,
-
-      'Nested/Controller/inner_txn'                           => expected_values,
-      ['Nested/Controller/inner_txn', 'Controller/inner_txn'] => expected_values,
-      'Nested/Controller/outer_txn'                           => expected_values,
-      ['Nested/Controller/outer_txn', 'Controller/inner_txn'] => expected_values,
-
-      ['foo'                    , 'Controller/inner_txn'] => expected_values,
-      'foo'                                               => expected_values,
-      'bar'                                               => expected_values
-    )
-  end
-
-  def test_metric_recording_in_3_nested_transactions
-    in_transaction('Controller/outer_txn') do
-      in_transaction('Controller/middle_txn') do
-        in_transaction('Controller/inner_txn') do
-          # erm
-        end
-      end
-    end
-
-    assert_metrics_recorded([
-      'Controller/inner_txn',
-      'Nested/Controller/inner_txn',
-      'Nested/Controller/middle_txn',
-      'Nested/Controller/outer_txn'
-      ])
-  end
-
-  def test_metric_recording_inside_transaction
-    in_transaction('outer') do
-      trace_execution_scoped(['foo', 'bar']) do
-        # erm
-      end
-    end
-
-    expected_values = { :call_count => 1 }
-    assert_metrics_recorded_exclusive(
-      'outer'          => expected_values,
-      'foo'            => expected_values,
-      ['foo', 'outer'] => expected_values,
-      'bar'            => expected_values
-    )
-  end
-
-  def test_metric_recording_with_metric_option_false
-    options = { :metric => false, :scoped_metric => false }
-
-    in_transaction('outer') do
-      trace_execution_scoped(['foo', 'bar'], options) do
-        # erm
-      end
-    end
-
-    expected_values = { :call_count => 1 }
-    assert_metrics_recorded_exclusive('outer' => expected_values)
-  end
-
-  def test_log_errors_base
-    ran = false
-    NewRelic::Agent::MethodTracerHelpers.log_errors("name") do
-      ran = true
-    end
-    assert ran, "should run the contents of the block"
-  end
-
-  def test_log_errors_with_return
-    ran = false
-    return_val = NewRelic::Agent::MethodTracerHelpers.log_errors('name') do
-      ran = true
-      'happy trees'
-    end
-
-    assert ran, "should run contents of block"
-    assert_equal 'happy trees', return_val, "should return contents of the block"
-  end
-
-  def test_log_errors_with_error
-    expects_logging(:error,
-      includes("Caught exception in name."),
-      instance_of(RuntimeError))
-
-    NewRelic::Agent::MethodTracerHelpers.log_errors("name") do
-      raise "should not propagate out of block"
-    end
-  end
-
-  def test_trace_execution_scoped_header
-    state = NewRelic::Agent::TransactionState.tl_get
-    stack = state.traced_method_stack
-    NewRelic::Agent::MethodTracerHelpers.expects(:log_errors).with(:trace_execution_scoped_header).yields
-    stack.expects(:push_frame).with(state, :method_tracer, 1.0)
-    NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, 1.0)
-  end
-
-  def test_trace_execution_scoped_calculates_exclusive_time
-    freeze_time
-    in_transaction('txn') do
-      trace_execution_scoped(['parent']) do
-        advance_time(10)
-        trace_execution_scoped(['child']) do
-          advance_time(10)
-        end
-      end
-    end
-
-    assert_metrics_recorded_exclusive(
-      'txn'    => {
-        :call_count           =>  1,
-      },
-      'parent' => {
-        :call_count           =>  1,
-        :total_call_time      => 20,
-        :total_exclusive_time => 10,
-      },
-      ['parent', 'txn'] => {
-        :call_count           =>  1,
-        :total_call_time      => 20,
-        :total_exclusive_time => 10,
-      },
-      'child'  => {
-        :call_count           =>  1,
-        :total_call_time      => 10,
-        :total_exclusive_time => 10,
-      },
-      ['child', 'txn']  => {
-        :call_count           =>  1,
-        :total_call_time      => 10,
-        :total_exclusive_time => 10,
-      }
-    )
-  end
-
-  def test_trace_execution_scoped_disabled
-    # make sure the method doesn't beyond the abort
-    self.expects(:set_if_nil).never
-    ran = false
-    value = trace_execution_scoped(nil, {:options => 'hash'}) do
-      ran = true
-      1172
-    end
-
-    assert ran, 'should run contents of block'
-    assert_equal 1172, value, 'should return contents of block'
-  end
-
-  def test_trace_execution_scope_runs_passed_block_and_returns_its_value
-    value = trace_execution_scoped(['metric', 'array'], {}) do
-      1172
-    end
-    assert_equal 1172, value, 'should return the contents of the block'
-  end
-
-  def test_trace_execution_scoped_does_not_swallow_errors
-    assert_raises(RuntimeError) do
-      trace_execution_scoped(['metric', 'array'], {}) do
-        raise 'raising a test error'
-      end
-    end
-  end
-
-  private
-
-  def mocked_object(name)
-    object = mock(name)
-    self.stubs(name).returns(object)
-    object
-  end
-
-  def mocked_control
-    mocked_object('control')
-  end
-end

data/test/new_relic/agent/method_tracer_test.rb

@@ -1,480 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-require 'new_relic/agent/mock_scope_listener'
-
-class Module
-  def method_traced?(method_name, metric_name)
-    traced_method_prefix = _traced_method_name(method_name, metric_name)
-
-    method_defined? traced_method_prefix
-  end
-end
-
-class Insider
-  def initialize(stats_engine)
-    @stats_engine = stats_engine
-  end
-  def catcher(level=0)
-    thrower(level) if level>0
-  end
-  def thrower(level)
-    if level == 0
-      # don't use a real sampler because we can't instantiate one
-      # NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
-      begin
-        fail "This should not have worked."
-      rescue
-      end
-    else
-      thrower(level-1)
-    end
-  end
-end
-
-module NewRelic
-  module Agent
-    extend self
-    def module_method_to_be_traced (x, testcase)
-      testcase.assert_equal 'x',  x
-    end
-  end
-end
-
-module TestModuleWithLog
-  extend self
-  def other_method
-    #just here to be traced
-    log "12345"
-  end
-
-  def log( msg )
-    msg
-  end
-  include NewRelic::Agent::MethodTracer
-  add_method_tracer :other_method, 'Custom/foo/bar'
-end
-
-class MyClass
-  def self.class_method
-  end
-
-  class << self
-    include NewRelic::Agent::MethodTracer
-    add_method_tracer :class_method
-  end
-end
-
-class NewRelic::Agent::MethodTracerTest < Minitest::Test
-  attr_reader :stats_engine
-
-  def setup
-    NewRelic::Agent::TransactionState.tl_clear_for_testing
-
-    NewRelic::Agent.manual_start
-    @stats_engine = NewRelic::Agent.instance.stats_engine
-    @stats_engine.clear_stats
-    @scope_listener = NewRelic::Agent::MockScopeListener.new
-    @old_sampler = NewRelic::Agent.instance.transaction_sampler
-    NewRelic::Agent.instance.stubs(:transaction_sampler).returns(@scope_listener)
-    @metric_name ||= nil
-
-    freeze_time
-
-    super
-  end
-
-  def teardown
-    @stats_engine.clear_stats
-    begin
-      self.class.remove_method_tracer :method_to_be_traced, @metric_name if @metric_name
-    rescue RuntimeError
-      # ignore 'no tracer' errors from remove method tracer
-    end
-
-    @metric_name = nil
-    NewRelic::Agent.shutdown
-    super
-  end
-
-  def test_preserve_logging
-    assert_equal '12345', TestModuleWithLog.other_method
-  end
-
-  def test_record_metrics_does_not_raise_outside_transaction
-    state = NewRelic::Agent::TransactionState.tl_get
-    NewRelic::Agent::MethodTracerHelpers.record_metrics(state, 'a', ['b'], 12, 10, :metric => true)
-
-    expected = { :call_count => 1, :total_call_time => 12, :total_exclusive_time => 10 }
-    assert_metrics_recorded('a' => expected, 'b' => expected)
-  end
-
-  def test_trace_execution_scoped_records_metric_data
-    metric = "hello"
-
-    in_transaction do
-      self.class.trace_execution_scoped(metric) do
-        advance_time 0.05
-      end
-    end
-
-    assert_metrics_recorded metric => {:call_count => 1, :total_call_time => 0.05}
-  end
-
-  def test_trace_execution_scoped_with_no_metrics_skips_out
-    self.class.trace_execution_scoped([]) do
-      advance_time 0.05
-    end
-
-    assert_metrics_recorded_exclusive([])
-  end
-
-  def test_trace_execution_scoped_pushes_transaction_scope
-    in_transaction do
-      self.class.trace_execution_scoped('yeap') do
-        'ptoo'
-      end
-      assert_equal 'yeap',  @scope_listener.scopes.last
-    end
-  end
-
-  METRIC = "metric"
-  def test_add_method_tracer
-    @metric_name = METRIC
-    self.class.add_method_tracer :method_to_be_traced, METRIC
-    in_transaction do
-      method_to_be_traced 1,2,3,true,METRIC
-
-      assert_equal METRIC, @scope_listener.scopes.last
-    end
-
-    begin
-      self.class.remove_method_tracer :method_to_be_traced, METRIC
-    rescue RuntimeError
-      # ignore 'no tracer' errors from remove method tracer
-    end
-
-    assert_metrics_recorded METRIC => {:call_count => 1, :total_call_time => 0.05}
-  end
-
-  def test_add_method_tracer__default
-    self.class.add_method_tracer :simple_method
-
-    in_transaction do
-      simple_method
-    end
-
-    metric = "Custom/#{self.class.name}/simple_method"
-    assert_metrics_recorded metric => {:call_count => 1}
-  end
-
-  def test_add_class_method_tracer
-    in_transaction do
-      MyClass.class_method
-    end
-
-    metric = "Custom/MyClass/Class/class_method"
-    assert_metrics_recorded metric => {:call_count => 1}
-  end
-
-  def test_add_anonymous_class_method_tracer
-    cls = Class.new do
-      def instance_method; end
-      include NewRelic::Agent::MethodTracer
-      add_method_tracer :instance_method
-    end
-
-    in_transaction do
-      cls.new.instance_method
-    end
-
-    metric = "Custom/AnonymousClass/instance_method"
-    assert_metrics_recorded metric => {:call_count => 1}
-  end
-
-  def test_add_method_tracer__reentry
-    self.class.add_method_tracer :simple_method
-    self.class.add_method_tracer :simple_method
-    self.class.add_method_tracer :simple_method
-
-    in_transaction do
-      simple_method
-    end
-
-    metric = "Custom/#{self.class.name}/simple_method"
-    assert_metrics_recorded metric => {:call_count => 1}
-  end
-
-  def test_method_traced?
-    assert !self.class.method_traced?(:method_to_be_traced, METRIC)
-    self.class.add_method_tracer :method_to_be_traced, METRIC
-    assert self.class.method_traced?(:method_to_be_traced, METRIC)
-    begin
-      self.class.remove_method_tracer :method_to_be_traced, METRIC
-    rescue RuntimeError
-      # ignore 'no tracer' errors from remove method tracer
-    end
-  end
-
-  def test_tt_only
-    assert @scope_listener.scopes.empty?
-
-    self.class.add_method_tracer :method_c1, "c1", :push_scope => true
-    self.class.add_method_tracer :method_c2, "c2", :metric => false
-    self.class.add_method_tracer :method_c3, "c3", :push_scope => false
-
-    in_transaction do
-      method_c1
-      assert_equal ['c2', 'c1'], @scope_listener.scopes
-    end
-
-    assert_metrics_recorded(['c1', 'c3'])
-    assert_metrics_not_recorded('c2')
-  end
-
-  def test_nested_scope_tracer
-    Insider.add_method_tracer :catcher, "catcher", :push_scope => true
-    Insider.add_method_tracer :thrower, "thrower", :push_scope => true
-
-    # This expects to use the real transaction sampler, so stub it back
-    NewRelic::Agent.instance.stubs(:transaction_sampler).returns(@old_sampler)
-
-    mock = Insider.new(@stats_engine)
-
-    in_transaction do
-      mock.catcher(0)
-      mock.catcher(5)
-    end
-
-    assert_metrics_recorded({
-      "catcher" => {:call_count => 2},
-      "thrower" => {:call_count => 6}
-    })
-
-    sample = @old_sampler.harvest!
-    refute_nil sample
-  end
-
-  def test_add_same_tracer_twice
-    @metric_name = METRIC
-    self.class.add_method_tracer :method_to_be_traced, METRIC
-    self.class.add_method_tracer :method_to_be_traced, METRIC
-
-    in_transaction do
-      method_to_be_traced 1,2,3,true,METRIC
-      assert_equal METRIC, @scope_listener.scopes.last
-      assert(METRIC != @scope_listener.scopes[-2],
-           'duplicate scope detected when redundant tracer is present')
-    end
-
-    begin
-      self.class.remove_method_tracer :method_to_be_traced, METRIC
-    rescue RuntimeError
-      # ignore 'no tracer' errors from remove method tracer
-    end
-
-    assert_metrics_recorded METRIC => {:call_count => 1, :total_call_time => 0.05}
-  end
-
-  def test_add_tracer_with_dynamic_metric
-    metric_code = '#{args[0]}.#{args[1]}'
-    @metric_name = metric_code
-    expected_metric = "1.2"
-    self.class.add_method_tracer :method_to_be_traced, metric_code
-
-    in_transaction do
-      method_to_be_traced 1,2,3,true,expected_metric
-      assert_equal expected_metric, @scope_listener.scopes.last
-    end
-
-    begin
-      self.class.remove_method_tracer :method_to_be_traced, metric_code
-    rescue RuntimeError
-      # ignore 'no tracer' errors from remove method tracer
-    end
-
-    assert_metrics_recorded expected_metric => {:call_count => 1, :total_call_time => 0.05}
-  end
-
-  def test_trace_method_with_block
-    self.class.add_method_tracer :method_with_block, METRIC
-    in_transaction do
-      method_with_block(1,2,3,true,METRIC) do
-        advance_time 0.1
-      end
-
-      assert_equal METRIC, @scope_listener.scopes.last
-    end
-
-    assert_metrics_recorded METRIC => {:call_count => 1, :total_call_time => 0.15}
-  end
-
-  def test_trace_module_method
-    NewRelic::Agent.add_method_tracer :module_method_to_be_traced, '#{args[0]}'
-    NewRelic::Agent.module_method_to_be_traced "x", self
-    NewRelic::Agent.remove_method_tracer :module_method_to_be_traced, '#{args[0]}'
-  end
-
-  def test_remove
-    self.class.add_method_tracer :method_to_be_traced, METRIC
-    self.class.remove_method_tracer :method_to_be_traced, METRIC
-
-    method_to_be_traced 1,2,3,false,METRIC
-
-    assert_metrics_not_recorded METRIC
-  end
-
-  def self.static_method(x, testcase, is_traced)
-    testcase.assert_equal 'x',  x
-  end
-
-  def trace_trace_static_method
-    self.add_method_tracer :static_method, '#{args[0]}'
-    self.class.static_method "x", self, true
-    assert_equal 'x', @scope_listener.scopes.last
-    @scope_listener = NewRelic::Agent::MockScopeListener.new
-    self.remove_method_tracer :static_method, '#{args[0]}'
-    self.class.static_method "x", self, false
-    assert_nil @scope_listener.scopes.last
-  end
-
-  def test_multiple_metrics__scoped
-    metrics = %w[first second third]
-    in_transaction do
-      self.class.trace_execution_scoped metrics do
-        advance_time 0.05
-      end
-    end
-
-
-    assert_metrics_recorded({
-      'first' => {:call_count => 1, :total_call_time => 0.05},
-      'second' => {:call_count => 1, :total_call_time => 0.05},
-      'third' => {:call_count => 1, :total_call_time => 0.05}
-    })
-  end
-
-  def test_multiple_metrics__unscoped
-    metrics = %w[first second third]
-    self.class.trace_execution_unscoped metrics do
-      advance_time 0.05
-    end
-
-    assert_metrics_recorded({
-      'first' => {:call_count => 1, :total_call_time => 0.05},
-      'second' => {:call_count => 1, :total_call_time => 0.05},
-      'third' => {:call_count => 1, :total_call_time => 0.05}
-    })
-    assert @scope_listener.scopes.empty?
-  end
-
-  def test_exception
-    begin
-      metric = "hey"
-      in_transaction do
-        self.class.trace_execution_scoped(metric) do
-          raise StandardError.new
-        end
-        # make sure the scope gets popped
-        assert_equal metric, @scope_listener.scopes.last
-      end
-
-      assert false # should never get here
-    rescue StandardError
-    end
-
-    assert_metrics_recorded metric => {:call_count => 1}
-  end
-
-  def test_add_multiple_tracers
-    in_transaction do
-      self.class.add_method_tracer :method_to_be_traced, 'XX', :push_scope => false
-      method_to_be_traced 1,2,3,true,nil
-      self.class.add_method_tracer :method_to_be_traced, 'YY'
-      method_to_be_traced 1,2,3,true,'YY'
-      self.class.remove_method_tracer :method_to_be_traced, 'YY'
-      method_to_be_traced 1,2,3,true,nil
-      self.class.remove_method_tracer :method_to_be_traced, 'XX'
-      method_to_be_traced 1,2,3,false,'XX'
-      assert_equal ['YY'], @scope_listener.scopes
-    end
-  end
-
-  def test_add_method_tracer_module_double_inclusion
-    mod = Module.new { def traced_method; end }
-    cls = Class.new { include mod }
-
-    mod.module_eval do
-      include NewRelic::Agent::MethodTracer
-      add_method_tracer :traced_method
-    end
-
-    cls.new.traced_method
-  end
-
-  # This test validates that including the MethodTracer module does not pollute
-  # the host class with any additional helper methods that are not part of the
-  # official public API.
-  def test_only_adds_methods_to_host_that_are_part_of_public_api
-    host_class  = Class.new { include ::NewRelic::Agent::MethodTracer }
-    plain_class = Class.new
-
-    host_instance_methods  = host_class.new.methods
-    plain_instance_methods = plain_class.new.methods
-
-    added_methods = host_instance_methods - plain_instance_methods
-
-    public_api_methods = [
-      'trace_execution_unscoped',
-      'trace_execution_scoped'
-    ]
-
-    assert_equal(public_api_methods.sort, added_methods.map(&:to_s).sort)
-  end
-
-  def trace_no_push_scope
-    self.class.add_method_tracer :method_to_be_traced, 'X', :push_scope => false
-    method_to_be_traced 1,2,3,true,nil
-    self.class.remove_method_tracer :method_to_be_traced, 'X'
-    method_to_be_traced 1,2,3,false,'X'
-
-    assert_nil @scope_listener.scopes
-  end
-
-  def check_time(t1, t2)
-    assert_in_delta t2, t1, 0.001
-  end
-
-  # =======================================================
-  # test methods to be traced
-  def method_to_be_traced(x, y, z, is_traced, expected_metric)
-    advance_time 0.05
-    assert x == 1
-    assert y == 2
-    assert z == 3
-  end
-
-  def method_with_block(x, y, z, is_traced, expected_metric, &block)
-    advance_time 0.05
-    assert x == 1
-    assert y == 2
-    assert z == 3
-    yield
-  end
-
-  def method_c1
-    method_c2
-  end
-
-  def method_c2
-    method_c3
-  end
-
-  def method_c3
-  end
-
-  def simple_method
-  end
-end