ruby-prof 0.11.0.rc1-x86-mingw32 → 0.11.0.rc2-x86-mingw32

data/test/measure_wall_time_test.rb

@@ -28,7 +28,7 @@ class MeasureWallTimeTest < Test::Unit::TestCase
     #   <Class::RubyProf::C1>#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
     # Check the names
@@ -63,7 +63,7 @@ class MeasureWallTimeTest < Test::Unit::TestCase
     #   C1#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(6, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureWallTimeTest#test_instance_methods', names[0])
@@ -110,7 +110,7 @@ class MeasureWallTimeTest < Test::Unit::TestCase
     #   M1#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
     assert_equal('MeasureWallTimeTest#test_module_methods', methods[0].full_name)
@@ -144,7 +144,7 @@ class MeasureWallTimeTest < Test::Unit::TestCase
     #   M1#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(6, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureWallTimeTest#test_module_instance_methods', names[0])
@@ -192,7 +192,7 @@ class MeasureWallTimeTest < Test::Unit::TestCase
       c3.hello
     end
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(2, methods.length)
 
     assert_equal('MeasureWallTimeTest#test_singleton', methods[0].full_name)

data/test/method_elimination_test.rb

@@ -37,7 +37,7 @@ class MethodEliminationTest < Test::Unit::TestCase
     result = RubyProf.profile do
       1000.times { 1+1 }
     end
-    method_infos = result.threads.values.first
+    method_infos = result.threads.first.methods
     assert(m1 = method_infos[0])
     assert(c1 = m1.call_infos.first)
     assert_equal(c1, c1.parent = c1)
@@ -59,8 +59,8 @@ class MethodEliminationTest < Test::Unit::TestCase
 
   private
   def assert_method_has_been_eliminated(result, eliminated_method)
-    result.threads.each do |thread_id, methods|
-      methods.each do |method|
+    result.threads.each do |thread|
+      thread.methods.each do |method|
         method.call_infos.each do |ci|
           assert(ci.target != eliminated_method, "broken self")
           assert(ci.parent.target != eliminated_method, "broken parent") if ci.parent

data/test/module_test.rb

@@ -32,7 +32,7 @@ class ModuleTest < Test::Unit::TestCase
       hello
     end
 
-    methods = result.threads.values.first
+    methods = result.threads.first.methods
 
     # Length should be 5
     assert_equal(5, methods.length)

data/test/no_method_class_test.rb

@@ -8,7 +8,7 @@ result = RubyProf.profile do
   sleep 1
 end
 
-methods = result.threads.values.first
+methods = result.threads.first.methods
 global_method = methods.sort_by {|method| method.full_name}.first
 if global_method.full_name != 'Global#[No method]'
   raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{global_method.full_name}")

data/test/printers_test.rb

@@ -7,13 +7,13 @@ require 'fileutils'
 
 # --  Tests ----
 class PrintersTest < Test::Unit::TestCase
-
   def go
     run_primes(1000)
   end
 
   def setup
-    RubyProf::measure_mode = RubyProf::WALL_TIME # WALL_TIME so we can use sleep in our test and get same measurements on linux and doze
+    # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
+    RubyProf::measure_mode = RubyProf::WALL_TIME
     @result = RubyProf.profile do
       begin
         run_primes(1000)
@@ -22,13 +22,18 @@ class PrintersTest < Test::Unit::TestCase
         p e
       end
     end
-
   end
 
   def test_printers
     assert_nothing_raised do
       output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : StringIO.new('')
 
+      printer = RubyProf::CallInfoPrinter.new(@result)
+      printer.print(output)
+
+      printer = RubyProf::CallTreePrinter.new(@result)
+      printer.print(output)
+
       printer = RubyProf::FlatPrinter.new(@result)
       printer.print(output)
 
@@ -41,8 +46,11 @@ class PrintersTest < Test::Unit::TestCase
       printer = RubyProf::GraphPrinter.new(@result)
       printer.print(output)
 
-      printer = RubyProf::CallTreePrinter.new(@result)
-      printer.print(output)
+    end
+  end
+
+  def test_print_to_files
+    assert_nothing_raised do
       output_dir = 'examples2'
 
       if ENV['SAVE_NEW_PRINTER_EXAMPLES']
