ruby-prof 0.16.2 → 1.1.0

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

data/test/method_elimination_test.rb

@@ -1,84 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Test data
-#     A
-#    / \
-#   B   C
-#        \
-#         B
-
-module MethodElimination
-  def self.a
-    1.times {|i| c}
-  end
-
-  def self.b
-    sleep 0.1
-  end
-
-  def self.c
-    1.times {|i| b}
-  end
-end
-
-class MethodEliminationTest < 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_setting_parent
-    result = RubyProf.profile do
-      1000.times { 1+1 }
-    end
-    method_infos = result.threads.first.methods.sort.reverse
-    assert(m1 = method_infos[0])
-    assert(c1 = m1.call_infos.first)
-    assert_nil(c1.parent)
-  end
-
-  def test_methods_can_be_eliminated
-    RubyProf.start
-    5.times {MethodElimination.a}
-    result = RubyProf.stop
-
-    methods = result.threads.first.methods.sort.reverse
-
-    assert_equal(6, methods.count)
-    assert_equal('MethodEliminationTest#test_methods_can_be_eliminated', methods[0].full_name)
-    assert_equal('Integer#times', methods[1].full_name)
-    assert_equal('<Module::MethodElimination>#a', methods[2].full_name)
-    assert_equal('<Module::MethodElimination>#c', methods[3].full_name)
-    assert_equal('<Module::MethodElimination>#b', methods[4].full_name)
-    assert_equal('Kernel#sleep', methods[5].full_name)
-
-    result.eliminate_methods!([/Integer#times/])
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(5, methods.count)
-    assert_equal('MethodEliminationTest#test_methods_can_be_eliminated', methods[0].full_name)
-    assert_equal('<Module::MethodElimination>#a', methods[1].full_name)
-    assert_equal('<Module::MethodElimination>#c', methods[2].full_name)
-    assert_equal('<Module::MethodElimination>#b', methods[3].full_name)
-    assert_equal('Kernel#sleep', methods[4].full_name)
-  end
-
-  private
-
-  def assert_method_has_been_eliminated(result, eliminated_method)
-    result.threads.each do |thread|
-      thread.methods.each do |method|
-        method.call_infos.each do |ci|
-          assert(ci.target != eliminated_method, "broken self")
-          assert(ci.parent.target != eliminated_method, "broken parent") if ci.parent
-          ci.children.each do |callee|
-            assert(callee.target != eliminated_method, "broken kid")
-          end
-        end
-      end
-    end
-  end
-end

data/test/module_test.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Need to use wall time for this test due to the sleep calls
-RubyProf::measure_mode = RubyProf::WALL_TIME
-
-module Foo
-  def Foo::hello
-    sleep(0.5)
-  end
-end
-
-module Bar
-  def Bar::hello
-    sleep(0.5)
-    Foo::hello
-  end
-
-  def hello
-    sleep(0.5)
-    Bar::hello
-  end
-end
-
-include Bar
-
-class ModuleTest < TestCase
-  def test_nested_modules
-    result = RubyProf.profile do
-      hello
-    end
-
-    methods = result.threads.first.methods
-
-    # Length should be 5
-    assert_equal(5, methods.length)
-
-    # these methods should be in there... (hard to tell order though).
-    for name in ['ModuleTest#test_nested_modules','Bar#hello','Kernel#sleep','<Module::Bar>#hello','<Module::Foo>#hello']
-      assert methods.map(&:full_name).include?( name )
-    end
-  end
-end

data/test/stack_test.rb

@@ -1,138 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Test data
-#     A
-#    / \
-#   B   C
-#        \
-#         B
-
-class StackClass
-  def a
-    sleep 1
-    b
-    c
-  end
-
-  def b
-    sleep 2
-  end
-
-  def c
-    sleep 3
-    b
-  end
-end
-
-class StackTest < 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_call_sequence
-    c = StackClass.new
-    result = RubyProf.profile do
-      c.a
-    end
-
-    # Length should be 5:
-    #   StackTest#test_call_sequence
-    #   StackClass#a
-    #   Kernel#sleep
-    #   StackClass#c
-    #   StackClass#b
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(5, methods.length)
-
-    # Check StackTest#test_call_sequence
-    method = methods[0]
-    assert_equal('StackTest#test_call_sequence', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(8, method.total_time, 0.25)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(8, method.children_time, 0.25)
-    assert_equal(1, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('StackTest#test_call_sequence', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    # Check StackClass#a
-    method = methods[1]
-    assert_equal('StackClass#a', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(8, method.total_time, 0.15)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(8, method.children_time, 0.05)
-    assert_equal(1, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('StackTest#test_call_sequence->StackClass#a', call_info.call_sequence)
-    assert_equal(3, call_info.children.length)
-
-    # Check Kernel#sleep
-    method = methods[2]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(4, method.called)
-    assert_in_delta(8, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(8, method.self_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-    assert_equal(4, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('StackTest#test_call_sequence->StackClass#a->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    call_info = method.call_infos[1]
-    assert_equal('StackTest#test_call_sequence->StackClass#a->StackClass#b->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    call_info = method.call_infos[2]
-    assert_equal('StackTest#test_call_sequence->StackClass#a->StackClass#c->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    call_info = method.call_infos[3]
-    assert_equal('StackTest#test_call_sequence->StackClass#a->StackClass#c->StackClass#b->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-
-    # Check StackClass#c
-    method = methods[3]
-    assert_equal('StackClass#c', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(5, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(5, method.children_time, 0.05)
-    assert_equal(1, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('StackTest#test_call_sequence->StackClass#a->StackClass#c', call_info.call_sequence)
-    assert_equal(2, call_info.children.length)
-
-    # Check StackClass#b
-    method = methods[4]
-    assert_equal('StackClass#b', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(4, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(4, method.children_time, 0.05)
-    assert_equal(2, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('StackTest#test_call_sequence->StackClass#a->StackClass#b', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    call_info = method.call_infos[1]
-    assert_equal('StackTest#test_call_sequence->StackClass#a->StackClass#c->StackClass#b', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-  end
-end