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

data/test/measure_wall_time_test.rb

@@ -0,0 +1,209 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class MeasureWallTimeTest < 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_mode
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    assert_equal(RubyProf::WALL_TIME, RubyProf::measure_mode)
+  end
+
+  def test_wall_time_enabled_defined
+    assert(defined?(RubyProf::WALL_TIME_ENABLED))
+  end
+
+  def test_class_methods
+    result = RubyProf.profile do
+      RubyProf::C1.hello
+    end
+
+    # Length should be 3:
+    #   MeasureWallTimeTest#test_class_methods
+    #   <Class::RubyProf::C1>#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('MeasureWallTimeTest#test_class_methods', methods[0].full_name)
+    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    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_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_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)
+  end
+
+  def test_instance_methods
+    result = RubyProf.profile do
+      RubyProf::C1.new.hello
+    end
+
+    # Methods called
+    #   MeasureWallTimeTest#test_instance_methods
+    #   Class.new
+    #   Class:Object#allocate
+    #   for Object#initialize
+    #   C1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(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"))
+
+    # Check times
+    assert_in_delta(0.2, 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, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.2, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    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)
+  end
+
+  def test_module_methods
+    result = RubyProf.profile do
+      RubyProf::C2.hello
+    end
+
+    # Methods:
+    #   MeasureWallTimeTest#test_module_methods
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    assert_equal('MeasureWallTimeTest#test_module_methods', methods[0].full_name)
+    assert_equal('RubyProf::M1#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.3, methods[0].total_time, 0.1)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
+
+    assert_in_delta(0.3, methods[1].total_time, 0.1)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.1)
+    assert_in_delta(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:
+    #   MeasureWallTimeTest#test_module_instance_methods
+    #   Class#new
+    #   <Class::Object>#allocate
+    #   Object#initialize
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(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"))
+
+    # Check times
+    assert_in_delta(0.3, methods[0].total_time, 0.1)
+    assert_in_delta(0, methods[0].wait_time, 0.1)
+    assert_in_delta(0, methods[0].self_time, 0.1)
+
+    assert_in_delta(0.3, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    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)
+  end
+
+  def test_singleton
+    c3 = RubyProf::C3.new
+
+    class << c3
+      def hello
+      end
+    end
+
+    result = RubyProf.profile do
+      c3.hello
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(2, methods.length)
+
+    assert_equal('MeasureWallTimeTest#test_singleton', methods[0].full_name)
+    assert_equal('<Object::RubyProf::C3>#hello', methods[1].full_name)
+
+    assert_in_delta(0, 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_in_delta(0, 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)
+  end
+end

data/test/method_elimination_test.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'tmpdir'
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class ESTPT
+  def a
+    100.times{b}
+    300.times{c}
+    c;c;c
+  end
+
+  def b
+    sleep 0
+  end
+
+  def c
+    5.times{b}
+  end
+end
+
+class MethodEliminationTest < 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_setting_parent
+    result = RubyProf.profile do
+      1000.times { 1+1 }
+    end
+    method_infos = result.threads.values.first
+    assert(m1 = method_infos[0])
+    assert(c1 = m1.call_infos.first)
+    assert_equal(c1, c1.parent = c1)
+    assert_equal c1, c1.parent
+  end
+
+  def test_methods_can_be_eliminated
+    RubyProf.start
+    5.times{ESTPT.new.a}
+    result = RubyProf.stop
+    # result.dump
+    eliminated = result.eliminate_methods!([/Integer#times/])
+    # puts eliminated.inspect
+    # result.dump
+    eliminated.each do |m|
+      assert_method_has_been_eliminated(result, m)
+    end
+  end
+
+  private
+  def assert_method_has_been_eliminated(result, eliminated_method)
+    result.threads.each do |thread_id, methods|
+      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
+          ci.children.each do |callee|
+            assert(callee.target != eliminated_method, "broken kid")
+          end
+        end
+      end
+    end
+  end
+end

data/test/module_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__)
 
 # Need to use wall time for this test due to the sleep calls
 RubyProf::measure_mode = RubyProf::WALL_TIME
@@ -16,7 +17,7 @@ module Bar
     sleep(0.5)
     Foo::hello
   end
-  
+
   def hello
     sleep(0.5)
     Bar::hello
@@ -31,24 +32,14 @@ class ModuleTest < Test::Unit::TestCase
       hello
     end
 
-    methods = result.threads.values.first.sort.reverse
-      
+    methods = result.threads.values.first
+
     # Length should be 5
     assert_equal(5, methods.length)
-    
-    method = methods[0]
-    assert_equal('ModuleTest#test_nested_modules', method.full_name)
-    
-    method = methods[1]
-    assert_equal('Bar#hello', method.full_name)
-
-    method = methods[2]
-    assert_equal('Kernel#sleep', method.full_name)
-    
-    method = methods[3]
-    assert_equal('<Module::Bar>#hello', method.full_name)
-    
-    method = methods[4]
-    assert_equal('<Module::Foo>#hello', method.full_name)
-  end 
+
+    # these methods should be in there... (hard to tell order though).
+    for name in ['ModuleTest#test_nested_modules','Bar#hello','Kernel#sleep','<Module::Bar>#hello','<Module::Foo>#hello']
+      assert methods.map(&:full_name).include?( name )
+    end
+  end
 end

data/test/multi_printer_test.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'tmpdir'
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class MSTPT
+  def a
+    100.times{b}
+    300.times{c}
+    c;c;c
+  end
+
+  def b
+    sleep 0
+  end
+
+  def c
+    5.times{b}
+  end
+end
+
+class MultiPrinterTest < 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_all_profiles_can_be_created
+    start_time = Time.now
+    RubyProf.start
+    5.times{MSTPT.new.a}
+    result = RubyProf.stop
+    end_time = Time.now
+    expected_time = end_time - start_time
+    stack = graph = nil
+    assert_nothing_raised { stack, graph = print(result) }
+    re = Regexp.new('
+\s*<table>
+\s*<tr>
+\s*<th>Thread ID</th>
+\s*<th>Total Time</th>
+\s*</tr>
+\s*
+\s*<tr>
+\s*<td><a href="#\d+">\d+</a></td>
+\s*<td>([\.0-9]+)</td>
+\s*</tr>
+\s*
+\s*</table>')
+    assert graph =~ re
+    display_time = $1.to_f
+    difference = (expected_time-display_time).abs
+    assert_in_delta expected_time, display_time, 0.005
+  end
+
+  private
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    path = Dir::tmpdir
+    profile = "ruby_prof_#{test}"
+    printer = RubyProf::MultiPrinter.new(result)
+    printer.print(:path => path, :profile => profile,
+                  :threshold => 0, :min_percent => 0, :title => "ruby_prof #{test}")
+    if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
+      system("open '#{printer.stack_profile}'")
+    end
+    if GC.respond_to?(:dump_file_and_line_info)
+      GC.start
+      GC.dump_file_and_line_info("heap.dump")
+    end
+    [File.open(printer.stack_profile){|f|f.read}, File.open(printer.graph_profile){|f|f.read}]
+  end
+end

data/test/no_method_class_test.rb

@@ -1,8 +1,10 @@
 #!/usr/bin/env ruby
-require 'ruby-prof'
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
 
 # Make sure this works with no class or method
-result = RubyProf.profile do 
+result = RubyProf.profile do
   sleep 1
 end
 
@@ -10,4 +12,4 @@ methods = result.threads.values.first
 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}")
-end
+end

data/test/prime.rb

@@ -1,7 +1,7 @@
 # A silly little test program that finds prime numbers.  It
 # is intentionally badly designed to show off the use
 # of ruby-prof.
-# 
+#
 # Source from http://people.cs.uchicago.edu/~bomb154/154/maclabs/profilers-lab/
 
 def make_random_array(length, maxnum)
@@ -9,10 +9,10 @@ def make_random_array(length, maxnum)
   result.each_index do |i|
     result[i] = rand(maxnum)
   end
-    
+
   result
 end
- 
+
 def is_prime(x)
   y = 2
   y.upto(x-1) do |i|
@@ -43,16 +43,13 @@ def find_largest(primes)
   largest
 end
 
-def run_primes
-  length = 10
-  maxnum = 1000
-  
+def run_primes(length=10, maxnum=1000)
   # Create random numbers
   random_array = make_random_array(length, maxnum)
-  
+
   # Find the primes
   primes = find_primes(random_array)
-  
+
   # Find the largest primes
   # largest = find_largest(primes)
-end
+end