ruby-prof 1.4.3 → 1.6.3

data/test/alias_test.rb

@@ -15,112 +15,103 @@ class AliasTest < TestCase
     end
   end
 
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  # This test only correct works on Ruby 2.5 and higher because - see:
-  # https://bugs.ruby-lang.org/issues/12747
-  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
-    def test_alias
-      result = RubyProf.profile do
-        TestMe.new.some_method
-      end
-
-      methods = result.threads.first.methods
-      assert_equal(6, methods.count)
-
-      # Method 0
-      method = methods[0]
-      assert_equal('AliasTest#test_alias', method.full_name)
-      assert_equal(28, method.line)
-      refute(method.recursive?)
-
-      assert_equal(0, method.call_trees.callers.count)
-
-      assert_equal(2, method.call_trees.callees.count)
-      call_tree = method.call_trees.callees[0]
-      assert_equal('Class#new', call_tree.target.full_name)
-      assert_equal(28, call_tree.line)
-
-      call_tree = method.call_trees.callees[1]
-      assert_equal('AliasTest::TestMe#some_method', call_tree.target.full_name)
-      assert_equal(28, call_tree.line)
-
-      # Method 1
-      method = methods[1]
-      assert_equal('Class#new', method.full_name)
-      assert_equal(0, method.line)
-      refute(method.recursive?)
-
-      assert_equal(1, method.call_trees.callers.count)
-      call_tree = method.call_trees.callers[0]
-      assert_equal('AliasTest#test_alias', call_tree.parent.target.full_name)
-      assert_equal(28, call_tree.line)
-
-      assert_equal(1, method.call_trees.callees.count)
-      call_tree = method.call_trees.callees[0]
-      assert_equal('BasicObject#initialize', call_tree.target.full_name)
-      assert_equal(0, call_tree.line)
-
-      # Method 2
-      method = methods[2]
-      assert_equal('BasicObject#initialize', method.full_name)
-      assert_equal(0, method.line)
-      refute(method.recursive?)
-
-      assert_equal(1, method.call_trees.callers.count)
-      call_tree = method.call_trees.callers[0]
-      assert_equal('Class#new', call_tree.parent.target.full_name)
-      assert_equal(0, call_tree.line)
-
-      assert_equal(0, method.call_trees.callees.count)
-
-      # Method 3
-      method = methods[3]
-      assert_equal('AliasTest::TestMe#some_method', method.full_name)
-      assert_equal(13, method.line)
-      refute(method.recursive?)
-
-      assert_equal(1, method.call_trees.callers.count)
-      call_tree = method.call_trees.callers[0]
-      assert_equal('AliasTest#test_alias', call_tree.parent.target.full_name)
-      assert_equal(28, call_tree.line)
-
-      assert_equal(1, method.call_trees.callees.count)
-      call_tree = method.call_trees.callees[0]
-      assert_equal('AliasTest::TestMe#some_method_original', call_tree.target.full_name)
-      assert_equal(14, call_tree.line)
-
-      # Method 4
-      method = methods[4]
-      assert_equal('AliasTest::TestMe#some_method_original', method.full_name)
-      assert_equal(8, method.line)
-      refute(method.recursive?)
-
-      assert_equal(1, method.call_trees.callers.count)
-      call_tree = method.call_trees.callers[0]
-      assert_equal('AliasTest::TestMe#some_method', call_tree.parent.target.full_name)
-      assert_equal(14, call_tree.line)
-
-      assert_equal(1, method.call_trees.callees.count)
-      call_tree = method.call_trees.callees[0]
-      assert_equal('Kernel#sleep', call_tree.target.full_name)
-      assert_equal(9, call_tree.line)
-
-      # Method 5
-      method = methods[5]
-      assert_equal('Kernel#sleep', method.full_name)
-      assert_equal(0, method.line)
-      refute(method.recursive?)
-
-      assert_equal(1, method.call_trees.callers.count)
-      call_tree = method.call_trees.callers[0]
-      assert_equal('AliasTest::TestMe#some_method_original', call_tree.parent.target.full_name)
-      assert_equal(9, call_tree.line)
-
-      assert_equal(0, method.call_trees.callees.count)
+  def test_alias
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      TestMe.new.some_method
     end
