ruby-prof 1.0.0

data/test/exclude_methods_test.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+module ExcludeMethodsModule
+  def c
+    1.times { |i| ExcludeMethodsModule.d }
+  end
+
+  def self.d
+    1.times { |i| ExcludeMethodsClass.e }
+  end
+end
+
+class ExcludeMethodsClass
+  include ExcludeMethodsModule
+
+  def a
+    1.times { |i| b }
+  end
+
+  def b
+    1.times { |i| c; self.class.e }
+  end
+
+  def self.e
+    1.times { |i| f }
+  end
+
+  def self.f
+    sleep 0.1
+  end
+end
+
+class ExcludeMethodsTest < 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_methods_can_be_profiled
+    obj = ExcludeMethodsClass.new
+    prf = RubyProf::Profile.new
+
+    result = prf.profile { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(10, methods.count)
+    assert_equal('ExcludeMethodsTest#test_methods_can_be_profiled', methods[0].full_name)
+    assert_equal('Integer#times', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[2].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[3].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#e', methods[4].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#f', methods[5].full_name)
+    assert_equal('Kernel#sleep', methods[6].full_name)
+    assert_equal('ExcludeMethodsModule#c', methods[7].full_name)
+    assert_equal('<Module::ExcludeMethodsModule>#d', methods[8].full_name)
+    assert_equal('Kernel#class', methods[9].full_name)
+  end
+
+  def test_methods_can_be_hidden1
+    obj = ExcludeMethodsClass.new
+    prf = RubyProf::Profile.new
+
+    prf.exclude_methods!(Integer, :times)
+
+    result = prf.profile { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(9, methods.count)
+    assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden1', methods[0].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+    assert_equal('Kernel#sleep', methods[5].full_name)
+    assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+    assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+    assert_equal('Kernel#class', methods[8].full_name)
+  end
+
+  def test_methods_can_be_hidden2
+    obj = ExcludeMethodsClass.new
+    prf = RubyProf::Profile.new
+
+    prf.exclude_methods!(Integer, :times)
+    prf.exclude_methods!(ExcludeMethodsClass.singleton_class, :f)
+    prf.exclude_methods!(ExcludeMethodsModule.singleton_class, :d)
+
+    result = prf.profile { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(7, methods.count)
+    assert_equal('ExcludeMethodsTest#test_methods_can_be_hidden2', methods[0].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+    assert_equal('Kernel#sleep', methods[4].full_name)
+    assert_equal('ExcludeMethodsModule#c', methods[5].full_name)
+    assert_equal('Kernel#class', methods[6].full_name)
+  end
+
+  def test_exclude_common_methods1
+    obj = ExcludeMethodsClass.new
+    prf = RubyProf::Profile.new
+
+    prf.exclude_common_methods!
+
+    result = prf.profile { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(9, methods.count)
+    assert_equal('ExcludeMethodsTest#test_exclude_common_methods1', methods[0].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+  end
+
+  def test_exclude_common_methods2
+    obj = ExcludeMethodsClass.new
+
+    result = RubyProf.profile(exclude_common: true) { 5.times {obj.a} }
+    methods = result.threads.first.methods.sort.reverse
+
+    assert_equal(9, methods.count)
+    assert_equal('ExcludeMethodsTest#test_exclude_common_methods2', methods[0].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('ExcludeMethodsClass#b', methods[2].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/exclude_threads_test.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+
+# --  Tests ----
+class ExcludeThreadsTest < TestCase
+  def test_exclude_threads
+
+    def thread1_proc
+      sleep(0.5)
+      sleep(2)
+    end
+
+    def thread2_proc
+      sleep(0.5)
+      sleep(2)
+    end
+
+    thread1 = Thread.new do
+      thread1_proc
+    end
+
+    thread2 = Thread.new do
+      thread2_proc
+    end
+
+    # exclude_threads already includes the minitest thread pool
+    RubyProf.exclude_threads += [ thread2 ]
+
+    RubyProf.start
+
+    thread1.join
+    thread2.join
+
+    result = RubyProf.stop
+
+    assert_equal(2, result.threads.length)
+
+    output = Array.new
+    result.threads.each do |thread|
+      thread.methods.each do | m |
+        if m.full_name.index("ExcludeThreadsTest#thread") == 0
+          output.push(m.full_name)
+        end
+      end
+    end
+
+    assert_equal(1, output.length)
+    assert_equal("ExcludeThreadsTest#thread1_proc", output[0])
+  end
+end

data/test/line_number_test.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class LineNumbers
+  def method_1
+    method_2
+    filler = 1
+    method_3
+  end
+
+  def method_2
+    filler = 1
+    2.times do |i|
+      filler = 2
+      method_3
+    end
+  end
+
+  def method_3
+    sleep(0.4)
+    method_4
+  end
+
+  def method_4
+    sleep(1)
+  end
+end
+
+# --  Tests ----
+class LineNumbersTest < TestCase
+  def test_function_line_no
+    numbers = LineNumbers.new
+
+    result = RubyProf.profile do
+      numbers.method_1
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(7, methods.length)
+
+    # Method 0
+    method = methods[0]
+    assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
+    assert_equal(37, method.line)
+
+    assert_equal(1, method.callers.count)
+    call_info = method.callers[0]
+    assert_nil(call_info.parent)
+    assert_equal(37, call_info.line)
+
+    assert_equal(1, method.callees.count)
+    call_info = method.callees[0]
+    assert_equal('LineNumbers#method_1', call_info.target.full_name)
+    assert_equal(37, call_info.line)
+
+    # Method 1
+    method = methods[1]
+    assert_equal('LineNumbers#method_1', method.full_name)
+    assert_equal(7, method.line)
+
+    assert_equal(1, method.callers.count)
+    call_info = method.callers[0]
+    assert_equal('LineNumbersTest#test_function_line_no', call_info.parent.full_name)
+    assert_equal(37, call_info.line)
+
+    assert_equal(2, method.callees.count)
+    call_info = method.callees[0]
+    assert_equal('LineNumbers#method_2', call_info.target.full_name)
+    assert_equal(8, call_info.line)
+
+    call_info = method.callees[1]
+    assert_equal('LineNumbers#method_3', call_info.target.full_name)
+    assert_equal(10, call_info.line)
+
+    # Method 2
+    method = methods[2]
+    assert_equal('LineNumbers#method_3', method.full_name)
+    assert_equal(21, method.line)
+
+    assert_equal(2, method.callers.count)
+    call_info = method.callers[0]
+    assert_equal('Integer#times', call_info.parent.full_name)
+    assert_equal(17, call_info.line)
+
+    call_info = method.callers[1]
+    assert_equal('LineNumbers#method_1', call_info.parent.full_name)
+    assert_equal(10, call_info.line)
+
+    assert_equal(2, method.callees.count)
+    call_info = method.callees[0]
+    assert_equal('Kernel#sleep', call_info.target.full_name)
+    assert_equal(22, call_info.line)
+
+    call_info = method.callees[1]
+    assert_equal('LineNumbers#method_4', call_info.target.full_name)
+    assert_equal(23, call_info.line)
+
+    # Method 3
+    method = methods[3]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(0, method.line)
+
+    assert_equal(2, method.callers.count)
+    call_info = method.callers[0]
+    assert_equal('LineNumbers#method_3', call_info.parent.full_name)
+    assert_equal(22, call_info.line)
+
+    call_info = method.callers[1]
+    assert_equal('LineNumbers#method_4', call_info.parent.full_name)
+    assert_equal(27, call_info.line)
+
+    assert_equal(0, method.callees.count)
+
+    # Method 4
+    method = methods[4]
+    assert_equal('LineNumbers#method_4', method.full_name)
+    assert_equal(26, method.line)
+
+    assert_equal(1, method.callers.count)
+    call_info = method.callers[0]
+    assert_equal('LineNumbers#method_3', call_info.parent.full_name)
+    assert_equal(23, call_info.line)
+
+    assert_equal(1, method.callees.count)
+    call_info = method.callees[0]
+    assert_equal('Kernel#sleep', call_info.target.full_name)
+    assert_equal(27, call_info.line)
+
+    # Method 5
+    method = methods[5]
+    assert_equal('LineNumbers#method_2', method.full_name)
+    assert_equal(13, method.line)
+
+    assert_equal(1, method.callers.count)
+    call_info = method.callers[0]
+    assert_equal('LineNumbers#method_1', call_info.parent.full_name)
+    assert_equal(8, call_info.line)
+
+    assert_equal(1, method.callees.count)
+    call_info = method.callees[0]
+    assert_equal('Integer#times', call_info.target.full_name)
+    assert_equal(15, call_info.line)
+
+    # Method 6
+    method = methods[6]
+    assert_equal('Integer#times', method.full_name)
+    assert_equal(0, method.line)
+
+    assert_equal(1, method.callers.count)
+    call_info = method.callers[0]
+    assert_equal('LineNumbers#method_2', call_info.parent.full_name)
+    assert_equal(15, call_info.line)
+
+    assert_equal(1, method.callees.count)
+    call_info = method.callees[0]
+    assert_equal('LineNumbers#method_3', call_info.target.full_name)
+    assert_equal(17, call_info.line)
+  end
+end

data/test/marshal_test.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path("../test_helper", __FILE__)
+require 'stringio'
+
+class MarshalTest < TestCase
+  def verify_profile(profile_1, profile_2)
+    verify_threads(profile_1.threads, profile_2.threads)
+  end
+
+  def verify_threads(threads_1, threads_2)
+    assert_equal(threads_1.count, threads_2.count)
+    threads_1.count.times do |i|
+      thread_1 = threads_1[i]
+      thread_2 = threads_2[i]
+      assert_nil(thread_2.id)
+      assert_equal(thread_1.fiber_id, thread_2.fiber_id)
+
+      verify_methods(thread_1.methods, thread_2.methods)
+    end
+  end
+
+  def verify_methods(methods_1, methods_2)
+    assert_equal(methods_1.count, methods_2.count)
+
+    methods_1.count.times do |i|
+      method_1 = methods_1[i]
+      method_2 = methods_2[i]
+
+      assert_equal(method_1.klass_name, method_2.klass_name)
+      assert_equal(method_1.klass_flags, method_2.klass_flags)
+
+      assert_equal(method_1.method_name, method_2.method_name)
+      assert_equal(method_1.full_name, method_2.full_name)
+
+      assert_equal(method_1.recursive?, method_2.recursive?)
+      assert_equal(method_1.root?, method_2.root?)
+      assert_equal(method_1.excluded?, method_2.excluded?)
+
+      assert_equal(method_1.source_file, method_2.source_file)
+      assert_equal(method_1.line, method_2.line)
+
+      verify_measurement(method_1.measurement, method_2.measurement)
+
+      verify_call_infos(method_1.callers, method_2.callers)
+      verify_call_infos(method_1.callees, method_2.callees)
+
+      verify_allocations(method_1.allocations, method_2.allocations)
+    end
+  end
+
+  def verify_allocations(allocations_1, allocations_2)
+    assert_equal(allocations_1.count, allocations_2.count)
+
+    allocations_1.count.times do |i|
+      allocation_1 = allocations_1[i]
+      allocation_2 = allocations_2[i]
+
+      assert_equal(allocation_1.klass_name, allocation_2.klass_name)
+      assert_equal(allocation_1.klass_flags, allocation_2.klass_flags)
+
+      assert_equal(allocation_1.count, allocation_2.count)
+      assert_equal(allocation_1.memory, allocation_2.memory)
+
+      assert_equal(allocation_1.source_file, allocation_2.source_file)
+      assert_equal(allocation_1.line, allocation_2.line)
+    end
+  end
+
+  def verify_call_infos(call_infos_1, call_infos_2)
+    assert_equal(call_infos_1.count, call_infos_2.count)
+    call_infos_1.count.times do |i|
+      call_info_1 = call_infos_1[i]
+      call_info_2 = call_infos_2[i]
+      verify_call_info(call_info_1, call_info_2)
+    end
+  end
+
+  def verify_call_info(call_info_1, call_info_2)
+    assert_equal(call_info_1.parent, call_info_2.parent)
+    assert_equal(call_info_1.target, call_info_2.target)
+
+    assert_equal(call_info_1.depth, call_info_2.depth)
+    assert_equal(call_info_1.source_file, call_info_2.source_file)
+    assert_equal(call_info_1.line, call_info_2.line)
+
+    verify_measurement(call_info_1.measurement, call_info_2.measurement)
+  end
+
+  def verify_measurement(measurement_1, measurement_2)
+    assert_equal(measurement_1.total_time, measurement_2.total_time)
+    assert_equal(measurement_1.self_time, measurement_2.self_time)
+    assert_equal(measurement_1.wait_time, measurement_2.wait_time)
+    assert_equal(measurement_1.called, measurement_2.called)
+  end
+
+  def test_marshal
+    profile_1 = RubyProf.profile do
+      1.times { RubyProf::C1.new.sleep_wait }
+    end
+
+    data = Marshal.dump(profile_1)
+    profile_2 = Marshal.load(data)
+
+    verify_profile(profile_1, profile_2)
+  end
+
+  def test_singleton
+    profile_1 = RubyProf.profile do
+      SingletonTest.instance.busy_wait
+    end
+
+    data = Marshal.dump(profile_1)
+    profile_2 = Marshal.load(data)
+
+    verify_profile(profile_1, profile_2)
+  end
+end