ruby-prof 0.17.0 → 0.18.0

data/test/call_info_visitor_test.rb

@@ -1,31 +1,31 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class CallInfoVisitorTest < 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_visit
-    result = RubyProf.profile do
-      RubyProf::C1.hello
-    end
-
-    visitor = RubyProf::CallInfoVisitor.new(result.threads.first.top_call_infos)
-
-    method_names = Array.new
-
-    visitor.visit do |call_info, event|
-      method_names << call_info.target.full_name if event == :enter
-    end
-
-    assert_equal(3, method_names.length)
-    assert_equal("CallInfoVisitorTest#test_visit", method_names[0])
-    assert_equal("<Class::RubyProf::C1>#hello", method_names[1])
-    assert_equal("Kernel#sleep", method_names[2])
-  end
-end
-
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class CallInfoVisitorTest < 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_visit
+    result = RubyProf.profile do
+      RubyProf::C1.hello
+    end
+
+    visitor = RubyProf::CallInfoVisitor.new(result.threads.first.top_call_infos)
+
+    method_names = Array.new
+
+    visitor.visit do |call_info, event|
+      method_names << call_info.target.full_name if event == :enter
+    end
+
+    assert_equal(3, method_names.length)
+    assert_equal("CallInfoVisitorTest#test_visit", method_names[0])
+    assert_equal("<Class::RubyProf::C1>#hello", method_names[1])
+    assert_equal("Kernel#sleep", method_names[2])
+  end
+end
+

data/test/duplicate_names_test.rb

@@ -1,32 +1,32 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class DuplicateNames < TestCase
-  def test_names
-    result = RubyProf::profile do
-      str = %{module Foo; class Bar; def foo; end end end}
-
-      eval str
-      Foo::Bar.new.foo
-      DuplicateNames.class_eval {remove_const :Foo}
-
-      eval str
-      Foo::Bar.new.foo
-      DuplicateNames.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 == 'DuplicateNames::Foo::Bar#foo'
-    end
-
-    assert_equal(3, methods.length)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class DuplicateNames < TestCase
+  def test_names
+    result = RubyProf::profile do
+      str = %{module Foo; class Bar; def foo; end end end}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNames.class_eval {remove_const :Foo}
+
+      eval str
+      Foo::Bar.new.foo
+      DuplicateNames.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 == 'DuplicateNames::Foo::Bar#foo'
+    end
+
+    assert_equal(3, methods.length)
+  end
+end

data/test/dynamic_method_test.rb

@@ -1,55 +1,55 @@
-#!/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
-
-    # RubyProf::FlatPrinter.new(result).print(STDOUT)
-
-    methods = result.threads.first.methods.sort.reverse
-    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
-    )
-    assert_equal expected_method_names.join("\n"), methods.map(&:full_name).join("\n")
-  end
-end
+#!/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
+
+    # RubyProf::FlatPrinter.new(result).print(STDOUT)
+
+    methods = result.threads.first.methods.sort.reverse
+    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
+    )
+    assert_equal expected_method_names.join("\n"), methods.map(&:full_name).join("\n")
+  end
+end

data/test/enumerable_test.rb

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

@@ -1,16 +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
-    refute_nil(result)
-  end
-end
+#!/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

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