ruby-prof 0.18.0 → 1.0.0

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/fiber_test.rb

@@ -1,79 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-require 'timeout'
-require 'set'
-begin
-  require 'fiber'
-rescue LoadError
-end
-
-# --  Tests ----
-class FiberTest < TestCase
-
-  def fiber_test
-    @fiber_ids << Fiber.current.object_id
-    enum = Enumerator.new do |yielder|
-        [1,2].each do |x|
-          @fiber_ids << Fiber.current.object_id
-          sleep 0.1
-          yielder.yield x
-        end
-      end
-    while true
-      begin
-        enum.next
-      rescue StopIteration
-        break
-      end
-    end
-    sleep 0.1
-  end
-
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    @fiber_ids  = Set.new
-    @root_fiber = Fiber.current.object_id
-    @thread_id  = Thread.current.object_id
-  end
-
-  def test_fibers
-    result  = RubyProf.profile { fiber_test }
-    profiled_fiber_ids = result.threads.map(&:fiber_id)
-    assert_equal(2, result.threads.length)
-    assert_equal([@thread_id], result.threads.map(&:id).uniq)
-    assert_equal(@fiber_ids, Set.new(profiled_fiber_ids))
-
-    assert profiled_fiber_ids.include?(@root_fiber)
-    assert(root_fiber_profile = result.threads.detect{|t| t.fiber_id == @root_fiber})
-    assert(enum_fiber_profile = result.threads.detect{|t| t.fiber_id != @root_fiber})
-
-    assert_in_delta(0.3, root_fiber_profile.total_time, 0.05)
-    assert_in_delta(0.2, enum_fiber_profile.total_time, 0.05)
-
-    assert(method_next = root_fiber_profile.methods.detect{|m| m.full_name == "Enumerator#next"})
-    assert(method_each = enum_fiber_profile.methods.detect{|m| m.full_name == "Enumerator#each"})
-
-    assert_in_delta(0.2, method_next.total_time, 0.05)
-    assert_in_delta(0.2, method_each.total_time, 0.05)
-  end
-
-  def test_merged_fibers
-    result  = RubyProf.profile(merge_fibers: true) { fiber_test }
-    assert_equal(1, result.threads.length)
-
-    profile = result.threads.first
-    assert_equal 0, profile.fiber_id
-
-    assert_in_delta(0.3, profile.total_time, 0.05)
-
-    assert(method_next = profile.methods.detect{|m| m.full_name == "Enumerator#next"})
-    assert(method_each = profile.methods.detect{|m| m.full_name == "Enumerator#each"})
-
-    assert_in_delta(0.2, method_next.total_time, 0.05)
-    assert_in_delta(0.2, method_each.total_time, 0.05)
-  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

data/test/measure_gc_runs_test.rb

@@ -1,32 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class MeasureGCRunsTest < TestCase
-  include MemoryTestHelper
-
-  def test_gc_runs_mode
-    RubyProf::measure_mode = RubyProf::GC_RUNS
-    assert_equal(RubyProf::GC_RUNS, RubyProf::measure_mode)
-  end
-
-  def test_gc_runs_enabled_defined
-    assert(defined?(RubyProf::GC_RUNS_ENABLED))
-  end
-
-  if RubyProf::GC_RUNS_ENABLED
-    def test_gc_runs
-      t = RubyProf.measure_gc_runs
-      assert_kind_of Integer, t
-
-      GC.enable_stats if GC.respond_to?(:enable_stats)
-      GC.start
-
-      u = RubyProf.measure_gc_runs
-      assert u > t, [t, u].inspect
-      RubyProf::measure_mode = RubyProf::GC_RUNS
-      memory_test_helper
-    end
-  end
-end