ruby-prof 0.13.1 → 1.4.2

data/test/multi_printer_test.rb

@@ -1,82 +1,71 @@
-#!/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 < 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_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
-    stack = graph = nil
-    assert_nothing_raised { stack, graph = print(result) }
-    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
+#!/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
+
+  private
+
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    path = Dir.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
+    [File.read(printer.stack_profile), File.read(printer.graph_profile)]
+  end
+end

data/test/no_method_class_test.rb

@@ -1,15 +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 != 'Global#[No method]'
-  raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{global_method.full_name}")
-end
+#!/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

@@ -1,166 +1,175 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-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}
-    # 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.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
-    profile = RubyProf::Profile.new(RubyProf::WALL_TIME,[])
-
-    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(RubyProf::WALL_TIME,[])
-
-    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(RubyProf::WALL_TIME,[])
-
-    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(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
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative 'measure_times'
+
+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.sleep_wait
+
+    # Not measured
+    RubyProf.pause
+    sleep 1
+    RubyProf::C1.sleep_wait
+
+    # Measured
+    RubyProf.resume
+    RubyProf::C1.sleep_wait
+
+    result = RubyProf.stop
+
+    # Length should be 3:
+    #   PauseResumeTest#test_pause_resume
+    #   <Class::RubyProf::C1>#sleep_wait
+    #   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>#sleep_wait', 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.22, 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.22, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0.22, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.22, 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.65, result.threads[0].methods.select {|m| m.full_name =~ /test_pause_resume_1$/}[0].total_time, 0.05)
+  end
+  def method_1a; sleep 0.22 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.22 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.65, 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.22
+    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