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

data/ext/ruby_prof/rp_thread.h

@@ -1,39 +1,39 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RP_THREAD__
-#define __RP_THREAD__
-
-#include "ruby_prof.h"
-#include "rp_stack.h"
-
-/* Profiling information for a thread. */
-typedef struct thread_data_t
-{
-    prof_owner_t owner;               /* Who owns this object */
-    VALUE object;                     /* Cache to wrapped object */
-    VALUE fiber;                      /* Fiber */
-    prof_stack_t* stack;              /* Stack of frames */
-    bool trace;                       /* Are we tracking this thread */
-    prof_call_tree_t* call_tree;      /* The root of the call tree*/
-    VALUE thread_id;                  /* Thread id */
-    VALUE fiber_id;                   /* Fiber id */
-    VALUE methods;                    /* Array of RubyProf::MethodInfo */
-    st_table* method_table;           /* Methods called in the thread */
-} thread_data_t;
-
-void rp_init_thread(void);
-st_table* threads_table_create(void);
-thread_data_t* threads_table_lookup(void* profile, VALUE fiber);
-thread_data_t* threads_table_insert(void* profile, VALUE fiber);
-void threads_table_free(st_table* table);
-
-thread_data_t* prof_get_thread(VALUE self);
-VALUE prof_thread_wrap(thread_data_t* thread);
-void prof_thread_mark(void* data);
-
-void switch_thread(void* profile, thread_data_t* thread_data, double measurement);
-int pause_thread(st_data_t key, st_data_t value, st_data_t data);
-int unpause_thread(st_data_t key, st_data_t value, st_data_t data);
-
-#endif //__RP_THREAD__
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_THREAD__
+#define __RP_THREAD__
+
+#include "ruby_prof.h"
+#include "rp_stack.h"
+
+/* Profiling information for a thread. */
+typedef struct thread_data_t
+{
+    prof_owner_t owner;               /* Who owns this object */
+    VALUE object;                     /* Cache to wrapped object */
+    VALUE fiber;                      /* Fiber */
+    prof_stack_t* stack;              /* Stack of frames */
+    bool trace;                       /* Are we tracking this thread */
+    prof_call_tree_t* call_tree;      /* The root of the call tree*/
+    VALUE thread_id;                  /* Thread id */
+    VALUE fiber_id;                   /* Fiber id */
+    VALUE methods;                    /* Array of RubyProf::MethodInfo */
+    st_table* method_table;           /* Methods called in the thread */
+} thread_data_t;
+
+void rp_init_thread(void);
+st_table* threads_table_create(void);
+thread_data_t* threads_table_lookup(void* profile, VALUE fiber);
+thread_data_t* threads_table_insert(void* profile, VALUE fiber);
+void threads_table_free(st_table* table);
+
+thread_data_t* prof_get_thread(VALUE self);
+VALUE prof_thread_wrap(thread_data_t* thread);
+void prof_thread_mark(void* data);
+
+void switch_thread(void* profile, thread_data_t* thread_data, double measurement);
+int pause_thread(st_data_t key, st_data_t value, st_data_t data);
+int unpause_thread(st_data_t key, st_data_t value, st_data_t data);
+
+#endif //__RP_THREAD__

data/ext/ruby_prof/vc/ruby_prof.vcxproj

@@ -104,17 +104,20 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.2.0-vc\include\ruby-3.2.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.2.0-vc\include\ruby-3.2.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.2.1-vc\include\ruby-3.2.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.2.1-vc\include\ruby-3.2.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <WarningLevel>Level3</WarningLevel>
     </ClCompile>
     <Link>
-      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.2.0-vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.2.1-vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>x64-vcruntime140-ruby320.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
       <SubSystem>Console</SubSystem>
     </Link>
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </ProjectReference>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>

data/lib/ruby-prof/printers/abstract_printer.rb

@@ -131,6 +131,7 @@ module RubyProf
 
           * MyObject#test - An instance method "test" of the class "MyObject"
           * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+
       EOT
     end
   end

data/lib/ruby-prof/profile.rb

