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

data/test/prime_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
-require 'test/unit'
-require 'ruby-prof'
-require 'prime'
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
 
 # --  Tests ----
 class PrimeTest< Test::Unit::TestCase

data/test/printers_test.rb

@@ -1,40 +1,68 @@
 #!/usr/bin/env ruby
-require 'test/unit'
-require 'ruby-prof'
-require File.dirname(__FILE__) + '/prime'
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'stringio'
+require 'fileutils'
 
 # --  Tests ----
 class PrintersTest < Test::Unit::TestCase
-  
+
   def go
-    run_primes
+    run_primes(1000)
   end
-  
+
   def setup
-    RubyProf::measure_mode = RubyProf::WALL_TIME # WALL_TIME so we can use sleep in our test
+    RubyProf::measure_mode = RubyProf::WALL_TIME # WALL_TIME so we can use sleep in our test and get same measurements on linux and doze
     @result = RubyProf.profile do
-      run_primes
-      go
+      begin
+        run_primes(1000)
+        go
+      rescue => e
+        p e
+      end
     end
-    
+
   end
-    
+
   def test_printers
-    printer = RubyProf::FlatPrinter.new(@result)
-    printer.print(STDOUT)
-    
-    printer = RubyProf::FlatPrinterWithLineNumbers.new(@result)
-    printer.print(STDOUT)
-    
-    printer = RubyProf::GraphHtmlPrinter.new(@result)
-    printer.print
-    
-    printer = RubyProf::GraphPrinter.new(@result)
-    printer.print
-    
-    printer = RubyProf::CallTreePrinter.new(@result)
-    printer.print(STDOUT)    
-    # we should get here    
+    assert_nothing_raised do
+      output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : StringIO.new('')
+
+      printer = RubyProf::FlatPrinter.new(@result)
+      printer.print(output)
+
+      printer = RubyProf::FlatPrinterWithLineNumbers.new(@result)
+      printer.print(output)
+
+      printer = RubyProf::GraphHtmlPrinter.new(@result)
+      printer.print(output)
+
+      printer = RubyProf::GraphPrinter.new(@result)
+      printer.print(output)
+
+      printer = RubyProf::CallTreePrinter.new(@result)
+      printer.print(output)
+      output_dir = 'examples2'
+
+      if ENV['SAVE_NEW_PRINTER_EXAMPLES']
+        output_dir = 'examples'
+      end
+      FileUtils.mkdir_p output_dir
+
+      printer = RubyProf::DotPrinter.new(@result)
+      File.open("#{output_dir}/graph.dot", "w") {|f| printer.print(f)}
+
+      printer = RubyProf::CallStackPrinter.new(@result)
+      File.open("#{output_dir}/stack.html", "w") {|f| printer.print(f, :application => "primes")}
+
+      printer = RubyProf::MultiPrinter.new(@result)
+      printer.print(:path => "#{output_dir}", :profile => "multi", :application => "primes")
+      for file in ['empty.png', 'graph.dot', 'minus.png', 'multi.flat.txt', 'multi.graph.html', 'multi.grind.dat', 'multi.stack.html', 'plus.png', 'stack.html']
+        existant_file = output_dir + '/' + file
+        assert File.size(existant_file) > 0
+      end
+    end
   end
 
   def test_flat_string
@@ -44,32 +72,32 @@ class PrintersTest < Test::Unit::TestCase
 
   def helper_test_flat_string klass
     output = ''
-    
+
     printer = klass.new(@result)
     printer.print(output)
