piko-max-mod 0.0.1

data/test-unit-3.7.8/lib/test/unit/test-suite-creator.rb

@@ -0,0 +1,103 @@
+#--
+#
+# Author:: Kouhei Sutou
+# Copyright::
+#   * Copyright (c) 2011 Kouhei Sutou <tt><kou@clear-code.com></tt>
+# License:: Ruby license.
+
+require_relative "data-sets"
+
+module Test
+  module Unit
+    class TestSuiteCreator # :nodoc:
+      class << self
+        def test_method?(test_case, method_name)
+          /\Atest./ =~ method_name.to_s or
+            test_case.find_attribute(method_name, :test)
+        end
+      end
+
+      def initialize(test_case)
+        @test_case = test_case
+      end
+
+      def create
+        suite = TestSuite.new(@test_case.name, @test_case)
+        collect_test_names.each do |test_name|
+          data_sets = extract_data_sets(test_name)
+          if data_sets
+            data_sets.each do |label, data|
+              append_test(suite, test_name) do |test|
+                test.assign_test_data(label, data)
+              end
+            end
+          else
+            append_test(suite, test_name)
+          end
+        end
+        append_test(suite, "default_test") if suite.empty?
+        suite
+      end
+
+      private
+      def extract_data_sets(test_name)
+        data_sets = @test_case.find_attribute(test_name,
+                                              :data,
+                                              :recursive => false)
+        data_method_name = "data_#{test_name}"
+        test = @test_case.new(test_name)
+        if test.respond_to?(data_method_name)
+          data_method = test.method(data_method_name)
+          if data_method.arity <= 0
+            data_sets ||= DataSets.new
+            data_sets << data_method
+          end
+        end
+        data_sets
+      end
+
+      def append_test(suite, test_name)
+        test = @test_case.new(test_name)
+        yield(test) if block_given?
+        suite << test if test.valid?
+      end
+
+      def collect_test_names
+        methods = @test_case.public_instance_methods(true)
+        super_test_case = @test_case.superclass
+        methods -= super_test_case.public_instance_methods(true)
+        methods |= @test_case.public_instance_methods(false)
+        method_names = methods.collect(&:to_s)
+        test_names = method_names.find_all do |method_name|
+          self.class.test_method?(@test_case, method_name)
+        end
+        __send__("sort_test_names_in_#{@test_case.test_order}_order", test_names)
+      end
+
+      def sort_test_names_in_alphabetic_order(test_names)
+        test_names.sort
+      end
+
+      def sort_test_names_in_random_order(test_names)
+        test_names.sort_by {rand(test_names.size)}
+      end
+
+      def sort_test_names_in_defined_order(test_names)
+        added_method_names = @test_case.added_method_names
+        test_names.sort do |test1, test2|
+          test1_defined_order = added_method_names.index(test1)
+          test2_defined_order = added_method_names.index(test2)
+          if test1_defined_order and test2_defined_order
+            test1_defined_order <=> test2_defined_order
+          elsif test1_defined_order
+            1
+          elsif test2_defined_order
+            -1
+          else
+            test1 <=> test2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,205 @@
+#--
+#
+# 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)
+                  # They are replaced later. This is just for ensuring calling
+                  # `Process.waitpid(pid)` on error.
+                  workers << Worker.new(pid, nil, nil)
+                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
+              if Gem.win_platform?
+                workers = workers.collect do
+                  data_socket = tcp_server.accept
+                  pid = Marshal.load(data_socket)
+                  Worker.new(pid, data_socket, data_socket)
+                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/test-unit-3.7.8/lib/test/unit/test-suite-runner.rb

