ruby-prof 1.4.4-x64-mingw-ucrt

data/test/duplicate_names_test.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class DuplicateNamesTest < TestCase
+  def test_names
+    result = RubyProf::profile do
+      str = %{module Foo; class Bar; def foo; end end end}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNamesTest.class_eval {remove_const :Foo}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNamesTest.class_eval {remove_const :Foo}
+
+      eval str
+      Foo::Bar.new.foo
+    end
+
+    # There should be 3 foo methods
+    methods = result.threads.first.methods.sort.reverse
+
+    methods = methods.select do |method|
+      method.full_name == 'DuplicateNamesTest::Foo::Bar#foo'
+    end
+
+    assert_equal(3, methods.length)
+  end
+end

data/test/dynamic_method_test.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path("../test_helper", __FILE__)
+
+class DynamicMethodTest < TestCase
+
+  class FruitMedley
+    define_method(:apple) do
+      sleep(0.1)
+      "I'm a peach"
+    end
+
+    define_method(:orange) do
+      sleep(0.2)
+      "I'm an orange"
+    end
+
+    [:banana, :peach].each_with_index do |fruit,i|
+      define_method(fruit) do
+        sleep(i == 0 ? 0.3 : 0.4)
+        "I'm a #{fruit}"
+      end
+    end
+  end
+
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_dynamic_method
+    medley = FruitMedley.new
+    result = RubyProf.profile do
+      medley.apple
+      medley.orange
+      medley.banana
+      medley.peach
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+
+    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
+      expected_method_names = %w(
+        DynamicMethodTest#test_dynamic_method
+        Kernel#sleep
+        DynamicMethodTest::FruitMedley#peach
+        DynamicMethodTest::FruitMedley#banana
+        DynamicMethodTest::FruitMedley#orange
+        DynamicMethodTest::FruitMedley#apple
+        Symbol#to_s
+      )
+    else
+      expected_method_names = %w(
+        DynamicMethodTest#test_dynamic_method
+        Kernel#sleep
+        DynamicMethodTest::FruitMedley#peach
+        DynamicMethodTest::FruitMedley#banana
+        DynamicMethodTest::FruitMedley#orange
+        DynamicMethodTest::FruitMedley#apple
+        Integer#==
+      )
+    end
+
+    assert_equal expected_method_names.join("\n"), methods.map(&:full_name).join("\n")
+  end
+end