@@ -1,70 +1,70 @@
-# encoding: utf-8
-
-require 'ruby-prof/exclude_common_methods'
-
-module RubyProf
-  class Profile
-    def measure_mode_string
-      case self.measure_mode
-        when WALL_TIME
-          "wall_time"
-        when PROCESS_TIME
-          "process_time"
-        when ALLOCATIONS
-          "allocations"
-        when MEMORY
-          "memory"
-      end
-    end
-
-    # Hides methods that, when represented as a call graph, have
-    # extremely large in and out degrees and make navigation impossible.
-    def exclude_common_methods!
-      ExcludeCommonMethods.apply!(self)
-    end
-
-    def exclude_methods!(mod, *method_names)
-      [method_names].flatten.each do |method_name|
-        exclude_method!(mod, method_name)
-      end
-    end
-
-    def exclude_singleton_methods!(mod, *method_names)
-      exclude_methods!(mod.singleton_class, *method_names)
-    end
-
-    # call-seq:
-    # merge! -> self
-    #
-    # Merges RubyProf threads whose root call_trees reference the same target method. This is useful
-    # when profiling code that uses a main thread/fiber to distribute work to multiple workers.
-    # If there are tens or hundreds of workers, viewing results per worker thread/fiber can be
-    # overwhelming. Using +merge!+ will combine the worker times together into one result.
-    #
-    # Note the reported time will be much greater than the actual wall time. For example, if there
-    # are 10 workers that each run for 5 seconds, merged results will show one thread that
-    # ran for 50 seconds.
-    #
-    def merge!
-      # First group threads by their root call tree target (method). If the methods are
-      # different than there is nothing to merge
-      grouped = threads.group_by do |thread|
-        thread.call_tree.target
-      end
-
-      # For each target, get the first thread. Then loop over the remaining threads,
-      # and merge them into the first one and ten delete them. So we will be left with
-      # one thread per target.
-      grouped.each do |target, threads|
-        thread = threads.shift
-        threads.each do |other_thread|
-          thread.merge!(other_thread)
-          remove_thread(other_thread)
-        end
-        thread
-      end
-
-      self
-    end
-  end
-end
+# encoding: utf-8
+
+require 'ruby-prof/exclude_common_methods'
+
+module RubyProf
+  class Profile
+    def measure_mode_string
+      case self.measure_mode
+        when WALL_TIME
+          "wall_time"
+        when PROCESS_TIME
+          "process_time"
+        when ALLOCATIONS
+          "allocations"
+        when MEMORY
+          "memory"
+      end
+    end
+
+    # Hides methods that, when represented as a call graph, have
+    # extremely large in and out degrees and make navigation impossible.
+    def exclude_common_methods!
+      ExcludeCommonMethods.apply!(self)
+    end
+
+    def exclude_methods!(mod, *method_names)
+      [method_names].flatten.each do |method_name|
+        exclude_method!(mod, method_name)
+      end
+    end
+
+    def exclude_singleton_methods!(mod, *method_names)
+      exclude_methods!(mod.singleton_class, *method_names)
+    end
+
+    # call-seq:
+    # merge! -> self
+    #
+    # Merges RubyProf threads whose root call_trees reference the same target method. This is useful
+    # when profiling code that uses a main thread/fiber to distribute work to multiple workers.
+    # If there are tens or hundreds of workers, viewing results per worker thread/fiber can be
+    # overwhelming. Using +merge!+ will combine the worker times together into one result.
+    #
+    # Note the reported time will be much greater than the actual wall time. For example, if there
+    # are 10 workers that each run for 5 seconds, merged results will show one thread that
+    # ran for 50 seconds.
+    #
+    def merge!
+      # First group threads by their root call tree target (method). If the methods are
+      # different than there is nothing to merge
+      grouped = threads.group_by do |thread|
+        thread.call_tree.target
+      end
+
+      # For each target, get the first thread. Then loop over the remaining threads,
+      # and merge them into the first one and ten delete them. So we will be left with
+      # one thread per target.
+      grouped.each do |target, threads|
+        thread = threads.shift
+        threads.each do |other_thread|
+          thread.merge!(other_thread)
+          remove_thread(other_thread)
+        end
+        thread
+      end
+
+      self
+    end
+  end
+end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "1.6.1"
+  VERSION = "1.6.2"
 end

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/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|
@@ -209,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.profile(measure_mode: RubyProf::WALL_TIME) { 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.profile(measure_mode: RubyProf::WALL_TIME) { 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

@@ -37,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

data/test/measure_process_time_test.rb

@@ -780,7 +780,7 @@ class MeasureProcessTimeTest < TestCase
         assert_in_delta(0.0, method.self_time, 0.05)
         assert_in_delta(0.0, method.children_time, 0.05)
       end
-    else
+    else # Ruby 3.1 and higher
       def test_class_methods_sleep
         result = RubyProf::Profile.profile(measure_mode: RubyProf::PROCESS_TIME) do
           RubyProf::C1.sleep_wait
@@ -996,7 +996,8 @@ class MeasureProcessTimeTest < TestCase
         assert_in_delta(0.05, method.children_time, 0.05)
 
         method = methods[2]
-        assert_equal('<Module::Process>#clock_gettime', method.full_name)
+        assert('<Module::Process>#clock_gettime' == method.full_name ||
+               'Float#<' == method.full_name)
         assert_in_delta(0.05, method.total_time, 0.05)
         assert_in_delta(0.0, method.wait_time, 0.05)
         assert_in_delta(0.05, method.self_time, 0.05)