test-unit 3.7.3 → 3.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd21cedf50b5fd312063641964e1aa8e40c1a31a8e800d3d1614cc80b7f0dec0
-  data.tar.gz: 4ee73eac75a4fad3424c60de60b21ffb049990b15bbc363d57913195b302a638
+  metadata.gz: 5d16114e7ad17600025f6908efd1fea35e59c5b5ff953e31bf0048a573a742e5
+  data.tar.gz: 857951ac70e9f668102998ace9099388fd66c5fa6a889d36b2e9ecb1decc3315
 SHA512:
-  metadata.gz: fe16e356b97ef49cb0dcf737b5cbda6f2d620e27dd25eee14032227804bce23a72f18a061e30c7802c566c6e9a24eaeb2633b27f8be45f322c3cbeee25ce6495
-  data.tar.gz: d1f952865068e5f721b0bdeca26470167e2ffb45a7d20ef62031bfe128c278fa15674eb25fc78ceae7bda1659695cbdd65b3c0a48a34ffe2856f299f7d7e6bc4
+  metadata.gz: 1d2d8e9bf468101d11b2436cbe02d66d76d8a1c262f6e3b09792fb6d068876caa6dce7d64516792b69342bd3e0077b805f038123063f9ca8cc9d93ead8b28edc
+  data.tar.gz: 01c8e73369f1a4d63c62de6fc181539b4866bbac3dee7307658d7f4c121557e132aacfd15f7afcc4376d30415bee03a7ab690a799a8587da71b5fda0cd4453a4

data/doc/text/news.md

@@ -1,5 +1,48 @@
 # News
 
+## 3.7.4 - 2025-12-23 {#version-3-7-4}
+
+### Improvements
+
+  * Added support for process based parallel test running. You can use
+    it by the `--parallel=process` option. You need to specify load
+    path options (e.g. `-Ilib`). Tests that startup/shutdown (test case
+    level setup/teardown) are defined run in the same process.
+    * GH-235
+    * GH-339
+    * GH-340
+    * GH-341
+    * GH-342
+    * GH-344
+    * GH-346
+    * GH-348
+    * Co authored by Naoto Ono
+
+  * Added support for `worker_id` for the parallel runner. You can
+    use it in your test, setup/teardown and startup/shutdown (test case
+    level setup/teardown).
+    * GH-235
+    * GH-345
+    * Co authored by Naoto Ono
+
+  * parallel: thread: Improved shutdown (test case level teardown)
+    timing. As a result, tests that startup (test case level setup) or
+    teardown are defined now run in the same thread.
+    * GH-235
+    * GH-343
+    * Co authored by Naoto Ono
+
+### Fixes
+
+  * parallel: thread: Fixed a bug that running tests failed with the
+    `--verbose` option.
+    * GH-350
+    * GH-351
+
+### Thanks
+
+  * Naoto Ono
+
 ## 3.7.3 - 2025-11-26 {#version-3-7-3}
 
 ### Improvements

data/lib/test/unit/autorunner.rb

@@ -6,6 +6,7 @@ require_relative "priority"
 require_relative "attribute-matcher"
 require_relative "testcase"
 require_relative "test-suite-thread-runner"
+require_relative "test-suite-process-runner"
 require_relative "version"
 
 module Test
