ruby-prof 0.6.0 → 0.7.0

data/test/profile_unit_test.rb

@@ -1,24 +1,22 @@
 #!/usr/bin/env ruby
-
 require 'test/unit'
 require 'ruby-prof'
-require 'test_helper'
-require 'ruby-prof/profile_test_case'
 
 # Need to use wall time for this test due to the sleep calls
 RubyProf::measure_mode = RubyProf::WALL_TIME
 
 # --  Tests ----
 class ProfileTest < Test::Unit::TestCase
-  def test_profile
-    sleep(2)    
-  end
-
+  include RubyProf::Test
+  
   def teardown
-    profile_dir = output_directory
-    assert(File.exists?(profile_dir))
+    profile_dir = output_dir
     
-    file_path = File.join(profile_dir, 'test_profile_profile_test.html')
-    assert(File.exists?(file_path))
+    #file_path = File.join(profile_dir, 'test_profile_profile_test.html')
+    #assert(File.exists?(file_path))
+  end
+  
+  def test_profile
+    sleep(1)    
   end
-end
+end

data/test/recursive_test.rb

@@ -1,11 +1,6 @@
 #!/usr/bin/env ruby
-
 require 'test/unit'
 require 'ruby-prof'
-require 'test_helper'
-
-# Need to use wall time for this test due to the sleep calls
-RubyProf::measure_mode = RubyProf::WALL_TIME
 
 def simple(n)
   sleep(1)
@@ -25,120 +20,235 @@ def sub_cycle(n)
   cycle(n)
 end
 
-def factorial(n)
-  if n < 2 then
-    n
-  else 
-    n * factorial(n-1)
-  end
-end
-
 
 # --  Tests ----
 class RecursiveTest < Test::Unit::TestCase
-  def test_recursive
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_simple
     result = RubyProf.profile do
       simple(2)
     end
-    
-    result.threads.values.each do |methods|
-      methods.each do |method|
-        check_parent_times(method)
-        check_parent_calls(method)
-        check_child_times(method)   
-      end
-    end
-    
-    
+
     methods = result.threads.values.first.sort.reverse
-    assert_equal(6, methods.length)   
+    assert_equal(6, methods.length)
 
     method = methods[0]
