ruby-prof 0.16.2 → 1.1.0

data/test/stack_printer_test.rb

@@ -1,78 +1,64 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Test data
-#     A
-#    / \
-#   B   C
-#        \
-#         B
-
-class STPT
-  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 StackPrinterTest < 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) }
-    # TODO: why are thread ids negative on travis-ci.org (32 bit build maybe?)
-    re = /Thread: (-?\d+)(, Fiber: (-?\d+))? \(100\.00% ~ ([\.0-9]+)\)/
-    assert_match(re, file_contents)
-    file_contents =~ re
-    actual_time = $4.to_f
-    assert_in_delta(expected_time, actual_time, 0.1)
-  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 = "#{RubyProf.tmpdir}/ruby_prof_#{test}.html"
-    # puts "printing to #{testfile_name}"
-    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_RUBY_PROF_PRINTER_OUTPUT']=="1"
-    assert File.exist?(testfile_name), "#{testfile_name} does not exist"
-    assert File.readable?(testfile_name), "#{testfile_name} is no readable"
-    File.read(testfile_name)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class STPT
+  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 StackPrinterTest < 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
+    file_contents = print(result)
+    re = /Thread: (\d+)(, Fiber: (\d+))? \([\.0-9]+.[\.0-9]+% ~ ([\.0-9]+)\)/
+    assert_match(re, file_contents)
+    file_contents =~ re
+    actual_time = $4.to_f
+    assert_in_delta(expected_time, actual_time, 0.1)
+  end
+
+  private
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    testfile_name = "#{Dir.tmpdir}/ruby_prof_#{test}.html"
+    # puts "printing to #{testfile_name}"
+    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_RUBY_PROF_PRINTER_OUTPUT']=="1"
+    assert File.exist?(testfile_name), "#{testfile_name} does not exist"
+    assert File.readable?(testfile_name), "#{testfile_name} is no readable"
+    File.read(testfile_name)
+  end
+end

data/test/start_stop_test.rb

