ruby-prof 1.1.0-x64-mingw32 → 1.3.0-x64-mingw32

data/test/measure_process_time_test.rb

@@ -23,10 +23,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.0, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_class_methods_sleep", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
@@ -66,10 +62,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.0, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_class_methods_sleep_threaded", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -105,10 +97,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.last
     assert_in_delta(0.0, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_class_methods_sleep_threaded", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -146,10 +134,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.08, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_class_methods_busy", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
@@ -189,10 +173,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.1, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_class_methods_busy_threaded", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -228,10 +208,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.last
     assert_in_delta(0.1, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_class_methods_busy_threaded", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -269,10 +245,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.0, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_instance_methods_sleep", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(5, methods.length)
 
@@ -378,10 +350,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.0, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_instance_methods_sleep_threaded", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -417,10 +385,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.last
     assert_in_delta(0.0, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_instance_methods_sleep_threaded", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -472,10 +436,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.2, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_instance_methods_busy", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(5, methods.length)
 
@@ -581,10 +541,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.2, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_instance_methods_busy_threaded", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -620,10 +576,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.last
     assert_in_delta(0.2, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_instance_methods_busy_threaded", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -675,10 +627,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.0, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_module_methods_sleep", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
@@ -713,10 +661,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.3, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_module_methods_busy", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
@@ -751,10 +695,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.0, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_module_instance_methods_sleep", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(5, methods.length)
 
@@ -803,10 +743,6 @@ class MeasureProcessTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.3, thread.total_time, 0.05)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureProcessTimeTest#test_module_instance_methods_busy", root_methods.first.full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(5, methods.length)
 

data/test/measure_times.rb

@@ -1,4 +1,6 @@
 # Some classes used in measurement tests
+require 'singleton'
+
 module RubyProf
   class C1
     def C1.sleep_wait

data/test/measure_wall_time_test.rb

@@ -8,7 +8,6 @@ class MeasureWallTimeTest < TestCase
   def setup
     # Need to use wall time for this test due to the sleep calls
     RubyProf::measure_mode = RubyProf::WALL_TIME
-    GC.start
   end
 
   def test_mode
@@ -24,10 +23,6 @@ class MeasureWallTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.1, thread.total_time, 0.03)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureWallTimeTest#test_class_methods", root_methods[0].full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
@@ -63,10 +58,6 @@ class MeasureWallTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.1, thread.total_time, 0.03)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureWallTimeTest#test_class_methods_threaded", root_methods[0].full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -98,10 +89,6 @@ class MeasureWallTimeTest < TestCase
     thread = result.threads.last
     assert_in_delta(0.1, thread.total_time, 0.03)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureWallTimeTest#test_class_methods_threaded", root_methods[0].full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -136,10 +123,6 @@ class MeasureWallTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.2, thread.total_time, 0.03)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureWallTimeTest#test_instance_methods", root_methods[0].full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(5, methods.length)
     names = methods.map(&:full_name)
@@ -244,10 +227,6 @@ class MeasureWallTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.2, thread.total_time, 0.03)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureWallTimeTest#test_instance_methods_threaded", root_methods[0].full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -279,10 +258,6 @@ class MeasureWallTimeTest < TestCase
     thread = result.threads.last
     assert_in_delta(0.2, thread.total_time, 0.03)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureWallTimeTest#test_instance_methods_threaded", root_methods[0].full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
@@ -329,10 +304,6 @@ class MeasureWallTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.3, thread.total_time, 0.03)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureWallTimeTest#test_module_methods", root_methods[0].full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
@@ -362,10 +333,6 @@ class MeasureWallTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.3, thread.total_time, 0.03)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureWallTimeTest#test_module_instance_methods", root_methods[0].full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(5, methods.length)
     names = methods.map(&:full_name)
@@ -407,10 +374,6 @@ class MeasureWallTimeTest < TestCase
     thread = result.threads.first
     assert_in_delta(0.3, thread.total_time, 0.03)
 
-    root_methods = thread.root_methods
-    assert_equal(1, root_methods.count)
-    assert_equal("MeasureWallTimeTest#test_singleton_methods", root_methods[0].full_name)
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(7, methods.length)
 
@@ -432,28 +395,41 @@ 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)
 
