ruby-prof 0.18.0 → 1.2.0

data/test/block_test.rb

@@ -1,74 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path("../test_helper", __FILE__)
-
-class BlockMethodTest < 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_block
-    result = RubyProf.profile do
-      1.times { RubyProf::C1.new.hello }
-    end
-
-    # Methods called
-    #  Kernel#sleep
-    #  <Class::BasicObject>#allocate
-    #  #{RubyProf.parent_object}#inizialize
-    #  RubyProf::C1#hello
-    #  Class#new
-    #  Integer#times
-    #  BlockMethodTest#test_block
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(RubyProf.ruby_2? ? 6 : 7, methods.length)
-
-    # Check times
-    assert_equal("BlockMethodTest#test_block", methods[0].full_name)
-    assert_in_delta(0.2, methods[0].total_time, 0.02)
-    assert_in_delta(0.0, methods[0].wait_time, 0.02)
-    assert_in_delta(0.0, methods[0].self_time, 0.02)
-
-    assert_equal("Integer#times", methods[1].full_name)
-    assert_in_delta(0.2, methods[1].total_time, 0.02)
-    assert_in_delta(0.0, methods[1].wait_time, 0.02)
-    assert_in_delta(0.0, methods[1].self_time, 0.02)
-
-    assert_equal("RubyProf::C1#hello", methods[2].full_name)
-    assert_in_delta(0.2, methods[2].total_time, 0.02)
-    assert_in_delta(0.0, methods[2].wait_time, 0.02)
-    assert_in_delta(0.0, methods[2].self_time, 0.02)
-
-    assert_equal("Kernel#sleep", methods[3].full_name)
-    assert_in_delta(0.2, methods[3].total_time, 0.01)
-    assert_in_delta(0.0, methods[3].wait_time, 0.01)
-    assert_in_delta(0.2, methods[3].self_time, 0.01)
-
-    assert_equal("Class#new", methods[4].full_name)
-    assert_in_delta(0.0, methods[4].total_time, 0.01)
-    assert_in_delta(0.0, methods[4].wait_time, 0.01)
-    assert_in_delta(0.0, methods[4].self_time, 0.01)
-
-    # the timing difference between #initialize and #allocate is so small
-    # that we cannot rely on #initialize appearing first.
-    # so switch them, if necessary
-    if methods[5].full_name =~ /#allocate/
-      methods[5], methods[6] = methods[6], methods[5]
-    end
-
-    assert_equal("#{RubyProf.parent_object}#initialize", methods[5].full_name)
-    assert_in_delta(0.0, methods[5].total_time, 0.01)
-    assert_in_delta(0.0, methods[5].wait_time, 0.01)
-    assert_in_delta(0.0, methods[5].self_time, 0.01)
-
-    unless RubyProf.ruby_2?
-      assert_equal("<Class::#{RubyProf.parent_object}>#allocate", methods[6].full_name)
-      assert_in_delta(0.0, methods[6].total_time, 0.01)
-      assert_in_delta(0.0, methods[6].wait_time, 0.01)
-      assert_in_delta(0.0, methods[6].self_time, 0.01)
-    end
-  end
-end

data/test/call_info_test.rb

@@ -1,78 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class CallInfoTest < 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_clone
-#    result = RubyProf.profile do
-#      RubyProf::C1.hello
-#    end
-#
-#    method = result.threads.first.top_methods.first
-#    call_info = method.call_infos.first
-#    call_info_clone = call_info.clone
-#
-##    assert_equal(call_info.target, call_info_clone.target)
-#    assert_equal(call_info.total_time, call_info_clone.total_time)
-#  end
-
-  def test_merge
-    result1 = RubyProf.profile do
-      RubyProf::C1.hello
-    end
-
-    methods = result1.threads.first.methods.sort.reverse
-    assert_equal(3, methods.length)
-
-    assert_equal('CallInfoTest#test_merge', methods[0].full_name)
-    assert_in_delta(0.1, 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_equal(1, methods[0].called)
-
-    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
-    assert_in_delta(0.1, methods[1].total_time, 0.01)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.01)
-    assert_equal(1, methods[1].called)
-
-    assert_equal('Kernel#sleep', methods[2].full_name)
-    assert_in_delta(0.1, methods[2].total_time, 0.01)
-    assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.1, methods[2].self_time, 0.01)
-    assert_equal(1, methods[2].called)
-
-    RubyProf.profile do
-      RubyProf::C1.hello
-    end
-
-    # Merge the trees
-    methods = result1.threads.first.methods.sort.reverse
-    assert_equal(3, methods.length)
-
-    assert_equal('CallInfoTest#test_merge', methods[0].full_name)
-    assert_in_delta(0.1, 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_equal(1, methods[0].called)
-
-    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
-    assert_in_delta(0.1, methods[1].total_time, 0.01)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.01)
-    assert_equal(1, methods[1].called)
-
-    assert_equal('Kernel#sleep', methods[2].full_name)
-    assert_in_delta(0.1, methods[2].total_time, 0.01)
-    assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.1, methods[2].self_time, 0.01)
-    assert_equal(1, methods[2].called)
-  end
-end
-

