ruby-prof 0.18.0-x64-mingw32

data/test/method_elimination_test.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+module MethodElimination
+  def self.a
+    1.times {|i| c}
+  end
+
+  def self.b
+    sleep 0.1
+  end
+
+  def self.c
+    1.times {|i| b}
+  end
+end
+
+class MethodEliminationTest < 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_setting_parent
+    result = RubyProf.profile do
+      1000.times { 1+1 }
+    end
+    method_infos = result.threads.first.methods.sort.reverse
+    assert(m1 = method_infos[0])
+    assert(c1 = m1.call_infos.first)
+    assert_nil(c1.parent)
+  end
+
+  def test_methods_can_be_eliminated
+    RubyProf.start
+    5.times {MethodElimination.a}
+    result = RubyProf.stop
+
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(6, methods.count)
+    assert_equal('MethodEliminationTest#test_methods_can_be_eliminated', methods[0].full_name)
+    assert_equal('Integer#times', methods[1].full_name)
+    assert_equal('<Module::MethodElimination>#a', methods[2].full_name)
+    assert_equal('<Module::MethodElimination>#c', methods[3].full_name)
+    assert_equal('<Module::MethodElimination>#b', methods[4].full_name)
+    assert_equal('Kernel#sleep', methods[5].full_name)
+
+    result.eliminate_methods!([/Integer#times/])
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(5, methods.count)
+    assert_equal('MethodEliminationTest#test_methods_can_be_eliminated', methods[0].full_name)
+    assert_equal('<Module::MethodElimination>#a', methods[1].full_name)
+    assert_equal('<Module::MethodElimination>#c', methods[2].full_name)
+    assert_equal('<Module::MethodElimination>#b', methods[3].full_name)
+    assert_equal('Kernel#sleep', methods[4].full_name)
+  end
+
+  private
+
+  def assert_method_has_been_eliminated(result, eliminated_method)
+    result.threads.each do |thread|
+      thread.methods.each do |method|
+        method.call_infos.each do |ci|
+          assert(ci.target != eliminated_method, "broken self")
+          assert(ci.parent.target != eliminated_method, "broken parent") if ci.parent
+          ci.children.each do |callee|
+            assert(callee.target != eliminated_method, "broken kid")
+          end
+        end
+      end
+    end
+  end
+end

data/test/module_test.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Need to use wall time for this test due to the sleep calls
+RubyProf::measure_mode = RubyProf::WALL_TIME
+
+module Foo
+  def Foo::hello
+    sleep(0.5)
+  end
+end
+
+module Bar
+  def Bar::hello
+    sleep(0.5)
+    Foo::hello
+  end
+
+  def hello
+    sleep(0.5)
+    Bar::hello
+  end
+end
+
+include Bar
+
+class ModuleTest < TestCase
+  def test_nested_modules
+    result = RubyProf.profile do
+      hello
+    end
+
+    methods = result.threads.first.methods
+
+    # Length should be 5
+    assert_equal(5, methods.length)
+
+    # these methods should be in there... (hard to tell order though).
+    for name in ['ModuleTest#test_nested_modules','Bar#hello','Kernel#sleep','<Module::Bar>#hello','<Module::Foo>#hello']
+      assert methods.map(&:full_name).include?( name )
+    end
+  end
+end

data/test/multi_printer_test.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class MSTPT
+  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 MultiPrinterTest < 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_refuses_io_objects
+    # we don't need a real profile for this test
+    p = RubyProf::MultiPrinter.new nil
+    begin
+      p.print(STDOUT)
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/IO/, e.to_s)
+    end
+  end
+
+  def test_refuses_non_hashes
+    # we don't need a real profile for this test
+    p = RubyProf::MultiPrinter.new nil
+    begin
+      p.print([])
+      flunk "should have raised an ArgumentError"
+    rescue ArgumentError => e
+      assert_match(/hash/, e.to_s)
+    end
+  end
+
+  def test_all_profiles_can_be_created
+    start_time = Time.now
+    RubyProf.start
+    5.times{MSTPT.new.a}
+    result = RubyProf.stop
+    end_time = Time.now
+    expected_time = end_time - start_time
+    graph = print(result)[1]
+    re = Regexp.new('
+\s*<table>
+\s*<tr>
+\s*<th>Thread ID</th>
+\s*(<th>Fiber ID</th>)?
+\s*<th>Total Time</th>
+\s*</tr>
+\s*
+\s*<tr>
+\s*(<td>([\.0-9]+)</td>)?
+\s*<td><a href="#-?\d+">-?\d+</a></td>
+\s*<td>([\.0-9e]+)</td>
+\s*</tr>
+\s*
+\s*</table>')
+    assert_match(re, graph)
+    graph =~ re
+    display_time = $4.to_f
+    assert_in_delta expected_time, display_time, 0.001
+  end
+
+  private
+
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    path = RubyProf.tmpdir
+    profile = "ruby_prof_#{test}"
+    printer = RubyProf::MultiPrinter.new(result)
+    printer.print(:path => path, :profile => profile,
+                  :threshold => 0, :min_percent => 0, :title => "ruby_prof #{test}")
+    if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
+      system("open '#{printer.stack_profile}'")
+    end
+    # if GC.respond_to?(:dump_file_and_line_info)
+    #   GC.start
+    #   GC.dump_file_and_line_info("heap.dump")
+    # end
+    [File.read(printer.stack_profile), File.read(printer.graph_profile)]
+  end
+end

data/test/no_method_class_test.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Make sure this works with no class or method
+result = RubyProf.profile do
+  sleep 1
+end
+
+methods = result.threads.first.methods
+global_method = methods.sort_by {|method| method.full_name}.first
+if global_method.full_name != 'Kernel#sleep'
+  raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{global_method.full_name}")
+end

data/test/pause_resume_test.rb

@@ -0,0 +1,166 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class PauseResumeTest < 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_pause_resume
+    # Measured
+    RubyProf.start
+    RubyProf::C1.hello
+
+    # Not measured
+    RubyProf.pause
+    sleep 1
+    RubyProf::C1.hello
+
+    # Measured
+    RubyProf.resume
+    RubyProf::C1.hello
+
+    result = RubyProf.stop
+
+    # Length should be 3:
+    #   PauseResumeTest#test_pause_resume
+    #   <Class::RubyProf::C1>#hello
+    #   Kernel#sleep
+
+    methods = result.threads.first.methods.sort_by {|method_info| method_info.full_name}
+    # remove methods called by pause/resume
+    called_methods = ['Array#include?', 'Fixnum#==', 'Kernel#respond_to?', 'Kernel#respond_to_missing?']
+    methods.reject!{|m| called_methods.include?(m.full_name) }
+    # TODO: fix pause/resume to not include those methods in the first place
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('<Class::RubyProf::C1>#hello', methods[0].full_name)
+    assert_equal('Kernel#sleep', methods[1].full_name)
+    assert_equal('PauseResumeTest#test_pause_resume', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.2, methods[0].total_time, 0.02)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0.2, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0, methods[2].self_time, 0.02)
+  end
+
+  # pause/resume in the same frame
+  def test_pause_resume_1
+    profile = RubyProf::Profile.new
+
+    profile.start
+    method_1a
+
+    profile.pause
+    method_1b
+
+    profile.resume
+    method_1c
+
+    result = profile.stop
+    assert_in_delta(0.6, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_1$/}[0].total_time, 0.05)
+  end
+  def method_1a; sleep 0.2 end
+  def method_1b; sleep 1   end
+  def method_1c; sleep 0.4 end
+
+  # pause in parent frame, resume in child
+  def test_pause_resume_2
+    profile = RubyProf::Profile.new
+
+    profile.start
+    method_2a
+
+    profile.pause
+    sleep 0.5
+    method_2b(profile)
+
+    result = profile.stop
+    assert_in_delta(0.6, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_2$/}[0].total_time, 0.05)
+  end
+  def method_2a; sleep 0.2 end
+  def method_2b(profile); sleep 0.5; profile.resume; sleep 0.4 end
+
+  # pause in child frame, resume in parent
+  def test_pause_resume_3
+    profile = RubyProf::Profile.new
+
+    profile.start
+    method_3a(profile)
+
+    sleep 0.5
+    profile.resume
+    method_3b
+
+    result = profile.stop
+    assert_in_delta(0.6, result.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_3$/}[0].total_time, 0.05)
+  end
+  def method_3a(profile); sleep 0.2; profile.pause; sleep 0.5 end
+  def method_3b; sleep 0.4 end
+
+  def test_pause_seq
+    profile = RubyProf::Profile.new
+    profile.start ; assert !profile.paused?
+    profile.pause ; assert profile.paused?
+    profile.resume; assert !profile.paused?
+    profile.pause ; assert profile.paused?
+    profile.pause ; assert profile.paused?
+    profile.resume; assert !profile.paused?
+    profile.resume; assert !profile.paused?
+    profile.stop  ; assert !profile.paused?
+  end
+
+  def test_pause_block
+    profile = RubyProf::Profile.new
+    profile.start
+    profile.pause
+    assert profile.paused?
+
+    times_block_invoked = 0
+    retval= profile.resume{
+      times_block_invoked += 1
+      120 + times_block_invoked
+    }
+    assert_equal 1, times_block_invoked
+    assert profile.paused?
+
+    assert_equal 121, retval, "resume() should return the result of the given block."
+
+    profile.stop
+  end
+
+  def test_pause_block_with_error
+    profile = RubyProf::Profile.new
+    profile.start
+    profile.pause
+    assert profile.paused?
+
+    begin
+      profile.resume{ raise }
+      flunk 'Exception expected.'
+    rescue
+      assert profile.paused?
+    end
+
+    profile.stop
+  end
+
+  def test_resume_when_not_paused
+    profile = RubyProf::Profile.new
+    profile.start ; assert !profile.paused?
+    profile.resume; assert !profile.paused?
+    profile.stop  ; assert !profile.paused?
+  end
+end

data/test/prime.rb

@@ -0,0 +1,54 @@
+# 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|
+    prime = primes[i]
+    if prime > largest
+      largest = prime
+    end
+  end
+  largest
+end
+
+def run_primes(length=10, maxnum=1000)
+  # Create random numbers
+  random_array = make_random_array(length, maxnum)
+
+  # Find the primes
+  primes = find_primes(random_array)
+
+  # Find the largest primes
+  find_largest(primes)
+end