ruby-prof 1.0.0

data/test/singleton_test.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'timeout'
+
+# --  Test for bug [#5657]
+# http://rubyforge.org/tracker/index.php?func=detail&aid=5657&group_id=1814&atid=7060
+
+
+class A
+  attr_accessor :as
+  def initialize
+    @as = []
+    class << @as
+      def <<(an_a)
+        super
+      end
+    end
+  end
+
+  def <<(an_a)
+    @as << an_a
+  end
+end
+
+class SingletonTest < TestCase
+  def test_singleton
+    result = RubyProf.profile do
+      a = A.new
+      a << :first_thing
+      assert_equal(1, a.as.size)
+    end
+    printer = RubyProf::FlatPrinter.new(result)
+    output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : ''
+    printer.print(output)
+  end
+end

data/test/stack_printer_test.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class STPT
+  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 StackPrinterTest < 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_stack_can_be_printed
+    start_time = Time.now
+    RubyProf.start
+    5.times{STPT.new.a}
+    result = RubyProf.stop
+    end_time = Time.now
+    expected_time = end_time - start_time
+
+    file_contents = nil
+    file_contents = print(result)
+    re = /Thread: (\d+)(, Fiber: (\d+))? \([\.0-9]+.[\.0-9]+% ~ ([\.0-9]+)\)/
+    assert_match(re, file_contents)
+    file_contents =~ re
+    actual_time = $4.to_f
+    assert_in_delta(expected_time, actual_time, 0.1)
+  end
+
+  private
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    testfile_name = "#{Dir.tmpdir}/ruby_prof_#{test}.html"
+    # puts "printing to #{testfile_name}"
+    printer = RubyProf::CallStackPrinter.new(result)
+    File.open(testfile_name, "w") {|f| printer.print(f, :threshold => 0, :min_percent => 0, :title => "ruby_prof #{test}")}
+    system("open '#{testfile_name}'") if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
+    assert File.exist?(testfile_name), "#{testfile_name} does not exist"
+    assert File.readable?(testfile_name), "#{testfile_name} is no readable"
+    File.read(testfile_name)
+  end
+end