-    assert_equal('<Class::RubyProf::C3>#instance', methods[3].full_name)
-    assert_in_delta(0.0, methods[3].total_time, 0.03)
-    assert_in_delta(0.0, methods[3].wait_time, 0.03)
-    assert_in_delta(0.0, methods[3].self_time, 0.03)
-    assert_in_delta(0.0, methods[3].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
 
-    assert_equal('Thread::Mutex#synchronize', methods[4].full_name)
-    assert_in_delta(0.0, methods[4].total_time, 0.03)
-    assert_in_delta(0.0, methods[4].wait_time, 0.03)
-    assert_in_delta(0.0, methods[4].self_time, 0.03)
-    assert_in_delta(0.0, methods[4].children_time, 0.03)
+    method = methods.detect {|a_method| a_method.full_name == 'Thread::Mutex#synchronize'}
+    assert_equal('Thread::Mutex#synchronize', 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 == 'Class#new'}
+    assert_equal('Class#new', 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)
 
-    assert_equal('Class#new', methods[5].full_name)
-    assert_in_delta(0.0, methods[5].total_time, 0.03)
-    assert_in_delta(0.0, methods[5].wait_time, 0.03)
-    assert_in_delta(0.0, methods[5].self_time, 0.03)
-    assert_in_delta(0.0, methods[5].children_time, 0.03)
-
-    assert_equal('BasicObject#initialize', methods[6].full_name)
-    assert_in_delta(0.0, methods[6].total_time, 0.03)
-    assert_in_delta(0.0, methods[6].wait_time, 0.03)
-    assert_in_delta(0.0, methods[6].self_time, 0.03)
-    assert_in_delta(0.0, methods[6].children_time, 0.03)
+    method = methods.detect {|a_method| a_method.full_name == 'BasicObject#initialize'}
+    assert_equal('BasicObject#initialize', 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
 end

data/test/pause_resume_test.rb

@@ -2,6 +2,7 @@
 # encoding: UTF-8
 
 require File.expand_path('../test_helper', __FILE__)
+require_relative 'measure_times'
 
 class PauseResumeTest < TestCase
   def setup
@@ -43,15 +44,15 @@ class PauseResumeTest < TestCase
     assert_equal('PauseResumeTest#test_pause_resume', methods[2].full_name)
 
     # Check times
-    assert_in_delta(0.2, methods[0].total_time, 0.02)
+    assert_in_delta(0.22, methods[0].total_time, 0.02)
     assert_in_delta(0, methods[0].wait_time, 0.02)
     assert_in_delta(0, methods[0].self_time, 0.02)
 
-    assert_in_delta(0.2, methods[1].total_time, 0.02)
+    assert_in_delta(0.22, methods[1].total_time, 0.02)
     assert_in_delta(0, methods[1].wait_time, 0.02)
-    assert_in_delta(0.2, methods[1].self_time, 0.02)
+    assert_in_delta(0.22, methods[1].self_time, 0.02)
 
-    assert_in_delta(0.2, methods[2].total_time, 0.02)
+    assert_in_delta(0.22, methods[2].total_time, 0.02)
     assert_in_delta(0, methods[2].wait_time, 0.02)
     assert_in_delta(0, methods[2].self_time, 0.02)
   end
@@ -70,9 +71,9 @@ class PauseResumeTest < TestCase
     method_1c
 
     result = profile.stop
-    assert_in_delta(0.6, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_1$/}[0].total_time, 0.05)
+    assert_in_delta(0.65, result.threads[0].methods.select {|m| m.full_name =~ /test_pause_resume_1$/}[0].total_time, 0.05)
   end
-  def method_1a; sleep 0.2 end
+  def method_1a; sleep 0.22 end
   def method_1b; sleep 1   end
   def method_1c; sleep 0.4 end
 
@@ -90,7 +91,7 @@ class PauseResumeTest < TestCase
     result = profile.stop
     assert_in_delta(0.6, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_2$/}[0].total_time, 0.05)
   end
-  def method_2a; sleep 0.2 end
+  def method_2a; sleep 0.22 end
   def method_2b(profile); sleep 0.5; profile.resume; sleep 0.4 end
 
   # pause in child frame, resume in parent
@@ -105,10 +106,18 @@ class PauseResumeTest < TestCase
     method_3b
 
     result = profile.stop
-    assert_in_delta(0.6, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_3$/}[0].total_time, 0.05)
+    assert_in_delta(0.65, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_3$/}[0].total_time, 0.05)
+  end
+
+  def method_3a(profile)
+    sleep 0.22
+    profile.pause
+    sleep 0.5
+  end
+
+  def method_3b
+    sleep 0.4
   end
-  def method_3a(profile); sleep 0.2; profile.pause; sleep 0.5 end
-  def method_3b; sleep 0.4 end
 
   def test_pause_seq
     profile = RubyProf::Profile.new

data/test/prime.rb

@@ -4,8 +4,6 @@
 #
 # Source from http://people.cs.uchicago.edu/~bomb154/154/maclabs/profilers-lab/
 
-require File.expand_path('../test_helper', __FILE__)
-
 def make_random_array(length, maxnum)
   result = Array.new(length)
   result.each_index do |i|
@@ -44,7 +42,7 @@ def find_largest(primes)
   largest
 end
 
-def run_primes(length=10, maxnum=1000)
+def run_primes(length=10, maxnum=1_000)
   # Create random numbers
   random_array = make_random_array(length, maxnum)
 

data/test/prime_script.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# This file is used to test bin/ruby-prof
+require_relative './prime'
+run_primes(100, 1_000_000)

