ruby-prof 0.18.0-x64-mingw32 → 1.1.0-x64-mingw32

data/test/test_helper.rb

@@ -2,6 +2,7 @@
 
 require "rubygems"
 gem "minitest"
+require 'singleton'
 
 # To make testing/debugging easier, test within this source tree versus an installed gem
 dir = File.dirname(__FILE__)
@@ -14,254 +15,10 @@ $LOAD_PATH << ext
 
 require 'ruby-prof'
 
-# stub deprecation warnings
-module RubyProf
-  module SuppressDeprecationWarnings
-    def deprecation_warning(*args)
-      super if ENV['SHOW_RUBY_PROF_DEPRECATION_WARNINGS'] == '1'
-    end
-  end
-  extend SuppressDeprecationWarnings
-end
-
+# 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
-  # 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
-    path = File.expand_path('../../tmp', __FILE__)
-    unless Dir.exist?(path)
-      Dir.mkdir(path)
-    end
-    path
-  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
+end

data/test/thread_test.rb

@@ -75,10 +75,7 @@ class ThreadTest < TestCase
     assert_in_delta(0, method.self_time, 0.05)
     assert_in_delta(0, method.wait_time, 0.05)
     assert_in_delta(1, method.children_time, 0.05)
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
+    assert_equal(1, method.callers.length)
 
     method = methods[1]
     assert_equal('Kernel#sleep', method.full_name)
@@ -88,10 +85,8 @@ class ThreadTest < TestCase
     assert_in_delta(0, method.wait_time, 0.05)
     assert_in_delta(0, method.children_time, 0.05)
 
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
+    assert_equal(1, method.callers.length)
+    assert_equal(0, method.callees.length)
 
     # Check foreground thread
     rp_thread = result.threads.detect {|athread| athread.id == Thread.current.object_id}
@@ -110,10 +105,8 @@ class ThreadTest < TestCase
     assert_in_delta(0, method.wait_time, 0.05)
     assert_in_delta(1, method.children_time, 0.05)
 
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings', call_info.call_sequence)
-    assert_equal(2, call_info.children.length)
+    assert_equal(1, method.callers.length)
+    assert_equal(2, method.callees.length)
 
     method = methods[1]
     assert_equal('Thread#join', method.full_name)
@@ -123,10 +116,8 @@ class ThreadTest < TestCase
     assert_in_delta(1.0, method.wait_time, 0.05)
     assert_in_delta(0, method.children_time, 0.05)
 
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings->Thread#join', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
+    assert_equal(1, method.callers.length)
+    assert_equal(0, method.callees.length)
 
     method = methods[2]
     assert_equal('<Class::Thread>#new', method.full_name)
@@ -136,10 +127,8 @@ class ThreadTest < TestCase
     assert_in_delta(0, method.wait_time, 0.05)
     assert_in_delta(0, method.children_time, 0.05)
 
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings-><Class::Thread>#new', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
+    assert_equal(1, method.callers.length)
+    assert_equal(1, method.callees.length)
 
     method = methods[3]
     assert_equal('Thread#initialize', method.full_name)
@@ -149,39 +138,7 @@ class ThreadTest < TestCase
     assert_in_delta(0, method.wait_time, 0.05)
     assert_in_delta(0, method.children_time, 0.05)
 
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('ThreadTest#test_thread_timings-><Class::Thread>#new->Thread#initialize', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-  end
-
-  # useless test: what does it test?
-  def test_thread_back_and_forth
-    result = nil
-    seconds = Benchmark.realtime do
-      result = RubyProf.profile do
-        a = Thread.new { 100_000.times { sleep 0 }}
-        b = Thread.new { 100_000.times { sleep 0 }}
-        a.join
-        b.join
-      end
-    end
-    methods = result.threads.map {|thread| thread.methods}
-    timings = methods.flatten.sort
-    assert(timings[-1].total_time < seconds)
-  end
-
-  # useless test: what does it test?
-  def test_thread
-    RubyProf.profile do
-      begin
-        Timeout::timeout(2) do
-          while true
-            next
-          end
-        end
-      rescue Timeout::Error
-      end
-    end
+    assert_equal(1, method.callers.length)
+    assert_equal(0, method.callees.length)
   end
 end

data/test/unique_call_path_test.rb

@@ -67,8 +67,8 @@ class UniqueCallPathTest < TestCase
     assert_equal(1, root_methods.length)
 
     root_children = Array.new
-    root_methods[0].children.each do | c |
-      if c.parent.target.eql?(root_methods[0])
+    root_methods[0].callees.each do | c |
+      if c.parent.eql?(root_methods[0])
         root_children.push(c)
       end
     end
@@ -103,32 +103,26 @@ class UniqueCallPathTest < TestCase
     method = root_methods[0]
     assert_equal('UniqueCallPathTest#test_children_of', method.full_name)
 
-    call_info_a = nil
-    root_methods[0].children.each do | c |
-      if c.target.full_name == "UniqueCallPath#method_a"
-        call_info_a = c
-        break
-      end
+    call_info_a = root_methods[0].callees.detect do |call_info|
+      call_info.target.full_name == "UniqueCallPath#method_a"
     end
-
-    assert !call_info_a.nil?
+    refute_nil(call_info_a)
 
     children_of_a = Array.new
 
-    call_info_a.children.each do | c |
+    call_info_a.target.callees.each do | c |
       if c.parent.eql?(call_info_a)
         children_of_a.push(c)
       end
     end
 
-    assert_equal(2, call_info_a.target.children.length)
+    assert_equal(2, call_info_a.target.callees.length)
 
     children_of_a = children_of_a.sort do |c1, c2|
       c1.target.full_name <=> c2.target.full_name
     end
 
-    assert_equal(1, children_of_a.length)
-    assert_equal("UniqueCallPath#method_b", children_of_a[0].target.full_name)
+    assert_equal(0, children_of_a.length)
   end
 
   def test_id2ref
@@ -147,8 +141,7 @@ class UniqueCallPathTest < TestCase
       end
     end
 
-    child = root_methods[0].children[0]
-
+    child = root_methods[0].callees[0]
     refute_equal(0, child.object_id)
     #assert_equal(RubyProf::CallInfo.id2ref(child.id).target.full_name, child.target.full_name)
   end
@@ -172,31 +165,26 @@ class UniqueCallPathTest < TestCase
 
     assert_equal(1, root_methods.length)
 
-    call_info_a = nil
-    root_methods[0].children.each do | c |
-      if c.target.full_name == "UniqueCallPath#method_a"
-        call_info_a = c
-        break
-      end
+    call_info_a = root_methods[0].callees.detect do |call_info|
+      call_info.target.full_name == "UniqueCallPath#method_a"
     end
-
-    assert !call_info_a.nil?
+    refute_nil(call_info_a)
 
     children_of_a = Array.new
-    call_info_a.children.each do |c|
-      if c.parent.eql?(call_info_a)
+    call_info_a.target.callees.each do |c|
+      if c.parent.eql?(call_info_a.target)
         children_of_a.push(c)
       end
     end
 
-    assert_equal(2, call_info_a.target.children.length)
+    assert_equal(1, call_info_a.target.callees.length)
 
     children_of_a = children_of_a.sort do |c1, c2|
       c1.target.full_name <=> c2.target.full_name
     end
 
     assert_equal(1, children_of_a.length)
-    assert_equal(1, children_of_a[0].called)
+    assert_equal(2, children_of_a[0].called)
     assert_equal("UniqueCallPath#method_b", children_of_a[0].target.full_name)
   end
 end