data/test/start_stop_test.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class StartStopTest < 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_extra_stop_should_raise
+    RubyProf.start
+    assert_raises(RuntimeError) do
+      RubyProf.start
+    end
+    
+    assert_raises(RuntimeError) do
+      RubyProf.profile {}
+    end
+    
+    RubyProf.stop # ok
+    assert_raises(RuntimeError) do
+      RubyProf.stop
+    end
+  end
+    
+  def test_different_methods
+    method1
+
+    # Ruby prof should be stopped
+    assert_equal(false, RubyProf.running?)
+
+    methods = @result.threads.first.methods.sort.reverse
+    assert_equal(4, methods.length)
+
+    method = methods[0]
+    assert_equal('StartStopTest#method1', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.05)
+
+    assert_equal(1, method.callees.length)
+    call_info = method.callees[0]
+    assert_equal('StartStopTest#method2', call_info.target.full_name)
+
+    method = methods[1]
+    assert_equal('StartStopTest#method2', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.05)
+
+    assert_equal(1, method.callers.length)
+    call_info = method.callers[0]
+    assert_equal('StartStopTest#method1', call_info.parent.full_name)
+
+    assert_equal(1, method.callees.length)
+    call_info = method.callees[0]
+    assert_equal('StartStopTest#method3', call_info.target.full_name)
+
+    method = methods[2]
+    assert_equal('StartStopTest#method3', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.02)
+
+    assert_equal(1, method.callers.length)
+    call_info = method.callers[0]
+    assert_equal('StartStopTest#method2', call_info.parent.full_name)
+
+    assert_equal(1, method.callees.length)
+    call_info = method.callees[0]
+    assert_equal('Kernel#sleep', call_info.target.full_name)
+
+    method = methods[3]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(2, method.self_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+
+    assert_equal(1, method.callers.length)
+    call_info = method.callers[0]
+    assert_equal('StartStopTest#method3', call_info.parent.full_name)
+
+    assert_equal(0, method.callees.length)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+require "rubygems"
+gem "minitest"
+require 'singleton'
+
+# To make testing/debugging easier, test within this source tree versus an installed gem
+dir = File.dirname(__FILE__)
+root = File.expand_path(File.join(dir, '..'))
+lib = File.expand_path(File.join(root, 'lib'))
+ext = File.expand_path(File.join(root, 'ext', 'ruby_prof'))
+
+$LOAD_PATH << lib
+$LOAD_PATH << ext
+
+require 'ruby-prof'
+
+# Disable minitest parallel tests. The problem is the thread switching will cahnge test results
+# (self vs wait time)
+ENV["N"] = "0"
+require 'minitest/autorun'
+
+class TestCase < Minitest::Test
+end

data/test/thread_test.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'timeout'
+require 'benchmark'
+
+# --  Tests ----
+class ThreadTest < 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.length)
+  end
+
+  def test_thread_identity
+    RubyProf.start
+    sleep_thread = Thread.new do
+      sleep(1)
+    end
+    sleep_thread.join
+    result = RubyProf.stop
+
+    thread_ids = result.threads.map {|thread| thread.id}.sort
+    threads = [Thread.current, sleep_thread]
+    assert_equal(2, result.threads.length)
+
+    assert(thread_ids.include?(threads[0].object_id))
+    assert(thread_ids.include?(threads[1].object_id))
+
+    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[0]))
+    assert(threads.include?(ObjectSpace._id2ref(thread_ids[0])))
+
+    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[1]))
+    assert(threads.include?(ObjectSpace._id2ref(thread_ids[1])))
+  end
+
+  def test_thread_timings
+    RubyProf.start
+    thread = Thread.new do
+      sleep 0
+      # force it to hit thread.join, below, first
+      # thus forcing sleep(1), below, to be counted as (wall) self_time
+      # since we currently count time "in some other thread" as self.wait_time
+      # for whatever reason
+      sleep(1)
+    end
+    thread.join
+    result = RubyProf.stop
+
+    # Check background thread
+    assert_equal(2, result.threads.length)
+
+    rp_thread = result.threads.detect {|t| t.id == thread.object_id}
+    methods = rp_thread.methods.sort.reverse
+    # fails on travis. why?
+    # expected_methods = ["ThreadTest#test_thread_timings", "Kernel#sleep"]
+    # assert_equal(expected_methods, methods.map(&:full_name))
+
+    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.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(1, method.children_time, 0.05)
+    assert_equal(1, method.callers.length)
+
+    method = methods[1]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(2, method.called)
+    assert_in_delta(1, method.total_time, 0.05)
+    assert_in_delta(1.0, 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(1, method.callers.length)
+    assert_equal(0, method.callees.length)
+
+    # Check foreground thread
+    rp_thread = result.threads.detect {|athread| athread.id == Thread.current.object_id}
+    methods = rp_thread.methods.sort.reverse
+    assert_equal(4, methods.length)
+    methods = methods.sort.reverse
+
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    # the sub calls to Object#new, when popped,
+    # cause the parent frame to be created for method #test_thread_timings, which means a +1 when it's popped in the end
+    # xxxx a test that shows it the other way, too (never creates parent frame--if that's even possible)
+    assert_equal(1, method.called)
+    assert_in_delta(1, 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(1, method.children_time, 0.05)
+
+    assert_equal(1, method.callers.length)
+    assert_equal(2, method.callees.length)
+
+    method = methods[1]
+    assert_equal('Thread#join', 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.05)
+    assert_in_delta(1.0, method.wait_time, 0.05)
+    assert_in_delta(0, method.children_time, 0.05)
+
+    assert_equal(1, method.callers.length)
+    assert_equal(0, method.callees.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.05)
+    assert_in_delta(0, 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(1, method.callers.length)
+    assert_equal(1, method.callees.length)
+
+    method = methods[3]
+    assert_equal('Thread#initialize', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, 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(0, method.children_time, 0.05)
+
+    assert_equal(1, method.callers.length)
+    assert_equal(0, method.callees.length)
+  end
+end

data/test/unique_call_path_test.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+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
+  end
+
+  def method_k(i)
+    method_a(i)
+  end
+end
+
+
+# --  Tests ----
+class UniqueCallPathTest < 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|
+      thread.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|
+      thread.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].callees.each do | c |
+      if c.parent.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|
+      thread.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 = root_methods[0].callees.detect do |call_info|
+      call_info.target.full_name == "UniqueCallPath#method_a"
+    end
+    refute_nil(call_info_a)
+
+    children_of_a = Array.new
+
+    call_info_a.target.callees.each do | c |
+      if c.parent.eql?(call_info_a)
+        children_of_a.push(c)
+      end
+    end
+
+    assert_equal(2, call_info_a.target.callees.length)
+
+    children_of_a = children_of_a.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(0, children_of_a.length)
+  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|
+      thread.methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    child = root_methods[0].callees[0]
+    refute_equal(0, child.object_id)
+    #assert_equal(RubyProf::CallInfo.id2ref(child.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|
+      thread.methods.each do | m |
+        if m.root?
+          root_methods.push(m)
+        end
+      end
+    end
+
+    assert_equal(1, root_methods.length)
+
+    call_info_a = root_methods[0].callees.detect do |call_info|
+      call_info.target.full_name == "UniqueCallPath#method_a"
+    end
+    refute_nil(call_info_a)
+
+    children_of_a = Array.new
+    call_info_a.target.callees.each do |c|
+      if c.parent.eql?(call_info_a.target)
+        children_of_a.push(c)
+      end
+    end
+
+    assert_equal(1, call_info_a.target.callees.length)
+
+    children_of_a = children_of_a.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(1, children_of_a.length)
+    assert_equal(2, children_of_a[0].called)
+    assert_equal("UniqueCallPath#method_b", children_of_a[0].target.full_name)
+  end
+end