skaes-ruby-prof 0.7.3

data/test/no_method_class_test.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'ruby-prof'
+
+# Make sure this works with no class or method
+result = RubyProf.profile do 
+  sleep 1
+end
+
+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

data/test/prime.rb

@@ -0,0 +1,58 @@
+# 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)
+  result = Array.new(length)
+  result.each_index do |i|
+    result[i] = rand(maxnum)
+  end
+    
+  result
+end
+ 
+def is_prime(x)
+  y = 2
+  y.upto(x-1) do |i|
+    return false if (x % i) == 0
+  end
+  true
+end
+
+def find_primes(arr)
+  result = arr.select do |value|
+    is_prime(value)
+  end
+  result
+end
+
+def find_largest(primes)
+  largest = primes.first
+
+  # Intentionally use upto for example purposes
+  # (upto is also called from is_prime)
+  0.upto(primes.length-1) do |i|
+    sleep(0.02)
+    prime = primes[i]
+    if prime > largest
+      largest = prime
+    end
+  end
+  largest
+end
+
+def run_primes
+  length = 10
+  maxnum = 10000
+  
+  # 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

data/test/prime_test.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require 'prime'
+
+# --  Tests ----
+class PrimeTest< Test::Unit::TestCase
+  def test_consistency
+    result = RubyProf.profile do
+      run_primes
+    end
+  end
+end

data/test/printers_test.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require 'prime'
+
+# --  Tests ----
+class PrintersTest < Test::Unit::TestCase
+  def setup
+    RubyProf::measure_mode = RubyProf::PROCESS_TIME
+    @result = RubyProf.profile do
+      run_primes
+    end
+  end
+
+  def test_printers
+    output = ENV['SHOW_FILES'] == "1" ? STDOUT : ''
+
+    printer = RubyProf::FlatPrinter.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)
+
+    # we should get here
+    assert(true)
+  end
+
+  def test_flat_string
+    output = ''
+
+    printer = RubyProf::FlatPrinter.new(@result)
+    assert_nothing_raised { printer.print(output) }
+
+    assert_match(/Thread ID: -?\d+/i, output)
+    assert_match(/Total: \d+\.\d+/i, output)
+    assert_match(/Object#run_primes/i, output)
+  end
+
+  def test_graph_html_string
+    output = ''
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    assert_nothing_raised { printer.print(output) }
+
+    assert_match( /DTD HTML 4\.01/i, output )
+    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)
+    assert_nothing_raised { printer.print(output) }
+
+    assert_match( /Thread ID: -?\d+/i, output )
+    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)
+    assert_nothing_raised { printer.print(output) }
+
+    assert_match(/fn=Object::find_primes/i, output)
+    assert_match(/events: process_time/i, output)
+  end
+end

data/test/recursive_test.rb

@@ -0,0 +1,215 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+
+def simple(n)
+  sleep(1)
+  n -= 1
+  return if n == 0
+  simple(n)
+end
+
+def cycle(n)
+  sub_cycle(n)
+end
+
+def sub_cycle(n)
+  sleep(1)
+  n -= 1
+  return if n == 0
+  cycle(n)
+end
+
+
+# --  Tests ----
+class RecursiveTest < 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_simple
+    result = RubyProf.profile do
+      simple(2)
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(5, methods.length)
+
+    method = methods[0]
+    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_equal(2, 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(2, 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_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_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->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[3]
+    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_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->Fixnum#-', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[4]
+    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_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->Fixnum#==', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+  end
+
+  def test_cycle
+    result = RubyProf.profile do
+      cycle(2)
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(6, 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(2, 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(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(2, 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(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)
+    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->Object#sub_cycle->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[4]
+    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->Object#sub_cycle->Fixnum#-', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[5]
+    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->Object#sub_cycle->Fixnum#==', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+  end
+end

data/test/singleton_test.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+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 < Test::Unit::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_FILES'] == "1" ? STDOUT : ''
+    printer.print(output)
+  end
+end

data/test/stack_printer_test.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'tmpdir'
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class STPT
+  def a
+    100.times{b}
+    300.times{c}
+    c;c;c
+  end
+
+  def b
+    sleep 0.0001
+  end
+
+  def c
+    5.times{b}
+  end
+end
+
+class StackPrinterTest < 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_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
+    assert_nothing_raised { file_contents = print(result) }
+    assert file_contents =~ /Thread: (\d+) \(100\.00% ~ ([.0-9]+) seconds\)/
+    actual_time = $2.to_f
+    difference = (expected_time-actual_time).abs
+    assert difference<0.001 # less than 1 ms
+  end
+
+  def test_method_elimination
+    RubyProf.start
+    5.times{STPT.new.a}
+    result = RubyProf.stop
+    assert_nothing_raised {
+      # result.dump
+      result.eliminate_methods!([/Integer#times/])
+      # $stderr.puts "================================"
+      # result.dump
+      print(result)
+    }
+  end
+
+  private
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    testfile_name = "#{Dir::tmpdir}/ruby_prof_#{test}.html"
+    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_FILES']=="1"
+    File.open(testfile_name, "r"){|f| f.read}
+  end
+end