data/test/enumerable_test.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# --  Test for bug
+# http://github.com/rdp/ruby-prof/issues#issue/12
+
+class EnumerableTest < TestCase
+  def test_enumerable
+    result = RubyProf.profile do
+      3.times {  [1,2,3].any? {|n| n} }
+    end
+    methods = if RUBY_VERSION >= "2.2.0"
+      %w(EnumerableTest#test_enumerable Integer#times Array#any?)
+    else
+      %w(EnumerableTest#test_enumerable Integer#times Enumerable#any? Array#each)
+    end
+    assert_equal(methods, result.threads.first.methods.map(&:full_name))
+  end
+end

data/test/exceptions_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class ExceptionsTest < TestCase
+  def test_profile
+    result = begin
+      RubyProf.profile do
+        raise(RuntimeError, 'Test error')
+      end
+    rescue
+    end
+    assert_kind_of(RubyProf::Profile, result)
+  end
+
+  def test_profile_allows_exceptions
+    assert_raises(RuntimeError) do
+      RubyProf.profile(:allow_exceptions => true) do
+        raise(RuntimeError, 'Test error')
+      end
+    end
+  end
+end

data/test/exclude_methods_test.rb

@@ -0,0 +1,151 @@
+#!/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 {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('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('Integer#times', 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 {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 {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 {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)
+    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_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_excluded(result, excluded_method)
+    result.threads.each do |thread|
+      thread.methods.each do |method|
+        method.call_trees.each do |ci|
+          assert(ci.target != excluded_method, "broken self")
+          assert(ci.parent.target != excluded_method, "broken parent") if ci.parent
+          ci.children.each do |callee|
+            assert(callee.target != excluded_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/fiber_test.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fiber'
+require 'timeout'
+require 'set'
+
+# --  Tests ----
+class FiberTest < TestCase
+
+  def enumerator_with_fibers
+    enum = Enumerator.new do |yielder|
+      [1,2].each do |x|
+        yielder.yield x
+      end
+    end
+
+    enum.next
+    enum.next
+  end
+
+  def fiber_yield_resume
+    fiber = Fiber.new do
+              Fiber.yield 1
+              Fiber.yield 2
+            end
+
+    fiber.resume
+    fiber.resume
+  end
+
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_fibers
+    result  = RubyProf.profile { enumerator_with_fibers }
+
+    assert_equal(2, result.threads.size)
+
+    thread1 = result.threads[0]
+    methods = thread1.methods.sort.reverse
+    assert_equal(5, methods.count)
+
+    method = methods[0]
+    assert_equal('FiberTest#test_fibers', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[1]
+    assert_equal('FiberTest#enumerator_with_fibers', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[2]
+    assert_equal('Enumerator#next', method.full_name)
+    assert_equal(2, method.called)
+
+    method = methods[3]
+    assert_equal('Class#new', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[4]
+    assert_equal('Enumerator#initialize', method.full_name)
+    assert_equal(1, method.called)
+
+    thread2 = result.threads[1]
+    methods = thread2.methods.sort.reverse
+    assert_equal(4, methods.count)
+
+    method = methods[0]
+    assert_equal('Enumerator#each', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[1]
+    assert_equal('Enumerator::Generator#each', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[2]
+    assert_equal('Array#each', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[3]
+    assert_equal('Enumerator::Yielder#yield', method.full_name)
+    assert_equal(2, method.called)
+  end
+
+  def test_fiber_resume
+    result  = RubyProf.profile { fiber_yield_resume }
+
+    assert_equal(2, result.threads.size)
+
+    thread1 = result.threads[0]
+    methods = thread1.methods.sort.reverse
+    assert_equal(5, methods.count)
+
+    method = methods[0]
+    assert_equal('FiberTest#test_fiber_resume', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[1]
+    assert_equal('FiberTest#fiber_yield_resume', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[2]
+    assert_equal('Fiber#resume', method.full_name)
+    assert_equal(2, method.called)
+
+    method = methods[3]
+    assert_equal('Class#new', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[4]
+    assert_equal('Fiber#initialize', method.full_name)
+    assert_equal(1, method.called)
+
+    thread1 = result.threads[1]
+    methods = thread1.methods.sort.reverse
+    assert_equal(2, methods.count)
+
+    method = methods[0]
+    assert_equal('FiberTest#fiber_yield_resume', method.full_name)
+    assert_equal(1, method.called)
+
+    method = methods[1]
+    assert_equal('<Class::Fiber>#yield', method.full_name)
+    assert_equal(2, method.called)
+  end
+end

data/test/gc_test.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+Minitest::Test.i_suck_and_my_tests_are_order_dependent!
+
+class GcTest < TestCase
+  def setup
+    GC.stress = true
+  end
+
+  def teardown
+    GC.stress = false
+  end
+
+  def some_method
+    Array.new(3 * 4)
+  end
+
+  def run_profile
+    RubyProf.profile do
+      self.some_method
+    end
+  end
+
+  def test_hold_onto_thread
+    threads = 5.times.reduce(Array.new) do |array, i|
+      array.concat(run_profile.threads)
+      array
+    end
+
+    GC.start
+
+    threads.each do |thread|
+      refute_nil(thread.id)
+    end
+  end
+
+
+  def test_hold_onto_method
+    methods = 5.times.reduce(Array.new) do |array, i|
+      profile = run_profile
+      array.concat(profile.threads.map(&:methods).flatten)
+      array
+    end
+
+    GC.start
+
+    methods.each do |method|
+      refute_nil(method.method_name)
+    end
+  end
+
+  def test_hold_onto_call_trees
+    method_call_infos = 5.times.reduce(Array.new) do |array, i|
+      profile = run_profile
+      call_trees = profile.threads.map(&:methods).flatten.map(&:call_trees).flatten
+      array.concat(call_trees)
+      array
+    end
+
+    GC.start
+
+    method_call_infos.each do |call_trees|
+      refute_empty(call_trees.call_trees)
+    end
+  end
+
+  def test_hold_onto_measurements
+    measurements = 5.times.reduce(Array.new) do |array, i|
+      profile = run_profile
+      measurements_2 = profile.threads.map(&:methods).flatten.map(&:measurement)
+      array.concat(measurements_2)
+      array
+    end
+
+    GC.start
+
+    measurements.each do |measurement|
+      error = assert_raises(RuntimeError) do
+        measurement.total_time
+      end
+      assert_match(/RubyProf::Measurement instance has already been freed/, error.message)
+    end
+    assert(true)
+  end
+
+  def test_hold_onto_root_call_tree
+    call_trees = 5.times.reduce(Array.new) do |array, i|
+      array.concat(run_profile.threads.map(&:call_tree))
+      array
+    end
+
+    GC.start
+
+    call_trees.each do |call_tree|
+      refute_nil(call_tree.source_file)
+    end
+  end
+end