skaes-ruby-prof 0.7.3

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 StackClass
+  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 = StackClass.new
+    result = RubyProf.profile do
+      c.a
+    end
+
+    # Length should be 5:
+    #   StackTest#test_call_sequence
+    #   StackClass#a
+    #   Kernel#sleep
+    #   StackClass#c
+    #   StackClass#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 StackClass#a
+    method = methods[1]
+    assert_equal('StackClass#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->StackClass#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->StackClass#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->StackClass#a->StackClass#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->StackClass#a->StackClass#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->StackClass#a->StackClass#c->StackClass#b->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    # Check StackClass#c
+    method = methods[3]
+    assert_equal('StackClass#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->StackClass#a->StackClass#c', call_info.call_sequence)
+    assert_equal(2, call_info.children.length)
+
+    # Check StackClass#b
+    method = methods[4]
+    assert_equal('StackClass#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->StackClass#a->StackClass#b', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    call_info = method.call_infos[1]
+    assert_equal('StackTest#test_call_sequence->StackClass#a->StackClass#c->StackClass#b', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+  end
+end

data/test/start_stop_test.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+ 
+class StartStopTest < 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 method1
+     RubyProf.start
+     method2
+  end
+
+  def method2
+     method3
+  end
+
+  def method3
+    sleep(2)
+    @result = RubyProf.stop
+  end
+
+  def test_different_methods
+    method1
+
+    # Ruby prof should be stopped
+    assert_equal(false, RubyProf.running?)
+
+
+    # Length should be 4:
+    #   StartStopTest#method1
+    #   StartStopTest#method2
+    #   StartStopTest#method3
+    #   Kernel#sleep
+
+    methods = @result.threads.values.first.sort.reverse
+    assert_equal(4, methods.length)
+
+    # Check StackTest#test_call_sequence
+    method = methods[0]
+    assert_equal('StartStopTest#method1', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, 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(2, method.children_time, 0.01)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StartStopTest#method1', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[1]
+    assert_equal('StartStopTest#method2', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, 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(2, method.children_time, 0.01)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StartStopTest#method1->StartStopTest#method2', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[2]
+    assert_equal('StartStopTest#method3', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, 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(2, method.children_time, 0.01)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StartStopTest#method1->StartStopTest#method2->StartStopTest#method3', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[3]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(2, method.self_time, 0.01)
+    assert_in_delta(0, method.children_time, 0.01)
+    assert_equal(1, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('StartStopTest#method1->StartStopTest#method2->StartStopTest#method3->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+  end
+end

data/test/test_suite.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+
+require 'aggregate_test'
+require 'basic_test'
+require 'duplicate_names_test'
+require 'exceptions_test'
+require 'line_number_test'
+require 'measurement_test'
+require 'module_test'
+require 'no_method_class_test'
+require 'prime_test'
+require 'printers_test'
+require 'recursive_test'
+require 'singleton_test'
+require 'stack_test'
+require 'start_stop_test'
+require 'thread_test'
+require 'unique_call_path_test'
+require 'stack_printer_test'
+require 'multi_printer_test'
+require 'method_elimination_test'
+
+# Can't use this one here cause it breaks
+# the rest of the unit tets (Ruby Prof gets
+# started twice).
+#require 'profile_unit_test'

data/test/thread_test.rb

@@ -0,0 +1,159 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require 'timeout'
+
+# --  Tests ----
+class ThreadTest < 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_thread_count
+    RubyProf.start
+
+    thread = Thread.new do
+      sleep(1)
+    end
+
+    thread.join
+    result = RubyProf.stop
+
+    assert_equal(2, result.threads.keys.length)
+  end
+
+  def test_thread_identity
+    RubyProf.start
+
+    thread = Thread.new do
+      sleep(1)
+    end
+
+    thread.join
+    result = RubyProf.stop
+
+    thread_ids = result.threads.keys.sort
+    threads = [Thread.current, thread].sort_by {|thread| thread.object_id}
+
+    assert_equal(threads[0].object_id, thread_ids[0])
+    assert_equal(threads[1].object_id, thread_ids[1])
+
+    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[0]))
+    assert_equal(threads[0], ObjectSpace._id2ref(thread_ids[0]))
+
+    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[1]))
+    assert_equal(threads[1], ObjectSpace._id2ref(thread_ids[1]))
+  end
+
+  def test_thread_timings
+    RubyProf.start
+
+    thread = Thread.new do
+      sleep(1)
+    end
+
+    thread.join
+
+    result = RubyProf.stop
+
+    # Check background thread
+    methods = result.threads[thread.object_id].sort.reverse
+    assert_equal(2, methods.length)
+
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', 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(1, method.wait_time, 0.01)
+    assert_in_delta(0, method.children_time, 0.01)
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[1]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(1, method.total_time, 0.01)
+    assert_in_delta(1.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(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    # Check foreground thread
+    methods = result.threads[Thread.current.object_id].sort.reverse
+    assert_equal(4, methods.length)
+    methods = methods.sort.reverse
+
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    assert_equal(0, method.called)
+    assert_in_delta(1, method.total_time, 0.01)
+    assert_in_delta(0, method.self_time, 0.01)
+    assert_in_delta(1.0, method.wait_time, 0.01)
+    assert_in_delta(0, method.children_time, 0.01)
+
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings', call_info.call_sequence)
+    assert_equal(2, call_info.children.length)
+
+    method = methods[1]
+    assert_equal('Thread#join', 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(1.0, method.wait_time, 0.01)
+    assert_in_delta(0, method.children_time, 0.01)
+
+    assert_equal(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings->Thread#join', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[2]
+    assert_equal('<Class::Thread>#new', method.full_name)
+    assert_equal(1, 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(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings-><Class::Thread>#new', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[3]
+    assert_equal('Thread#initialize', method.full_name)
+    assert_equal(1, 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(1, method.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('ThreadTest#test_thread_timings-><Class::Thread>#new->Thread#initialize', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+  end
+  
+  def test_thread
+    result = RubyProf.profile do
+      begin
+        status = Timeout::timeout(2) do
+          while true
+            next
+          end
+        end
+      rescue Timeout::Error
+      end
+    end
+  end
+end

data/test/unique_call_path_test.rb

@@ -0,0 +1,206 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+class UniqueCallPath
+  def method_a(i)
+    if i==1
+      method_b
+    else
+      method_c
+    end
+  end
+
+  def method_b
+    method_c
+  end
+
+  def method_c
+    c = 3
+  end
+
+  def method_k(i)
+    method_a(i)
+  end
+end
+
+
+# --  Tests ----
+class UniqueCallPathTest < Test::Unit::TestCase
+  def test_root_method
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+    end
+
+    root_methods = Array.new
+    result.threads.each do | thread_id, methods |
+      methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    assert_equal(1, root_methods.length)
+    assert_equal("UniqueCallPathTest#test_root_method", root_methods[0].full_name)
+  end
+
+  def test_root_children
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+      unique_call_path.method_k(2)
+    end
+
+    root_methods = Array.new
+    result.threads.each do | thread_id, methods |
+      methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    assert_equal(1, root_methods.length)
+
+    root_children = Array.new
+    root_methods[0].children.each do | c |
+      if c.parent.target.eql?(root_methods[0])
+        root_children.push(c)
+      end
+    end
+
+    children = root_children.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(2, children.length)
+    assert_equal("UniqueCallPath#method_a", children[0].target.full_name)
+    assert_equal("UniqueCallPath#method_k", children[1].target.full_name)
+  end
+
+  def test_children_of
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+      unique_call_path.method_k(2)
+    end
+
+    root_methods = Array.new
+    result.threads.each do | thread_id, methods |
+      methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    assert_equal(1, root_methods.length)
+    method = root_methods[0]
+    assert_equal('UniqueCallPathTest#test_children_of', method.full_name)
+
+    call_info_a = nil
+    root_methods[0].children.each do | c |
+      if c.target.full_name == "UniqueCallPath#method_a"
+        call_info_a = c
+        break
+      end
+    end
+
+    assert !call_info_a.nil?
+
+    children_of_a = Array.new
+
+    call_info_a.children.each do | c |
+      if c.parent.eql?(call_info_a)
+        children_of_a.push(c)
+      end
+    end
+
+    assert_equal(4, call_info_a.target.children.length)
+
+    children_of_a = children_of_a.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(2, children_of_a.length)
+    assert_equal("Fixnum#==", children_of_a[0].target.full_name)
+    assert_equal("UniqueCallPath#method_b", children_of_a[1].target.full_name)
+  end
+
+  def test_id2ref
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+    end
+
+    root_methods = Array.new
+    result.threads.each do | thread_id, methods |
+      methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    child = root_methods[0].children[0]
+
+    assert_not_equal(0, child.object_id)
+    #assert_equal(RubyProf::CallInfo.id2ref(child.object_id).target.full_name, child.target.full_name)
+  end
+
+  def test_unique_path
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf.profile do
+      unique_call_path.method_a(1)
+      unique_call_path.method_k(1)
+    end
+
+    root_methods = Array.new
+    result.threads.each do | thread_id, methods |
+      methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    assert_equal(1, root_methods.length)
+
+    call_info_a = nil
+    root_methods[0].children.each do | c |
+      if c.target.full_name == "UniqueCallPath#method_a"
+        call_info_a = c
+        break
+      end
+    end
+
+    assert !call_info_a.nil?
+
+    children_of_a = Array.new
+    call_info_a.children.each do |c|
+      if c.parent.eql?(call_info_a)
+        children_of_a.push(c)
+      end
+    end
+
+    assert_equal(4, call_info_a.target.children.length)
+
+    children_of_a = children_of_a.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(2, children_of_a.length)
+    assert_equal(1, children_of_a[0].called)
+    assert_equal("Fixnum#==", children_of_a[0].target.full_name)
+    assert_equal(1, children_of_a[1].called)
+    assert_equal("UniqueCallPath#method_b", children_of_a[1].target.full_name)
+  end
+end