@@ -0,0 +1,132 @@
+#--
+#
+# 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-2025 Tsutomu Katsube. All rights reserved.
+# License:: Ruby license.
+
+require "etc"
+
+require_relative "test-run-context"
+
+module Test
+  module Unit
+    class TestSuiteRunner
+      @n_workers = Etc.respond_to?(:nprocessors) ? Etc.nprocessors : 1
+      class << self
+        def run_all_tests(result, options)
+          yield(TestRunContext.new(self))
+        end
+
+        def n_workers
+          @n_workers
+        end
+
+        def n_workers=(n)
+          @n_workers = n
+        end
+      end
+
+      def initialize(test_suite)
+        @test_suite = test_suite
+      end
+
+      def run(worker_context, &progress_block)
+        yield(TestSuite::STARTED, @test_suite.name)
+        yield(TestSuite::STARTED_OBJECT, @test_suite)
+        run_startup(worker_context)
+        run_tests(worker_context, &progress_block)
+      ensure
+        begin
+          run_shutdown(worker_context)
+        ensure
+          yield(TestSuite::FINISHED, @test_suite.name)
+          yield(TestSuite::FINISHED_OBJECT, @test_suite)
+        end
+      end
+
+      private
+      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 => e
+          raise unless handle_exception(e, worker_context.result)
+        end
+      end
+
+      def run_tests(worker_context, &progress_block)
+        @test_suite.tests.each do |test|
+          run_test(test, worker_context, &progress_block)
+        end
+      end
+
+      def run_test(test, worker_context)
+        finished_is_yielded = false
+        finished_object_is_yielded = false
+        previous_event_name = nil
+        event_listener = lambda do |event_name, *args|
+          case previous_event_name
+          when Test::Unit::TestCase::STARTED
+            if event_name != Test::Unit::TestCase::STARTED_OBJECT
+              yield(Test::Unit::TestCase::STARTED_OBJECT, test)
+            end
+          when Test::Unit::TestCase::FINISHED
+            if event_name != Test::Unit::TestCase::FINISHED_OBJECT
+              yield(Test::Unit::TestCase::FINISHED_OBJECT, test)
+            end
+            finished_object_is_yielded = true
+          end
+
+          case event_name
+          when Test::Unit::TestCase::STARTED
+            finished_is_yielded = false
+            finished_object_is_yielded = false
+          when Test::Unit::TestCase::FINISHED
+            finished_is_yielded = true
+          end
+
+          previous_event_name = event_name
+          yield(event_name, *args)
+        end
+
+        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(worker_context.result, &event_listener)
+        end
+
+        if finished_is_yielded and not finished_object_is_yielded
+          yield(Test::Unit::TestCase::FINISHED_OBJECT, test)
+        end
+      end
+
+      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 => e
+          raise unless handle_exception(e, worker_context.result)
+        end
+      end
+
+      def handle_exception(exception, result)
+        case exception
+        when *ErrorHandler::PASS_THROUGH_EXCEPTIONS
+          false
+        else
+          result.add_error(Error.new(@test_suite.test_case.name, exception))
+          true
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,96 @@
+#--
+#
+# Author:: Tsutomu Katsube.
+# Copyright:: Copyright (c) 2024-2025 Tsutomu Katsube. All rights reserved.
+# License:: Ruby license.
+
+require_relative "sub-test-result"
+require_relative "test-suite-runner"
+require_relative "test-thread-run-context"
+
+module Test
+  module Unit
+    class TestSuiteThreadRunner < TestSuiteRunner
+      class << self
+        def run_all_tests(result, options)
+          n_workers = TestSuiteRunner.n_workers
+          test_suite = options[:test_suite]
+
+          queue = Thread::Queue.new
+          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
+
+          workers = []
+          sub_exceptions = []
+          n_workers.times do |i|
+            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, worker_id)
+                  end
+                end
+              rescue Exception => exception
+                sub_exceptions << exception
+              end
+            end
+          end
+          workers.each(&:join)
+
+          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(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?
+          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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+#--
+#
+# 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 TestThreadRunContext < TestRunContext
+      attr_reader :queue
+      attr_accessor :progress_block
+      attr_accessor :parallel_unsafe_tests
+      def initialize(runner_class, queue)
+        super(runner_class)
+        @queue = queue
+        @progress_block = nil
+        @parallel_unsafe_tests = []
+      end
+    end
+  end
+end