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

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/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

data/test/measure_gc_time_test.rb

@@ -1,36 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class MeasureGCTimeTest < TestCase
-  include MemoryTestHelper
-
-  def test_gc_time_mode
-    RubyProf::measure_mode = RubyProf::GC_TIME
-    assert_equal(RubyProf::GC_TIME, RubyProf::measure_mode)
-  end
-
-  def test_gc_time_enabled_defined
-    assert(defined?(RubyProf::GC_TIME_ENABLED))
-  end
-
-  if RubyProf::GC_TIME_ENABLED
-    def test_gc_time
-      RubyProf::measure_mode = RubyProf::GC_TIME
-      RubyProf.enable_gc_stats_if_needed
-
-      t = RubyProf.measure_gc_time
-      assert_kind_of Float, t
-
-      GC.start
-
-      u = RubyProf.measure_gc_time
-      assert u > t, [t, u].inspect
-
-      memory_test_helper
-    ensure
-      RubyProf.disable_gc_stats_if_needed
-    end
-  end
-end

data/test/measure_memory_test.rb

@@ -1,33 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class MeasureMemoryTest < TestCase
-  include MemoryTestHelper
-
-  def test_memory_mode
-    RubyProf::measure_mode = RubyProf::MEMORY
-    assert_equal(RubyProf::MEMORY, RubyProf::measure_mode)
-  end
-
-  def test_memory_enabled_defined
-    assert(defined?(RubyProf::MEMORY_ENABLED))
-  end
-
-  if RubyProf::MEMORY_ENABLED
-    def test_memory
-      RubyProf::measure_mode = RubyProf::MEMORY
-      RubyProf.enable_gc_stats_if_needed
-      t = RubyProf.measure_memory
-      assert_kind_of Float, t
-      u = RubyProf.measure_memory
-      assert_operator u, :>, t
-      total = memory_test_helper
-      assert(total > 0, 'Should measure more than zero kilobytes of memory usage')
-      refute_equal(0, total % 1, 'Should not truncate fractional kilobyte measurements')
-    ensure
-      RubyProf.disable_gc_stats_if_needed
-    end
-  end
-end