ruby-prof 1.4.5 → 1.5.0

data/test/call_tree_test.rb

@@ -0,0 +1,197 @@
+# 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
+
+  def test_merge
+    call_tree_1 = create_call_tree_1
+    call_tree_2 = create_call_tree_2
+    call_tree_1.merge!(call_tree_2)
+
+    # Root
+    call_tree = call_tree_1
+    assert_equal(:root, call_tree.target.method_name)
+    assert_in_delta(11.6, call_tree.total_time, 0.00001)
+    assert_in_delta(0, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(11.6, call_tree.children_time, 0.00001)
+
+    assert_in_delta(11.6, call_tree.target.total_time, 0.00001)
+    assert_in_delta(0, call_tree.target.self_time, 0.00001)
+    assert_in_delta(0, call_tree.target.wait_time, 0.00001)
+    assert_in_delta(11.6, call_tree.target.children_time, 0.00001)
+
+    # a
+    call_tree = call_tree_1.children[0]
+    assert_equal(:a, call_tree.target.method_name)
+
+    assert_in_delta(4.1, call_tree.total_time, 0.00001)
+    assert_in_delta(0, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(4.1, call_tree.children_time, 0.00001)
+
+    assert_in_delta(4.1, call_tree.target.total_time, 0.00001)
+    assert_in_delta(0, call_tree.target.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
+    assert_in_delta(4.1, call_tree.target.children_time, 0.00001)
+
+    # aa
+    call_tree = call_tree_1.children[0].children[0]
+    assert_equal(:aa, call_tree.target.method_name)
+
+    assert_in_delta(1.5, call_tree.total_time, 0.00001)
+    assert_in_delta(1.5, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    assert_in_delta(1.5, call_tree.target.total_time, 0.00001)
+    assert_in_delta(1.5, call_tree.target.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
+
+    # ab
+    call_tree = call_tree_1.children[0].children[1]
+    assert_equal(:ab, call_tree.target.method_name)
+
+    assert_in_delta(2.6, call_tree.total_time, 0.00001)
+    assert_in_delta(2.6, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    assert_in_delta(2.6, call_tree.target.total_time, 0.00001)
+    assert_in_delta(2.6, call_tree.target.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
+
+    # b
+    call_tree = call_tree_1.children[1]
+    assert_equal(:b, call_tree.target.method_name)
+
+    assert_in_delta(7.5, call_tree.total_time, 0.00001)
+    assert_in_delta(0, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(7.5, call_tree.children_time, 0.00001)
+
+    assert_in_delta(7.5, call_tree.target.total_time, 0.00001)
+    assert_in_delta(0, call_tree.target.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
+    assert_in_delta(7.5, call_tree.target.children_time, 0.00001)
+
+    # bb
+    call_tree = call_tree_1.children[1].children[0]
+    assert_equal(:bb, call_tree.target.method_name)
+
+    assert_in_delta(6.6, call_tree.total_time, 0.00001)
+    assert_in_delta(6.6, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    assert_in_delta(6.6, call_tree.target.total_time, 0.00001)
+    assert_in_delta(6.6, call_tree.target.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
+
+    # ba
+    call_tree = call_tree_1.children[1].children[1]
+    assert_equal(:ba, call_tree.target.method_name)
+
+    assert_in_delta(0.9, call_tree.total_time, 0.00001)
+    assert_in_delta(0.7, call_tree.self_time, 0.00001)
+    assert_in_delta(0.2, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    assert_in_delta(0.9, call_tree.target.total_time, 0.00001)
+    assert_in_delta(0.7, call_tree.target.self_time, 0.00001)
+    assert_in_delta(0.2, call_tree.target.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
+  end
+end

data/test/call_trees_test.rb

@@ -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,7 +45,7 @@ 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

data/test/fiber_test.rb

@@ -5,9 +5,25 @@ require File.expand_path('../test_helper', __FILE__)
 require 'fiber'
 require 'timeout'
 require 'set'
+require_relative './scheduler'
 
 # --  Tests ----
 class FiberTest < TestCase
+  def worker
+    sleep(0.5)
+  end
+
+  def concurrency
+    scheduler = Scheduler.new
+    Fiber.set_scheduler(scheduler)
+
+    3.times do
+      Fiber.schedule do |a|
+        worker
+      end
+    end
+    Fiber.scheduler.close
+  end
 
   def enumerator_with_fibers
     enum = Enumerator.new do |yielder|
@@ -36,7 +52,7 @@ class FiberTest < TestCase
   end
 
   def test_fibers
-    result  = RubyProf.profile { enumerator_with_fibers }
+    result = RubyProf.profile { enumerator_with_fibers }
 
     assert_equal(2, result.threads.size)
 
@@ -47,42 +63,82 @@ class FiberTest < TestCase
     method = methods[0]
     assert_equal('FiberTest#test_fibers', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[1]
     assert_equal('FiberTest#enumerator_with_fibers', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[2]
     assert_equal('Enumerator#next', method.full_name)
     assert_equal(2, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[3]
     assert_equal('Class#new', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[4]
     assert_equal('Enumerator#initialize', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     thread2 = result.threads[1]
     methods = thread2.methods.sort.reverse
     assert_equal(4, methods.count)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[0]
     assert_equal('Enumerator#each', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[1]
     assert_equal('Enumerator::Generator#each', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[2]
     assert_equal('Array#each', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[3]
     assert_equal('Enumerator::Yielder#yield', method.full_name)
     assert_equal(2, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
   end
 
   def test_fiber_resume
@@ -97,33 +153,99 @@ class FiberTest < TestCase
     method = methods[0]
     assert_equal('FiberTest#test_fiber_resume', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[1]
     assert_equal('FiberTest#fiber_yield_resume', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[2]
     assert_equal('Fiber#resume', method.full_name)
     assert_equal(2, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[3]
     assert_equal('Class#new', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[4]
     assert_equal('Fiber#initialize', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     thread1 = result.threads[1]
     methods = thread1.methods.sort.reverse
     assert_equal(2, methods.count)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[0]
     assert_equal('FiberTest#fiber_yield_resume', method.full_name)
     assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
 
     method = methods[1]
     assert_equal('<Class::Fiber>#yield', method.full_name)
     assert_equal(2, method.called)
+    assert_in_delta(0, method.total_time)
+    assert_in_delta(0, method.self_time)
+    assert_in_delta(0, method.wait_time)
+    assert_in_delta(0, method.children_time)
+  end
+
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.1.0')
+    def test_times_no_merge
+      result  = RubyProf.profile { concurrency }
+
+      assert_equal(4, result.threads.size)
+
+      result.threads.each do |thread|
+        assert_in_delta(0.5, thread.call_tree.target.total_time, 0.2)
+        assert_in_delta(0.0, thread.call_tree.target.self_time)
+        assert_in_delta(0.0, thread.call_tree.target.wait_time)
+        assert_in_delta(0.5, thread.call_tree.target.children_time, 0.2)
+      end
+    end
+
+    def test_times_merge
+      result  = RubyProf.profile { concurrency }
+      result.merge!
+
+      assert_equal(2, result.threads.size)
+
+      thread = result.threads[0]
+      assert_in_delta(0.5, thread.call_tree.target.total_time, 0.2)
+      assert_in_delta(0.0, thread.call_tree.target.self_time)
+      assert_in_delta(0.0, thread.call_tree.target.wait_time)
+      assert_in_delta(0.5, thread.call_tree.target.children_time, 0.2)
+
+      thread = result.threads[1]
+      assert_in_delta(1.5, thread.call_tree.target.total_time, 0.2)
+      assert_in_delta(0.0, thread.call_tree.target.self_time)
+      assert_in_delta(0.0, thread.call_tree.target.wait_time)
+      assert_in_delta(1.5, thread.call_tree.target.children_time, 0.2)
+    end
   end
 end

data/test/gc_test.rb

@@ -67,16 +67,18 @@ class GcTest < TestCase
   end
 
   def test_hold_onto_measurements
-    measurements = 5.times.reduce(Array.new) do |array, i|
-      profile = run_profile
-      measurements_2 = profile.threads.map(&:methods).flatten.map(&:measurement)
-      array.concat(measurements_2)
-      array
-    end
+    # Run a profile
+    profile = run_profile
+
+    # Get measurement objects
+    measurements = profile.threads.map(&:methods).flatten.map(&:measurement)
+
+    # Free the profiles which frees the measurements
+    profile = nil
 
     GC.start
 
-    measurements.each do |measurement|
+    measurements.each_with_index do |measurement|
       error = assert_raises(RuntimeError) do
         measurement.total_time
       end

data/test/line_number_test.rb

@@ -19,12 +19,10 @@ class LineNumbers
   end
 
   def method_3
-    sleep(0.3)
     method_4
   end
 
   def method_4
-    sleep(1.2)
   end
 end
 
@@ -37,20 +35,24 @@ class LineNumbersTest < TestCase
       numbers.method_1
     end
 
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(7, methods.length)
+    # Sort methods by name to have stable results
+    methods = result.threads.first.methods.sort_by(&:full_name)
+    assert_equal(6, methods.length)
 
     # Method 0
     method = methods[0]
-    assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
-    assert_equal(37, method.line)
+    assert_equal('Integer#times', method.full_name)
+    assert_equal(0, method.line)
 
-    assert_equal(0, method.call_trees.callers.count)
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('LineNumbers#method_2', call_tree.parent.target.full_name)
+    assert_equal(15, call_tree.line)
 
     assert_equal(1, method.call_trees.callees.count)
     call_tree = method.call_trees.callees[0]
-    assert_equal('LineNumbers#method_1', call_tree.target.full_name)
-    assert_equal(37, call_tree.line)
+    assert_equal('LineNumbers#method_3', call_tree.target.full_name)
+    assert_equal(17, call_tree.line)
 
     # Method 1
     method = methods[1]
@@ -60,7 +62,7 @@ class LineNumbersTest < TestCase
     assert_equal(1, method.call_trees.callers.count)
     call_tree = method.call_trees.callers[0]
     assert_equal('LineNumbersTest#test_function_line_no', call_tree.parent.target.full_name)
-    assert_equal(37, call_tree.line)
+    assert_equal(35, call_tree.line)
 
     assert_equal(2, method.call_trees.callees.count)
     call_tree = method.call_trees.callees[0]
@@ -73,6 +75,21 @@ class LineNumbersTest < TestCase
 
     # Method 2
     method = methods[2]
+    assert_equal('LineNumbers#method_2', method.full_name)
+    assert_equal(13, method.line)
+
+    assert_equal(1, method.call_trees.callers.count)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('LineNumbers#method_1', call_tree.parent.target.full_name)
+    assert_equal(8, call_tree.line)
+
+    assert_equal(1, method.call_trees.callees.count)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Integer#times', call_tree.target.full_name)
+    assert_equal(15, call_tree.line)
+
+    # Method 3
+    method = methods[3]
     assert_equal('LineNumbers#method_3', method.full_name)
     assert_equal(21, method.line)
 
@@ -85,74 +102,33 @@ class LineNumbersTest < TestCase
     assert_equal('LineNumbers#method_1', call_tree.parent.target.full_name)
     assert_equal(10, call_tree.line)
 
-    assert_equal(2, method.call_trees.callees.count)
+    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(22, call_tree.line)
-
-    call_tree = method.call_trees.callees[1]
     assert_equal('LineNumbers#method_4', call_tree.target.full_name)
-    assert_equal(23, call_tree.line)
-
-    # Method 3
-    method = methods[3]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(0, method.line)
-
-    assert_equal(2, method.call_trees.callers.count)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('LineNumbers#method_3', call_tree.parent.target.full_name)
     assert_equal(22, call_tree.line)
 
-    call_tree = method.call_trees.callers[1]
-    assert_equal('LineNumbers#method_4', call_tree.parent.target.full_name)
-    assert_equal(27, call_tree.line)
-
-    assert_equal(0, method.call_trees.callees.count)
-
     # Method 4
     method = methods[4]
     assert_equal('LineNumbers#method_4', method.full_name)
-    assert_equal(26, method.line)
+    assert_equal(25, method.line)
 
     assert_equal(1, method.call_trees.callers.count)
     call_tree = method.call_trees.callers[0]
     assert_equal('LineNumbers#method_3', call_tree.parent.target.full_name)
-    assert_equal(23, call_tree.line)
+    assert_equal(22, 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(27, call_tree.line)
+    assert_equal(0, method.call_trees.callees.count)
 
     # Method 5
     method = methods[5]
-    assert_equal('LineNumbers#method_2', method.full_name)
-    assert_equal(13, method.line)
-
-    assert_equal(1, method.call_trees.callers.count)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('LineNumbers#method_1', call_tree.parent.target.full_name)
-    assert_equal(8, call_tree.line)
-
-    assert_equal(1, method.call_trees.callees.count)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('Integer#times', call_tree.target.full_name)
-    assert_equal(15, call_tree.line)
-
-    # Method 6
-    method = methods[6]
-    assert_equal('Integer#times', method.full_name)
-    assert_equal(0, method.line)
+    assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
+    assert_equal(35, method.line)
 
-    assert_equal(1, method.call_trees.callers.count)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('LineNumbers#method_2', call_tree.parent.target.full_name)
-    assert_equal(15, call_tree.line)
+    assert_equal(0, method.call_trees.callers.count)
 
     assert_equal(1, method.call_trees.callees.count)
     call_tree = method.call_trees.callees[0]
-    assert_equal('LineNumbers#method_3', call_tree.target.full_name)
-    assert_equal(17, call_tree.line)
+    assert_equal('LineNumbers#method_1', call_tree.target.full_name)
+    assert_equal(35, call_tree.line)
   end
 end