ruby-prof 0.18.0-x64-mingw32

data/test/measure_cpu_time_test.rb

@@ -0,0 +1,212 @@
+#!/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

@@ -0,0 +1,32 @@
+#!/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

@@ -0,0 +1,36 @@
+#!/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

@@ -0,0 +1,33 @@
+#!/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

data/test/measure_process_time_test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class MeasureProcessTimeTest < TestCase
+  def setup
+    # Need to fix this for linux (windows works since PROCESS_TIME is WALL_TIME anyway)
+    RubyProf::measure_mode = RubyProf::PROCESS_TIME
+  end
+
+  def test_mode
+    assert_equal(RubyProf::PROCESS_TIME, RubyProf::measure_mode)
+  end
+
+  def test_process_time_enabled_defined
+    assert(defined?(RubyProf::PROCESS_TIME_ENABLED))
+  end
+
+  def test_primes
+    start = Process.times
+    result = RubyProf.profile do
+      run_primes(10000)
+    end
+    finish = Process.times
+
+    total_time = (finish.utime - start.utime) + (finish.stime - start.stime)
+
+    thread = result.threads.first
+    assert_in_delta(total_time, thread.total_time, 0.03)
+
+    methods = result.threads.first.methods.sort.reverse
+
+    expected_number_of_methods =
+      case RUBY_VERSION
+      when /^2\.(1|2)/ then 14
+      else                  13
+      end
+    # puts methods.map(&:full_name).inspect
+    assert_equal expected_number_of_methods, methods.length
+
+    # Check times
+    assert_equal("MeasureProcessTimeTest#test_primes", methods[0].full_name)
+    assert_in_delta(total_time, methods[0].total_time, 0.02)
+    assert_in_delta(0.0, methods[0].wait_time, 0.01)
+    assert_in_delta(0.0, methods[0].self_time, 0.01)
+
+    assert_equal("Object#run_primes", methods[1].full_name)
+    assert_in_delta(total_time, methods[1].total_time, 0.02)
+    assert_in_delta(0.0, methods[1].wait_time, 0.01)
+    assert_in_delta(0.0, methods[1].self_time, 0.01)
+
+    assert_equal("Object#find_primes", methods[2].full_name)
+    assert_equal("Array#select", methods[3].full_name)
+    assert_equal("Object#is_prime", methods[4].full_name)
+    assert_equal("Integer#upto", methods[5].full_name)
+    assert_equal("Object#make_random_array", methods[6].full_name)
+    assert_equal("Array#each_index", methods[7].full_name)
+    assert_equal("Kernel#rand", methods[8].full_name)
+  end
+end

data/test/measure_wall_time_test.rb

@@ -0,0 +1,255 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class MeasureWallTimeTest < 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_mode
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    assert_equal(RubyProf::WALL_TIME, RubyProf::measure_mode)
+  end
+
+  def test_wall_time_enabled_defined
+    assert(defined?(RubyProf::WALL_TIME_ENABLED))
+  end
+
+  def test_class_methods
+    result = RubyProf.profile do
+      RubyProf::C1.hello
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.1, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_class_methods", top_methods[0].full_name)
+
+    # Length should be 3:
+    #   MeasureWallTimeTest#test_class_methods
+    #   <Class::RubyProf::C1>#hello
+    #   Kernel#sleep
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('MeasureWallTimeTest#test_class_methods', methods[0].full_name)
+    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    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_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_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)
+  end
+
+  def test_instance_methods
+    result = RubyProf.profile do
+      RubyProf::C1.new.hello
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.2, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_instance_methods", top_methods[0].full_name)
+
+    # Methods called
+    #   MeasureWallTimeTest#test_instance_methods
+    #   Class.new
+    #   Class:Object#allocate
+    #   for Object#initialize
+    #   C1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(RubyProf.ruby_2? ? 5 : 6, methods.length)
+    names = methods.map(&:full_name)
+    assert_equal('MeasureWallTimeTest#test_instance_methods', names[0])
+    assert_equal('RubyProf::C1#hello', names[1])
+    assert_equal('Kernel#sleep', names[2])
+    assert_equal('Class#new', names[3])
+
+    # order can differ
+    assert(names.include?("#{RubyProf.parent_object}#initialize"))
+    unless RubyProf.ruby_2?
+      assert(names.include?("<Class::#{RubyProf.parent_object}>#allocate"))
+    end
+
+    # Check times
+    assert_in_delta(0.2, methods[0].total_time, 0.02)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.2, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    unless RubyProf.ruby_2?
+      assert_in_delta(0, methods[5].total_time, 0.01)
+      assert_in_delta(0, methods[5].wait_time, 0.01)
+      assert_in_delta(0, methods[5].self_time, 0.01)
+    end
+  end
+
+  def test_module_methods
+    result = RubyProf.profile do
+      RubyProf::C2.hello
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_module_methods", top_methods[0].full_name)
+
+    # Methods:
+    #   MeasureWallTimeTest#test_module_methods
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    assert_equal('MeasureWallTimeTest#test_module_methods', methods[0].full_name)
+    assert_equal('RubyProf::M1#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].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.02)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.1)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.3, methods[2].self_time, 0.1)
+  end
+
+  def test_module_instance_methods
+    result = RubyProf.profile do
+      RubyProf::C2.new.hello
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_module_instance_methods", top_methods[0].full_name)
+
+    # Methods:
+    #   MeasureWallTimeTest#test_module_instance_methods
+    #   Class#new
+    #   <Class::Object>#allocate
+    #   Object#initialize
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(RubyProf.ruby_2? ? 5 : 6, methods.length)
+    names = methods.map(&:full_name)
+    assert_equal('MeasureWallTimeTest#test_module_instance_methods', names[0])
+    assert_equal('RubyProf::M1#hello', names[1])
+    assert_equal('Kernel#sleep', names[2])
+    assert_equal('Class#new', names[3])
+
+    # order can differ
+    assert(names.include?("#{RubyProf.parent_object}#initialize"))
+    unless RubyProf.ruby_2?
+      assert(names.include?("<Class::#{RubyProf.parent_object}>#allocate"))
+    end
+
+    # 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.02)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    unless RubyProf.ruby_2?
+      assert_in_delta(0, methods[5].total_time, 0.01)
+      assert_in_delta(0, methods[5].wait_time, 0.01)
+      assert_in_delta(0, methods[5].self_time, 0.01)
+    end
+  end
+
+  def test_singleton
+    c3 = RubyProf::C3.new
+
+    class << c3
+      def hello
+      end
+    end
+
+    result = RubyProf.profile do
+      c3.hello
+    end
+
+    thread = result.threads.first
+    assert_in_delta(0.0, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods
+    assert_equal(1, top_methods.count)
+    assert_equal("MeasureWallTimeTest#test_singleton", top_methods[0].full_name)
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(2, methods.length)
+
+    assert_equal('MeasureWallTimeTest#test_singleton', methods[0].full_name)
+    assert_equal('<Object::RubyProf::C3>#hello', 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
+end