ruby-prof 1.4.3 → 1.4.4

data/test/measure_wall_time_test.rb

@@ -395,21 +395,12 @@ class MeasureWallTimeTest < TestCase
     assert_in_delta(0.3, methods[2].self_time, 0.03)
     assert_in_delta(0.0, methods[2].children_time, 0.03)
 
-    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.7')
-      method = methods.detect {|a_method| a_method.full_name == '<Class::RubyProf::C3>#instance'}
-      assert_equal('<Class::RubyProf::C3>#instance', method.full_name)
-      assert_in_delta(0.0, method.total_time, 0.03)
-      assert_in_delta(0.0, method.wait_time, 0.03)
-      assert_in_delta(0.0, method.self_time, 0.03)
-      assert_in_delta(0.0, method.children_time, 0.03)
-    else
-      method = methods.detect {|a_method| a_method.full_name == 'Singleton::SingletonClassMethods#instance'}
-      assert_equal('Singleton::SingletonClassMethods#instance', method.full_name)
-      assert_in_delta(0.0, method.total_time, 0.03)
-      assert_in_delta(0.0, method.wait_time, 0.03)
-      assert_in_delta(0.0, method.self_time, 0.03)
-      assert_in_delta(0.0, method.children_time, 0.03)
-    end
+    method = methods.detect {|a_method| a_method.full_name == 'Singleton::SingletonClassMethods#instance'}
+    assert_equal('Singleton::SingletonClassMethods#instance', method.full_name)
+    assert_in_delta(0.0, method.total_time, 0.03)
+    assert_in_delta(0.0, method.wait_time, 0.03)
+    assert_in_delta(0.0, method.self_time, 0.03)
+    assert_in_delta(0.0, method.children_time, 0.03)
 
     method = methods.detect {|a_method| a_method.full_name == 'Thread::Mutex#synchronize'}
     assert_equal('Thread::Mutex#synchronize', method.full_name)

data/test/printer_call_tree_test.rb

@@ -19,8 +19,8 @@ class PrinterCallTreeTest < TestCase
   def test_call_tree_string
     printer = RubyProf::CallTreePrinter.new(@result)
 
-    printer.print(:profile => "lolcat", :path => Dir.tmpdir)
-    main_output_file_name = File.join(Dir.tmpdir, "lolcat.callgrind.out.#{$$}")
+    printer.print(:path => Dir.tmpdir)
+    main_output_file_name = File.join(Dir.tmpdir, "callgrind.out.#{$$}")
     assert(File.exist?(main_output_file_name))
     output = File.read(main_output_file_name)
     assert_match(/fn=Object::find_primes/i, output)

data/test/recursive_test.rb

@@ -46,64 +46,158 @@ class RecursiveTest < TestCase
     end
 
     methods = result.threads.first.methods.sort.reverse