data/test/call_info_visitor_test.rb

@@ -1,31 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class CallInfoVisitorTest < 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_visit
-    result = RubyProf.profile do
-      RubyProf::C1.hello
-    end
-
-    visitor = RubyProf::CallInfoVisitor.new(result.threads.first.top_call_infos)
-
-    method_names = Array.new
-
-    visitor.visit do |call_info, event|
-      method_names << call_info.target.full_name if event == :enter
-    end
-
-    assert_equal(3, method_names.length)
-    assert_equal("CallInfoVisitorTest#test_visit", method_names[0])
-    assert_equal("<Class::RubyProf::C1>#hello", method_names[1])
-    assert_equal("Kernel#sleep", method_names[2])
-  end
-end
-

data/test/issue137_test.rb

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# issue 137 is about correctly attributing time of recursive children
-
-class RecursiveChildrenTest < TestCase
-  class SlowClass
-    def time_sink
-      1234567890 ** 100 == 0
-    end
-  end
-
-  class SlowSearcher
-    def do_find(slow_objects)
-      slow_objects.find(&:time_sink)
-    end
-  end
-
-  class MainClass
-    def self.main_method
-      slow_objects = [SlowClass.new] * 100_000
-      slow_searcher = SlowSearcher.new
-      slow_searcher.do_find(slow_objects)
-    end
-  end
-
-  include PrinterTestHelper
-
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def test_simple
-    result = RubyProf.profile do
-      # make array each recursive
-      [1].each do
-        MainClass.main_method
-      end
-    end
-
-    # methods = result.threads.first.methods.sort.reverse
-
-    printer = RubyProf::GraphPrinter.new(result)
-
-    buffer = ''
-    printer.print(StringIO.new(buffer))
-
-    puts buffer if ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1"
-
-    parsed_output = MetricsArray.parse(buffer)
-
-    assert( enum_find  = parsed_output.metrics_for("Enumerable#find") )
-    assert( array_each = enum_find.child("Array#each") )
-
-    assert_operator enum_find.metrics.total, :>=, array_each.total
-    assert_operator enum_find.metrics.total, :>, 0
-    assert_in_delta enum_find.metrics.total, array_each.total, 0.02
-  end
-
-end

data/test/measure_cpu_time_test.rb

