ruby-prof 0.8.1-x86-mingw32

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,130 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'ruby-prof'
+require File.dirname(__FILE__) + '/prime'
+
+# --  Tests ----
+class PrintersTest < Test::Unit::TestCase
+  
+  def go
+    run_primes
+  end
+  
+  def setup
+    RubyProf::measure_mode = RubyProf::WALL_TIME # WALL_TIME so we can use sleep in our test
+    @result = RubyProf.profile do
+      run_primes
+      go
+    end
+    
+  end
+    
+  def test_printers
+    printer = RubyProf::FlatPrinter.new(@result)
+    printer.print(STDOUT)
+    
+    printer = RubyProf::FlatPrinterWithLineNumbers.new(@result)
+    printer.print(STDOUT)
+    
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    printer.print
+    
+    printer = RubyProf::GraphPrinter.new(@result)
+    printer.print
+    
+    printer = RubyProf::CallTreePrinter.new(@result)
+    printer.print(STDOUT)    
+    # we should get here    
+  end
+
+  def test_flat_string
+    output = helper_test_flat_string RubyProf::FlatPrinter
+    assert_no_match(/prime.rb/, output)
+  end
+
+  def helper_test_flat_string klass
+    output = ''
+    
+    printer = klass.new(@result)
+    printer.print(output)
+    
+    assert_match(/Thread ID: -?\d+/i, output)
+    assert_match(/Total: \d+\.\d+/i, output)
+    assert_match(/Object#run_primes/i, output)
+    output
+  end
+  
+  def test_flat_string_with_numbers
+    output = helper_test_flat_string RubyProf::FlatPrinterWithLineNumbers
+    assert_match(/prime.rb/, output)    
+    assert_no_match(/ruby_runtime:0/, output)
+    assert_match(/called from/, output)
+    
+    # should combine common parents
+    if RUBY_VERSION < '1.9'
+        assert_equal(3, output.scan(/Object#is_prime/).length)
+	  else
+		  # 1.9
+		  assert_equal(2, output.scan(/Object#is_prime/).length)		
+    end
+	  assert_no_match(/\.\/test\/prime.rb/, output) # don't use relative paths
+  end
+    
+  def test_graph_html_string
+    output = ''
+    printer = RubyProf::GraphHtmlPrinter.new(@result)
+    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)
+    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)
+    printer.print(output)
+
+    assert_match(/fn=Object::find_primes/i, output)
+    assert_match(/events: wall_time/i, output)
+  end
+  
+  def do_nothing
+    start = Time.now
+    while(Time.now == start)
+    end
+  end
+  
+  def test_all_with_small_percentiles
+    
+    result = RubyProf.profile do
+      sleep 2
+      do_nothing 
+    end
+    
+    # RubyProf::CallTreePrinter doesn't "do" a min_percent
+    # RubyProf::FlatPrinter only outputs if self time > percent...
+    # RubyProf::FlatPrinterWithLineNumbers same
+    for klass in [ RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter]
+      puts klass
+      printer = klass.new(result)
+      out = ''
+      output = printer.print(out, :min_percent => 0.00000001 )
+      assert_match(/do_nothing/, out)      
+    end
+    
+  end    
+  
+  
+  
+end

data/test/recursive_test.rb

@@ -0,0 +1,275 @@
+#!/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
+    
+    if RUBY_VERSION < '1.9'
+      assert_equal(6, methods.length) # includes Fixnum+, Fixnum==...
+    else
+      assert_equal(4, methods.length)
+    end
+    
+    method = methods[0]
+    assert_equal('RecursiveTest#test_simple', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05)
+    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.05)
+
+    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(1, method.called)
+    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.call_infos.length)
+    call_info = method.call_infos[0]
+    assert_equal('RecursiveTest#test_simple->Object#simple', call_info.call_sequence)
+    if RUBY_VERSION < '1.9'
+      assert_equal(4, call_info.children.length)
+    else
+      assert_equal(2, call_info.children.length)
+    end
+    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(d1)->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[3]
+    assert_equal('Object#simple(d1)', 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_simple->Object#simple->Object#simple(d1)', call_info.call_sequence)
+    if RUBY_VERSION < '1.9'
+      assert_equal(3, 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(d1)->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_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(d1)->Fixnum#==', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+
+    else
+      assert_equal(1, call_info.children.length)
+    end
+  end
+
+  def test_cycle
+    result = RubyProf.profile do
+      cycle(2)
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    if RUBY_VERSION < '1.9'
+      assert_equal(8, methods.length) # includes Fixnum+ and Fixnum==, which aren't included in 1.9
+    else
+      assert_equal(6, methods.length)
+    end
+    method = methods[0]
+    assert_equal('RecursiveTest#test_cycle', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05)
+    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.05)
+
+    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.05)
+    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.05)
+
+    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.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(2, method.children_time, 0.05)
+
+    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)
+    if RUBY_VERSION < '1.9'
+      assert_equal(4, call_info.children.length)
+    else
+      assert_equal(2, call_info.children.length)
+    end
+
+    method = methods[3]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(2, method.called)
+    assert_in_delta(2, method.total_time, 0.05)
+    assert_in_delta(2, method.self_time, 0.05)
+    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(d1)->Object#sub_cycle(d1)->Kernel#sleep', call_info.call_sequence)
+    assert_equal(0, call_info.children.length)
+
+    method = methods[4]
+    assert_equal('Object#cycle(d1)', 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.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(1, method.children_time, 0.05)
+
+    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(d1)', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    method = methods[5]
+    assert_equal('Object#sub_cycle(d1)', 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)
+    call_info = method.call_infos[0]
+    assert_equal('RecursiveTest#test_cycle->Object#cycle->Object#sub_cycle->Object#cycle(d1)->Object#sub_cycle(d1)', call_info.call_sequence)
+    if RUBY_VERSION < '1.9'
+      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(d1)->Object#sub_cycle(d1)->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(d1)->Object#sub_cycle(d1)->Fixnum#==', call_info.call_sequence)
+      assert_equal(0, call_info.children.length)
+    else
+      assert_equal(1, call_info.children.length)
+    end
+
+  end
+end

data/test/ruby-prof-bin

@@ -0,0 +1,20 @@
+#!E:/installs/ruby191p376/bin/ruby.exe
+#
+# This file was generated by RubyGems.
+#
+# The application 'ruby-prof' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+version = ">= 0"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+#gem 'ruby-prof', version
+$: << File.dirname(__FILE__) + '/../lib'
+load File.dirname(__FILE__) + '/../bin/ruby-prof'

data/test/singleton_test.rb

@@ -0,0 +1,37 @@
+#!/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)
+    printer.print(STDOUT)
+  end
+end