-    assert_equal('RecursiveTest#test_recursive', method.full_name)
-    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(0, method.called)
-    assert_equal(0, method.parents.length)
-    assert_equal(1, method.children.length)
+    assert_equal('RecursiveTest#test_simple', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, 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(2, method.children_time, 0.01)
+
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('RecursiveTest#test_simple', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
 
     method = methods[1]
     assert_equal('Object#simple', method.full_name)
-    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(1, method.called)
-    assert_equal(1, method.parents.length)
-    assert_equal(4, method.children.length)
-    
+    assert_in_delta(2, 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(2, 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', call_info.call_sequence)
+    assert_equal(4, call_info.children.length)
+
     method = methods[2]
     assert_equal('Kernel#sleep', method.full_name)
-    assert_in_delta(2, method.total_time, 0.02)
-    assert_in_delta(2, method.self_time, 0.02)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(0, method.children_time, 0.02)
     assert_equal(2, method.called)
-    assert_equal(2, method.parents.length)
-    assert_equal(0, method.children.length)
-    
+    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_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)
+
+    call_info = method.call_infos[1]
+    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple-1->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
     method = methods[3]
     assert_equal('Object#simple-1', method.full_name)
-    assert_in_delta(1, 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(1, method.children_time, 0.02)
     assert_equal(1, method.called)
-    assert_equal(1, method.parents.length)
-    assert_equal(3, method.children.length)
-    
+    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-1', call_info.call_sequence)
+    assert_equal(3, call_info.children.length)
+
     method = methods[4]
-    assert_equal('Fixnum#==', method.full_name)
-    assert_in_delta(0, 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(0, method.children_time, 0.02)
+    assert_equal('Fixnum#-', method.full_name)
     assert_equal(2, method.called)
-    assert_equal(2, method.parents.length)
-    assert_equal(0, method.children.length)
-    
+    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_simple->Object#simple->Fixnum#-', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    call_info = method.call_infos[1]
+    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple-1->Fixnum#-', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
     method = methods[5]
-    assert_equal('Fixnum#-', method.full_name)
-    assert_in_delta(0, 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(0, method.children_time, 0.02)
+    assert_equal('Fixnum#==', method.full_name)
     assert_equal(2, method.called)
-    assert_equal(2, method.parents.length)
-    assert_equal(0, method.children.length)
+    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_simple->Object#simple->Fixnum#==', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    call_info = method.call_infos[1]
+    assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple-1->Fixnum#==', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
   end
   
   def test_cycle
     result = RubyProf.profile do
       cycle(2)
     end
-    result.threads.values.each do |methods|
-      methods.each do |method|
-        check_parent_times(method)
-        check_parent_calls(method)
-        check_child_times(method)   
-      end
-    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(8, methods.length)
+
+    method = methods[0]
+    assert_equal('RecursiveTest#test_cycle', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, 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(2, method.children_time, 0.01)
+
+    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)
+
+    method = methods[1]
+    assert_equal('Object#cycle', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, 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(2, method.children_time, 0.01)
+
+    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(1, call_info.children.length)
+
+    method = methods[2]
+    assert_equal('Object#sub_cycle', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, 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(2, method.children_time, 0.01)
+
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle', call_info.call_sequence)
+    assert_equal(4, call_info.children.length)
+
+    method = methods[3]
+    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_equal(2, 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)
+
+    call_info = method.call_infos[1]
+    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1->Object#sub_cycle-1->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[4]
+    assert_equal('Object#cycle-1', 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_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[5]
+    assert_equal('Object#sub_cycle-1', 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_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1->Object#sub_cycle-1', call_info.call_sequence)
+    assert_equal(3, call_info.children.length)
+
+    method = methods[6]
+    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)
+
+    call_info = method.call_infos[1]
+    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1->Object#sub_cycle-1->Fixnum#-', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[7]
+    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)
+
+    call_info = method.call_infos[1]
+    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle-1->Object#sub_cycle-1->Fixnum#==', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
   end
-  
-  def test_factorial
-    result = RubyProf.profile do
-      # Around 700 on windows causes "stack level too deep" error
-      factorial(650)
-    end
-   
-    result.threads.values.each do |methods|
-      methods.each do |method|
-        check_parent_times(method)
-        check_parent_calls(method)
-        check_child_times(method)   
-      end
-    end
-  end   
-end
+end

data/test/singleton_test.rb

@@ -34,5 +34,4 @@ class SingletonTest < Test::Unit::TestCase
     printer = RubyProf::FlatPrinter.new(result)
     printer.print(STDOUT)
   end
-end
-
+end

data/test/stack_test.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class C1
+  def a
+    sleep 1
+    b
+    c
+  end
+
+  def b
+    sleep 2
+  end
+
+  def c
+    sleep 3
+    b
+  end
+end
+
+class StackTest < 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_call_sequence
+    c = C1.new
+    result = RubyProf.profile do
+      c.a
+    end
+
+    # Length should be 5:
+    #   StackTest#test_call_sequence
+    #   C1#a
+    #   Kernel#sleep
+    #   C1#c
+    #   C1#b
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(5, methods.length)
+
+    # Check StackTest#test_call_sequence
+    method = methods[0]
+    assert_equal('StackTest#test_call_sequence', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(8, method.total_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(0, method.self_time, 0.01)
+    assert_in_delta(8, method.children_time, 0.01)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StackTest#test_call_sequence', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    # Check C1#a
+    method = methods[1]
+    assert_equal('C1#a', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(8, method.total_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(0, method.self_time, 0.01)
+    assert_in_delta(8, method.children_time, 0.01)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StackTest#test_call_sequence->C1#a', call_info.call_sequence)
+    assert_equal(3, call_info.children.length)
+    
+    # Check Kernel#sleep
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(4, method.called)
+    assert_in_delta(8, method.total_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(8, method.self_time, 0.01)
+    assert_in_delta(0, method.children_time, 0.01)
+    assert_equal(4, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StackTest#test_call_sequence->C1#a->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    call_info = method.call_infos[1]
+    assert_equal('StackTest#test_call_sequence->C1#a->C1#b->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    call_info = method.call_infos[2]
+    assert_equal('StackTest#test_call_sequence->C1#a->C1#c->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    call_info = method.call_infos[3]
+    assert_equal('StackTest#test_call_sequence->C1#a->C1#c->C1#b->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    # Check C1#c
+    method = methods[3]
+    assert_equal('C1#c', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(5, method.total_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(0, method.self_time, 0.01)
+    assert_in_delta(5, method.children_time, 0.01)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StackTest#test_call_sequence->C1#a->C1#c', call_info.call_sequence)
+    assert_equal(2, call_info.children.length)
+
+    # Check C1#b
+    method = methods[4]
+    assert_equal('C1#b', method.full_name)
+    assert_equal(2, method.called)
+    assert_in_delta(4, method.total_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(0, method.self_time, 0.01)
+    assert_in_delta(4, method.children_time, 0.01)
+    assert_equal(2, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StackTest#test_call_sequence->C1#a->C1#b', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    call_info = method.call_infos[1]
+    assert_equal('StackTest#test_call_sequence->C1#a->C1#c->C1#b', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+  end
+end