ruby-prof 0.11.2-x86-mingw32 → 0.12.1-x86-mingw32

data/test/call_info_test.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class CallInfoTest < Test::Unit::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_clone
+#    result = RubyProf.profile do
+#      RubyProf::C1.hello
+#    end
+#
+#    method = result.threads.first.top_methods.first
+#    call_info = method.call_infos.first
+#    call_info_clone = call_info.clone
+#
+##    assert_equal(call_info.target, call_info_clone.target)
+#    assert_equal(call_info.total_time, call_info_clone.total_time)
+#  end
+
+  def test_merge
+    result1 = RubyProf.profile do
+      RubyProf::C1.hello
+    end
+
+    methods = result1.threads.first.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    assert_equal('CallInfoTest#test_merge', methods[0].full_name)
+    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+    assert_equal(1, methods[0].called)
+
+    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+    assert_equal(1, methods[1].called)
+
+    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.1, methods[2].self_time, 0.01)
+    assert_equal(1, methods[2].called)
+
+    result2 = RubyProf.profile do
+      RubyProf::C1.hello
+    end
+
+    # Merge the trees
+    methods = result1.threads.first.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    assert_equal('CallInfoTest#test_merge', methods[0].full_name)
+    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+    assert_equal(1, methods[0].called)
+
+    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+    assert_equal(1, methods[1].called)
+
+    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.1, methods[2].self_time, 0.01)
+    assert_equal(1, methods[2].called)
+  end
+end
+

data/test/call_info_visitor_test.rb

@@ -6,7 +6,7 @@ require File.expand_path('../test_helper', __FILE__)
 class CallInfoVisitorTest < Test::Unit::TestCase
   def setup
     # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::CPU_TIME
+    RubyProf::measure_mode = RubyProf::WALL_TIME
   end
 
   def test_visit

data/test/dynamic_method_test.rb

@@ -3,8 +3,12 @@
 
 require File.expand_path("../test_helper", __FILE__)
 
-
 class DynamicMethodTest < Test::Unit::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_dynamic_method
     result = RubyProf.profile do
       1.times {RubyProf::C1.new.hello}
@@ -13,14 +17,14 @@ class DynamicMethodTest < Test::Unit::TestCase
     # Methods called
     #  Kernel#sleep
     #  <Class::BasicObject>#allocate
-    #  BasicObject#initialize
+    #  #{RubyProf.parent_object}
     #  RubyProf::C1#hello
     #  Class#new
     #  Integer#times
     #  DynamicMethodTest#test_dynamic_method
 
     methods = result.threads.first.methods.sort.reverse
-    assert_equal(7, methods.length)
+    assert_equal(RubyProf.ruby_2? ? 6 : 7, methods.length)
 
     # Check times
     assert_equal("DynamicMethodTest#test_dynamic_method", methods[0].full_name)
@@ -48,14 +52,16 @@ class DynamicMethodTest < Test::Unit::TestCase
     assert_in_delta(0.0, methods[4].wait_time, 0.01)
     assert_in_delta(0.0, methods[4].self_time, 0.01)
 
-    assert_equal("<Class::#{RubyProf::PARENT}>#allocate", methods[5].full_name)
+    assert_equal("#{RubyProf.parent_object}#initialize", methods[5].full_name)
     assert_in_delta(0.0, methods[5].total_time, 0.01)
     assert_in_delta(0.0, methods[5].wait_time, 0.01)
     assert_in_delta(0.0, methods[5].self_time, 0.01)
 
-    assert_equal("#{RubyProf::PARENT}#initialize", methods[6].full_name)
-    assert_in_delta(0.0, methods[5].total_time, 0.01)
-    assert_in_delta(0.0, methods[5].wait_time, 0.01)
-    assert_in_delta(0.0, methods[5].self_time, 0.01)
+    unless RubyProf.ruby_2?
+      assert_equal("<Class::#{RubyProf.parent_object}>#allocate", methods[6].full_name)
+      assert_in_delta(0.0, methods[6].total_time, 0.01)
+      assert_in_delta(0.0, methods[6].wait_time, 0.01)
+      assert_in_delta(0.0, methods[6].self_time, 0.01)
+    end
   end
 end

data/test/measure_cpu_time_test.rb

@@ -64,15 +64,18 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
     #   Kernel#sleep
 
     methods = result.threads.first.methods.sort.reverse