@@ -1,112 +1,109 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class StartStopTest < TestCase
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def method1
-     RubyProf.start
-     method2
-  end
-
-  def method2
-     method3
-  end
-
-  def method3
-    sleep(2)
-    @result = RubyProf.stop
-  end
-  
-  def test_extra_stop_should_raise
-    RubyProf.start
-    assert_raises(RuntimeError) do
-      RubyProf.start
-    end
-    
-    assert_raises(RuntimeError) do
-      RubyProf.profile {}
-    end
-    
-    RubyProf.stop # ok
-    assert_raises(RuntimeError) do
-      RubyProf.stop
-    end
-  end
-    
-
-  def test_different_methods
-    method1
-
-    # Ruby prof should be stopped
-    assert_equal(false, RubyProf.running?)
-
-
-    # Length should be 4:
-    #   StartStopTest#method1
-    #   StartStopTest#method2
-    #   StartStopTest#method3
-    #   Kernel#sleep
-
-    methods = @result.threads.first.methods.sort.reverse
-    assert_equal(4, methods.length)
-
-    # Check StackTest#test_call_sequence
-    method = methods[0]
-    assert_equal('StartStopTest#method1', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(0, method.self_time, 0.02)
-    assert_in_delta(2, method.children_time, 0.05)
-    assert_equal(1, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('StartStopTest#method1', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    method = methods[1]
-    assert_equal('StartStopTest#method2', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(0, method.self_time, 0.02)
-    assert_in_delta(2, method.children_time, 0.05)
-    assert_equal(1, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('StartStopTest#method1->StartStopTest#method2', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    method = methods[2]
-    assert_equal('StartStopTest#method3', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.02)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(0, method.self_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('StartStopTest#method1->StartStopTest#method2->StartStopTest#method3', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    method = methods[3]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.02)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(2, method.self_time, 0.02)
-    assert_in_delta(0, method.children_time, 0.02)
-    assert_equal(1, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('StartStopTest#method1->StartStopTest#method2->StartStopTest#method3->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class StartStopTest < TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def method1
+     RubyProf.start
+     method2
+  end
+
+  def method2
+     method3
+  end
+
+  def method3
+    sleep(2)
+    @result = RubyProf.stop
+  end
+  
+  def test_extra_stop_should_raise
+    RubyProf.start
+    assert_raises(RuntimeError) do
+      RubyProf.start
+    end
+    
+    assert_raises(RuntimeError) do
+      RubyProf.profile {}
+    end
+    
+    RubyProf.stop # ok
+    assert_raises(RuntimeError) do
+      RubyProf.stop
+    end
+  end
+    
+  def test_different_methods
+    method1
+
+    # Ruby prof should be stopped
+    assert_equal(false, RubyProf.running?)
+
+    methods = @result.threads.first.methods.sort.reverse
+    assert_equal(4, methods.length)
+
+    method = methods[0]
+    assert_equal('StartStopTest#method1', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.05)
+
+    assert_equal(1, method.callees.length)
+    call_info = method.callees[0]
+    assert_equal('StartStopTest#method2', call_info.target.full_name)
+
+    method = methods[1]
+    assert_equal('StartStopTest#method2', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.05)
+
+    assert_equal(1, method.callers.length)
+    call_info = method.callers[0]
+    assert_equal('StartStopTest#method1', call_info.parent.full_name)
+
+    assert_equal(1, method.callees.length)
+    call_info = method.callees[0]
+    assert_equal('StartStopTest#method3', call_info.target.full_name)
+
+    method = methods[2]
+    assert_equal('StartStopTest#method3', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.02)
+
+    assert_equal(1, method.callers.length)
+    call_info = method.callers[0]
+    assert_equal('StartStopTest#method2', call_info.parent.full_name)
+
+    assert_equal(1, method.callees.length)
+    call_info = method.callees[0]
+    assert_equal('Kernel#sleep', call_info.target.full_name)
+
+    method = methods[3]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(2, method.self_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+
+    assert_equal(1, method.callers.length)
+    call_info = method.callers[0]
+    assert_equal('StartStopTest#method3', call_info.parent.full_name)
+
+    assert_equal(0, method.callees.length)
+  end
+end

data/test/test_helper.rb

@@ -1,264 +1,24 @@
-# encoding: UTF-8
-
-# Make RubyMine happy
-require "rubygems"
-gem "minitest"
-
-if ENV["RM_INFO"] || ENV["TEAMCITY_VERSION"]
-  if RUBY_PLATFORM =~ /(win32|mingw)/
-    gem "win32console"
-  end
-  gem "minitest-reporters"
-  require 'minitest/reporters'
-  MiniTest::Reporters.use!
-end
-
-require "minitest/pride" if RUBY_VERSION == "1.9.3"
-
-# 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'))
-ext = File.expand_path(File.join(root, 'ext', 'ruby_prof'))
-
-$LOAD_PATH << lib
-$LOAD_PATH << ext
-
-require 'ruby-prof'
-require 'minitest/autorun'
-
-class TestCase < Minitest::Test
-  # I know this sucks, but ...
-  def assert_nothing_raised(*)
-    yield
-  end
-
-  def before_setup
-    # make sure to exclude all threads except the one running the test
-    # minitest allocates a thread pool and they would otherwise show
-    # up in the profile data, breaking tests randomly
-    RubyProf.exclude_threads = Thread.list.select{|t| t != Thread.current}
-  end
-
-  def after_teardown
-    # reset exclude threads after testing
-    RubyProf.exclude_threads = nil
-  end
-end
-
-require File.expand_path('../prime', __FILE__)
-
-# Some classes used in measurement tests
-module RubyProf
-  class C1
-    def C1.hello
-      sleep(0.1)
-    end
-
-    def hello
-      sleep(0.2)
-    end
-  end
-
-  module M1
-    def hello
-      sleep(0.3)
-    end
-  end
-
-  class C2
-    include M1
-    extend M1
-  end
-
-  class C3
-    def hello
-      sleep(0.4)
-    end
-  end
-
-  module M4
-    def hello
-      sleep(0.5)
-    end
-  end
-
-  module M5
-    include M4
-    def goodbye
-      hello
-    end
-  end
-
-  class C6
-    include M5
-    def test
-      goodbye
-    end
-  end
-
-  class C7
-    def self.busy_wait
-      t = Time.now.to_f
-      while Time.now.to_f - t < 0.1; end
-    end
-
-    def self.sleep_wait
-      sleep 0.1
-    end
-
-    def busy_wait
-      t = Time.now.to_f
-      while Time.now.to_f - t < 0.2; end
-    end
-
-    def sleep_wait
-      sleep 0.2
-    end
-  end
-
-  module M7
-    def busy_wait
-      t = Time.now.to_f
-      while Time.now.to_f - t < 0.3; end
-    end
-
-    def sleep_wait
-      sleep 0.3
-    end
-  end
-
-  class C8
-    include M7
-    extend M7
-  end
-
-  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
-
-  # store printer output in this directory
-  def self.tmpdir
-    File.expand_path('../../tmp', __FILE__)
-  end
-end
-
-module MemoryTestHelper
-  def memory_test_helper
-    result = RubyProf.profile {Array.new}
-    total = result.threads.first.methods.inject(0) { |sum, m| sum + m.total_time }
-    assert(total < 1_000_000, 'Total should not have subtract overflow error')
-    total
-  end
-end
-
-module PrinterTestHelper
-  Metrics = Struct.new(:name, :total, :self_t, :wait, :child, :calls)
-  class Metrics
-    def pp
-      "%s[total: %.2f, self: %.2f, wait: %.2f, child: %.2f, calls: %s]" %
-        [name, total, self_t, wait, child, calls]
-    end
-  end
-
-  Entry = Struct.new(:total_p, :self_p, :metrics, :parents, :children)
-  class Entry
-    def child(name)
-      children.detect{|m| m.name == name}
-    end
-
-    def parent(name)
-      parents.detect{|m| m.name == name}
-    end
-
-    def pp
-      res = ""
-      res << "NODE (total%%: %.2f, self%%: %.2f) %s\n" % [total_p, self_p, metrics.pp]
-      res << "  PARENTS:\n"
-      parents.each {|m| res << "    " + m.pp << "\n"}
-      res << "  CHILDREN:\n"
-      children.each {|m| res << "    " + m.pp << "\n"}
-      res
-    end
-  end
-
-  class MetricsArray < Array
-    def metrics_for(name)
-      detect {|e| e.metrics.name == name}
-    end
-
-    def pp(io = STDOUT)
-      entries = map do |e|
-        begin
-          e.pp
-        rescue
-          puts $!.message + e.inspect
-          ""
-        end
-      end
-      io.puts entries.join("--------------------------------------------------\n")
-    end
-
-    def self.parse(str)
-      res = new
-      entry = nil
-      relatives = []
-      state = :preamble
-
-      str.each_line do |l|
-        line = l.chomp.strip
-        if line =~ /-----/
-          if state == :preamble
-            state = :parsing_parents
-            entry = Entry.new
-          elsif state == :parsing_parents
-            entry = Entry.new
-          elsif state == :parsing_children
-            entry.children = relatives
-            res << entry
-            entry = Entry.new
-            relatives = []
-            state = :parsing_parents
-          end
-        elsif line =~ /^\s*$/ || line =~ /indicates recursively called methods/
-          next
-        elsif state != :preamble
-          elements = line.split(/\s+/)
-          method = elements.pop
-          numbers = elements[0..-2].map(&:to_f)
-          metrics = Metrics.new(method, *numbers[-4..-1], elements[-1])
-          if numbers.size == 6
-            entry.metrics = metrics
-            entry.total_p = numbers[0]
-            entry.self_p = numbers[1]
-            entry.parents = relatives
-            entry.children = relatives = []
-            state = :parsing_children
-            res << entry
-          else
-            relatives << metrics
-          end
-        end
-      end
-      res
-    end
-  end
-end
+# encoding: UTF-8
+
+require "rubygems"
+gem "minitest"
+require 'singleton'
+
+# 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'))
+ext = File.expand_path(File.join(root, 'ext', 'ruby_prof'))
+
+$LOAD_PATH << lib
+$LOAD_PATH << ext
+
+require 'ruby-prof'
+
+# Disable minitest parallel tests. The problem is the thread switching will cahnge test results
+# (self vs wait time)
+ENV["N"] = "0"
+require 'minitest/autorun'
+
+class TestCase < Minitest::Test
+end