@@ -66,11 +74,11 @@ class PrintersTest < Test::Unit::TestCase
   end
 
   def test_flat_string
-    output = helper_test_flat_string RubyProf::FlatPrinter
+    output = helper_test_flat_string(RubyProf::FlatPrinter)
     assert_no_match(/prime.rb/, output)
   end
 
-  def helper_test_flat_string klass
+  def helper_test_flat_string(klass)
     output = ''
 
     printer = klass.new(@result)
@@ -145,7 +153,7 @@ class PrintersTest < Test::Unit::TestCase
     for klass in [ RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter]
       printer = klass.new(result)
       out = ''
-      printer.print(out, :min_percent => 0.00000001 )
+      printer.print(out, :min_percent => 0.00000001)
       assert_match(/do_nothing/, out)
     end
 

data/test/recursive_test.rb

@@ -3,6 +3,7 @@
 
 require File.expand_path('../test_helper', __FILE__)
 
+# Simple recursive test
 def simple(n)
   sleep(1)
   n -= 1
@@ -10,17 +11,25 @@ def simple(n)
   simple(n)
 end
 
-def cycle(n)
-  sub_cycle(n)
-end
 
-def sub_cycle(n)
+# More complicated recursive test
+def render_partial(i)
   sleep(1)
-  n -= 1
-  return if n == 0
-  cycle(n)
+  case i
+  when 0
+    render_partial(10)
+  when 1
+    2.times do |j|
+      render_partial(j + 10)
+    end
+  end
 end
 
+def render
+  2.times do |i|
+    render_partial(i)
+  end
+end
 
 # --  Tests ----
 class RecursiveTest < Test::Unit::TestCase
@@ -34,60 +43,73 @@ class RecursiveTest < Test::Unit::TestCase
       simple(2)
     end
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.dup
 
-    if RUBY_VERSION < '1.9'
-      assert_equal(5, methods.length) # includes Fixnum+, Fixnum==...
-    else
-      assert_equal(3, methods.length) # which don't show up in 1.9
+    # Remove Fixnum+, Fixnum== for less than Ruby 1.9
+    methods.delete_if do |method|
+      method.full_name.match(/Fixnum/)
     end
 
