ruby-prof 1.5.0-x64-mingw-ucrt → 1.6.2-x64-mingw-ucrt

data/test/call_tree_test.rb

@@ -1,197 +1,94 @@
-# frozen_string_literal: true
-
-require File.expand_path('../test_helper', __FILE__)
-require_relative './call_tree_builder'
-require 'base64'
-
-class CallTreeTest < Minitest::Test
-  def test_initialize
-    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
-    call_tree = RubyProf::CallTree.new(method_info)
-    assert_equal(method_info, call_tree.target)
-  end
-
-  def test_measurement
-    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
-    call_tree = RubyProf::CallTree.new(method_info)
-
-    assert_equal(0, call_tree.total_time)
-    assert_equal(0, call_tree.self_time)
-    assert_equal(0, call_tree.wait_time)
-    assert_equal(0, call_tree.children_time)
-    assert_equal(0, call_tree.called)
-  end
-
-  def test_compare
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
-    call_tree_1 = RubyProf::CallTree.new(method_info_1)
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
-    call_tree_2 = RubyProf::CallTree.new(method_info_2)
-    assert_equal(0, call_tree_1 <=> call_tree_2)
-
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
-    call_tree_1 = RubyProf::CallTree.new(method_info_1)
-    call_tree_1.measurement.total_time = 1
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
-    call_tree_2 = RubyProf::CallTree.new(method_info_2)
-    assert_equal(1, call_tree_1 <=> call_tree_2)
-
-    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
-    call_tree_1 = RubyProf::CallTree.new(method_info_1)
-    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
-    call_tree_2 = RubyProf::CallTree.new(method_info_2)
-    call_tree_2.measurement.total_time = 1
-    assert_equal(-1, call_tree_1 <=> call_tree_2)
-  end
-
-  def test_to_s
-    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
-    call_tree = RubyProf::CallTree.new(method_info)
-    assert_equal("<RubyProf::CallTree - Base64#encode64>", call_tree.to_s)
-  end
-
-  def test_add_child
-    method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
-    call_tree_parent = RubyProf::CallTree.new(method_info_parent)
-
-    method_info_child = RubyProf::MethodInfo.new(Array, :pack)
-    call_tree_child = RubyProf::CallTree.new(method_info_child)
-
-    assert_equal(0, call_tree_parent.children.size)
-    assert_nil(call_tree_child.parent)
-
-    result = call_tree_parent.add_child(call_tree_child)
-    assert_equal(1, call_tree_parent.children.size)
-    assert_equal(call_tree_child, call_tree_parent.children.first)
-    assert_equal(call_tree_child, result)
-    assert_equal(call_tree_parent, call_tree_child.parent)
-  end
-
-  def test_add_child_gc
-    GC.stress = true
-
-    begin
-      method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
-      call_tree_parent = RubyProf::CallTree.new(method_info_parent)
-
-      method_info_child = RubyProf::MethodInfo.new(Array, :pack)
-      call_tree_child = RubyProf::CallTree.new(method_info_child)
-      call_tree_parent.add_child(call_tree_child)
-
-      # Free the child first
-      call_tree_child = nil
-      GC.start
-
-      # Now free the parent and make sure it doesn't free the child a second time
-      call_tree_parent = nil
-      GC.start
-
-      assert(true)
-    ensure
-      GC.stress = false
-    end
-  end
-
-  def test_merge
-    call_tree_1 = create_call_tree_1
-    call_tree_2 = create_call_tree_2
-    call_tree_1.merge!(call_tree_2)
-
-    # Root
-    call_tree = call_tree_1
-    assert_equal(:root, call_tree.target.method_name)
-    assert_in_delta(11.6, call_tree.total_time, 0.00001)
-    assert_in_delta(0, call_tree.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
-    assert_in_delta(11.6, call_tree.children_time, 0.00001)
-
-    assert_in_delta(11.6, call_tree.target.total_time, 0.00001)
-    assert_in_delta(0, call_tree.target.self_time, 0.00001)
-    assert_in_delta(0, call_tree.target.wait_time, 0.00001)
-    assert_in_delta(11.6, call_tree.target.children_time, 0.00001)
-
-    # a
-    call_tree = call_tree_1.children[0]
-    assert_equal(:a, call_tree.target.method_name)
-
-    assert_in_delta(4.1, call_tree.total_time, 0.00001)
-    assert_in_delta(0, call_tree.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
-    assert_in_delta(4.1, call_tree.children_time, 0.00001)
-
-    assert_in_delta(4.1, call_tree.target.total_time, 0.00001)
-    assert_in_delta(0, call_tree.target.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
-    assert_in_delta(4.1, call_tree.target.children_time, 0.00001)
-
-    # aa
-    call_tree = call_tree_1.children[0].children[0]
-    assert_equal(:aa, call_tree.target.method_name)
-
-    assert_in_delta(1.5, call_tree.total_time, 0.00001)
-    assert_in_delta(1.5, call_tree.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
-    assert_in_delta(0.0, call_tree.children_time, 0.00001)
-
-    assert_in_delta(1.5, call_tree.target.total_time, 0.00001)
-    assert_in_delta(1.5, call_tree.target.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
-    assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
-
-    # ab
-    call_tree = call_tree_1.children[0].children[1]
-    assert_equal(:ab, call_tree.target.method_name)
-
-    assert_in_delta(2.6, call_tree.total_time, 0.00001)
-    assert_in_delta(2.6, call_tree.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
-    assert_in_delta(0.0, call_tree.children_time, 0.00001)
-
-    assert_in_delta(2.6, call_tree.target.total_time, 0.00001)
-    assert_in_delta(2.6, call_tree.target.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
-    assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
-
-    # b
-    call_tree = call_tree_1.children[1]
-    assert_equal(:b, call_tree.target.method_name)
-
-    assert_in_delta(7.5, call_tree.total_time, 0.00001)
-    assert_in_delta(0, call_tree.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
-    assert_in_delta(7.5, call_tree.children_time, 0.00001)
-
-    assert_in_delta(7.5, call_tree.target.total_time, 0.00001)
-    assert_in_delta(0, call_tree.target.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
-    assert_in_delta(7.5, call_tree.target.children_time, 0.00001)
-
-    # bb
-    call_tree = call_tree_1.children[1].children[0]
-    assert_equal(:bb, call_tree.target.method_name)
-
-    assert_in_delta(6.6, call_tree.total_time, 0.00001)
-    assert_in_delta(6.6, call_tree.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
-    assert_in_delta(0.0, call_tree.children_time, 0.00001)
-
-    assert_in_delta(6.6, call_tree.target.total_time, 0.00001)
-    assert_in_delta(6.6, call_tree.target.self_time, 0.00001)
-    assert_in_delta(0.0, call_tree.target.wait_time, 0.00001)
-    assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
-
-    # ba
-    call_tree = call_tree_1.children[1].children[1]
-    assert_equal(:ba, call_tree.target.method_name)
-
-    assert_in_delta(0.9, call_tree.total_time, 0.00001)
-    assert_in_delta(0.7, call_tree.self_time, 0.00001)
-    assert_in_delta(0.2, call_tree.wait_time, 0.00001)
-    assert_in_delta(0.0, call_tree.children_time, 0.00001)
-
-    assert_in_delta(0.9, call_tree.target.total_time, 0.00001)
-    assert_in_delta(0.7, call_tree.target.self_time, 0.00001)
-    assert_in_delta(0.2, call_tree.target.wait_time, 0.00001)
-    assert_in_delta(0.0, call_tree.target.children_time, 0.00001)
-  end
-end
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './call_tree_builder'
+require 'base64'
+
+class CallTreeTest < Minitest::Test
+  def test_initialize
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree = RubyProf::CallTree.new(method_info)
+    assert_equal(method_info, call_tree.target)
+  end
+
+  def test_measurement
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree = RubyProf::CallTree.new(method_info)
+
+    assert_equal(0, call_tree.total_time)
+    assert_equal(0, call_tree.self_time)
+    assert_equal(0, call_tree.wait_time)
+    assert_equal(0, call_tree.children_time)
+    assert_equal(0, call_tree.called)
+  end
+
+  def test_compare
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_1 = RubyProf::CallTree.new(method_info_1)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_2 = RubyProf::CallTree.new(method_info_2)
+    assert_equal(0, call_tree_1 <=> call_tree_2)
+
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
+    call_tree_1 = RubyProf::CallTree.new(method_info_1)
+    call_tree_1.measurement.total_time = 1
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_2 = RubyProf::CallTree.new(method_info_2)
+    assert_equal(1, call_tree_1 <=> call_tree_2)
+
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
+    call_tree_1 = RubyProf::CallTree.new(method_info_1)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_2 = RubyProf::CallTree.new(method_info_2)
+    call_tree_2.measurement.total_time = 1
+    assert_equal(-1, call_tree_1 <=> call_tree_2)
+  end
+
+  def test_to_s
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree = RubyProf::CallTree.new(method_info)
+    assert_equal("<RubyProf::CallTree - Base64#encode64>", call_tree.to_s)
+  end
+
+  def test_add_child
+    method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
+    call_tree_parent = RubyProf::CallTree.new(method_info_parent)
+
+    method_info_child = RubyProf::MethodInfo.new(Array, :pack)
+    call_tree_child = RubyProf::CallTree.new(method_info_child)
+
+    assert_equal(0, call_tree_parent.children.size)
+    assert_nil(call_tree_child.parent)
+
+    result = call_tree_parent.add_child(call_tree_child)
+    assert_equal(1, call_tree_parent.children.size)
+    assert_equal(call_tree_child, call_tree_parent.children.first)
+    assert_equal(call_tree_child, result)
+    assert_equal(call_tree_parent, call_tree_child.parent)
+  end
+
+  def test_add_child_gc
+    GC.stress = true
+
+    begin
+      method_info_parent = RubyProf::MethodInfo.new(Base64, :encode64)
+      call_tree_parent = RubyProf::CallTree.new(method_info_parent)
+
+      method_info_child = RubyProf::MethodInfo.new(Array, :pack)
+      call_tree_child = RubyProf::CallTree.new(method_info_child)
+      call_tree_parent.add_child(call_tree_child)
+
+      # Free the child first
+      call_tree_child = nil
+      GC.start
+
+      # Now free the parent and make sure it doesn't free the child a second time
+      call_tree_parent = nil
+      GC.start
+
+      assert(true)
+    ensure
+      GC.stress = false
+    end
+  end
+end

data/test/call_tree_visitor_test.rb

@@ -5,13 +5,8 @@ require File.expand_path('../test_helper', __FILE__)
 require_relative './measure_times'
 
 class CallTreeVisitorTest < 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
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       RubyProf::C1.sleep_wait
     end
 

data/test/call_trees_test.rb

@@ -13,7 +13,7 @@ class CallTreesTest < TestCase
   end
 
   def test_call_infos
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile do
       some_method_1
     end
 
@@ -51,7 +51,7 @@ class CallTreesTest < TestCase
   end
 
   def test_gc
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile do
       some_method_1
     end
 

data/test/{basic_test.rb → compatibility_test.rb}

@@ -4,12 +4,18 @@
 require File.expand_path('../test_helper', __FILE__)
 require_relative './measure_times'
 
-class BasicTest < TestCase
+class CompatibilityTest < TestCase
   def setup
-    # Need to use wall time for this test due to the sleep calls
+    super
+    Gem::Deprecate.skip = true
     RubyProf::measure_mode = RubyProf::WALL_TIME
   end
 
+  def teardown
+    super
+    Gem::Deprecate.skip = false
+  end
+
   def test_running
     assert(!RubyProf.running?)
     RubyProf.start

data/test/duplicate_names_test.rb

@@ -5,7 +5,7 @@ require File.expand_path('../test_helper', __FILE__)
 
 class DuplicateNamesTest < TestCase
   def test_names
-    result = RubyProf::profile do
+    result = RubyProf::Profile.profile do
       str = %{module Foo; class Bar; def foo; end end end}
 
       eval str

data/test/dynamic_method_test.rb

@@ -24,14 +24,9 @@ class DynamicMethodTest < TestCase
     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
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       medley.apple
       medley.orange
       medley.banana

data/test/enumerable_test.rb

@@ -8,7 +8,7 @@ require File.expand_path('../test_helper', __FILE__)
 
 class EnumerableTest < TestCase
   def test_enumerable
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile do
       3.times {  [1,2,3].any? {|n| n} }
     end
     methods = if RUBY_VERSION >= "2.2.0"

data/test/exceptions_test.rb

@@ -6,7 +6,7 @@ require File.expand_path('../test_helper', __FILE__)
 class ExceptionsTest < TestCase
   def test_profile
     result = begin
-      RubyProf.profile do
+      RubyProf::Profile.profile do
         raise(RuntimeError, 'Test error')
       end
     rescue
@@ -16,7 +16,7 @@ class ExceptionsTest < TestCase
 
   def test_profile_allows_exceptions
     assert_raises(RuntimeError) do
-      RubyProf.profile(:allow_exceptions => true) do
+      RubyProf::Profile.profile(:allow_exceptions => true) do
         raise(RuntimeError, 'Test error')
       end
     end

data/test/exclude_methods_test.rb

@@ -34,14 +34,9 @@ class ExcludeMethodsClass
 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
+    prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
 
     result = prf.profile {obj.a}
     methods = result.threads.first.methods.sort.reverse
@@ -102,7 +97,7 @@ class ExcludeMethodsTest < TestCase
 
   def test_exclude_common_methods1
     obj = ExcludeMethodsClass.new
-    prf = RubyProf::Profile.new
+    prf = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
 
     prf.exclude_common_methods!
 
@@ -124,7 +119,7 @@ class ExcludeMethodsTest < TestCase
   def test_exclude_common_methods2
     obj = ExcludeMethodsClass.new
 
-    result = RubyProf.profile(exclude_common: true) { 5.times {obj.a} }
+    result = RubyProf::Profile.profile(exclude_common: true) { 5.times {obj.a} }
     methods = result.threads.first.methods.sort.reverse
 
     assert_equal(9, methods.count)

data/test/exclude_threads_test.rb

@@ -26,15 +26,10 @@ class ExcludeThreadsTest < TestCase
       thread2_proc
     end
 
-    # exclude_threads already includes the minitest thread pool
-    RubyProf.exclude_threads += [ thread2 ]
-
-    RubyProf.start
-
-    thread1.join
-    thread2.join
-
-    result = RubyProf.stop
+    result = RubyProf::Profile.profile(exclude_threads: [thread2]) do
+      thread1.join
+      thread2.join
+    end
 
     assert_equal(2, result.threads.length)
 

data/test/fiber_test.rb

@@ -5,26 +5,9 @@ require File.expand_path('../test_helper', __FILE__)
 require 'fiber'
 require 'timeout'
 require 'set'
-require_relative './scheduler'
 
 # --  Tests ----
 class FiberTest < TestCase
-  def worker
-    sleep(0.5)
-  end
-
-  def concurrency
-    scheduler = Scheduler.new
-    Fiber.set_scheduler(scheduler)
-
-    3.times do
-      Fiber.schedule do |a|
-        worker
-      end
-    end
-    Fiber.scheduler.close
-  end
-
   def enumerator_with_fibers
     enum = Enumerator.new do |yielder|
       [1,2].each do |x|
@@ -46,13 +29,8 @@ class FiberTest < TestCase
     fiber.resume
   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_fibers
-    result = RubyProf.profile { enumerator_with_fibers }
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { enumerator_with_fibers }
 
     assert_equal(2, result.threads.size)
 
@@ -142,7 +120,7 @@ class FiberTest < TestCase
   end
 
   def test_fiber_resume
-    result  = RubyProf.profile { fiber_yield_resume }
+    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { fiber_yield_resume }
 
     assert_equal(2, result.threads.size)
 
@@ -214,38 +192,4 @@ class FiberTest < TestCase
     assert_in_delta(0, method.wait_time)
     assert_in_delta(0, method.children_time)
   end
-
-  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.1.0')
-    def test_times_no_merge
-      result  = RubyProf.profile { concurrency }
-
-      assert_equal(4, result.threads.size)
-
-      result.threads.each do |thread|
-        assert_in_delta(0.5, thread.call_tree.target.total_time, 0.2)
-        assert_in_delta(0.0, thread.call_tree.target.self_time)
-        assert_in_delta(0.0, thread.call_tree.target.wait_time)
-        assert_in_delta(0.5, thread.call_tree.target.children_time, 0.2)
-      end
-    end
-
-    def test_times_merge
-      result  = RubyProf.profile { concurrency }
-      result.merge!
-
-      assert_equal(2, result.threads.size)
-
-      thread = result.threads[0]
-      assert_in_delta(0.5, thread.call_tree.target.total_time, 0.2)
-      assert_in_delta(0.0, thread.call_tree.target.self_time)
-      assert_in_delta(0.0, thread.call_tree.target.wait_time)
-      assert_in_delta(0.5, thread.call_tree.target.children_time, 0.2)
-
-      thread = result.threads[1]
-      assert_in_delta(1.5, thread.call_tree.target.total_time, 0.2)
-      assert_in_delta(0.0, thread.call_tree.target.self_time)
-      assert_in_delta(0.0, thread.call_tree.target.wait_time)
-      assert_in_delta(1.5, thread.call_tree.target.children_time, 0.2)
-    end
-  end
 end

data/test/gc_test.rb

@@ -6,6 +6,7 @@ Minitest::Test.i_suck_and_my_tests_are_order_dependent!
 
 class GcTest < TestCase
   def setup
+    super
     GC.stress = true
   end
 
@@ -18,7 +19,7 @@ class GcTest < TestCase
   end
 
   def run_profile
-    RubyProf.profile do
+    RubyProf::Profile.profile do
       self.some_method
     end
   end
@@ -36,7 +37,6 @@ class GcTest < TestCase
     end
   end
 
-
   def test_hold_onto_method
     methods = 5.times.reduce(Array.new) do |array, i|
       profile = run_profile