+
+    methods = result.threads.first.methods
+    assert_equal(6, methods.count)
+
+    # Method 0
+    method = methods[0]
+    assert_equal('AliasTest#test_alias', method.full_name)
+    assert_equal(20, method.line)
+    refute(method.recursive?)
+
+    assert_equal(0, method.call_trees.callers.count)
+
+    assert_equal(2, method.call_trees.callees.count)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Class#new', call_tree.target.full_name)
+    assert_equal(20, call_tree.line)
+
+    call_tree = method.call_trees.callees[1]
+    assert_equal('AliasTest::TestMe#some_method', call_tree.target.full_name)
+    assert_equal(20, call_tree.line)
+
+    # Method 1
+    method = methods[1]
+    assert_equal('Class#new', method.full_name)
+    assert_equal(0, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('AliasTest#test_alias', call_tree.parent.target.full_name)
+    assert_equal(20, call_tree.line)
+
+    assert_equal(1, method.call_trees.callees.count)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('BasicObject#initialize', call_tree.target.full_name)
+    assert_equal(0, call_tree.line)
+
+    # Method 2
+    method = methods[2]
+    assert_equal('BasicObject#initialize', method.full_name)
+    assert_equal(0, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('Class#new', call_tree.parent.target.full_name)
+    assert_equal(0, call_tree.line)
+
+    assert_equal(0, method.call_trees.callees.count)
+
+    # Method 3
+    method = methods[3]
+    assert_equal('AliasTest::TestMe#some_method', method.full_name)
+    assert_equal(13, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('AliasTest#test_alias', call_tree.parent.target.full_name)
+    assert_equal(20, call_tree.line)
+
+    assert_equal(1, method.call_trees.callees.count)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('AliasTest::TestMe#some_method_original', call_tree.target.full_name)
+    assert_equal(14, call_tree.line)
+
+    # Method 4
+    method = methods[4]
+    assert_equal('AliasTest::TestMe#some_method_original', method.full_name)
+    assert_equal(8, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('AliasTest::TestMe#some_method', call_tree.parent.target.full_name)
+    assert_equal(14, call_tree.line)
+
+    assert_equal(1, method.call_trees.callees.count)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Kernel#sleep', call_tree.target.full_name)
+    assert_equal(9, call_tree.line)
+
+    # Method 5
+    method = methods[5]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(0, method.line)
+    refute(method.recursive?)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('AliasTest::TestMe#some_method_original', call_tree.parent.target.full_name)
+    assert_equal(9, call_tree.line)
+
+    assert_equal(0, method.call_trees.callees.count)
   end
 end

data/test/call_tree_builder.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', __FILE__)
+require 'base64'
+
+# Create a DummyClass with methods so we can create call trees in the test_merge method below
+class DummyClass
+  %i[root a b aa ab ba bb].each do |method_name|
+    define_method(method_name) do
+    end
+  end
+end
+
+def create_call_tree(method_name)
+  method_info = RubyProf::MethodInfo.new(DummyClass, method_name)
+  RubyProf::CallTree.new(method_info)
+end
+
+def build_call_tree(tree_hash)
+  # tree_hash is a hash keyed on the parent method_name whose values are
+  # child methods. Example:
+  #
+  # tree_hash = {:root => [:a, :b],
+  #              :a => [:aa, :ab],
+  #              :b => [:bb]}
+  #
+  # Note this is a simplified structure for testing. It assumes methods
+  # are only called from one call_tree.
+
+  call_trees = Hash.new
+  tree_hash.each do |method_name, children|
+    parent = call_trees[method_name] ||= create_call_tree(method_name)
+    children.each do |child_method_name|
+      child = call_trees[child_method_name] ||= create_call_tree(child_method_name)
+      parent.add_child(child)
+    end
+  end
+
+  call_trees
+end
+
+def create_call_tree_1
+  #
+  #          root    
+  #        /     \   
+  #       a       b  
+  #     /  \       \ 
+  #   aa   ab      bb
+  #
+
+  # ------ Call Trees 1 -------------
+  tree_hash = {:root => [:a, :b],
+               :a => [:aa, :ab],
+               :b => [:bb]}
+
+  call_trees = build_call_tree(tree_hash)
+
+  # Setup times
+  call_trees[:aa].measurement.total_time = 1.5
+  call_trees[:aa].measurement.self_time = 1.5
+  call_trees[:ab].measurement.total_time = 2.2
+  call_trees[:ab].measurement.self_time = 2.2
+  call_trees[:a].measurement.total_time = 3.7
+
+  call_trees[:aa].target.measurement.total_time = 1.5
+  call_trees[:aa].target.measurement.self_time = 1.5
+  call_trees[:ab].target.measurement.total_time = 2.2
+  call_trees[:ab].target.measurement.self_time = 2.2
+  call_trees[:a].target.measurement.total_time = 3.7
+
+  call_trees[:bb].measurement.total_time = 4.3
+  call_trees[:bb].measurement.self_time = 4.3
+  call_trees[:b].measurement.total_time = 4.3
+
+  call_trees[:bb].target.measurement.total_time = 4.3
+  call_trees[:bb].target.measurement.self_time = 4.3
+  call_trees[:b].target.measurement.total_time = 4.3
+
+  call_trees[:root].measurement.total_time = 8.0
+  call_trees[:root].target.measurement.total_time = 8.0
+
+  call_trees[:root]
+end
+
+def create_call_tree_2
+  #
+  #      root
+  #    /     \
+  #   a       b
+  #    \     / \
+  #    ab  ba  bb
+
+  tree_hash = {:root => [:a, :b],
+               :a => [:ab],
+               :b => [:ba, :bb]}
+
+  call_trees = build_call_tree(tree_hash)
+
+  # Setup times
+  call_trees[:ab].measurement.total_time = 0.4
+  call_trees[:ab].measurement.self_time = 0.4
+  call_trees[:a].measurement.total_time = 0.4
+
+  call_trees[:ab].target.measurement.total_time = 0.4
+  call_trees[:ab].target.measurement.self_time = 0.4
+  call_trees[:a].target.measurement.total_time = 0.4
+
+  call_trees[:ba].measurement.total_time = 0.9
+  call_trees[:ba].measurement.self_time = 0.7
+  call_trees[:ba].measurement.wait_time = 0.2
+  call_trees[:bb].measurement.total_time = 2.3
+  call_trees[:bb].measurement.self_time = 2.3
+  call_trees[:b].measurement.total_time = 3.2
+
+  call_trees[:ba].target.measurement.total_time = 0.9
+  call_trees[:ba].target.measurement.self_time = 0.7
+  call_trees[:ba].target.measurement.wait_time = 0.2
+  call_trees[:bb].target.measurement.total_time = 2.3
+  call_trees[:bb].target.measurement.self_time = 2.3
+  call_trees[:b].target.measurement.total_time = 3.2
+
+  call_trees[:root].measurement.total_time = 3.6
+  call_trees[:root].target.measurement.total_time = 3.6
+
+  call_trees[:root]
+end

data/test/call_tree_test.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './call_tree_builder'
+require 'base64'
+
+class CallTreeTest < Minitest::Test
+  def test_initialize
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree = RubyProf::CallTree.new(method_info)
+    assert_equal(method_info, call_tree.target)
+  end
+
+  def test_measurement
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree = RubyProf::CallTree.new(method_info)
+
+    assert_equal(0, call_tree.total_time)
+    assert_equal(0, call_tree.self_time)
+    assert_equal(0, call_tree.wait_time)
+    assert_equal(0, call_tree.children_time)
+    assert_equal(0, call_tree.called)
+  end
+
+  def test_compare
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_1 = RubyProf::CallTree.new(method_info_1)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_2 = RubyProf::CallTree.new(method_info_2)
+    assert_equal(0, call_tree_1 <=> call_tree_2)
+
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
+    call_tree_1 = RubyProf::CallTree.new(method_info_1)
+    call_tree_1.measurement.total_time = 1
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_2 = RubyProf::CallTree.new(method_info_2)
+    assert_equal(1, call_tree_1 <=> call_tree_2)
+
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
+    call_tree_1 = RubyProf::CallTree.new(method_info_1)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_2 = RubyProf::CallTree.new(method_info_2)
+    call_tree_2.measurement.total_time = 1
+    assert_equal(-1, call_tree_1 <=> call_tree_2)
+  end
+
+  def test_to_s
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree = RubyProf::CallTree.new(method_info)
+    assert_equal("<RubyProf::CallTree - Base64#encode64>", call_tree.to_s)
+  end
+
+  def test_add_child
+    method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_parent = RubyProf::CallTree.new(method_info_parent)
+
+    method_info_child = RubyProf::MethodInfo.new(Array, :pack)
+    call_tree_child = RubyProf::CallTree.new(method_info_child)
+
+    assert_equal(0, call_tree_parent.children.size)
+    assert_nil(call_tree_child.parent)
+
+    result = call_tree_parent.add_child(call_tree_child)
+    assert_equal(1, call_tree_parent.children.size)
+    assert_equal(call_tree_child, call_tree_parent.children.first)
+    assert_equal(call_tree_child, result)
+    assert_equal(call_tree_parent, call_tree_child.parent)
+  end
+
+  def test_add_child_gc
+    GC.stress = true
+
+    begin
+      method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
+      call_tree_parent = RubyProf::CallTree.new(method_info_parent)
+
+      method_info_child = RubyProf::MethodInfo.new(Array, :pack)
+      call_tree_child = RubyProf::CallTree.new(method_info_child)
+      call_tree_parent.add_child(call_tree_child)
+
+      # Free the child first
+      call_tree_child = nil
+      GC.start
+
+      # Now free the parent and make sure it doesn't free the child a second time
+      call_tree_parent = nil
+      GC.start
+
+      assert(true)
+    ensure
+      GC.stress = false
+    end
+  end
+end

data/test/call_tree_visitor_test.rb

@@ -5,13 +5,8 @@ require File.expand_path('../test_helper', __FILE__)
 require_relative './measure_times'
 
 class CallTreeVisitorTest < TestCase
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
   def test_visit
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       RubyProf::C1.sleep_wait
     end
 

data/test/call_trees_test.rb

@@ -13,7 +13,7 @@ class CallTreesTest < TestCase
   end
 
   def test_call_infos
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile do
       some_method_1
     end
 
@@ -26,7 +26,7 @@ class CallTreesTest < TestCase
     call_trees = method.call_trees
     assert_empty(call_trees.callers)
     assert_equal(1, call_trees.callees.length)
-    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callees[0])
+    assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
     assert_equal('CallTreesTest#some_method_1', call_trees.callees[0].target.full_name)
 
     method = thread.methods[1]
@@ -34,10 +34,10 @@ class CallTreesTest < TestCase
 
     call_trees = method.call_trees
     assert_equal(1, call_trees.callers.length)
-    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callers[0])
+    assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
     assert_equal('CallTreesTest#test_call_infos', call_trees.callers[0].parent.target.full_name)
     assert_equal(1, call_trees.callees.length)
-    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callees[0])
+    assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
     assert_equal('CallTreesTest#some_method_2', call_trees.callees[0].target.full_name)
 
     method = thread.methods[2]
@@ -45,13 +45,13 @@ class CallTreesTest < TestCase
 
     call_trees = method.call_trees
     assert_equal(1, call_trees.callers.length)
-    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callers[0])
+    assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
     assert_equal('CallTreesTest#some_method_1', call_trees.callers[0].parent.target.full_name)
     assert_empty(call_trees.callees)
   end
 
   def test_gc
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile do
       some_method_1
     end
 

