ruby-prof 1.7.2 → 2.0.1

data/test/measurement_test.rb

@@ -1,82 +1,82 @@
-# frozen_string_literal: true
-
-require File.expand_path('../test_helper', __FILE__)
-
-class MeasurementTest < Minitest::Test
-  def test_initialize
-    measurement = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
-    assert_equal(3.3, measurement.total_time)
-    assert_equal(2.2, measurement.self_time)
-    assert_equal(1.1, measurement.wait_time)
-    assert_equal(4, measurement.called)
-  end
-
-  def test_clone
-    measurement_1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
-    measurement_2 = measurement_1.clone
-
-    refute(measurement_1.equal?(measurement_2))
-    refute(measurement_1.eql?(measurement_2))
-    refute(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_dup
-    measurement_1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
-    measurement_2 = measurement_1.dup
-
-    refute(measurement_1.equal?(measurement_2))
-    refute(measurement_1.eql?(measurement_2))
-    refute(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_merge!
-    measurement1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
-    measurement2 = RubyProf::Measurement.new(3, 2, 1, 3)
-
-    measurement1.merge!(measurement2)
-
-    assert_equal(6.3, measurement1.total_time)
-    assert_equal(4.2, measurement1.self_time)
-    assert_equal(2.1, measurement1.wait_time)
-    assert_equal(7, measurement1.called)
-
-    assert_equal(3, measurement2.total_time)
-    assert_equal(2, measurement2.self_time)
-    assert_equal(1, measurement2.wait_time)
-    assert_equal(3, measurement2.called)
-  end
-
-  def test_set_total_time
-    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
-    measurement.total_time = 5.1
-    assert_equal(5.1, measurement.total_time)
-  end
-
-  def test_set_self_time
-    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
-    measurement.self_time = 3.1
-    assert_equal(3.1, measurement.self_time)
-  end
-
-  def test_set_wait_time
-    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
-    measurement.wait_time = 1.1
-    assert_equal(1.1, measurement.wait_time)
-  end
-
-  def test_set_called
-    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
-    measurement.called = 2
-    assert_equal(2, measurement.called)
-  end
-end
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', __FILE__)
+
+class MeasurementTest < Minitest::Test
+  def test_initialize
+    measurement = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
+    assert_equal(3.3, measurement.total_time)
+    assert_equal(2.2, measurement.self_time)
+    assert_equal(1.1, measurement.wait_time)
+    assert_equal(4, measurement.called)
+  end
+
+  def test_clone
+    measurement_1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
+    measurement_2 = measurement_1.clone
+
+    refute(measurement_1.equal?(measurement_2))
+    refute(measurement_1.eql?(measurement_2))
+    refute(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_dup
+    measurement_1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
+    measurement_2 = measurement_1.dup
+
+    refute(measurement_1.equal?(measurement_2))
+    refute(measurement_1.eql?(measurement_2))
+    refute(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_merge!
+    measurement1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
+    measurement2 = RubyProf::Measurement.new(3, 2, 1, 3)
+
+    measurement1.merge!(measurement2)
+
+    assert_equal(6.3, measurement1.total_time)
+    assert_equal(4.2, measurement1.self_time)
+    assert_equal(2.1, measurement1.wait_time)
+    assert_equal(7, measurement1.called)
+
+    assert_equal(3, measurement2.total_time)
+    assert_equal(2, measurement2.self_time)
+    assert_equal(1, measurement2.wait_time)
+    assert_equal(3, measurement2.called)
+  end
+
+  def test_set_total_time
+    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
+    measurement.total_time = 5.1
+    assert_equal(5.1, measurement.total_time)
+  end
+
+  def test_set_self_time
+    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
+    measurement.self_time = 3.1
+    assert_equal(3.1, measurement.self_time)
+  end
+
+  def test_set_wait_time
+    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
+    measurement.wait_time = 1.1
+    assert_equal(1.1, measurement.wait_time)
+  end
+
+  def test_set_called
+    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
+    measurement.called = 2
+    assert_equal(2, measurement.called)
+  end
+end

data/test/merge_test.rb

@@ -52,28 +52,28 @@ class MergeTest < TestCase
     assert_equal(4, result.threads.size)
 
     thread = result.threads[0]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
 
     thread = result.threads[1]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
 
     thread = result.threads[2]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
 
     thread = result.threads[3]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
   end
 
   def test_single_worker_merged
@@ -83,16 +83,16 @@ class MergeTest < TestCase
     assert_equal(2, result.threads.size)
 
     thread = result.threads[0]
-    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
 
     thread = result.threads[1]
-    assert_in_delta(1.5, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(1.5, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(1.5, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(1.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
   end
 
   def test_multiple_workers_unmerged
@@ -100,28 +100,28 @@ class MergeTest < TestCase
     assert_equal(4, result.threads.count)
 
     thread = result.threads[0]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
 
     thread = result.threads[1]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
 
     thread = result.threads[2]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
 
     thread = result.threads[3]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
   end
 
   def test_multiple_workers_merged
@@ -131,16 +131,16 @@ class MergeTest < TestCase
     assert_equal(2, result.threads.count)
 
     thread = result.threads[0]
-    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
 
     thread = result.threads[1]
-    assert_in_delta(3.0, thread.call_tree.target.total_time, 0.1)
-    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
-    assert_in_delta(1.0, thread.call_tree.target.wait_time, 0.1)
-    assert_in_delta(2.0, thread.call_tree.target.children_time, 0.1)
+    assert_in_delta(3.0, thread.call_tree.target.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1 * delta_multiplier)
+    assert_in_delta(1.0, thread.call_tree.target.wait_time, 0.1 * delta_multiplier)
+    assert_in_delta(2.0, thread.call_tree.target.children_time, 0.1 * delta_multiplier)
   end
 end
 end

data/test/multi_printer_test.rb

@@ -1,66 +1,52 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Test data
-#     A
-#    / \
-#   B   C
-#        \
-#         B
-
-class MSTPT
-  def a
-    100.times{b}
-    300.times{c}
-    c;c;c
-  end
-
-  def b
-    sleep 0
-  end
-
-  def c
-    5.times{b}
-  end
-end
-
-class MultiPrinterTest < TestCase
-  def test_refuses_io_objects
-    # we don't need a real profile for this test
-    p = RubyProf::MultiPrinter.new nil
-    begin
-      p.print(STDOUT)
-      flunk "should have raised an ArgumentError"
-    rescue ArgumentError => e
-      assert_match(/IO/, e.to_s)
-    end
-  end
-
-  def test_refuses_non_hashes
-    # we don't need a real profile for this test
-    p = RubyProf::MultiPrinter.new nil
-    begin
-      p.print([])
-      flunk "should have raised an ArgumentError"
-    rescue ArgumentError => e
-      assert_match(/hash/, e.to_s)
-    end
-  end
-
-  private
-
-  def print(result)
-    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
-    path = Dir.tmpdir
-    profile = "ruby_prof_#{test}"
-    printer = RubyProf::MultiPrinter.new(result)
-    printer.print(:path => path, :profile => profile,
-                  :threshold => 0, :min_percent => 0, :title => "ruby_prof #{test}")
-    if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
-      system("open '#{printer.stack_profile}'")
-    end
-    [File.read(printer.stack_profile), File.read(printer.graph_profile)]
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class MSTPT
+  def a
+    100.times{b}
+    300.times{c}
+    c;c;c
+  end
+
+  def b
+    sleep 0
+  end
+
+  def c
+    5.times{b}
+  end
+end
+
+class MultiPrinterTest < TestCase
+  def test_refuses_positional_arguments
+    # we don't need a real profile for this test
+    p = RubyProf::MultiPrinter.new nil
+    assert_raises(ArgumentError) do
+      p.print(STDOUT)
+    end
+  end
+
+  private
+
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    path = Dir.tmpdir
+    profile = "ruby_prof_#{test}"
+    printer = RubyProf::MultiPrinter.new(result)
+    printer.print(path: path, profile: profile,
+                  threshold: 0, min_percent: 0, title: "ruby_prof #{test}")
+    if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
+      system("open '#{printer.stack_profile}'")
+    end
+    [File.read(printer.stack_profile), File.read(printer.graph_profile)]
+  end
+end

data/test/no_method_class_test.rb

@@ -1,15 +1,15 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Make sure this works with no class or method
-result = RubyProf::Profile.profile do
-  sleep 1
-end
-
-methods = result.threads.first.methods
-global_method = methods.sort_by {|method| method.full_name}.first
-if global_method.full_name != 'Kernel#sleep'
-  raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{global_method.full_name}")
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Make sure this works with no class or method
+result = RubyProf::Profile.profile do
+  sleep 1
+end
+
+methods = result.threads.first.methods
+global_method = methods.sort_by {|method| method.full_name}.first
+if global_method.full_name != 'Kernel#sleep'
+  raise(RuntimeError, "Wrong method name.  Expected: Global#[No method].  Actual: #{global_method.full_name}")
+end