airbnb-ruby-prof 0.0.1

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,63 @@
+#!/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 /^1\.9\.3/  then 16
+      when /^2\.0/     then 15
+      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

data/test/module_test.rb

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