data/test/{basic_test.rb → compatibility_test.rb}

@@ -4,12 +4,18 @@
 require File.expand_path('../test_helper', __FILE__)
 require_relative './measure_times'
 
-class BasicTest < TestCase
+class CompatibilityTest < TestCase
   def setup
-    # Need to use wall time for this test due to the sleep calls
+    super
+    Gem::Deprecate.skip = true
     RubyProf::measure_mode = RubyProf::WALL_TIME
   end
 
+  def teardown
+    super
+    Gem::Deprecate.skip = false
+  end
+
   def test_running
     assert(!RubyProf.running?)
     RubyProf.start

data/test/duplicate_names_test.rb

@@ -3,18 +3,18 @@
 
 require File.expand_path('../test_helper', __FILE__)
 
-class DuplicateNames < TestCase
+class DuplicateNamesTest < TestCase
   def test_names
-    result = RubyProf::profile do
+    result = RubyProf::Profile.profile do
       str = %{module Foo; class Bar; def foo; end end end}
 
       eval str
       Foo::Bar.new.foo
-      DuplicateNames.class_eval {remove_const :Foo}
+      DuplicateNamesTest.class_eval {remove_const :Foo}
 
       eval str
       Foo::Bar.new.foo
-      DuplicateNames.class_eval {remove_const :Foo}
+      DuplicateNamesTest.class_eval {remove_const :Foo}
 
       eval str
       Foo::Bar.new.foo
