ruby-prof 1.6.3 → 1.7.0

data/test/measure_wall_time_test.rb

@@ -157,56 +157,204 @@ class MeasureWallTimeTest < TestCase
     assert_in_delta(0, method.self_time, 0.03 * @delta_multiplier)
   end
 
-  def test_instance_methods_block
-    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
-      1.times { RubyProf::C1.new.sleep_wait }
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(6, methods.length)
-
-    # Check times
-    method = methods[0]
-    assert_equal("MeasureWallTimeTest#test_instance_methods_block", method.full_name)
-    assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
-
-    method = methods[1]
-    assert_equal("Integer#times", method.full_name)
-    assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
-
-    method = methods[2]
-    assert_equal("RubyProf::C1#sleep_wait", method.full_name)
-    assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.3')
+    def test_instance_methods_block
+      result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+        1.times { RubyProf::C1.new.sleep_wait }
+      end
 
-    method = methods[3]
-    assert_equal("Kernel#sleep", method.full_name)
-    assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.2, method.self_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+      methods = result.threads.first.methods.sort.reverse
+      assert_equal(6, methods.length)
+
+      # Check times
+      method = methods[0]
+      assert_equal("MeasureWallTimeTest#test_instance_methods_block", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[1]
+      assert_equal("Integer#times", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[2]
+      assert_equal("RubyProf::C1#sleep_wait", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[3]
+      assert_equal("Kernel#sleep", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[4]
+      assert_equal("Class#new", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[5]
+      assert_equal("BasicObject#initialize", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+    end
+  elsif Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.3')
+    def test_instance_methods_block
+      result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+        1.times { RubyProf::C1.new.sleep_wait }
+      end
 
-    method = methods[4]
-    assert_equal("Class#new", method.full_name)
-    assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+      methods = result.threads.first.methods.sort.reverse
+      assert_equal(9, methods.length)
+
+      # Check times
+      method = methods[0]
+      assert_equal("MeasureWallTimeTest#test_instance_methods_block", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[1]
+      assert_equal("Integer#times", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[2]
+      assert_equal("RubyProf::C1#sleep_wait", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[3]
+      assert_equal("Kernel#sleep", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[4]
+      assert_equal("Integer#succ", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[5]
+      assert_equal("Class#new", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[6]
+      assert_equal("Integer#<", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[7]
+      assert_equal("Kernel#block_given?", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[8]
+      assert_equal("BasicObject#initialize", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+    end
+  else
+    def test_instance_methods_block
+      result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+        1.times { RubyProf::C1.new.sleep_wait }
+      end
 
-    method = methods[5]
-    assert_equal("BasicObject#initialize", method.full_name)
-    assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
-    assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+      methods = result.threads.first.methods.sort.reverse
+      assert_equal(9, methods.length)
+
+      # Check times
+      method = methods[0]
+      assert_equal("MeasureWallTimeTest#test_instance_methods_block", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[1]
+      assert_equal("Integer#times", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[2]
+      assert_equal("RubyProf::C1#sleep_wait", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[3]
+      assert_equal("Kernel#sleep", method.full_name)
+      assert_in_delta(0.2, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.2, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[4]
+      assert_equal("Kernel#block_given?", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[5]
+      assert_equal("Integer#succ", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[6]
+      assert_equal("Integer#<", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[7]
+      assert_equal("Class#new", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+
+      method = methods[8]
+      assert_equal("BasicObject#initialize", method.full_name)
+      assert_in_delta(0.0, method.total_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.wait_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.self_time, 0.03 * @delta_multiplier)
+      assert_in_delta(0.0, method.children_time, 0.03 * @delta_multiplier)
+    end
   end
 
   def test_instance_methods_threaded

data/test/method_info_test.rb

@@ -23,7 +23,7 @@ class MethodInfoTest < Minitest::Test
     error = assert_raises(NoMethodError) do
       RubyProf::MethodInfo.new(nil, nil)
     end
-    assert_match(/undefined method `instance_method' for nil:NilClass/, error.message)
+    assert_match(/undefined method `instance_method' for nil/, error.message)
   end
 
   def test_initialize_nil_method_name

data/test/recursive_test.rb

@@ -302,7 +302,7 @@ class RecursiveTest < TestCase
       assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
 
       assert_equal(0, method.call_trees.callees.length)
-    else
+    elsif Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.3')
       assert_equal(6, methods.length)
 
       # Method 0
@@ -419,6 +419,203 @@ class RecursiveTest < TestCase
       call_tree = method.call_trees.callers[0]
       assert_equal('Integer#times', call_tree.parent.target.full_name)
 
+      assert_equal(0, method.call_trees.callees.length)
+    else
+      assert_equal(9, methods.length)
+
+      # Method 0
+      method = methods[0]
+      assert_equal('RecursiveTest#test_cycle', method.full_name)
+      assert_equal(1, method.called)
+      refute(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(0, method.call_trees.callers.length)
+
+      assert_equal(1, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('SimpleRecursion#render', call_tree.target.full_name)
+
+      # Method 1
+      method = methods[1]
+      assert_equal('SimpleRecursion#render', method.full_name)
+      assert_equal(1, method.called)
+      refute(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.01)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('RecursiveTest#test_cycle', call_tree.parent.target.full_name)
+
+      assert_equal(1, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Integer#times', call_tree.target.full_name)
+
+      # Method 2
+      method = methods[2]
+      assert_equal('Integer#times', method.full_name)
+      assert_equal(2, method.called)
+      assert(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.1)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(2, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#render', call_tree.parent.target.full_name)
+
+      call_tree = method.call_trees.callers[1]
+      assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+      assert_equal(5, method.call_trees.callees.length)
+
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Kernel#block_given?', call_tree.target.full_name)
+      assert_in_delta(0, call_tree.total_time)
+      assert_in_delta(0, call_tree.wait_time)
+      assert_in_delta(0, call_tree.self_time)
+      assert_in_delta(0, call_tree.children_time)
+
+      call_tree = method.call_trees.callees[1]
+      assert_equal('Integer#<', call_tree.target.full_name)
+      assert_in_delta(0, call_tree.total_time)
+      assert_in_delta(0, call_tree.wait_time)
+      assert_in_delta(0, call_tree.self_time)
+      assert_in_delta(0, call_tree.children_time)
+
+      call_tree = method.call_trees.callees[2]
+      assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
+      assert_in_delta(7.0, call_tree.total_time, 0.1)
+      assert_in_delta(0, call_tree.wait_time)
+      assert_in_delta(0, call_tree.self_time)
+      assert_in_delta(7.0, call_tree.children_time, 0.1)
+
+      call_tree = method.call_trees.callees[3]
+      assert_equal('Integer#succ', call_tree.target.full_name)
+      assert_in_delta(0, call_tree.total_time)
+      assert_in_delta(0, call_tree.wait_time)
+      assert_in_delta(0, call_tree.self_time)
+      assert_in_delta(0, call_tree.children_time)
+
+      call_tree = method.call_trees.callees[4]
+      assert_equal('Integer#+', call_tree.target.full_name)
+      assert_in_delta(0, call_tree.total_time)
+      assert_in_delta(0, call_tree.wait_time)
+      assert_in_delta(0, call_tree.self_time)
+      assert_in_delta(0, call_tree.children_time)
+
+      # Method 3
+      method = methods[3]
+      assert_equal('SimpleRecursion#render_partial', method.full_name)
+      assert_equal(5, method.called)
+      assert(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(5, method.children_time, 0.1)
+
+      assert_equal(2, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('Integer#times', call_tree.parent.target.full_name)
+
+      call_tree = method.call_trees.callers[1]
+      assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+      assert_equal(3, method.call_trees.callees.length)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Kernel#sleep', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[1]
+      assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
+
+      call_tree = method.call_trees.callees[2]
+      assert_equal('Integer#times', call_tree.target.full_name)
+
+      # Method 4
+      method = methods[4]
+      assert_equal('Kernel#sleep', method.full_name)
+      assert_equal(5, method.called)
+      refute(method.recursive?)
+      assert_in_delta(5, method.total_time, 0.1)
+      assert_in_delta(5, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+      assert_equal(0, method.call_trees.callees.length)
+
+      # Method 5
+      method = methods[5]
+      assert_equal('Kernel#block_given?', method.full_name)
+      assert_equal(2, method.called)
+      refute(method.recursive?)
+      assert_in_delta(0, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('Integer#times', call_tree.parent.target.full_name)
+
+      assert_equal(0, method.call_trees.callees.length)
+
+      # Method 6
+      method = methods[6]
+      assert_equal('Integer#succ', method.full_name)
+      assert_equal(4, method.called)
+      refute(method.recursive?)
+      assert_in_delta(0, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('Integer#times', call_tree.parent.target.full_name)
+
+      assert_equal(0, method.call_trees.callees.length)
+
+      # Method 7
+      method = methods[7]
+      assert_equal('Integer#<', method.full_name)
+      assert_equal(6, method.called)
+      refute(method.recursive?)
+      assert_in_delta(0, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('Integer#times', call_tree.parent.target.full_name)
+
+      assert_equal(0, method.call_trees.callees.length)
+
+      # Method 8
+      method = methods[8]
+      assert_equal('Integer#+', method.full_name)
+      assert_equal(2, method.called)
+      refute(method.recursive?)
+      assert_in_delta(0, method.total_time, 0.1)
+      assert_in_delta(0, method.self_time, 0.1)
+      assert_in_delta(0, method.wait_time, 0.01)
+      assert_in_delta(0, method.children_time, 0.01)
+
+      assert_equal(1, method.call_trees.callers.length)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('Integer#times', call_tree.parent.target.full_name)
+
       assert_equal(0, method.call_trees.callees.length)
     end
   end

data/test/thread_test.rb

@@ -144,7 +144,6 @@ class ThreadTest < TestCase
       # force it to hit thread.join, below, first
       # thus forcing sleep(1), below, to be counted as (wall) self_time
       # since we currently count time "in some other thread" as self.wait_time
-      # for whatever reason
       sleep(1)
     end
     thread.join
@@ -155,9 +154,6 @@ class ThreadTest < TestCase
 
     rp_thread = result.threads.detect {|t| t.id == thread.object_id}
     methods = rp_thread.methods.sort.reverse
-    # fails on travis. why?
-    # expected_methods = ["ThreadTest#test_thread_timings", "Kernel#sleep"]
-    # assert_equal(expected_methods, methods.map(&:full_name))
 
     method = methods[0]
     assert_equal('ThreadTest#test_thread_timings', method.full_name)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-prof
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.7.0
 platform: ruby
 authors:
 - Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-20 00:00:00.000000000 Z
+date: 2024-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -117,6 +117,7 @@ files:
 - test/call_tree_visitor_test.rb
 - test/call_trees_test.rb
 - test/compatibility_test.rb
+- test/crash2.rb
 - test/duplicate_names_test.rb
 - test/dynamic_method_test.rb
 - test/enumerable_test.rb
@@ -167,7 +168,7 @@ metadata:
   bug_tracker_uri: https://github.com/ruby-prof/ruby-prof/issues
   changelog_uri: https://github.com/ruby-prof/ruby-prof/blob/master/CHANGES
   documentation_uri: https://ruby-prof.github.io/
-  source_code_uri: https://github.com/ruby-prof/ruby-prof/tree/v1.6.3
+  source_code_uri: https://github.com/ruby-prof/ruby-prof/tree/v1.7.0
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -176,14 +177,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.8
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Fast Ruby profiler