-    
+
     assert_match(/Thread ID: -?\d+/i, output)
     assert_match(/Total: \d+\.\d+/i, output)
     assert_match(/Object#run_primes/i, output)
     output
   end
-  
+
   def test_flat_string_with_numbers
     output = helper_test_flat_string RubyProf::FlatPrinterWithLineNumbers
-    assert_match(/prime.rb/, output)    
+    assert_match(/prime.rb/, output)
     assert_no_match(/ruby_runtime:0/, output)
     assert_match(/called from/, output)
-    
+
     # should combine common parents
     if RUBY_VERSION < '1.9'
-        assert_equal(3, output.scan(/Object#is_prime/).length)
-	  else
-		  # 1.9
-		  assert_equal(2, output.scan(/Object#is_prime/).length)		
+      assert_equal(3, output.scan(/Object#is_prime/).length)
+    else
+      # 1.9 inlines it's  Fixnum#- so we don't see as many
+      assert_equal(2, output.scan(/Object#is_prime/).length)
     end
-	  assert_no_match(/\.\/test\/prime.rb/, output) # don't use relative paths
+    assert_no_match(/\.\/test\/prime.rb/, output) # don't use relative paths
   end
-    
+
   def test_graph_html_string
     output = ''
     printer = RubyProf::GraphHtmlPrinter.new(@result)
@@ -79,7 +107,7 @@ class PrintersTest < Test::Unit::TestCase
     assert_match( %r{<th>Total Time</th>}i, output )
     assert_match( /Object#run_primes/i, output )
   end
-    
+
   def test_graph_string
     output = ''
     printer = RubyProf::GraphPrinter.new(@result)
@@ -89,42 +117,140 @@ class PrintersTest < Test::Unit::TestCase
     assert_match( /Total Time: \d+\.\d+/i, output )
     assert_match( /Object#run_primes/i, output )
   end
-    
+
   def test_call_tree_string
     output = ''
     printer = RubyProf::CallTreePrinter.new(@result)
     printer.print(output)
-
-    assert_match(/fn=Object::find_primes/i, output)
+    assert_match(/fn=Object#find_primes/i, output)
     assert_match(/events: wall_time/i, output)
+    assert_no_match(/d\d\d\d\d\d/, output) # old bug looked [in error] like Object::run_primes(d5833116)
   end
-  
+
   def do_nothing
     start = Time.now
     while(Time.now == start)
     end
   end
-  
+
   def test_all_with_small_percentiles
-    
     result = RubyProf.profile do
       sleep 2
-      do_nothing 
+      do_nothing
     end
-    
+
     # RubyProf::CallTreePrinter doesn't "do" a min_percent
     # RubyProf::FlatPrinter only outputs if self time > percent...
     # RubyProf::FlatPrinterWithLineNumbers same
     for klass in [ RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter]
-      puts klass
       printer = klass.new(result)
       out = ''
-      output = printer.print(out, :min_percent => 0.00000001 )
-      assert_match(/do_nothing/, out)      
+      printer.print(out, :min_percent => 0.00000001 )
+      assert_match(/do_nothing/, out)
     end
-    
-  end    
-  
-  
-  
+
+  end
+
+  def test_flat_result_sorting_by_self_time_is_default
+    printer = RubyProf::FlatPrinter.new(@result)
+
+    printer.print(output = '')
+    self_times = flat_output_nth_column_values(output, 3)
+
+    assert_sorted self_times
+  end
+
+  def test_flat_result_sorting
+    printer = RubyProf::FlatPrinter.new(@result)
+
+    sort_method_with_column_number = {:total_time => 2, :self_time => 3, :wait_time => 4, :children_time => 5}
+
+    sort_method_with_column_number.each_pair do |sort_method, n|
+      printer.print(output = '', :sort_method => sort_method)
+      times = flat_output_nth_column_values(output, n)
+      assert_sorted times
+    end
+  end
+
+  def test_flat_result_with_line_numbers_sorting_by_self_time_is_default
+    printer = RubyProf::FlatPrinterWithLineNumbers.new(@result)
+
+    printer.print(output = '')
+    self_times = flat_output_nth_column_values(output, 3)
+
+    assert_sorted self_times
+  end
+
+  def test_flat_with_line_numbers_result_sorting
+    printer = RubyProf::FlatPrinterWithLineNumbers.new(@result)
+
+    sort_method_with_column_number = {:total_time => 2, :self_time => 3, :wait_time => 4, :children_time => 5}
+
+    sort_method_with_column_number.each_pair do |sort_method, n|
+      printer.print(output = '', :sort_method => sort_method)
+      times = flat_output_nth_column_values(output, n)
+      assert_sorted times
+    end
+  end
+
+  def test_graph_result_sorting_by_total_time_is_default
+    printer = RubyProf::GraphPrinter.new(@result)
+    printer.print(output = '')
+    total_times = graph_output_nth_column_values(output, 3)
+
+    assert_sorted total_times
+  end
+
+  def test_graph_results_sorting
+    printer = RubyProf::GraphPrinter.new(@result)
+
+    sort_method_with_column_number = {:total_time => 3, :self_time => 4, :wait_time => 5, :children_time => 6}
+
+    sort_method_with_column_number.each_pair do |sort_method, n|
+      printer.print(output = '', :sort_method => sort_method)
+      times = graph_output_nth_column_values(output, n)
+      assert_sorted times
+    end
+  end
+
+  def test_graph_html_result_sorting_by_total_time_is_default
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    printer.print(output = '')
+    total_times = graph_html_output_nth_column_values(output, 3)
+
+    assert_sorted total_times
+  end
+
+  def test_graph_html_result_sorting
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+
+    sort_method_with_column_number = {:total_time => 3, :self_time => 4, :wait_time => 5, :children_time => 6}
+
+    sort_method_with_column_number.each_pair do |sort_method, n|
+      printer.print(output = '', :sort_method => sort_method)
+      times = graph_html_output_nth_column_values(output, n)
+      assert_sorted times
+    end
+  end
+
+  private
+  def flat_output_nth_column_values(output, n)
+    only_method_calls = output.split("\n").select { |line| line =~ /^ +\d+/ }
+    only_method_calls.collect { |line| line.split(/ +/)[n] }
+  end
+
+  def graph_output_nth_column_values(output, n)
+    only_root_calls = output.split("\n").select { |line| line =~ /^ +[\d\.]+%/ }
+    only_root_calls.collect { |line| line.split(/ +/)[n] }
+  end
+
+  def graph_html_output_nth_column_values(output, n)
+    only_root_calls = output.split('<tr class="method">')
+    only_root_calls.delete_at(0)
+    only_root_calls.collect {|line| line.scan(/[\d\.]+/)[n - 1] }
+  end
+
+  def assert_sorted array
+    assert_equal array, array.sort.reverse, "Array #{array.inspect} is not sorted"
+  end
 end

data/test/recursive_test.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
-require 'test/unit'
-require 'ruby-prof'
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
 
 def simple(n)
   sleep(1)
@@ -34,13 +35,13 @@ class RecursiveTest < Test::Unit::TestCase
     end
 
     methods = result.threads.values.first.sort.reverse
-    
+
     if RUBY_VERSION < '1.9'
-      assert_equal(6, methods.length) # includes Fixnum+, Fixnum==...
+      assert_equal(5, methods.length) # includes Fixnum+, Fixnum==...
     else
-      assert_equal(4, methods.length)
+      assert_equal(3, methods.length) # which don't show up in 1.9
     end
-    
+
     method = methods[0]
     assert_equal('RecursiveTest#test_simple', method.full_name)
     assert_equal(1, method.called)
@@ -56,13 +57,13 @@ class RecursiveTest < Test::Unit::TestCase
 
     method = methods[1]
     assert_equal('Object#simple', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.02)
-    assert_in_delta(0, method.self_time, 0.02)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(2, method.children_time, 0.02)
+    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_equal(1, method.call_infos.length)
+    assert_equal(2, method.call_infos.length)
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_simple->Object#simple', call_info.call_sequence)
     if RUBY_VERSION < '1.9'
@@ -70,13 +71,14 @@ class RecursiveTest < Test::Unit::TestCase
     else
       assert_equal(2, call_info.children.length)
     end
+
     method = methods[2]
     assert_equal('Kernel#sleep', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(2, method.total_time, 0.01)
-    assert_in_delta(2, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.children_time, 0.01)
+    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_equal(2, method.call_infos.length)
     call_info = method.call_infos[0]
@@ -84,24 +86,11 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal(0, call_info.children.length)
 
     call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple(d1)->Kernel#sleep', call_info.call_sequence)
+    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
 
-    method = methods[3]
-    assert_equal('Object#simple(d1)', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(1, 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(1, method.children_time, 0.01)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple(d1)', call_info.call_sequence)
     if RUBY_VERSION < '1.9'
-      assert_equal(3, call_info.children.length)
-
-      method = methods[4]
+      method = methods[3]
       assert_equal('Fixnum#-', method.full_name)
       assert_equal(2, method.called)
       assert_in_delta(0, method.total_time, 0.01)
@@ -115,10 +104,10 @@ class RecursiveTest < Test::Unit::TestCase
       assert_equal(0, call_info.children.length)
 
       call_info = method.call_infos[1]
-      assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple(d1)->Fixnum#-', call_info.call_sequence)
+      assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple->Fixnum#-', call_info.call_sequence)
       assert_equal(0, call_info.children.length)
 
-      method = methods[5]
+      method = methods[4]
       assert_equal('Fixnum#==', method.full_name)
       assert_equal(2, method.called)
       assert_in_delta(0, method.total_time, 0.01)
@@ -132,11 +121,8 @@ class RecursiveTest < Test::Unit::TestCase
       assert_equal(0, call_info.children.length)
 
       call_info = method.call_infos[1]
-      assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple(d1)->Fixnum#==', call_info.call_sequence)
+      assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple->Fixnum#==', call_info.call_sequence)
       assert_equal(0, call_info.children.length)
-
-    else
-      assert_equal(1, call_info.children.length)
     end
   end
 
@@ -147,9 +133,9 @@ class RecursiveTest < Test::Unit::TestCase
 
     methods = result.threads.values.first.sort.reverse
     if RUBY_VERSION < '1.9'
-      assert_equal(8, methods.length) # includes Fixnum+ and Fixnum==, which aren't included in 1.9
+      assert_equal(6, methods.length) # includes Fixnum+ and Fixnum==, which aren't included in 1.9
     else
-      assert_equal(6, methods.length)
+      assert_equal(4, methods.length) # which don't show up in 1.9
     end
     method = methods[0]
     assert_equal('RecursiveTest#test_cycle', method.full_name)
@@ -166,26 +152,26 @@ class RecursiveTest < Test::Unit::TestCase
 
     method = methods[1]
     assert_equal('Object#cycle', method.full_name)
-    assert_equal(1, method.called)
+    assert_equal(2, method.called)
     assert_in_delta(2, method.total_time, 0.05)
     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_equal(1, method.call_infos.length)
+    assert_equal(2, method.call_infos.length)
     call_info = method.call_infos[0]
     assert_equal('RecursiveTest#test_cycle->Object#cycle', call_info.call_sequence)
     assert_equal(1, call_info.children.length)
 
     method = methods[2]
     assert_equal('Object#sub_cycle', method.full_name)
-    assert_equal(1, method.called)
+    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_equal(1, method.call_infos.length)
+    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'
@@ -208,33 +194,11 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal(0, call_info.children.length)
 
     call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle(d1)->Object#sub_cycle(d1)->Kernel#sleep', call_info.call_sequence)
+    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)
 
-    method = methods[4]
-    assert_equal('Object#cycle(d1)', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(1, method.children_time, 0.05)
-
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle(d1)', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    method = methods[5]
-    assert_equal('Object#sub_cycle(d1)', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle(d1)->Object#sub_cycle(d1)', call_info.call_sequence)
     if RUBY_VERSION < '1.9'
-      assert_equal(3, call_info.children.length)
-      method = methods[6]
+      method = methods[4]
       assert_equal('Fixnum#-', method.full_name)
       assert_equal(2, method.called)
       assert_in_delta(0, method.total_time, 0.01)
@@ -248,10 +212,10 @@ class RecursiveTest < Test::Unit::TestCase
       assert_equal(0, call_info.children.length)
 
       call_info = method.call_infos[1]
-      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle(d1)->Object#sub_cycle(d1)->Fixnum#-', call_info.call_sequence)
+      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)
 
-      method = methods[7]
+      method = methods[5]
       assert_equal('Fixnum#==', method.full_name)
       assert_equal(2, method.called)
       assert_in_delta(0, method.total_time, 0.01)
@@ -265,10 +229,8 @@ class RecursiveTest < Test::Unit::TestCase
       assert_equal(0, call_info.children.length)
 
       call_info = method.call_infos[1]
-      assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle(d1)->Object#sub_cycle(d1)->Fixnum#==', call_info.call_sequence)
+      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)
-    else
-      assert_equal(1, call_info.children.length)
     end
 
   end