data/test/printers_test.rb

@@ -20,7 +20,7 @@ class PrintersTest < TestCase
   def test_printers
     output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : StringIO.new('')
 
-    printer = RubyProf::CallInfoPrinter.new(@result)
+    printer = RubyProf::CallStackPrinter.new(@result)
     printer.print(output)
 
     printer = RubyProf::CallTreePrinter.new(@result)

data/test/recursive_test.rb

@@ -58,13 +58,11 @@ class RecursiveTest < TestCase
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(2, method.children_time, 0.1)
 
-    assert_equal(1, method.callers.length)
-    call_info = method.callers[0]
-    assert_nil(call_info.parent)
+    assert_equal(0, method.call_trees.callers.length)
 
-    assert_equal(1, method.callees.length)
-    call_info = method.callees[0]
-    assert_equal('SimpleRecursion#simple', call_info.target.full_name)
+    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]
@@ -76,19 +74,19 @@ class RecursiveTest < TestCase
     assert_in_delta(0, method.wait_time, 0.1)
     assert_in_delta(2, method.children_time, 0.1)
 
-    assert_equal(2, method.callers.length)
-    call_info = method.callers[0]
-    assert_equal('RecursiveTest#test_simple', call_info.parent.full_name)
+    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_info = method.callers[1]
-    assert_equal('SimpleRecursion#simple', call_info.parent.full_name)
+    call_tree = method.call_trees.callers[1]
+    assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
 
-    assert_equal(2, method.callees.length)
-    call_info = method.callees[0]
-    assert_equal('Kernel#sleep', call_info.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_info = method.callees[1]
-    assert_equal('SimpleRecursion#simple', call_info.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]
@@ -100,12 +98,12 @@ class RecursiveTest < TestCase
     assert_in_delta(0, method.wait_time, 0.1)
     assert_in_delta(0, method.children_time, 0.1)
 
-    assert_equal(1, method.callers.length)
-    call_info = method.callers[0]
-    assert_equal('SimpleRecursion#simple', call_info.parent.full_name)
-    assert_equal(0, method.callees.length)
+    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.callees.length)
+    assert_equal(0, method.call_trees.callees.length)
   end
 
   def test_cycle
@@ -125,13 +123,11 @@ class RecursiveTest < TestCase
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(5, method.children_time, 0.1)
 
-    assert_equal(1, method.callers.length)
-    call_info = method.callers[0]
-    assert_nil(call_info.parent)
+    assert_equal(0, method.call_trees.callers.length)
 
-    assert_equal(1, method.callees.length)
-    call_info = method.callees[0]
-    assert_equal('SimpleRecursion#render', call_info.target.full_name)
+    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)
@@ -142,13 +138,13 @@ class RecursiveTest < TestCase
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(5, method.children_time, 0.1)
 
-    assert_equal(1, method.callers.length)
-    call_info = method.callers[0]
-    assert_equal('RecursiveTest#test_cycle', call_info.parent.full_name)
+    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.callees.length)
-    call_info = method.callees[0]
-    assert_equal('Integer#times', call_info.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)
@@ -159,16 +155,16 @@ class RecursiveTest < TestCase
     assert_in_delta(0, method.wait_time, 0.1)
     assert_in_delta(5, method.children_time, 0.1)
 
-    assert_equal(2, method.callers.length)
-    call_info = method.callers[0]
-    assert_equal('SimpleRecursion#render', call_info.parent.full_name)
+    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_info = method.callers[1]
-    assert_equal('SimpleRecursion#render_partial', call_info.parent.full_name)
+    call_tree = method.call_trees.callers[1]
+    assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
 
-    assert_equal(1, method.callees.length)
-    call_info = method.callees[0]
-    assert_equal('SimpleRecursion#render_partial', call_info.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)
@@ -179,22 +175,22 @@ class RecursiveTest < TestCase
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(5, method.children_time, 0.05)
 
-    assert_equal(2, method.callers.length)
-    call_info = method.callers[0]
-    assert_equal('Integer#times', call_info.parent.full_name)
+    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_info = method.callers[1]
-    assert_equal('SimpleRecursion#render_partial', call_info.parent.full_name)
+    call_tree = method.call_trees.callers[1]
+    assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
 
-    assert_equal(3, method.callees.length)
-    call_info = method.callees[0]
-    assert_equal('Kernel#sleep', call_info.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_info = method.callees[1]
-    assert_equal('SimpleRecursion#render_partial', call_info.target.full_name)
+    call_tree = method.call_trees.callees[1]
+    assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
 
-    call_info = method.callees[2]
-    assert_equal('Integer#times', call_info.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)
@@ -205,6 +201,6 @@ class RecursiveTest < TestCase
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(0, method.children_time, 0.01)
 
-    assert_equal(0, method.callees.length)
+    assert_equal(0, method.call_trees.callees.length)
   end
 end