@@ -24,7 +24,7 @@ class DuplicateNames < TestCase
     methods = result.threads.first.methods.sort.reverse
 
     methods = methods.select do |method|
-      method.full_name == 'DuplicateNames::Foo::Bar#foo'
+      method.full_name == 'DuplicateNamesTest::Foo::Bar#foo'
     end
 
     assert_equal(3, methods.length)

data/test/dynamic_method_test.rb

@@ -24,14 +24,9 @@ class DynamicMethodTest < TestCase
     end
   end
 
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
   def test_dynamic_method
     medley = FruitMedley.new
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       medley.apple
       medley.orange
       medley.banana
@@ -39,15 +34,29 @@ class DynamicMethodTest < TestCase
     end
 
     methods = result.threads.first.methods.sort.reverse
-    expected_method_names = %w(
-      DynamicMethodTest#test_dynamic_method
-      Kernel#sleep
-      DynamicMethodTest::FruitMedley#peach
-      DynamicMethodTest::FruitMedley#banana
-      DynamicMethodTest::FruitMedley#orange
-      DynamicMethodTest::FruitMedley#apple
-      Symbol#to_s
-    )
+
+    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
+      expected_method_names = %w(
+        DynamicMethodTest#test_dynamic_method
+        Kernel#sleep
+        DynamicMethodTest::FruitMedley#peach
+        DynamicMethodTest::FruitMedley#banana
+        DynamicMethodTest::FruitMedley#orange
+        DynamicMethodTest::FruitMedley#apple
+        Symbol#to_s
+      )
+    else
+      expected_method_names = %w(
+        DynamicMethodTest#test_dynamic_method
+        Kernel#sleep
+        DynamicMethodTest::FruitMedley#peach
+        DynamicMethodTest::FruitMedley#banana
+        DynamicMethodTest::FruitMedley#orange
+        DynamicMethodTest::FruitMedley#apple
+        Integer#==
+      )
+    end
+
     assert_equal expected_method_names.join("\n"), methods.map(&:full_name).join("\n")
   end
 end

