ruby-prof 0.11.3 → 0.12.1

data/test/method_elimination_test.rb

@@ -11,19 +11,17 @@ require 'tmpdir'
 #        \
 #         B
 
-class ESTPT
-  def a
-    100.times{b}
-    300.times{c}
-    c;c;c
+module MethodElimination
+  def self.a
+    1.times {|i| c}
   end
 
-  def b
-    sleep 0
+  def self.b
+    sleep 0.1
   end
 
-  def c
-    5.times{b}
+  def self.c
+    1.times {|i| b}
   end
 end
 
@@ -40,24 +38,37 @@ class MethodEliminationTest < Test::Unit::TestCase
     method_infos = result.threads.first.methods
     assert(m1 = method_infos[0])
     assert(c1 = m1.call_infos.first)
-    assert_equal(c1, c1.parent = c1)
-    assert_equal c1, c1.parent
+    assert_nil(c1.parent)
   end
 
   def test_methods_can_be_eliminated
     RubyProf.start
-    5.times{ESTPT.new.a}
+    5.times {MethodElimination.a}
     result = RubyProf.stop
-    # result.dump
-    eliminated = result.eliminate_methods!([/Integer#times/])
-    # puts eliminated.inspect
-    # result.dump
-    eliminated.each do |m|
-      assert_method_has_been_eliminated(result, m)
-    end
+
+    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|

data/test/pause_resume_test.rb

@@ -4,22 +4,72 @@
 require File.expand_path('../test_helper', __FILE__)
 
 class PauseResumeTest < 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_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}
+    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.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+
+    assert_in_delta(0.2, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0.2, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.2, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0, methods[2].self_time, 0.01)
+  end
 
   # pause/resume in the same frame
   def test_pause_resume_1
-    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    profile = RubyProf::Profile.new(RubyProf::WALL_TIME,[])
 
-    p.start
+    # Measured
+    profile.start
     method_1a
 
-    p.pause
+    # Not measured
+    profile.pause
     method_1b
 
-    p.resume
+    # Measured
+    profile.resume
     method_1c
 
-    r= p.stop
-    assert_in_delta(0.6, r.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_1$/}[0].total_time, 0.05)
+    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
@@ -27,35 +77,92 @@ class PauseResumeTest < Test::Unit::TestCase
 
   # pause in parent frame, resume in child
   def test_pause_resume_2
-    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    profile = RubyProf::Profile.new(RubyProf::WALL_TIME,[])
 
-    p.start
+    # Measured
+    profile.start
     method_2a
 
-    p.pause
+    # Not Measured
+    profile.pause
     sleep 0.5
-    method_2b(p)
+    method_2b(profile)
 
-    r= p.stop
-    assert_in_delta(0.6, r.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_2$/}[0].total_time, 0.05)
+    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(p); sleep 0.5; p.resume; sleep 0.4 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
-    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
-
-    p.start
-    method_3a(p)
+    profile = RubyProf::Profile.new(RubyProf::WALL_TIME,[])
 
+    # Measured
+    profile.start
+    method_3a(profile)
     sleep 0.5
-    p.resume
+
+    profile.resume
     method_3b
 
-    r= p.stop
-    assert_in_delta(0.6, r.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_3$/}[0].total_time, 0.05)
+    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(p); sleep 0.2; p.pause; sleep 0.5 end
+  def method_3a(profile); sleep 0.2; profile.pause; sleep 0.5 end
   def method_3b; sleep 0.4 end
-end
+
+  def test_pause_seq
+    profile = RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    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(RubyProf::WALL_TIME,[])
+    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(RubyProf::WALL_TIME,[])
+    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(RubyProf::WALL_TIME,[])
+    profile.start ; assert !profile.paused?
+    profile.resume; assert !profile.paused?
+    profile.stop  ; assert !profile.paused?
+  end
+end

data/test/prime.rb

@@ -34,7 +34,6 @@ def find_largest(primes)
   # 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

data/test/printers_test.rb

@@ -7,20 +7,11 @@ require 'fileutils'
 
 # --  Tests ----
 class PrintersTest < Test::Unit::TestCase
-  def go
-    run_primes(1000)
-  end
-
   def setup
     # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
     RubyProf::measure_mode = RubyProf::WALL_TIME
     @result = RubyProf.profile do
-      begin
-        run_primes(1000)
-        go
-      rescue => e
-        p e
-      end
+      run_primes(200)
     end
   end
 
