ruby-prof 1.7.2 → 2.0.1

data/test/call_trees_test.rb

@@ -1,66 +1,66 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# --  Tests ----
-class CallTreesTest < TestCase
-  def some_method_1
-    some_method_2
-  end
-
-  def some_method_2
-  end
-
-  def test_call_infos
-    result = RubyProf::Profile.profile do
-      some_method_1
-    end
-
-    thread = result.threads.first
-    assert_equal(3, thread.methods.length)
-
-    method = thread.methods[0]
-    assert_equal('CallTreesTest#test_call_infos', method.full_name)
-
-    call_trees = method.call_trees
-    assert_empty(call_trees.callers)
-    assert_equal(1, call_trees.callees.length)
-    assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
-    assert_equal('CallTreesTest#some_method_1', call_trees.callees[0].target.full_name)
-
-    method = thread.methods[1]
-    assert_equal('CallTreesTest#some_method_1', method.full_name)
-
-    call_trees = method.call_trees
-    assert_equal(1, call_trees.callers.length)
-    assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
-    assert_equal('CallTreesTest#test_call_infos', call_trees.callers[0].parent.target.full_name)
-    assert_equal(1, call_trees.callees.length)
-    assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
-    assert_equal('CallTreesTest#some_method_2', call_trees.callees[0].target.full_name)
-
-    method = thread.methods[2]
-    assert_equal('CallTreesTest#some_method_2', method.full_name)
-
-    call_trees = method.call_trees
-    assert_equal(1, call_trees.callers.length)
-    assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
-    assert_equal('CallTreesTest#some_method_1', call_trees.callers[0].parent.target.full_name)
-    assert_empty(call_trees.callees)
-  end
-
-  def test_gc
-    result = RubyProf::Profile.profile do
-      some_method_1
-    end
-
-    method = result.threads.first.methods[1]
-
-    100.times do |i|
-      method.call_trees.callers
-      GC.start
-    end
-    assert(true)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# --  Tests ----
+class CallTreesTest < TestCase
+  def some_method_1
+    some_method_2
+  end
+
+  def some_method_2
+  end
+
+  def test_call_infos
+    result = RubyProf::Profile.profile do
+      some_method_1
+    end
+
+    thread = result.threads.first
+    assert_equal(3, thread.methods.length)
+
+    method = thread.methods[0]
+    assert_equal('CallTreesTest#test_call_infos', method.full_name)
+
+    call_trees = method.call_trees
+    assert_empty(call_trees.callers)
+    assert_equal(1, call_trees.callees.length)
+    assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
+    assert_equal('CallTreesTest#some_method_1', call_trees.callees[0].target.full_name)
+
+    method = thread.methods[1]
+    assert_equal('CallTreesTest#some_method_1', method.full_name)
+
+    call_trees = method.call_trees
+    assert_equal(1, call_trees.callers.length)
+    assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
+    assert_equal('CallTreesTest#test_call_infos', call_trees.callers[0].parent.target.full_name)
+    assert_equal(1, call_trees.callees.length)
+    assert_kind_of(RubyProf::CallTree, call_trees.callees[0])
+    assert_equal('CallTreesTest#some_method_2', call_trees.callees[0].target.full_name)
+
+    method = thread.methods[2]
+    assert_equal('CallTreesTest#some_method_2', method.full_name)
+
+    call_trees = method.call_trees
+    assert_equal(1, call_trees.callers.length)
+    assert_kind_of(RubyProf::CallTree, call_trees.callers[0])
+    assert_equal('CallTreesTest#some_method_1', call_trees.callers[0].parent.target.full_name)
+    assert_empty(call_trees.callees)
+  end
+
+  def test_gc
+    result = RubyProf::Profile.profile do
+      some_method_1
+    end
+
+    method = result.threads.first.methods[1]
+
+    100.times do |i|
+      method.call_trees.callers
+      GC.start
+    end
+    assert(true)
+  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 DuplicateNamesTest < TestCase
-  def test_names
-    result = RubyProf::Profile.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
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class DuplicateNamesTest < TestCase
+  def test_names
+    result = RubyProf::Profile.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

@@ -1,50 +1,50 @@
-#!/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 test_dynamic_method
-    medley = FruitMedley.new
-    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
-      medley.apple
-      medley.orange
-      medley.banana
-      medley.peach
-    end
-
-    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
-      Integer#==
-    )
-
-    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 test_dynamic_method
+    medley = FruitMedley.new
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      medley.apple
+      medley.orange
+      medley.banana
+      medley.peach
+    end
+
+    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
+      Integer#==
+    )
+
+    assert_equal expected_method_names.join("\n"), methods.map(&:full_name).join("\n")
+  end
+end

data/test/exceptions_test.rb

@@ -16,7 +16,7 @@ class ExceptionsTest < TestCase
 
   def test_profile_allows_exceptions
     assert_raises(RuntimeError) do
-      RubyProf::Profile.profile(:allow_exceptions => true) do
+      RubyProf::Profile.profile(allow_exceptions: true) do
         raise(RuntimeError, 'Test error')
       end
     end

data/test/exclude_threads_test.rb

@@ -1,48 +1,48 @@
-#!/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
-
-    result = RubyProf::Profile.profile(exclude_threads: [thread2]) do
-      thread1.join
-      thread2.join
-    end
-
-    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
+#!/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
+
+    result = RubyProf::Profile.profile(exclude_threads: [thread2]) do
+      thread1.join
+      thread2.join
+    end
+
+    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

@@ -41,82 +41,82 @@ class FiberTest < TestCase
     method = methods[0]
     assert_equal('FiberTest#test_fibers', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[1]
     assert_equal('FiberTest#enumerator_with_fibers', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[2]
     assert_equal('Enumerator#next', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[3]
     assert_equal('Class#new', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[4]
     assert_equal('Enumerator#initialize', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     thread2 = result.threads[1]
     methods = thread2.methods.sort.reverse
     assert_equal(4, methods.count)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[0]
     assert_equal('Enumerator#each', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[1]
     assert_equal('Enumerator::Generator#each', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[2]
     assert_equal('Array#each', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[3]
     assert_equal('Enumerator::Yielder#yield', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
   end
 
   def test_fiber_resume
@@ -131,65 +131,65 @@ class FiberTest < TestCase
     method = methods[0]
     assert_equal('FiberTest#test_fiber_resume', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[1]
     assert_equal('FiberTest#fiber_yield_resume', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[2]
     assert_equal('Fiber#resume', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[3]
     assert_equal('Class#new', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[4]
     assert_equal('Fiber#initialize', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     thread1 = result.threads[1]
     methods = thread1.methods.sort.reverse
     assert_equal(2, methods.count)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[0]
     assert_equal('FiberTest#fiber_yield_resume', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
 
     method = methods[1]
     assert_equal('<Class::Fiber>#yield', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time)
-    assert_in_delta(0, method.self_time)
-    assert_in_delta(0, method.wait_time)
-    assert_in_delta(0, method.children_time)
+    assert_in_delta(0, method.total_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.001 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.001 * delta_multiplier)
   end
 end