+    assert_equal(3, methods.length) # which don't show up in 1.9
+
+    # Method 0: RecursiveTest#test_simple
     method = methods[0]
     assert_equal('RecursiveTest#test_simple', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
+    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.05)
+    assert_in_delta(2, method.children_time, 0.1)
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
+    assert(!call_info.recursive)
     assert_equal('RecursiveTest#test_simple', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
 
+    # Method 1: Object#simple
     method = methods[1]
     assert_equal('Object#simple', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(2, method.children_time, 0.05)
+    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_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_simple->Object#simple', call_info.call_sequence)
+
+    call_info = method.call_infos.first
     if RUBY_VERSION < '1.9'
       assert_equal(4, call_info.children.length)
     else
       assert_equal(2, call_info.children.length)
     end
+    assert_equal('RecursiveTest#test_simple->Object#simple', call_info.call_sequence)
+    assert(!call_info.recursive)
+
+    call_info = method.call_infos.last
+    assert_equal(1, call_info.children.length)
+    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple', call_info.call_sequence)
+    assert(call_info.recursive)
 
     method = methods[2]
     assert_equal('Kernel#sleep', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(2, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    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(2, method.call_infos.length)
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_simple->Object#simple->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
+    assert(!call_info.recursive)
 
     call_info = method.call_infos[1]
     assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
+    assert(!call_info.recursive)
 
     if RUBY_VERSION < '1.9'
       method = methods[3]
@@ -128,110 +150,112 @@ class RecursiveTest < Test::Unit::TestCase
 
   def test_cycle
     result = RubyProf.profile do
-      cycle(2)
+      render
     end
 
-    methods = result.threads.values.first.sort.reverse
-    if RUBY_VERSION < '1.9'
-      assert_equal(6, methods.length) # includes Fixnum+ and Fixnum==, which aren't included in 1.9
+    printer = RubyProf::GraphPrinter.new(result)
+    printer.print(STDOUT)
+
+    methods = result.threads.first.methods.sort.reverse
+    if RUBY_VERSION < '1.9' # Fixnum#+, Fixnum#===, Kernel#===
+      assert_equal(8, methods.length)
     else
-      assert_equal(4, methods.length) # which don't show up in 1.9
+      assert_equal(5, methods.length)
     end
+
     method = methods[0]
     assert_equal('RecursiveTest#test_cycle', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
+    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(2, method.children_time, 0.05)
+    assert_in_delta(5, method.children_time, 0.1)
 
     assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
+    assert(!call_info.recursive)
 
     method = methods[1]
-    assert_equal('Object#cycle', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
+    assert_equal('Object#render', method.full_name)
+    assert_equal(1, method.called)
+    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(2, method.children_time, 0.05)
+    assert_in_delta(5, method.children_time, 0.1)
 
-    assert_equal(2, method.call_infos.length)
+    assert_equal(1, method.call_infos.length)
     call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle', call_info.call_sequence)
+    assert_equal('RecursiveTest#test_cycle->Object#render', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
+    assert(!call_info.recursive)
 
     method = methods[2]
-    assert_equal('Object#sub_cycle', method.full_name)
+    assert_equal('Integer#times', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(2, method.children_time, 0.05)
+    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_infos.length)
     call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle', call_info.call_sequence)
-    if RUBY_VERSION < '1.9'
-      assert_equal(4, call_info.children.length)
-    else
-      assert_equal(2, call_info.children.length)
-    end
+    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+    assert(!call_info.recursive)
+
+    call_info = method.call_infos[1]
+    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Integer#times', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+    assert(call_info.recursive)
 
     method = methods[3]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(2, method.self_time, 0.05)
+    assert_equal('Object#render_partial', method.full_name)
+    assert_equal(5, method.called)
+    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(0, method.children_time, 0.01)
+    assert_in_delta(5, method.children_time, 0.01)
 
-    assert_equal(2, method.call_infos.length)
+    assert_equal(3, method.call_infos.length)
     call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
+    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial', call_info.call_sequence)
+    assert_equal(3, call_info.children.length)
+    assert(!call_info.recursive)
 
     call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle->Object#sub_cycle->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    if RUBY_VERSION < '1.9'
-      method = methods[4]
-      assert_equal('Fixnum#-', method.full_name)
-      assert_equal(2, method.called)
-      assert_in_delta(0, method.total_time, 0.01)
-      assert_in_delta(0, method.self_time, 0.01)
-      assert_in_delta(0, method.wait_time, 0.01)
-      assert_in_delta(0, method.children_time, 0.01)
-
-      assert_equal(2, method.call_infos.length)
-      call_info = method.call_infos[0]
-      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Fixnum#-', call_info.call_sequence)
-      assert_equal(0, call_info.children.length)
+    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Object#render_partial', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+    assert(call_info.recursive)
 
-      call_info = method.call_infos[1]
-      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle->Object#sub_cycle->Fixnum#-', call_info.call_sequence)
-      assert_equal(0, call_info.children.length)
+    call_info = method.call_infos[2]
+    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Integer#times->Object#render_partial', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+    assert(call_info.recursive)
 
-      method = methods[5]
-      assert_equal('Fixnum#==', method.full_name)
-      assert_equal(2, method.called)
-      assert_in_delta(0, method.total_time, 0.01)
-      assert_in_delta(0, method.self_time, 0.01)
-      assert_in_delta(0, method.wait_time, 0.01)
-      assert_in_delta(0, method.children_time, 0.01)
+    method = methods[4]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(5, method.called)
+    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(2, method.call_infos.length)
-      call_info = method.call_infos[0]
-      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Fixnum#==', call_info.call_sequence)
-      assert_equal(0, call_info.children.length)
+    assert_equal(3, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+    assert(!call_info.recursive)
 
-      call_info = method.call_infos[1]
-      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle->Object#sub_cycle->Fixnum#==', call_info.call_sequence)
-      assert_equal(0, call_info.children.length)
-    end
+    call_info = method.call_infos[1]
+    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Object#render_partial->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+    assert(!call_info.recursive)
 
+    call_info = method.call_infos[2]
+    assert_equal('RecursiveTest#test_cycle->Object#render->Integer#times->Object#render_partial->Integer#times->Object#render_partial->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+    assert(!call_info.recursive)
   end
-end
+end