@@ -415,6 +416,7 @@ module Test
 
           parallel_options = [
             :thread,
+            :process,
           ]
           o.on("--[no-]parallel=[thread]", parallel_options,
                "Runs tests in parallel",
@@ -422,6 +424,8 @@ module Test
             case parallel
             when nil, :thread
               @test_suite_runner_class = TestSuiteThreadRunner
+            when :process
+              @test_suite_runner_class = TestSuiteProcessRunner
             else
               @test_suite_runner_class = TestSuiteRunner
             end

data/lib/test/unit/process-test-result.rb

@@ -0,0 +1,55 @@
+#--
+#
+# Author:: Tsutomu Katsube.
+# Copyright:: Copyright (c) 2025 Tsutomu Katsube. All rights reserved.
+# License:: Ruby license.
+
+module Test
+  module Unit
+    class ProcessTestResult
+      def initialize(output)
+        @output = output
+      end
+
+      def add_run
+        send_result(__method__)
+      end
+
+      def add_pass
+        send_result(__method__)
+      end
+
+      # Records an individual assertion.
+      def add_assertion
+        send_result(__method__)
+      end
+
+      def add_error(error)
+        send_result(__method__, error)
+      end
+
+      def add_failure(failure)
+        send_result(__method__, failure)
+      end
+
+      def add_pending(pending)
+        send_result(__method__, pending)
+      end
+
+      def add_omission(omission)
+        send_result(__method__, omission)
+      end
+
+      def add_notification(notification)
+        send_result(__method__, notification)
+      end
+
+      private
+
+      def send_result(action, *args)
+        Marshal.dump({status: :result, action: action, args: args}, @output)
+        @output.flush
+      end
+    end
+  end
+end

data/lib/test/unit/process-worker.rb

@@ -0,0 +1,83 @@
+#--
+#
+# Author:: Tsutomu Katsube.
+# Copyright:: Copyright (c) 2025 Tsutomu Katsube. All rights reserved.
+# License:: Ruby license.
+
+require "optparse"
+require "socket"
+
+parser = OptionParser.new
+parser.on("--load-path=PATH") do |path|
+  $LOAD_PATH << path
+end
+base_directory = nil
+parser.on("--base-directory=PATH") do |path|
+  base_directory = path
+end
+worker_id = nil
+parser.on("--worker-id=ID", Integer) do |id|
+  worker_id = id
+end
+remote_ip_address = nil
+parser.on("--ip-address=ADDRESS") do |address|
+  remote_ip_address = address
+end
+remote_ip_port = nil
+parser.on("--ip-port=PORT", Integer) do |port|
+  remote_ip_port = port
+end
+test_paths = parser.parse!
+
+require_relative "../unit"
+require_relative "collector/load"
+require_relative "process-test-result"
+require_relative "worker-context"
+Test::Unit::AutoRunner.need_auto_run = false
+collector = Test::Unit::Collector::Load.new
+collector.base = base_directory
+suite = collector.collect(*test_paths)
+
+io_open = lambda do |&block|
+  if Gem.win_platform?
+    TCPSocket.open(remote_ip_address, remote_ip_port) do |data_socket|
+      block.call(data_socket, data_socket)
+    end
+  else
+    IO.open(Test::Unit::TestSuiteProcessRunner::MAIN_TO_WORKER_INPUT_FILENO) do |data_input|
+      IO.open(Test::Unit::TestSuiteProcessRunner::WORKER_TO_MAIN_OUTPUT_FILENO) do |data_output|
+        block.call(data_input, data_output)
+      end
+    end
+  end
+end
+
+io_open.call do |data_input, data_output|
+  loop do
+    Marshal.dump({status: :ready}, data_output)
+    data_output.flush
+    test_name = Marshal.load(data_input)
+    break if test_name.nil?
+    test = suite.find(test_name)
+    result = Test::Unit::ProcessTestResult.new(data_output)
+    run_context = Test::Unit::TestRunContext.new(Test::Unit::TestSuiteRunner)
+
+    event_listener = lambda do |event_name, *args|
+      Marshal.dump({status: :event, event_name: event_name, args: args}, data_output)
+      data_output.flush
+    end
+    if test.is_a?(Test::Unit::TestSuite)
+      test_suite = test
+    else
+      test_suite = Test::Unit::TestSuite.new(test.class.name, test.class)
+      test_suite << test
+    end
+    runner = Test::Unit::TestSuiteRunner.new(test_suite)
+    worker_context = Test::Unit::WorkerContext.new(worker_id, run_context, result)
+    runner.run(worker_context, &event_listener)
+  end
+  Marshal.dump({status: :done}, data_output)
+  data_output.flush
+
+  Marshal.load(data_input)
+end

data/lib/test/unit/test-process-run-context.rb

@@ -0,0 +1,21 @@
+#--
+#
+# Author:: Tsutomu Katsube.
+# Copyright:: Copyright (c) 2025 Tsutomu Katsube. All rights reserved.
+# License:: Ruby license.
+
+require_relative "test-run-context"
+
+module Test
+  module Unit
+    class TestProcessRunContext < TestRunContext
+      attr_reader :test_names
+      attr_accessor :progress_block
+      def initialize(runner_class)
+        super(runner_class)
+        @test_names = []
+        @progress_block = nil
+      end
+    end
+  end
+end

data/lib/test/unit/test-suite-process-runner.rb

@@ -0,0 +1,197 @@
+#--
+#
+# Author:: Tsutomu Katsube.
+# Copyright:: Copyright (c) 2025 Tsutomu Katsube. All rights reserved.
+# License:: Ruby license.
+
+require "socket"
+
+require_relative "process-test-result"
+require_relative "sub-test-result"
+require_relative "test-process-run-context"
+require_relative "test-suite-runner"
+
+module Test
+  module Unit
+    class TestSuiteProcessRunner < TestSuiteRunner
+      MAIN_TO_WORKER_INPUT_FILENO = 3
+      WORKER_TO_MAIN_OUTPUT_FILENO = 4
+
+      class << self
+        class Worker
+          attr_reader :main_to_worker_output, :worker_to_main_input
+          def initialize(pid, main_to_worker_output, worker_to_main_input)
+            @pid = pid
+            @main_to_worker_output = main_to_worker_output
+            @worker_to_main_input = worker_to_main_input
+          end
+
+          def receive
+            Marshal.load(@worker_to_main_input)
+          end
+
+          def send(data)
+            Marshal.dump(data, @main_to_worker_output)
+            @main_to_worker_output.flush
+          end
+
+          def wait
+            begin
+              Process.waitpid(@pid)
+            ensure
+              begin
+                @main_to_worker_output.close
+              ensure
+                @worker_to_main_input.close
+              end
+            end
+          end
+        end
+
+        def run_all_tests(result, options)
+          n_workers = TestSuiteRunner.n_workers
+          test_suite = options[:test_suite]
+
+          start_tcp_server do |tcp_server|
+            workers = []
+            begin
+              n_workers.times do |i|
+                load_paths = options[:load_paths]
+                base_directory = options[:base_directory]
+                test_paths = options[:test_paths]
+                command_line = [Gem.ruby, File.join(__dir__, "process-worker.rb")]
+                load_paths.each do |load_path|
+                  command_line << "--load-path" << load_path
+                end
+                unless base_directory.nil?
+                  command_line << "--base-directory" << base_directory
+                end
+                command_line << "--worker-id" << (i + 1).to_s
+                if Gem.win_platform?
+                  local_address = tcp_server.local_address
+                  command_line << "--ip-address" << local_address.ip_address
+                  command_line << "--ip-port" << local_address.ip_port.to_s
+                end
+                command_line.concat(test_paths)
+                if Gem.win_platform?
+                  # On Windows, file descriptors 3 and above cannot be passed to
+                  # child processes.
+                  pid = spawn(*command_line)
+                  data_socket = tcp_server.accept
+                  workers << Worker.new(pid, data_socket, data_socket)
+                else
+                  main_to_worker_input, main_to_worker_output = IO.pipe
+                  worker_to_main_input, worker_to_main_output = IO.pipe
+                  pid = spawn(*command_line, {MAIN_TO_WORKER_INPUT_FILENO => main_to_worker_input,
+                                              WORKER_TO_MAIN_OUTPUT_FILENO => worker_to_main_output})
+                  main_to_worker_input.close
+                  worker_to_main_output.close
+                  workers << Worker.new(pid, main_to_worker_output, worker_to_main_input)
+                end
+              end
+
+              run_context = TestProcessRunContext.new(self)
+              yield(run_context)
+              run_context.progress_block.call(TestSuite::STARTED, test_suite.name)
+              run_context.progress_block.call(TestSuite::STARTED_OBJECT, test_suite)
+
+              worker_inputs = workers.collect(&:worker_to_main_input)
+              until run_context.test_names.empty? do
+                select_each_worker(worker_inputs, workers) do |_, worker, data|
+                  case data[:status]
+                  when :ready
+                    test_name = run_context.test_names.shift
+                    break if test_name.nil?
+                    worker.send(test_name)
+                  when :result
+                    add_result(result, data)
+                  when :event
+                    emit_event(options[:event_listener], data)
+                  end
+                end
+              end
+              workers.each do |worker|
+                worker.send(nil)
+              end
+              until worker_inputs.empty? do
+                select_each_worker(worker_inputs, workers) do |worker_to_main_input, worker, data|
+                  case data[:status]
+                  when :result
+                    add_result(result, data)
+                  when :event
+                    emit_event(options[:event_listener], data)
+                  when :done
+                    worker_inputs.delete(worker_to_main_input)
+                    worker.send(nil)
+                  end
+                end
+              end
+            ensure
+              workers.each do |worker|
+                worker.wait
+              end
+            end
+
+            run_context.progress_block.call(TestSuite::FINISHED, test_suite.name)
+            run_context.progress_block.call(TestSuite::FINISHED_OBJECT, test_suite)
+          end
+        end
+
+        private
+        def start_tcp_server
+          if Gem.win_platform?
+            TCPServer.open("127.0.0.1", 0) do |tcp_server|
+              yield(tcp_server)
+            end
+          else
+            yield
+          end
+        end
+
+        def select_each_worker(worker_inputs, workers)
+          readables, = IO.select(worker_inputs)
+          readables.each do |worker_to_main_input|
+            worker = workers.find do |w|
+              w.worker_to_main_input == worker_to_main_input
+            end
+            data = worker.receive
+            yield(worker_to_main_input, worker, data)
+          end
+        end
+
+        def add_result(result, data)
+          action = data[:action]
+          args = data[:args]
+          result.__send__(action, *args)
+        end
+
+        def emit_event(event_listener, data)
+          event_name = data[:event_name]
+          args = data[:args]
+          event_listener.call(event_name, *args)
+        end
+      end
+
+      def run(worker_context, &progress_block)
+        worker_context.run_context.progress_block = progress_block
+        run_tests_recursive(@test_suite, worker_context, &progress_block)
+      end
+
+      private
+      def run_tests_recursive(test_suite, worker_context, &progress_block)
+        run_context = worker_context.run_context
+        if test_suite.have_fixture?
+          run_context.test_names << test_suite.name
+        else
+          test_suite.tests.each do |test|
+            if test.is_a?(TestSuite)
+              run_tests_recursive(test, worker_context, &progress_block)
+            else
+              run_context.test_names << test.name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test/unit/test-suite-runner.rb

@@ -3,7 +3,7 @@
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
 # Copyright:: Copyright (c) 2008-2011 Kouhei Sutou. All rights reserved.
-# Copyright:: Copyright (c) 2024 Tsutomu Katsube. All rights reserved.
+# Copyright:: Copyright (c) 2024-2025 Tsutomu Katsube. All rights reserved.
 # License:: Ruby license.
 
 require "etc"
@@ -15,7 +15,7 @@ module Test
     class TestSuiteRunner
       @n_workers = Etc.respond_to?(:nprocessors) ? Etc.nprocessors : 1
       class << self
-        def run_all_tests
+        def run_all_tests(result, options)
           yield(TestRunContext.new(self))
         end
 
@@ -32,14 +32,14 @@ module Test
         @test_suite = test_suite
       end
 
-      def run(result, run_context: nil, &progress_block)
+      def run(worker_context, &progress_block)
         yield(TestSuite::STARTED, @test_suite.name)
         yield(TestSuite::STARTED_OBJECT, @test_suite)
-        run_startup(result)
-        run_tests(result, run_context: run_context, &progress_block)
+        run_startup(worker_context)
+        run_tests(worker_context, &progress_block)
       ensure
         begin
-          run_shutdown(result)
+          run_shutdown(worker_context)
         ensure
           yield(TestSuite::FINISHED, @test_suite.name)
           yield(TestSuite::FINISHED_OBJECT, @test_suite)
@@ -47,23 +47,24 @@ module Test
       end
 
       private
-      def run_startup(result)
+      def run_startup(worker_context)
         test_case = @test_suite.test_case
         return if test_case.nil? or !test_case.respond_to?(:startup)
+        test_case.worker_id = worker_context.id
         begin
           test_case.startup
         rescue Exception
-          raise unless handle_exception($!, result)
+          raise unless handle_exception($!, worker_context.result)
         end
       end
 
-      def run_tests(result, run_context: nil, &progress_block)
+      def run_tests(worker_context, &progress_block)
         @test_suite.tests.each do |test|
-          run_test(test, result, run_context: run_context, &progress_block)
+          run_test(test, worker_context, &progress_block)
         end
       end
 
-      def run_test(test, result, run_context: nil)
+      def run_test(test, worker_context)
         finished_is_yielded = false
         finished_object_is_yielded = false
         previous_event_name = nil
@@ -92,12 +93,12 @@ module Test
           yield(event_name, *args)
         end
 
-        if test.method(:run).arity == -2
-          test.run(result, run_context: run_context, &event_listener)
+        if test.method(:run).parameters[0] == [:req, :worker_context]
+          test.run(worker_context, &event_listener)
         else
           # For backward compatibility. There are scripts that overrides
           # Test::Unit::TestCase#run without keyword arguments.
-          test.run(result, &event_listener)
+          test.run(worker_context.result, &event_listener)
         end
 
         if finished_is_yielded and not finished_object_is_yielded
@@ -105,13 +106,14 @@ module Test
         end
       end
 
-      def run_shutdown(result)
+      def run_shutdown(worker_context)
         test_case = @test_suite.test_case
         return if test_case.nil? or !test_case.respond_to?(:shutdown)
+        test_case.worker_id = worker_context.id
         begin
           test_case.shutdown
         rescue Exception
-          raise unless handle_exception($!, result)
+          raise unless handle_exception($!, worker_context.result)
         end
       end
 

data/lib/test/unit/test-suite-thread-runner.rb

@@ -1,7 +1,7 @@
 #--
 #
 # Author:: Tsutomu Katsube.
-# Copyright:: Copyright (c) 2024 Tsutomu Katsube. All rights reserved.
+# Copyright:: Copyright (c) 2024-2025 Tsutomu Katsube. All rights reserved.
 # License:: Ruby license.
 
 require_relative "sub-test-result"
@@ -12,12 +12,16 @@ module Test
   module Unit
     class TestSuiteThreadRunner < TestSuiteRunner
       class << self
-        def run_all_tests
+        def run_all_tests(result, options)
           n_workers = TestSuiteRunner.n_workers
+          test_suite = options[:test_suite]
 
           queue = Thread::Queue.new
-          shutdowns = []
-          yield(TestThreadRunContext.new(self, queue, shutdowns))
+          run_context = TestThreadRunContext.new(self, queue)
+          yield(run_context)
+          run_context.progress_block.call(TestSuite::STARTED, test_suite.name)
+          run_context.progress_block.call(TestSuite::STARTED_OBJECT, test_suite)
+          run_context.parallel_unsafe_tests.each(&:call)
           n_workers.times do
             queue << nil
           end
@@ -25,13 +29,13 @@ module Test
           workers = []
           sub_exceptions = []
           n_workers.times do |i|
-            workers << Thread.new(i) do |worker_id|
+            workers << Thread.new(i + 1) do |worker_id|
               begin
                 loop do
                   task = queue.pop
                   break if task.nil?
                   catch do |stop_tag|
-                    task.call(stop_tag)
+                    task.call(stop_tag, worker_id)
                   end
                 end
               rescue Exception => exception
@@ -41,41 +45,49 @@ module Test
           end
           workers.each(&:join)
 
-          shutdowns.each(&:call)
+          run_context.progress_block.call(TestSuite::FINISHED, test_suite.name)
+          run_context.progress_block.call(TestSuite::FINISHED_OBJECT, test_suite)
+
           sub_exceptions.each do |exception|
             raise exception
           end
         end
       end
 
-      def run(result, run_context: nil, &progress_block)
-        yield(TestSuite::STARTED, @test_suite.name)
-        yield(TestSuite::STARTED_OBJECT, @test_suite)
-        run_startup(result)
-        run_tests(result, run_context: run_context, &progress_block)
-      ensure
-        run_context.shutdowns << lambda do
-          begin
-            run_shutdown(result)
-          ensure
-            yield(TestSuite::FINISHED, @test_suite.name)
-            yield(TestSuite::FINISHED_OBJECT, @test_suite)
-          end
-        end
+      def run(worker_context, &progress_block)
+        worker_context.run_context.progress_block = progress_block
+        run_tests_recursive(@test_suite, worker_context, &progress_block)
       end
 
       private
-      def run_tests(result, run_context: nil, &progress_block)
-        @test_suite.tests.each do |test|
-          if test.is_a?(TestSuite) or not @test_suite.parallel_safe?
-            run_test(test, result, run_context: run_context, &progress_block)
-          else
-            task = lambda do |stop_tag|
-              sub_result = SubTestResult.new(result)
-              sub_result.stop_tag = stop_tag
-              run_test(test, sub_result, run_context: run_context, &progress_block)
+      def run_tests_recursive(test_suite, worker_context, &progress_block)
+        run_context = worker_context.run_context
+        if test_suite.have_fixture?
+          task = lambda do |stop_tag, worker_id|
+            sub_result = SubTestResult.new(worker_context.result)
+            sub_result.stop_tag = stop_tag
+            sub_runner = TestSuiteRunner.new(test_suite)
+            sub_worker_context = WorkerContext.new(worker_id, run_context, sub_result)
+            sub_runner.run(sub_worker_context, &progress_block)
+          end
+          run_context.queue << task
+        else
+          test_suite.tests.each do |test|
+            if test.is_a?(TestSuite)
+              run_tests_recursive(test, worker_context, &progress_block)
+            elsif test_suite.parallel_safe?
+              task = lambda do |stop_tag, worker_id|
+                sub_result = SubTestResult.new(worker_context.result)
+                sub_result.stop_tag = stop_tag
+                sub_worker_context = WorkerContext.new(worker_id, run_context, sub_result)
+                run_test(test, sub_worker_context, &progress_block)
+              end
+              run_context.queue << task
+            else
+              run_context.parallel_unsafe_tests << lambda do
+                run_test(test, worker_context, &progress_block)
+              end
             end
-            run_context.queue << task
           end
         end
       end

data/lib/test/unit/test-thread-run-context.rb

@@ -9,11 +9,14 @@ require_relative "test-run-context"
 module Test
   module Unit
     class TestThreadRunContext < TestRunContext
-      attr_reader :queue, :shutdowns
-      def initialize(runner_class, queue, shutdowns)
+      attr_reader :queue
+      attr_accessor :progress_block
+      attr_accessor :parallel_unsafe_tests
+      def initialize(runner_class, queue)
         super(runner_class)
         @queue = queue
-        @shutdowns = shutdowns
+        @progress_block = nil
+        @parallel_unsafe_tests = []
       end
     end
   end

data/lib/test/unit/testcase.rb

@@ -439,8 +439,9 @@ module Test
         #
         # The difference of them are the following:
         #
-        # * Test case created by {sub_test_case} is an anonymous class.
-        #   So you can't refer the test case by name.
+        # * Test case created by {sub_test_case} is backed by an anonymous class,
+        #   but it is assigned to an auto generated constant. So it can be referred
+        #   to by name (e.g. for `Marshal.dump` and across process use).
         # * The class name of class style must follow
         #   constant naming rule in Ruby. But the name of test case
         #   created by {sub_test_case} doesn't need to follow the rule.
@@ -500,6 +501,24 @@ module Test
           available_locations
         end
 
+        # Returns a current worker ID for the test case. This return depends on
+        # how tests are run:
+        #
+        #   * Sequential: always returns `0`
+        #
+        #   * Parallel: returns a one-based to the number of workers.
+        #
+        # @return [Integer]
+        #
+        # @since 3.7.4
+        def worker_id
+          @worker_id || 0
+        end
+
+        def worker_id=(worker_id) # :nodoc:
+          @worker_id = worker_id
+        end
+
         private
         # @private
         @@method_locations = {}
@@ -545,12 +564,16 @@ module Test
         # @private
         def sub_test_case_class(name)
           parent_test_case = self
-          Class.new(self) do
+          sub_test_case = Class.new(self) do
             singleton_class = class << self; self; end
             singleton_class.__send__(:define_method, :name) do
               [parent_test_case.name, name].compact.join("::")
             end
           end
+          # Give the anonymous class a unique, Base64 encoded constant name.
+          # So it becomes a named class that `Marshal` can safely dump even across processes.
+          const_set(:"TEST_#{[sub_test_case.name].pack("m").delete("\n=")}", sub_test_case)
+          sub_test_case
         end
       end
 
@@ -585,11 +608,17 @@ module Test
       # Runs the individual test method represented by this
       # instance of the fixture, collecting statistics, failures
       # and errors in result.
-      def run(result, run_context: nil)
+      def run(worker_context)
         begin
+          unless worker_context.is_a?(WorkerContext)
+            result = worker_context
+            worker_context = WorkerContext.new(nil, nil, result)
+          end
+          result = worker_context.result
           @_result = result
           instance_variables_before = instance_variables
-          @internal_data.run_context = run_context
+          @internal_data.run_context = worker_context.run_context
+          @internal_data.worker_id = worker_context.id
           @internal_data.test_started
           yield(STARTED, name)
           yield(STARTED_OBJECT, self)
@@ -782,6 +811,16 @@ module Test
         1
       end
 
+      # Returns a current worker ID for the test. See {TestCase.worker_id}
+      # for details.
+      #
+      # @return [Integer]
+      #
+      # @since 3.7.4
+      def worker_id
+        @internal_data.worker_id || 0
+      end
+
       # Returns a label of test data for the test. If the
       # test isn't associated with any test data, it returns
       # `nil`.
@@ -887,6 +926,18 @@ module Test
         current_result.add_pass
       end
 
+      def marshal_dump
+        {
+          method_name: @method_name,
+          internal_data: @internal_data,
+        }
+      end
+
+      def marshal_load(data)
+        @method_name = data[:method_name]
+        @internal_data = data[:internal_data]
+      end
+
       private
       def current_result
         @_result
@@ -935,6 +986,7 @@ module Test
         attr_reader :start_time, :elapsed_time
         attr_reader :test_data_label, :test_data
         attr_accessor :run_context
+        attr_accessor :worker_id
         def initialize
           @start_time = nil
           @elapsed_time = nil
@@ -943,6 +995,7 @@ module Test
           @test_data_label = nil
           @test_data = nil
           @run_context = nil
+          @worker_id = nil
         end
 
         def passed?
@@ -977,6 +1030,24 @@ module Test
         def interrupted
           @interrupted = true
         end
+
+        def marshal_dump
+          {
+            start_time: @start_time,
+            elapsed_time: @elapsed_time,
+            passed: @passed,
+            interrupted: @interrupted,
+            test_data_label: @test_data_label,
+          }
+        end
+
+        def marshal_load(data)
+          @start_time = data[:start_time]
+          @elapsed_time = data[:elapsed_time]
+          @passed = data[:passed]
+          @interrupted = data[:interrupted]
+          @test_data_label = data[:test_data_label]
+        end
       end
     end
   end

data/lib/test/unit/testsuite.rb

@@ -40,20 +40,41 @@ module Test
         @elapsed_time = nil
       end
 
+      def find(name)
+        return self if @name == name
+        @tests.each do |test|
+          if test.is_a?(self.class)
+            t = test.find(name)
+            return t if t
+          else
+            return test if test.name == name
+          end
+        end
+        nil
+      end
+
       def parallel_safe?
         return true if @test_case.nil?
         @test_case.parallel_safe?
       end
 
+      def have_fixture?
+        return false if @test_case.nil?
+        return true if @test_case.method(:startup).owner != TestCase.singleton_class
+        return true if @test_case.method(:shutdown).owner != TestCase.singleton_class
+        false
+      end
+
       # Runs the tests and/or suites contained in this
       # TestSuite.
-      def run(result, run_context: nil, &progress_block)
+      def run(worker_context, &progress_block)
+        run_context = worker_context.run_context
         if run_context
           runner_class = run_context.runner_class
         else
           runner_class = TestSuiteRunner
         end
-        runner_class.new(self).run(result, run_context: run_context) do |event, *args|
+        runner_class.new(self).run(worker_context) do |event, *args|
           case event
           when STARTED
             @start_time = Time.now

data/lib/test/unit/ui/testrunnermediator.rb

@@ -6,6 +6,7 @@
 
 require_relative '../util/observable'
 require_relative '../testresult'
+require_relative '../worker-context'
 
 module Test
   module Unit
@@ -40,13 +41,18 @@ module Test
           start_time = Time.now
           begin
             with_listener(result) do
-              @test_suite_runner_class.run_all_tests do |run_context|
+              event_listener = lambda do |channel, value|
+                notify_listeners(channel, value)
+              end
+              @options[:event_listener] = event_listener
+              @options[:test_suite] = @suite
+              @test_suite_runner_class.run_all_tests(result, @options) do |run_context|
                 catch do |stop_tag|
                   result.stop_tag = stop_tag
                   notify_listeners(RESET, @suite.size)
                   notify_listeners(STARTED, result)
 
-                  run_suite(result, run_context)
+                  run_suite(result, run_context: run_context)
                 end
               end
             end
@@ -65,13 +71,12 @@ module Test
         #
         # See GitHub#38
         #   https://github.com/test-unit/test-unit/issues/38
-        def run_suite(result=nil, run_context=nil)
+        def run_suite(result=nil, run_context: nil)
           if result.nil?
             run
           else
-            @suite.run(result, run_context: run_context) do |channel, value|
-              notify_listeners(channel, value)
-            end
+            worker_context = WorkerContext.new(nil, run_context, result)
+            @suite.run(worker_context, &@options[:event_listener])
           end
         end
 

data/lib/test/unit/version.rb

@@ -1,5 +1,5 @@
 module Test
   module Unit
-    VERSION = "3.7.3"
+    VERSION = "3.7.4"
   end
 end

data/lib/test/unit/worker-context.rb

@@ -0,0 +1,20 @@
+#--
+#
+# Author:: Tsutomu Katsube.
+# Copyright:: Copyright (c) 2025 Tsutomu Katsube. All rights reserved.
+# License:: Ruby license.
+
+module Test
+  module Unit
+    class WorkerContext
+      attr_reader :id
+      attr_reader :run_context
+      attr_reader :result
+      def initialize(id, run_context, result)
+        @id = id
+        @run_context = run_context
+        @result = result
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: test-unit
 version: !ruby/object:Gem::Version
-  version: 3.7.3
+  version: 3.7.4
 platform: ruby
 authors:
 - Kouhei Sutou
@@ -75,12 +75,16 @@ files:
 - lib/test/unit/omission.rb
 - lib/test/unit/pending.rb
 - lib/test/unit/priority.rb
+- lib/test/unit/process-test-result.rb
+- lib/test/unit/process-worker.rb
 - lib/test/unit/runner/console.rb
 - lib/test/unit/runner/emacs.rb
 - lib/test/unit/runner/xml.rb
 - lib/test/unit/sub-test-result.rb
+- lib/test/unit/test-process-run-context.rb
 - lib/test/unit/test-run-context.rb
 - lib/test/unit/test-suite-creator.rb
+- lib/test/unit/test-suite-process-runner.rb
 - lib/test/unit/test-suite-runner.rb
 - lib/test/unit/test-suite-thread-runner.rb
 - lib/test/unit/test-thread-run-context.rb
@@ -102,6 +106,7 @@ files:
 - lib/test/unit/util/procwrapper.rb
 - lib/test/unit/version.rb
 - lib/test/unit/warning.rb
+- lib/test/unit/worker-context.rb
 - sample/adder.rb
 - sample/subtracter.rb
 - sample/test_adder.rb