ruby-prof 1.7.2 → 2.0.0

data/test/stack_printer_test.rb

@@ -1,61 +1,61 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Test data
-#     A
-#    / \
-#   B   C
-#        \
-#         B
-
-class STPT
-  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 StackPrinterTest < TestCase
-  def test_stack_can_be_printed
-    start_time = Time.now
-    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
-      5.times{STPT.new.a}
-    end
-
-    end_time = Time.now
-    expected_time = end_time - start_time
-
-    file_contents = nil
-    file_contents = print(result)
-    re = /Thread: (\d+)(, Fiber: (\d+))? \([\.0-9]+.[\.0-9]+% ~ ([\.0-9]+)\)/
-    assert_match(re, file_contents)
-    file_contents =~ re
-    actual_time = $4.to_f
-    assert_in_delta(expected_time, actual_time, 0.1)
-  end
-
-  private
-
-  def print(result)
-    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
-    testfile_name = "#{Dir.tmpdir}/ruby_prof_#{test}.html"
-    # puts "printing to #{testfile_name}"
-    printer = RubyProf::CallStackPrinter.new(result)
-    File.open(testfile_name, "w") {|f| printer.print(f, :threshold => 0, :min_percent => 0, :title => "ruby_prof #{test}")}
-    system("open '#{testfile_name}'") if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
-    assert File.exist?(testfile_name), "#{testfile_name} does not exist"
-    assert File.readable?(testfile_name), "#{testfile_name} is no readable"
-    File.read(testfile_name)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class STPT
+  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 StackPrinterTest < TestCase
+  def test_stack_can_be_printed
+    start_time = Time.now
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      5.times{STPT.new.a}
+    end
+
+    end_time = Time.now
+    expected_time = end_time - start_time
+
+    file_contents = nil
+    file_contents = print(result)
+    re = /Thread: (\d+)(, Fiber: (\d+))? \([\.0-9]+.[\.0-9]+% ~ ([\.0-9]+)\)/
+    assert_match(re, file_contents)
+    file_contents =~ re
+    actual_time = $4.to_f
+    assert_in_delta(expected_time, actual_time, 0.1)
+  end
+
+  private
+
+  def print(result)
+    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
+    testfile_name = "#{Dir.tmpdir}/ruby_prof_#{test}.html"
+    # puts "printing to #{testfile_name}"
+    printer = RubyProf::CallStackPrinter.new(result)
+    File.open(testfile_name, "w") {|f| printer.print(f, threshold: 0, min_percent: 0, title: "ruby_prof #{test}")}
+    system("open '#{testfile_name}'") if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
+    assert File.exist?(testfile_name), "#{testfile_name} does not exist"
+    assert File.readable?(testfile_name), "#{testfile_name} is no readable"
+    File.read(testfile_name)
+  end
+end

data/test/start_stop_test.rb