-    assert_equal(3, methods.length)
-
-    # Method 0: RecursiveTest#test_simple
-    method = methods[0]
-    assert_equal('RecursiveTest#test_simple', method.full_name)
-    assert_equal(1, method.called)
-    refute(method.recursive?)
-    assert_in_delta(2, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(2, method.children_time, 0.1)
-
-    assert_equal(0, method.call_trees.callers.length)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
-
-    # Method 1: SimpleRecursion#simple
-    method = methods[1]
-    assert_equal('SimpleRecursion#simple', method.full_name)
-    assert_equal(2, method.called)
-    assert(method.recursive?)
-    assert_in_delta(2, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.1)
-    assert_in_delta(2, method.children_time, 0.1)
-
-    assert_equal(2, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('RecursiveTest#test_simple', call_tree.parent.target.full_name)
-
-    call_tree = method.call_trees.callers[1]
-    assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
-
-    assert_equal(2, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('Kernel#sleep', call_tree.target.full_name)
-
-    call_tree = method.call_trees.callees[1]
-    assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
-
-    # Method 2: Kernel#sleep
-    method = methods[2]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(2, method.called)
-    refute(method.recursive?)
-    assert_in_delta(2, method.total_time, 0.1)
-    assert_in_delta(2, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.1)
-    assert_in_delta(0, method.children_time, 0.1)
-
-    assert_equal(1, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
-    assert_equal(0, method.call_trees.callees.length)
-
-    assert_equal(0, method.call_trees.callees.length)
+
+    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
+      assert_equal(3, methods.length)
+
+      # Method 0: RecursiveTest#test_simple
+      method = methods[0]
+      assert_equal('RecursiveTest#test_simple', method.full_name)
+      assert_equal(1, method.called)
+      refute(method.recursive?)
+      assert_in_delta(2, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(2, method.children_time, 0.1)
+
+      assert_equal(0, method.call_trees.callers.length)
+
+      assert_equal(1, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
+
+      # Method 1: SimpleRecursion#simple
+      method = methods[1]
+      assert_equal('SimpleRecursion#simple', method.full_name)
+      assert_equal(2, method.called)
+      assert(method.recursive?)
+      assert_in_delta(2, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.1)
+      assert_in_delta(2, method.children_time, 0.1)
+
+      assert_equal(2, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('RecursiveTest#test_simple', call_tree.parent.target.full_name)
+
+      call_tree = method.call_trees.callers[1]
+      assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
+
+      assert_equal(2, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Kernel#sleep', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[1]
+      assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
+
+      # Method 2: Kernel#sleep
+      method = methods[2]
+      assert_equal('Kernel#sleep', method.full_name)
+      assert_equal(2, method.called)
+      refute(method.recursive?)
+
+      assert_in_delta(2, method.total_time, 0.1)
+      assert_in_delta(2, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.1)
+      assert_in_delta(0, method.children_time, 0.1)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
+      assert_equal(0, method.call_trees.callees.length)
+
+      assert_equal(0, method.call_trees.callees.length)
+    else
+      assert_equal(5, methods.length)
+
+      # Method 0: RecursiveTest#test_simple
+      method = methods[0]
+      assert_equal('RecursiveTest#test_simple', method.full_name)
+      assert_equal(1, method.called)
+      refute(method.recursive?)
+      assert_in_delta(2, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(2, method.children_time, 0.1)
+
+      assert_equal(0, method.call_trees.callers.length)
+
+      assert_equal(1, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
+
+      # Method 1: SimpleRecursion#simple
+      method = methods[1]
+      assert_equal('SimpleRecursion#simple', method.full_name)
+      assert_equal(2, method.called)
+      assert(method.recursive?)
+      assert_in_delta(2, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.1)
+      assert_in_delta(2, method.children_time, 0.1)
+
+      assert_equal(2, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('RecursiveTest#test_simple', call_tree.parent.target.full_name)
+
+      call_tree = method.call_trees.callers[1]
+      assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
+
+      assert_equal(4, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Kernel#sleep', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[1]
+      assert_equal('Integer#==', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[2]
+      assert_equal('Integer#-', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[3]
+      assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
+
+      # Method 2: Kernel#sleep
+      method = methods[2]
+      assert_equal('Kernel#sleep', method.full_name)
+      assert_equal(2, method.called)
+      refute(method.recursive?)
+
+      assert_in_delta(2, method.total_time, 0.1)
+      assert_in_delta(2, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.1)
+      assert_in_delta(0, method.children_time, 0.1)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
+      assert_equal(0, method.call_trees.callees.length)
+
+      assert_equal(0, method.call_trees.callees.length)
+
+      # Method 3
+      method = methods[3]
+      assert_equal('Integer#==', method.full_name)
+      assert_equal(2, method.called)
+      refute(method.recursive?)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
+
+      assert_equal(0, method.call_trees.callees.length)
+
+      # Method 4
+      method = methods[4]
+      assert_equal('Integer#-', method.full_name)
+      assert_equal(1, method.called)
+      refute(method.recursive?)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
+
+      assert_equal(0, method.call_trees.callees.length)
+    end
   end
 
   def test_cycle
@@ -112,95 +206,225 @@ class RecursiveTest < TestCase
     end
 
     methods = result.threads.first.methods.sort.reverse
-    assert_equal(5, methods.length)
-
-    method = methods[0]
-    assert_equal('RecursiveTest#test_cycle', method.full_name)
-    assert_equal(1, method.called)
-    refute(method.recursive?)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(5, method.children_time, 0.1)
-
-    assert_equal(0, method.call_trees.callers.length)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('SimpleRecursion#render', call_tree.target.full_name)
-
-    method = methods[1]
-    assert_equal('SimpleRecursion#render', method.full_name)
-    assert_equal(1, method.called)
-    refute(method.recursive?)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(5, method.children_time, 0.1)
-
-    assert_equal(1, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('RecursiveTest#test_cycle', call_tree.parent.target.full_name)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('Integer#times', call_tree.target.full_name)
-
-    method = methods[2]
-    assert_equal('Integer#times', method.full_name)
-    assert_equal(2, method.called)
-    assert(method.recursive?)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.1)
-    assert_in_delta(5, method.children_time, 0.1)
-
-    assert_equal(2, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('SimpleRecursion#render', call_tree.parent.target.full_name)
-
-    call_tree = method.call_trees.callers[1]
-    assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
-
-    method = methods[3]
-    assert_equal('SimpleRecursion#render_partial', method.full_name)
-    assert_equal(5, method.called)
-    assert(method.recursive?)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(5, method.children_time, 0.05)
-
-    assert_equal(2, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('Integer#times', call_tree.parent.target.full_name)
-
-    call_tree = method.call_trees.callers[1]
-    assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
-
-    assert_equal(3, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('Kernel#sleep', call_tree.target.full_name)
-
-    call_tree = method.call_trees.callees[1]
-    assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
-
-    call_tree = method.call_trees.callees[2]
-    assert_equal('Integer#times', call_tree.target.full_name)
-
-    method = methods[4]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(5, method.called)
-    refute(method.recursive?)
-    assert_in_delta(5, method.total_time, 0.1)
-    assert_in_delta(5, method.self_time, 0.1)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
-
-    assert_equal(0, method.call_trees.callees.length)
+
+    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
+      assert_equal(5, methods.length)
+
+      # Method 0
+      method = methods[0]
+      assert_equal('RecursiveTest#test_cycle', method.full_name)
+      assert_equal(1, method.called)
+      refute(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(0, method.call_trees.callers.length)
+
+      assert_equal(1, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('SimpleRecursion#render', call_tree.target.full_name)
+
+      # Method 1
+      method = methods[1]
+      assert_equal('SimpleRecursion#render', method.full_name)
+      assert_equal(1, method.called)
+      refute(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('RecursiveTest#test_cycle', call_tree.parent.target.full_name)
+
+      assert_equal(1, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Integer#times', call_tree.target.full_name)
+
+      # Method 2
+      method = methods[2]
+      assert_equal('Integer#times', method.full_name)
+      assert_equal(2, method.called)
+      assert(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.1)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(2, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#render', call_tree.parent.target.full_name)
+
+      call_tree = method.call_trees.callers[1]
+      assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+      assert_equal(1, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
+
+      # Method 3
+      method = methods[3]
+      assert_equal('SimpleRecursion#render_partial', method.full_name)
+      assert_equal(5, method.called)
+      assert(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(5, method.children_time, 0.05)
+
+      assert_equal(2, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('Integer#times', call_tree.parent.target.full_name)
+
+      call_tree = method.call_trees.callers[1]
+      assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+      assert_equal(3, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Kernel#sleep', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[1]
+      assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[2]
+      assert_equal('Integer#times', call_tree.target.full_name)
+
+      # Method 4
+      method = methods[4]
+      assert_equal('Kernel#sleep', method.full_name)
+      assert_equal(5, method.called)
+      refute(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(5, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+      assert_equal(0, method.call_trees.callees.length)
+    else
+      assert_equal(6, methods.length)
+
+      # Method 0
+      method = methods[0]
+      assert_equal('RecursiveTest#test_cycle', method.full_name)
+      assert_equal(1, method.called)
+      refute(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(0, method.call_trees.callers.length)
+
+      assert_equal(1, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('SimpleRecursion#render', call_tree.target.full_name)
+
+      # Method 1
+      method = methods[1]
+      assert_equal('SimpleRecursion#render', method.full_name)
+      assert_equal(1, method.called)
+      refute(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('RecursiveTest#test_cycle', call_tree.parent.target.full_name)
+
+      assert_equal(1, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Integer#times', call_tree.target.full_name)
+
+      # Method 2
+      method = methods[2]
+      assert_equal('Integer#times', method.full_name)
+      assert_equal(2, method.called)
+      assert(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.1)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(2, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#render', call_tree.parent.target.full_name)
+
+      call_tree = method.call_trees.callers[1]
+      assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+      assert_equal(2, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
+      call_tree = method.call_trees.callees[1]
+      assert_equal('Integer#+', call_tree.target.full_name)
+
+      # Method 3
+      method = methods[3]
+      assert_equal('SimpleRecursion#render_partial', method.full_name)
+      assert_equal(5, method.called)
+      assert(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(5, method.children_time, 0.05)
+
+      assert_equal(2, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('Integer#times', call_tree.parent.target.full_name)
+
+      call_tree = method.call_trees.callers[1]
+      assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+      assert_equal(3, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Kernel#sleep', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[1]
+      assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[2]
+      assert_equal('Integer#times', call_tree.target.full_name)
+
+      # Method 4
+      method = methods[4]
+      assert_equal('Kernel#sleep', method.full_name)
+      assert_equal(5, method.called)
+      refute(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(5, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+      assert_equal(0, method.call_trees.callees.length)
+
+      # Method 5
+      method = methods[5]
+      assert_equal('Integer#+', method.full_name)
+      assert_equal(2, method.called)
+      refute(method.recursive?)
+      assert_in_delta(0, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('Integer#times', call_tree.parent.target.full_name)
+
+      assert_equal(0, method.call_trees.callees.length)
+    end
   end
 end

data/test/test_helper.rb

@@ -1,17 +1,13 @@
 # encoding: UTF-8
 
 require 'bundler/setup'
-require 'minitest/autorun'
+require 'ruby-prof'
 
 # Disable minitest parallel tests. The problem is the thread switching will change test results
 # (self vs wait time)
-if Gem::Version.new(Minitest::VERSION) > Gem::Version.new('5.11.3')
-  ENV["MT_CPU"] = "0" # Newer versions minitest
-else
-  ENV["N"] = "0" # Older versions of minitest
-end
-
-require 'ruby-prof'
+ENV["MT_CPU"] = "0" # New versions of minitest
+ENV["N"] = "0" # Older versions of minitest
 
+require 'minitest/autorun'
 class TestCase < Minitest::Test
 end

data/test/unique_call_path_test.rb

@@ -79,8 +79,14 @@ class UniqueCallPathTest < TestCase
       array
     end
 
-    assert_equal(1, call_info_a.children.length)
-    assert_equal("UniqueCallPath#method_b", call_info_a.children.first.target.full_name)
+    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
+      assert_equal(1, call_info_a.children.length)
+      assert_equal("UniqueCallPath#method_b", call_info_a.children[0].target.full_name)
+    else
+      assert_equal(2, call_info_a.children.length)
+      assert_equal("Integer#==", call_info_a.children[0].target.full_name)
+      assert_equal("UniqueCallPath#method_b", call_info_a.children[1].target.full_name)
+    end
   end
 
   def test_unique_path
@@ -106,15 +112,25 @@ class UniqueCallPathTest < TestCase
       array
     end
 
-    assert_equal(1, call_info_a.children.length)
-    assert_equal(1, children_of_a.length)
-
     children_of_a = children_of_a.sort do |c1, c2|
       c1.target.full_name <=> c2.target.full_name
     end
 
-    assert_equal(1, children_of_a.length)
-    assert_equal(1, children_of_a[0].called)
-    assert_equal("UniqueCallPath#method_b", children_of_a[0].target.full_name)
+    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
+      assert_equal(1, call_info_a.children.length)
+      assert_equal(1, children_of_a.length)
+
+      assert_equal(1, children_of_a[0].called)
+      assert_equal("UniqueCallPath#method_b", children_of_a[0].target.full_name)
+    else
+      assert_equal(2, call_info_a.children.length)
+      assert_equal(2, children_of_a.length)
+
+      assert_equal(1, children_of_a[0].called)
+      assert_equal("Integer#==", children_of_a[0].target.full_name)
+
+      assert_equal(1, children_of_a[1].called)
+      assert_equal("UniqueCallPath#method_b", children_of_a[1].target.full_name)
+    end
   end
 end