-    assert_equal(6, methods.length)
+    assert_equal(RubyProf.ruby_2? ? 5 : 6, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureCpuTimeTest#test_instance_methods', names[0])
     assert_equal('RubyProf::C1#hello', names[1])
     assert_equal('Kernel#sleep', names[2])
     assert_equal('Class#new', names[3])
+
     # order can differ
-    assert(names.include?("<Class::#{RubyProf::PARENT}>#allocate"))
-    assert(names.include?("#{RubyProf::PARENT}#initialize"))
+    assert(names.include?("#{RubyProf.parent_object}#initialize"))
+    unless RubyProf.ruby_2?
+      assert(names.include?("<Class::#{RubyProf.parent_object}>#allocate"))
+    end
 
     # Check times
     assert_in_delta(0.2, methods[0].total_time, 0.02)
@@ -95,9 +98,11 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
     assert_in_delta(0, methods[4].wait_time, 0.01)
     assert_in_delta(0, methods[4].self_time, 0.01)
 
-    assert_in_delta(0, methods[5].total_time, 0.01)
-    assert_in_delta(0, methods[5].wait_time, 0.01)
-    assert_in_delta(0, methods[5].self_time, 0.01)
+    unless RubyProf.ruby_2?
+      assert_in_delta(0, methods[5].total_time, 0.01)
+      assert_in_delta(0, methods[5].wait_time, 0.01)
+      assert_in_delta(0, methods[5].self_time, 0.01)
+    end
   end
 
   def test_module_methods
@@ -145,14 +150,18 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
     #   Kernel#sleep
 
     methods = result.threads.first.methods.sort.reverse
-    assert_equal(6, methods.length)
+    assert_equal(RubyProf.ruby_2? ? 5 : 6, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureCpuTimeTest#test_module_instance_methods', names[0])
     assert_equal('RubyProf::M1#hello', names[1])
     assert_equal('Kernel#sleep', names[2])
     assert_equal('Class#new', names[3])
-    assert(names.include?("<Class::#{RubyProf::PARENT}>#allocate"))
-    assert(names.include?("#{RubyProf::PARENT}#initialize"))
+
+    # order can differ
+    assert(names.include?("#{RubyProf.parent_object}#initialize"))
+    unless RubyProf.ruby_2?
+      assert(names.include?("<Class::#{RubyProf.parent_object}>#allocate"))
+    end
 
     # Check times
     assert_in_delta(0.3, methods[0].total_time, 0.1)
@@ -175,9 +184,11 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
     assert_in_delta(0, methods[4].wait_time, 0.01)
     assert_in_delta(0, methods[4].self_time, 0.01)
 
-    assert_in_delta(0, methods[5].total_time, 0.01)
-    assert_in_delta(0, methods[5].wait_time, 0.01)
-    assert_in_delta(0, methods[5].self_time, 0.01)
+    unless RubyProf.ruby_2?
+      assert_in_delta(0, methods[5].total_time, 0.01)
+      assert_in_delta(0, methods[5].wait_time, 0.01)
+      assert_in_delta(0, methods[5].self_time, 0.01)
+    end
   end
 
   def test_singleton

data/test/measure_process_time_test.rb

@@ -5,7 +5,7 @@ require File.expand_path('../test_helper', __FILE__)
 
 class MeasureProcessTimeTest < Test::Unit::TestCase
   def setup
-    # Need to use wall time for this test due to the sleep calls
+    # Need to fix this for linux (windows works since PROCESS_TIME is WALL_TIME anyway)
     RubyProf::measure_mode = RubyProf::PROCESS_TIME
   end
 
@@ -18,188 +18,39 @@ class MeasureProcessTimeTest < Test::Unit::TestCase
     assert(defined?(RubyProf::PROCESS_TIME_ENABLED))
   end
 
-  def test_class_methods
+  def test_primes
+    start = Process.times
     result = RubyProf.profile do
-      RubyProf::C1.hello
+      run_primes(10000)
     end
+    finish = Process.times
 
-    # Length should be 3:
-    #   MeasureProcessTimeTest#test_class_methods
-    #   <Class::RubyProf::C1>#hello
-    #   Kernel#sleep
+    total_time = (finish.utime - start.utime) + (finish.stime - start.stime)
 
-    methods = result.threads.first.methods.sort.reverse
-    puts methods[0].total_time
-
-    assert_equal(3, methods.length)
-
-    # Check times
-    assert_equal("MeasureProcessTimeTest#test_class_methods", methods[0].full_name)
-    assert_in_delta(0.1, methods[0].total_time, 0.01)
-    assert_in_delta(0.0, methods[0].wait_time, 0.01)
-    assert_in_delta(0.0, methods[0].self_time, 0.01)
-
-    assert_equal("<Class::RubyProf::C1>#hello", methods[1].full_name)
-    assert_in_delta(0.1, methods[1].total_time, 0.01)
-    assert_in_delta(0.0, methods[1].wait_time, 0.01)
-    assert_in_delta(0.0, methods[1].self_time, 0.01)
-
-    assert_equal("Kernel#sleep", methods[2].full_name)
-    assert_in_delta(0.1, methods[2].total_time, 0.01)
-    assert_in_delta(0.0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.1, methods[2].self_time, 0.01)
-  end
-
-  def test_instance_methods
-    result = RubyProf.profile do
-      RubyProf::C1.new.hello
-    end
-
-    # Methods called
-    #   MeasureProcessTimeTest#test_instance_methods
-    #   Class.new
-    #   Class:Object#allocate
-    #   for Object#initialize
-    #   C1#hello
-    #   Kernel#sleep
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(6, methods.length)
-
-    # Check times
-    assert_equal("MeasureProcessTimeTest#test_instance_methods", methods[0].full_name)
-    assert_in_delta(0.2, methods[0].total_time, 0.02)
-    assert_in_delta(0.0, methods[0].wait_time, 0.02)
-    assert_in_delta(0.0, methods[0].self_time, 0.02)
-
-    assert_equal("RubyProf::C1#hello", methods[1].full_name)
-    assert_in_delta(0.2, methods[1].total_time, 0.02)
-    assert_in_delta(0.0, methods[1].wait_time, 0.02)
-    assert_in_delta(0.0, methods[1].self_time, 0.02)
-
-    assert_equal("Kernel#sleep", methods[2].full_name)
-    assert_in_delta(0.2, methods[2].total_time, 0.02)
-    assert_in_delta(0.0, methods[2].wait_time, 0.02)
-    assert_in_delta(0.2, methods[2].self_time, 0.02)
-
-    assert_equal("Class#new", methods[3].full_name)
-    assert_in_delta(0.0, methods[3].total_time, 0.01)
-    assert_in_delta(0.0, methods[3].wait_time, 0.01)
-    assert_in_delta(0.0, methods[3].self_time, 0.01)
-
-    assert_equal("<Class::#{RubyProf::PARENT}>#allocate", methods[4].full_name)
-    assert_in_delta(0.0, methods[4].total_time, 0.01)
-    assert_in_delta(0.0, methods[4].wait_time, 0.01)
-    assert_in_delta(0.0, methods[4].self_time, 0.01)
-
-    assert_equal("#{RubyProf::PARENT}#initialize", methods[5].full_name)
-    assert_in_delta(0.0, methods[5].total_time, 0.01)
-    assert_in_delta(0.0, methods[5].wait_time, 0.01)
-    assert_in_delta(0.0, methods[5].self_time, 0.01)
-  end
-
-  def test_module_methods
-    result = RubyProf.profile do
-      RubyProf::C2.hello
-    end
-
-    # Methods:
-    #   MeasureProcessTimeTest#test_module_methods
-    #   M1#hello
-    #   Kernel#sleep
+    thread = result.threads.first
+    assert_in_delta(total_time, thread.total_time, 0.01)
 
     methods = result.threads.first.methods.sort.reverse
-    assert_equal(3, methods.length)
 
-    # Check times
-    assert_equal("MeasureProcessTimeTest#test_module_methods", methods[0].full_name)
-    assert_in_delta(0.3, methods[0].total_time, 0.1)
-    assert_in_delta(0.0, methods[0].wait_time, 0.02)
-    assert_in_delta(0.0, methods[0].self_time, 0.02)
-
-    assert_equal("RubyProf::M1#hello", methods[1].full_name)
-    assert_in_delta(0.3, methods[1].total_time, 0.1)
-    assert_in_delta(0.0, methods[1].wait_time, 0.02)
-    assert_in_delta(0.0, methods[1].self_time, 0.02)
-
-    assert_equal("Kernel#sleep", methods[2].full_name)
-    assert_in_delta(0.3, methods[2].total_time, 0.1)
-    assert_in_delta(0.0, methods[2].wait_time, 0.02)
-    assert_in_delta(0.3, methods[2].self_time, 0.1)
-  end
-
-  def test_module_instance_methods
-    result = RubyProf.profile do
-      RubyProf::C2.new.hello
-    end
-
-    # Methods:
-    #   MeasureProcessTimeTest#test_module_instance_methods
-    #   Class#new
-    #   <Class::Object>#allocate
-    #   Object#initialize
-    #   M1#hello
-    #   Kernel#sleep
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(6, methods.length)
+    assert_equal(RubyProf.ruby_2? ? 15 : 16, methods.length)
 
     # Check times
-    assert_equal("MeasureProcessTimeTest#test_module_instance_methods", methods[0].full_name)
-    assert_in_delta(0.3, methods[0].total_time, 0.1)
-    assert_in_delta(0.0, methods[0].wait_time, 0.1)
-    assert_in_delta(0.0, methods[0].self_time, 0.1)
-
-    assert_equal("RubyProf::M1#hello", methods[1].full_name)
-    assert_in_delta(0.3, methods[1].total_time, 0.02)
-    assert_in_delta(0.0, methods[1].wait_time, 0.01)
-    assert_in_delta(0.0, methods[1].self_time, 0.01)
-
-    assert_equal("Kernel#sleep", methods[2].full_name)
-    assert_in_delta(0.3, methods[2].total_time, 0.02)
-    assert_in_delta(0.0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.3, methods[2].self_time, 0.02)
-
-    assert_equal("Class#new", methods[3].full_name)
-    assert_in_delta(0.0, methods[3].total_time, 0.01)
-    assert_in_delta(0.0, methods[3].wait_time, 0.01)
-    assert_in_delta(0.0, methods[3].self_time, 0.01)
-
-    assert_equal("<Class::#{RubyProf::PARENT}>#allocate", methods[4].full_name)
-    assert_in_delta(0.0, methods[4].total_time, 0.01)
-    assert_in_delta(0.0, methods[4].wait_time, 0.01)
-    assert_in_delta(0.0, methods[4].self_time, 0.01)
-
-    assert_equal("#{RubyProf::PARENT}#initialize", methods[5].full_name)
-    assert_in_delta(0.0, methods[5].total_time, 0.01)
-    assert_in_delta(0.0, methods[5].wait_time, 0.01)
-    assert_in_delta(0.0, methods[5].self_time, 0.01)
-  end
-
-  def test_singleton
-    c3 = RubyProf::C3.new
-
-    class << c3
-      def hello
-      end
-    end
-
-    result = RubyProf.profile do
-      c3.hello
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(2, methods.length)
-
-    assert_equal("MeasureProcessTimeTest#test_singleton", methods[0].full_name)
-    assert_equal("<Object::RubyProf::C3>#hello", methods[1].full_name)
-
-    assert_in_delta(0.0, methods[0].total_time, 0.01)
+    assert_equal("MeasureProcessTimeTest#test_primes", methods[0].full_name)
+    assert_in_delta(total_time, methods[0].total_time, 0.01)
     assert_in_delta(0.0, methods[0].wait_time, 0.01)
     assert_in_delta(0.0, methods[0].self_time, 0.01)
 
-    assert_in_delta(0.0, methods[1].total_time, 0.01)
+    assert_equal("Object#run_primes", methods[1].full_name)
+    assert_in_delta(total_time, methods[1].total_time, 0.01)
     assert_in_delta(0.0, methods[1].wait_time, 0.01)
     assert_in_delta(0.0, methods[1].self_time, 0.01)
+
+    assert_equal("Object#find_primes", methods[2].full_name)
+    assert_equal("Array#select", methods[3].full_name)
+    assert_equal("Object#is_prime", methods[4].full_name)
+    assert_equal("Integer#upto", methods[5].full_name)
+    assert_equal("Object#make_random_array", methods[6].full_name)
+    assert_equal("Array#each_index", methods[7].full_name)
+    assert_equal("Kernel#rand", methods[8].full_name)
   end
 end

data/test/measure_wall_time_test.rb

@@ -23,6 +23,13 @@ class MeasureWallTimeTest < Test::Unit::TestCase
       RubyProf::C1.hello
     end
 
+    thread = result.threads.first
+    assert_in_delta(0.1, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_class_methods", top_methods[0].full_name)
+
     # Length should be 3:
     #   MeasureWallTimeTest#test_class_methods
     #   <Class::RubyProf::C1>#hello
@@ -55,6 +62,13 @@ class MeasureWallTimeTest < Test::Unit::TestCase
       RubyProf::C1.new.hello
     end
 
+    thread = result.threads.first
+    assert_in_delta(0.2, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_instance_methods", top_methods[0].full_name)
+
     # Methods called
     #   MeasureWallTimeTest#test_instance_methods
     #   Class.new
@@ -64,15 +78,18 @@ class MeasureWallTimeTest < Test::Unit::TestCase
     #   Kernel#sleep
 
     methods = result.threads.first.methods.sort.reverse
-    assert_equal(6, methods.length)
+    assert_equal(RubyProf.ruby_2? ? 5 : 6, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureWallTimeTest#test_instance_methods', names[0])
     assert_equal('RubyProf::C1#hello', names[1])
     assert_equal('Kernel#sleep', names[2])
     assert_equal('Class#new', names[3])
+
     # order can differ
-    assert(names.include?("<Class::#{RubyProf::PARENT}>#allocate"))
-    assert(names.include?("#{RubyProf::PARENT}#initialize"))
+    assert(names.include?("#{RubyProf.parent_object}#initialize"))
+    unless RubyProf.ruby_2?
+      assert(names.include?("<Class::#{RubyProf.parent_object}>#allocate"))
+    end
 
     # Check times
     assert_in_delta(0.2, methods[0].total_time, 0.02)
@@ -95,9 +112,11 @@ class MeasureWallTimeTest < Test::Unit::TestCase
     assert_in_delta(0, methods[4].wait_time, 0.01)
     assert_in_delta(0, methods[4].self_time, 0.01)
 
-    assert_in_delta(0, methods[5].total_time, 0.01)
-    assert_in_delta(0, methods[5].wait_time, 0.01)
-    assert_in_delta(0, methods[5].self_time, 0.01)
+    unless RubyProf.ruby_2?
+      assert_in_delta(0, methods[5].total_time, 0.01)
+      assert_in_delta(0, methods[5].wait_time, 0.01)
+      assert_in_delta(0, methods[5].self_time, 0.01)
+    end
   end
 
   def test_module_methods
@@ -105,6 +124,13 @@ class MeasureWallTimeTest < Test::Unit::TestCase
       RubyProf::C2.hello
     end
 
+    thread = result.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_module_methods", top_methods[0].full_name)
+
     # Methods:
     #   MeasureWallTimeTest#test_module_methods
     #   M1#hello
@@ -136,6 +162,13 @@ class MeasureWallTimeTest < Test::Unit::TestCase
       RubyProf::C2.new.hello
     end
 
+    thread = result.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_module_instance_methods", top_methods[0].full_name)
+
     # Methods:
     #   MeasureWallTimeTest#test_module_instance_methods
     #   Class#new
@@ -145,14 +178,18 @@ class MeasureWallTimeTest < Test::Unit::TestCase
     #   Kernel#sleep
 
     methods = result.threads.first.methods.sort.reverse
-    assert_equal(6, methods.length)
+    assert_equal(RubyProf.ruby_2? ? 5 : 6, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureWallTimeTest#test_module_instance_methods', names[0])
     assert_equal('RubyProf::M1#hello', names[1])
     assert_equal('Kernel#sleep', names[2])
     assert_equal('Class#new', names[3])
-    assert(names.include?("<Class::#{RubyProf::PARENT}>#allocate"))
-    assert(names.include?("#{RubyProf::PARENT}#initialize"))
+
+    # order can differ
+    assert(names.include?("#{RubyProf.parent_object}#initialize"))
+    unless RubyProf.ruby_2?
+      assert(names.include?("<Class::#{RubyProf.parent_object}>#allocate"))
+    end
 
     # Check times
     assert_in_delta(0.3, methods[0].total_time, 0.1)
@@ -175,9 +212,11 @@ class MeasureWallTimeTest < Test::Unit::TestCase
     assert_in_delta(0, methods[4].wait_time, 0.01)
     assert_in_delta(0, methods[4].self_time, 0.01)
 
-    assert_in_delta(0, methods[5].total_time, 0.01)
-    assert_in_delta(0, methods[5].wait_time, 0.01)
-    assert_in_delta(0, methods[5].self_time, 0.01)
+    unless RubyProf.ruby_2?
+      assert_in_delta(0, methods[5].total_time, 0.01)
+      assert_in_delta(0, methods[5].wait_time, 0.01)
+      assert_in_delta(0, methods[5].self_time, 0.01)
+    end
   end
 
   def test_singleton
@@ -192,6 +231,13 @@ class MeasureWallTimeTest < Test::Unit::TestCase
       c3.hello
     end
 
+    thread = result.threads.first
+    assert_in_delta(0.0, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_singleton", top_methods[0].full_name)
+
     methods = result.threads.first.methods.sort.reverse
     assert_equal(2, methods.length)
 
@@ -206,4 +252,4 @@ class MeasureWallTimeTest < Test::Unit::TestCase
     assert_in_delta(0, methods[1].wait_time, 0.01)
     assert_in_delta(0, methods[1].self_time, 0.01)
   end
-end
+end