@@ -1,106 +1,106 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class StartStopTest < TestCase
-  def setup
-    super
-    # Need to use wall time for this test due to the sleep calls
-    @profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-  end
-
-  def method1
-    @profile.start
-    method2
-  end
-
-  def method2
-    method3
-  end
-
-  def method3
-    sleep(2)
-    @result = @profile.stop
-  end
-
-  def test_extra_stop_should_raise
-    @profile.start
-    assert_raises(RuntimeError) do
-      @profile.start
-    end
-
-    @profile.stop # ok
-    assert_raises(RuntimeError) do
-      @profile.stop
-    end
-  end
-
-  def test_different_methods
-    method1
-
-    # Ruby prof should be stopped
-    assert_equal(false, @profile.running?)
-
-    methods = @result.threads.first.methods.sort.reverse
-    assert_equal(4, methods.length)
-
-    method = methods[0]
-    assert_equal('StartStopTest#method1', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(0, method.self_time, 0.02)
-    assert_in_delta(2, method.children_time, 0.05)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('StartStopTest#method2', call_tree.target.full_name)
-
-    method = methods[1]
-    assert_equal('StartStopTest#method2', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(0, method.self_time, 0.02)
-    assert_in_delta(2, method.children_time, 0.05)
-
-    assert_equal(1, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('StartStopTest#method1', call_tree.parent.target.full_name)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('StartStopTest#method3', call_tree.target.full_name)
-
-    method = methods[2]
-    assert_equal('StartStopTest#method3', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(0, method.self_time, 0.02)
-    assert_in_delta(2, method.children_time, 0.05)
-
-    assert_equal(1, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('StartStopTest#method2', call_tree.parent.target.full_name)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('Kernel#sleep', call_tree.target.full_name)
-
-    method = methods[3]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.02)
-    assert_in_delta(2, method.self_time, 0.02)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    assert_equal(1, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('StartStopTest#method3', call_tree.parent.target.full_name)
-
-    assert_equal(0, method.call_trees.callees.length)
-  end
-end
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class StartStopTest < TestCase
+  def setup
+    super
+    # Need to use wall time for this test due to the sleep calls
+    @profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+  end
+
+  def method1
+    @profile.start
+    method2
+  end
+
+  def method2
+    method3
+  end
+
+  def method3
+    sleep(2)
+    @result = @profile.stop
+  end
+
+  def test_extra_stop_should_raise
+    @profile.start
+    assert_raises(RuntimeError) do
+      @profile.start
+    end
+
+    @profile.stop # ok
+    assert_raises(RuntimeError) do
+      @profile.stop
+    end
+  end
+
+  def test_different_methods
+    method1
+
+    # Ruby prof should be stopped
+    assert_equal(false, @profile.running?)
+
+    methods = @result.threads.first.methods.sort.reverse
+    assert_equal(4, methods.length)
+
+    method = methods[0]
+    assert_equal('StartStopTest#method1', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.02 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.02 * delta_multiplier)
+    assert_in_delta(2, method.children_time, 0.05 * delta_multiplier)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('StartStopTest#method2', call_tree.target.full_name)
+
+    method = methods[1]
+    assert_equal('StartStopTest#method2', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.02 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.02 * delta_multiplier)
+    assert_in_delta(2, method.children_time, 0.05 * delta_multiplier)
+
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('StartStopTest#method1', call_tree.parent.target.full_name)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('StartStopTest#method3', call_tree.target.full_name)
+
+    method = methods[2]
+    assert_equal('StartStopTest#method3', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.02 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.02 * delta_multiplier)
+    assert_in_delta(2, method.children_time, 0.05 * delta_multiplier)
+
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('StartStopTest#method2', call_tree.parent.target.full_name)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Kernel#sleep', call_tree.target.full_name)
+
+    method = methods[3]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(2, method.total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.02 * delta_multiplier)
+    assert_in_delta(2, method.self_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.02 * delta_multiplier)
+
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('StartStopTest#method3', call_tree.parent.target.full_name)
+
+    assert_equal(0, method.call_trees.callees.length)
+  end
+end

data/test/test_helper.rb

@@ -16,5 +16,9 @@ ENV["MT_CPU"] = "0" # New versions of minitest
 ENV["N"] = "0" # Older versions of minitest
 
 require 'minitest/autorun'
+Minitest.load_plugins
 class TestCase < Minitest::Test
+  def delta_multiplier
+    osx? && ENV["GITHUB_ACTIONS"] ? 6 : 1
+  end
 end

data/test/thread_test.rb

@@ -126,11 +126,11 @@ class ThreadTest < TestCase
     assert(thread_ids.include?(threads[0].object_id))
     assert(thread_ids.include?(threads[1].object_id))
 
-    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[0]))
-    assert(threads.include?(ObjectSpace._id2ref(thread_ids[0])))
-
-    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[1]))
-    assert(threads.include?(ObjectSpace._id2ref(thread_ids[1])))
+    thread_ids.each do |id|
+      thread = threads.find { |t| t.object_id == id }
+      refute_nil(thread)
+      assert_instance_of(Thread, thread)
+    end
   end
 
   def test_thread_timings
@@ -156,19 +156,19 @@ class ThreadTest < TestCase
     method = methods[0]
     assert_equal('ThreadTest#test_thread_timings', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.1)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(1, method.children_time, 0.1)
+    assert_in_delta(1, method.total_time, 0.1 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.05 * delta_multiplier)
+    assert_in_delta(1, method.children_time, 0.1 * delta_multiplier)
     assert_equal(0, method.call_trees.callers.length)
 
     method = methods[1]
     assert_equal('Kernel#sleep', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(1, method.total_time, 0.05)
-    assert_in_delta(1.0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    assert_in_delta(1, method.total_time, 0.05 * delta_multiplier)
+    assert_in_delta(1.0, method.self_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.05 * delta_multiplier)
 
     assert_equal(1, method.call_trees.callers.length)
     assert_equal(0, method.call_trees.callees.length)
@@ -185,10 +185,10 @@ class ThreadTest < TestCase
     # cause the parent frame to be created for method #test_thread_timings, which means a +1 when it's popped in the end
     # xxxx a test that shows it the other way, too (never creates parent frame--if that's even possible)
     assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(1, method.children_time, 0.05)
+    assert_in_delta(1, method.total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.05 * delta_multiplier)
+    assert_in_delta(1, method.children_time, 0.05 * delta_multiplier)
 
     assert_equal(0, method.call_trees.callers.length)
     assert_equal(2, method.call_trees.callees.length)
@@ -196,10 +196,10 @@ class ThreadTest < TestCase
     method = methods[1]
     assert_equal('Thread#join', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(1.0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    assert_in_delta(1, method.total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.05 * delta_multiplier)
+    assert_in_delta(1.0, method.wait_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.05 * delta_multiplier)
 
     assert_equal(1, method.call_trees.callers.length)
     assert_equal(0, method.call_trees.callees.length)
@@ -207,10 +207,10 @@ class ThreadTest < TestCase
     method = methods[2]
     assert_equal('<Class::Thread>#new', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    assert_in_delta(0, method.total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.05 * delta_multiplier)
 
     assert_equal(1, method.call_trees.callers.length)
     assert_equal(1, method.call_trees.callees.length)
@@ -218,10 +218,10 @@ class ThreadTest < TestCase
     method = methods[3]
     assert_equal('Thread#initialize', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    assert_in_delta(0, method.total_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.self_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.wait_time, 0.05 * delta_multiplier)
+    assert_in_delta(0, method.children_time, 0.05 * delta_multiplier)
 
     assert_equal(1, method.call_trees.callers.length)
     assert_equal(0, method.call_trees.callees.length)