@@ -1,212 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class MeasureCpuTimeTest < TestCase
-  def setup
-    RubyProf::measure_mode = RubyProf::CPU_TIME
-  end
-
-  def teardown
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def test_mode
-    assert_equal(RubyProf::CPU_TIME, RubyProf::measure_mode)
-  end
-
-  def test_cpu_time_enabled_defined
-    assert(defined?(RubyProf::CPU_TIME_ENABLED))
-  end
-
-  def test_class_methods
-    result = RubyProf.profile do
-      RubyProf::C7.busy_wait
-    end
-
-    # Length should be greater 2:
-    #   MeasureCpuTimeTest#test_class_methods
-    #   <Class::RubyProf::C1>#busy_wait
-    #   ....
-
-    methods = result.threads.first.methods.sort.reverse[0..1]
-    assert_equal(2, methods.length)
-
-    # Check the names
-    assert_equal('MeasureCpuTimeTest#test_class_methods', methods[0].full_name)
-    assert_equal('<Class::RubyProf::C7>#busy_wait', methods[1].full_name)
-
-    # Check times
-    assert_in_delta(0.1, methods[0].total_time, 0.05)
-    assert_in_delta(0, methods[0].wait_time, 0.05)
-    assert_in_delta(0, methods[0].self_time, 0.05)
-
-    assert_in_delta(0.1, methods[1].total_time, 0.05)
-    assert_in_delta(0, methods[1].wait_time, 0.05)
-    assert_in_delta(0, methods[1].self_time, 0.05)
-  end
-
-  def test_instance_methods
-    result = RubyProf.profile do
-      RubyProf::C7.new.busy_wait
-    end
-
-    methods = result.threads.first.methods.sort.reverse[0..1]
-    assert_equal(2, methods.length)
-
-    # Methods at this point:
-    #   MeasureCpuTimeTest#test_instance_methods
-    #   C7#busy_wait
-    #   ...
-
-    names = methods.map(&:full_name)
-    assert_equal('MeasureCpuTimeTest#test_instance_methods', names[0])
-    assert_equal('RubyProf::C7#busy_wait', names[1])
-
-
-    # Check times
-    assert_in_delta(0.2, methods[0].total_time, 0.03)
-    assert_in_delta(0, methods[0].wait_time, 0.03)
-    assert_in_delta(0, methods[0].self_time, 0.03)
-
-    assert_in_delta(0.2, methods[1].total_time, 0.03)
-    assert_in_delta(0, methods[1].wait_time, 0.03)
-    assert_in_delta(0, methods[1].self_time, 0.2)
-  end
-
-  def test_module_methods
-    result = RubyProf.profile do
-      RubyProf::C8.busy_wait
-    end
-
-    # Methods:
-    #   MeasureCpuTimeTest#test_module_methods
-    #   M1#busy_wait
-    #   ...
-
-    methods = result.threads.first.methods.sort.reverse[0..1]
-    assert_equal(2, methods.length)
-
-    assert_equal('MeasureCpuTimeTest#test_module_methods', methods[0].full_name)
-    assert_equal('RubyProf::M7#busy_wait', methods[1].full_name)
-
-    # Check times
-    assert_in_delta(0.3, methods[0].total_time, 0.1)
-    assert_in_delta(0, methods[0].wait_time, 0.02)
-    assert_in_delta(0, methods[0].self_time, 0.02)
-
-    assert_in_delta(0.3, methods[1].total_time, 0.1)
-    assert_in_delta(0, methods[1].wait_time, 0.02)
-    assert_in_delta(0, methods[1].self_time, 0.1)
-  end
-
-  def test_module_instance_methods
-    result = RubyProf.profile do
-      RubyProf::C8.new.busy_wait
-    end
-
-    # Methods:
-    #   MeasureCpuTimeTest#test_module_instance_methods
-    #   M7#busy_wait
-    #   ...
-
-    methods = result.threads.first.methods.sort.reverse[0..1]
-    assert_equal(2, methods.length)
-    names = methods.map(&:full_name)
-    assert_equal('MeasureCpuTimeTest#test_module_instance_methods', names[0])
-    assert_equal('RubyProf::M7#busy_wait', names[1])
-
-    # Check times
-    assert_in_delta(0.3, methods[0].total_time, 0.1)
-    assert_in_delta(0, methods[0].wait_time, 0.1)
-    assert_in_delta(0, methods[0].self_time, 0.1)
-
-    assert_in_delta(0.3, methods[1].total_time, 0.1)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.1)
-  end
-
-  def test_singleton
-    c3 = RubyProf::C3.new
-
-    class << c3
-      def busy_wait
-      end
-    end
-
-    result = RubyProf.profile do
-      c3.busy_wait
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(2, methods.length)
-
-    assert_equal('MeasureCpuTimeTest#test_singleton', methods[0].full_name)
-    assert_equal('<Object::RubyProf::C3>#busy_wait', methods[1].full_name)
-
-    assert_in_delta(0, 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, methods[1].total_time, 0.01)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.01)
-  end
-
-
-  def test_sleeping_does_accumulate_wall_time
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    result = RubyProf.profile do
-      sleep 0.1
-    end
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(["MeasureCpuTimeTest#test_sleeping_does_accumulate_wall_time", "Kernel#sleep"], methods.map(&:full_name))
-    assert_in_delta(0.1, methods[1].total_time, 0.01)
-    assert_equal(0, methods[1].wait_time)
-    assert_in_delta(0.1, methods[1].self_time, 0.01)
-  end
-
-  def test_sleeping_does_not_accumulate_significant_cpu_time
-    result = RubyProf.profile do
-      sleep 0.1
-    end
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(["MeasureCpuTimeTest#test_sleeping_does_not_accumulate_significant_cpu_time", "Kernel#sleep"], methods.map(&:full_name))
-    assert_in_delta(0, methods[1].total_time, 0.01)
-    assert_equal(0, methods[1].wait_time)
-    assert_in_delta(0, methods[1].self_time, 0.01)
-  end
-
-  def test_waiting_for_threads_does_not_accumulate_cpu_time
-    background_thread = nil
-    result = RubyProf.profile do
-      background_thread = Thread.new{ sleep 0.1 }
-      background_thread.join
-    end
-    # check number of threads
-    assert_equal(2, result.threads.length)
-    fg, bg = result.threads
-    assert(fg.methods.map(&:full_name).include?("Thread#join"))
-    assert(bg.methods.map(&:full_name).include?("Kernel#sleep"))
-    assert_in_delta(0, fg.total_time, 0.01)
-    assert_in_delta(0, bg.total_time, 0.01)
-  end
-
-  def test_waiting_for_threads_does_accumulate_wall_time
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    background_thread = nil
-    result = RubyProf.profile do
-      background_thread = Thread.new{ sleep 0.1 }
-      background_thread.join
-    end
-    # check number of threads
-    assert_equal(2, result.threads.length)
-    fg, bg = result.threads
-    assert(fg.methods.map(&:full_name).include?("Thread#join"))
-    assert(bg.methods.map(&:full_name).include?("Kernel#sleep"))
-    assert_in_delta(0.1, fg.total_time, 0.01)
-    assert_in_delta(0.1, fg.wait_time, 0.01)
-    assert_in_delta(0.1, bg.total_time, 0.01)
-  end
-end