@@ -45,7 +36,6 @@ class PrintersTest < Test::Unit::TestCase
 
       printer = RubyProf::GraphPrinter.new(@result)
       printer.print(output)
-
     end
   end
 
@@ -111,9 +101,9 @@ class PrintersTest < Test::Unit::TestCase
     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 )
+    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
@@ -121,9 +111,9 @@ class PrintersTest < Test::Unit::TestCase
     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 )
+    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
@@ -262,5 +252,4 @@ class PrintersTest < Test::Unit::TestCase
     array = array.map{|n| n.to_f} # allow for > 10s times to sort right, since lexographically 4.0 > 10.0
     assert_equal array, array.sort.reverse, "Array #{array.inspect} is not sorted"
   end
-
 end

data/test/recursive_test.rb

@@ -43,17 +43,13 @@ class RecursiveTest < Test::Unit::TestCase
       simple(2)
     end
 
-    methods = result.threads.first.methods.dup
-
     # Remove Fixnum+, Fixnum== for less than Ruby 1.9
-    methods.delete_if do |method|
-      method.full_name.match(/Fixnum/)
-    end
+    result.eliminate_methods!(%w(Fixnum#== Fixnum#-))
 
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
     # Method 0: RecursiveTest#test_simple
-    methods.sort!.reverse!
     method = methods[0]
     assert_equal('RecursiveTest#test_simple', method.full_name)
     assert_equal(1, method.called)
@@ -80,12 +76,12 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal(2, method.call_infos.length)
 
     call_info = method.call_infos.first
-    assert_equal(2 + (RUBY_VERSION < '1.9.0' ? 2 : 0), call_info.children.length)
+    assert_equal(2, call_info.children.length)
     assert_equal('RecursiveTest#test_simple->Object#simple', call_info.call_sequence)
     assert(!call_info.recursive)
 
     call_info = method.call_infos.last
-    assert_equal(1 + (RUBY_VERSION < '1.9.0' ? 2 : 0), call_info.children.length)
+    assert_equal(1, call_info.children.length)
     assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple', call_info.call_sequence)
     assert(call_info.recursive)
 
@@ -107,43 +103,6 @@ class RecursiveTest < Test::Unit::TestCase
     assert_equal('RecursiveTest#test_simple->Object#simple->Object#simple->Kernel#sleep', call_info.call_sequence)
     assert_equal(0, call_info.children.length)
     assert(!call_info.recursive)
-
-    if RUBY_VERSION < '1.9'
-      methods = result.threads.first.methods.dup.sort!.reverse!
-      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
   end
 
   def test_cycle
@@ -151,9 +110,6 @@ class RecursiveTest < Test::Unit::TestCase
       render
     end
 
-    printer = RubyProf::GraphPrinter.new(result)
-    printer.print(STDOUT)
-
     methods = result.threads.first.methods.sort.reverse
     if RUBY_VERSION < '1.9' # Fixnum#+, Fixnum#===, Kernel#===
       assert_equal(8, methods.length)

data/test/test_helper.rb

@@ -1,16 +1,21 @@
 # encoding: UTF-8
 
+# Make ruby 1.8.7 happy
+require "rubygems"
+
 # Make RubyMine happy
+gem "minitest"
+
 if ENV["RM_INFO"] || ENV["TEAMCITY_VERSION"]
-  gem 'win32console'
-  gem 'minitest-reporters'
+  if RUBY_PLATFORM =~ /(win32|mingw)/
+    gem "win32console"
+  end
+  gem "minitest-reporters"
   require 'minitest/reporters'
-  MiniTest::Unit.runner = MiniTest::SuiteRunner.new
-  MiniTest::Unit.runner.reporters << MiniTest::Reporters::RubyMineReporter.new
+  MiniTest::Reporters.use!
 end
 
 # 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'))
@@ -71,11 +76,26 @@ module RubyProf
       goodbye
     end
   end
-  
-  if RUBY_VERSION < '1.9'
-    PARENT = Object
-  else
-    PARENT = BasicObject
+
+  def self.ruby_major_version
+    match = RUBY_VERSION.match(/(\d)\.(\d)/)
+    return Integer(match[1])
   end
 
+  def self.ruby_minor_version
+    match = RUBY_VERSION.match(/(\d)\.(\d)/)
+    return Integer(match[2])
+  end
+
+  def self.parent_object
+    if ruby_major_version == 1 && ruby_minor_version == 8
+      Object
+    else
+      BasicObject
+    end
+  end
+
+  def self.ruby_2?
+    ruby_major_version == 2
+  end
 end