data/test/enumerable_test.rb

@@ -8,7 +8,7 @@ require File.expand_path('../test_helper', __FILE__)
 
 class EnumerableTest < TestCase
   def test_enumerable
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile do
       3.times {  [1,2,3].any? {|n| n} }
     end
     methods = if RUBY_VERSION >= "2.2.0"

data/test/exceptions_test.rb

@@ -6,7 +6,7 @@ require File.expand_path('../test_helper', __FILE__)
 class ExceptionsTest < TestCase
   def test_profile
     result = begin
-      RubyProf.profile do
+      RubyProf::Profile.profile do
         raise(RuntimeError, 'Test error')
       end
     rescue
@@ -16,7 +16,7 @@ class ExceptionsTest < TestCase
 
   def test_profile_allows_exceptions
     assert_raises(RuntimeError) do
-      RubyProf.profile(:allow_exceptions => true) do
+      RubyProf::Profile.profile(:allow_exceptions => true) do
         raise(RuntimeError, 'Test error')
       end
     end

data/test/exclude_methods_test.rb

@@ -34,14 +34,9 @@ class ExcludeMethodsClass
 end
 
 class ExcludeMethodsTest < TestCase
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
   def test_methods_can_be_profiled
     obj = ExcludeMethodsClass.new
-    prf = RubyProf::Profile.new
+    prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
 
     result = prf.profile {obj.a}
     methods = result.threads.first.methods.sort.reverse
@@ -102,7 +97,7 @@ class ExcludeMethodsTest < TestCase
 
   def test_exclude_common_methods1
     obj = ExcludeMethodsClass.new
-    prf = RubyProf::Profile.new
+    prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
 
     prf.exclude_common_methods!
 
@@ -124,7 +119,7 @@ class ExcludeMethodsTest < TestCase
   def test_exclude_common_methods2
     obj = ExcludeMethodsClass.new
 
-    result = RubyProf.profile(exclude_common: true) { 5.times {obj.a} }
+    result = RubyProf::Profile.profile(exclude_common: true) { 5.times {obj.a} }
     methods = result.threads.first.methods.sort.reverse
 
     assert_equal(9, methods.count)

data/test/exclude_threads_test.rb

@@ -26,15 +26,10 @@ class ExcludeThreadsTest < TestCase
       thread2_proc
     end
 
-    # exclude_threads already includes the minitest thread pool
-    RubyProf.exclude_threads += [ thread2 ]
-
-    RubyProf.start
-
-    thread1.join
-    thread2.join
-
-    result = RubyProf.stop
+    result = RubyProf::Profile.profile(exclude_threads: [thread2]) do
+      thread1.join
+      thread2.join
+    end
 
     assert_equal(2, result.threads.length)