piko-max-mod 0.0.1

data/test-unit-3.7.8/lib/test/unit/pending.rb

@@ -0,0 +1,155 @@
+require_relative 'util/backtracefilter'
+
+module Test
+  module Unit
+    class Pending
+      include Util::BacktraceFilter
+      attr_reader :test_name, :location, :message
+      attr_reader :method_name
+
+      SINGLE_CHARACTER = 'P'
+      LABEL = "Pending"
+
+      # Creates a new Pending with the given location and
+      # message.
+      def initialize(test_name, location, message, options={})
+        @test_name = test_name
+        @location = location
+        @message = message
+        @method_name = options[:method_name]
+      end
+
+      # Returns a single character representation of a pending.
+      def single_character_display
+        SINGLE_CHARACTER
+      end
+
+      def label
+        LABEL
+      end
+
+      # Returns a brief version of the error description.
+      def short_display
+        "#{@test_name}: #{@message.split("\n")[0]}"
+      end
+
+      # Returns a verbose version of the error description.
+      def long_display
+        backtrace = filter_backtrace(location).join("\n")
+        "#{label}: #{@message}\n#{@test_name}\n#{backtrace}"
+      end
+
+      # Overridden to return long_display.
+      def to_s
+        long_display
+      end
+
+      def critical?
+        true
+      end
+    end
+
+    class PendedError < StandardError
+    end
+
+
+    module TestCasePendingSupport
+      class << self
+        def included(base)
+          base.class_eval do
+            include PendingHandler
+          end
+        end
+      end
+
+      # Marks the test or part of the test is pending.
+      #
+      # Example:
+      #
+      #     def test_pending
+      #       pend
+      #       # Not reached here
+      #     end
+      #
+      #     def test_pending_with_here
+      #       pend do
+      #         # Ran here
+      #         # Fails if the block doesn't raise any error.
+      #         # Because it means the block is passed unexpectedly.
+      #       end
+      #       # Reached here
+      #     end
+      def pend(message=nil, &block)
+        message ||= "pended."
+        if block_given?
+          pending = nil
+          begin
+            yield
+          rescue Exception
+            pending = Pending.new(name, filter_backtrace(caller), message,
+                                  :method_name => @method_name)
+            add_pending(pending)
+          end
+          unless pending
+            flunk("Pending block should not be passed: #{message}")
+          end
+        else
+          raise PendedError.new(message)
+        end
+      end
+
+      private
+      def add_pending(pending)
+        problem_occurred
+        current_result.add_pending(pending)
+      end
+    end
+
+    module PendingHandler
+      class << self
+        def included(base)
+          base.exception_handler(:handle_pended_error)
+        end
+      end
+
+      private
+      def handle_pended_error(exception)
+        return false unless exception.is_a?(PendedError)
+        pending = Pending.new(name,
+                              filter_backtrace(exception.backtrace),
+                              exception.message,
+                              :method_name => @method_name)
+        add_pending(pending)
+        true
+      end
+    end
+
+    module TestResultPendingSupport
+      attr_reader :pendings
+
+      # Records a Test::Unit::Pending.
+      def add_pending(pending)
+        @pendings << pending
+        notify_fault(pending)
+        notify_changed
+      end
+
+      # Returns the number of pendings this TestResult has
+      # recorded.
+      def pending_count
+        @pendings.size
+      end
+
+      private
+      def initialize_containers
+        super
+        @pendings = []
+        @summary_generators << :pending_summary
+      end
+
+      def pending_summary
+        "#{pending_count} pendings"
+      end
+    end
+  end
+end

data/test-unit-3.7.8/lib/test/unit/priority.rb

@@ -0,0 +1,194 @@
+module Test
+  module Unit
+    module Priority
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+
+          base.class_eval do
+            setup :priority_setup, :before => :prepend
+            teardown :priority_teardown, :after => :append
+          end
+        end
+
+        @@enabled = false
+        def enabled?
+          @@enabled
+        end
+
+        def enable
+          require "fileutils"
+          require "tmpdir"
+          @@enabled = true
+        end
+
+        def disable
+          @@enabled = false
+        end
+
+        @@default = :normal
+        def default
+          @@default || :normal
+        end
+
+        def default=(default)
+          @@default = default
+        end
+
+        def available_values
+          Checker.available_priorities
+        end
+      end
+
+      class Checker
+        class << self
+          def have_priority?(name)
+            singleton_class = (class << self; self; end)
+            singleton_class.method_defined?(priority_check_method_name(name))
+          end
+
+          def need_to_run?(test)
+            priority = test[:priority] || Priority.default
+            if have_priority?(priority)
+              __send__(priority_check_method_name(priority), test)
+            else
+              true
+            end
+          end
+
+          def available_priorities
+            methods(false).collect do |name|
+              /\Arun_priority_(.+)\?\z/ =~ name.to_s
+              $1
+            end.compact
+          end
+
+          def run_priority_must?(test)
+            true
+          end
+
+          def run_priority_important?(test)
+            rand > 0.1
+          end
+
+          def run_priority_high?(test)
+            rand > 0.3
+          end
+
+          def run_priority_normal?(test)
+            rand > 0.5
+          end
+
+          def run_priority_low?(test)
+            rand > 0.75
+          end
+
+          def run_priority_never?(test)
+            false
+          end
+
+          private
+          def priority_check_method_name(priority_name)
+            "run_priority_#{priority_name}?"
+          end
+        end
+
+        attr_reader :test
+        def initialize(test)
+          @test = test
+        end
+
+        def setup
+          FileUtils.rm_f(passed_file)
+        end
+
+        def teardown
+          if @test.__send__(:passed?)
+            FileUtils.touch(passed_file)
+          else
+            FileUtils.rm_f(passed_file)
+          end
+        end
+
+        def need_to_run?
+          !previous_test_success? or self.class.need_to_run?(@test)
+        end
+
+        private
+        def previous_test_success?
+          File.exist?(passed_file)
+        end
+
+        def result_dir
+          components = [
+            ".test-result",
+            escape_class_name(@test.class.name || "AnonymousTestCase"),
+            escaped_method_name,
+          ]
+          parent_directories = [File.dirname($0), Dir.pwd]
+          if Process.respond_to?(:uid)
+            parent_directories << File.join(Dir.tmpdir, Process.uid.to_s)
+          end
+          parent_directories.each do |parent_directory|
+            dir = File.expand_path(File.join(parent_directory, *components))
+            begin
+              FileUtils.mkdir_p(dir)
+              return dir
+            rescue Errno::EACCES
+            end
+          end
+
+          raise Errno::EACCES, parent_directories.join(", ")
+        end
+
+        def passed_file
+          File.join(result_dir, "passed")
+        end
+
+        def escape_class_name(class_name)
+          escape_name(class_name)
+        end
+
+        def escaped_method_name
+          escape_name(@test.method_name.to_s)
+        end
+
+        def escape_name(name)
+          name.gsub(/(?:[: \/!?=])/) do |matched|
+            case matched
+            when ":"
+              "_colon_"
+            when " ", "/"
+              "_"
+            when "!"
+              ".destructive"
+            when "?"
+              ".predicate"
+            when "="
+              ".equal"
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        def priority(name, *tests)
+          unless Checker.have_priority?(name)
+            raise ArgumentError, "unknown priority: #{name}"
+          end
+          attribute(:priority, name, {:keep => true}, *tests)
+        end
+      end
+
+      def priority_setup(&_)
+        return unless Priority.enabled?
+        Checker.new(self).setup
+      end
+
+      def priority_teardown
+        return unless Priority.enabled?
+        Checker.new(self).teardown
+      end
+    end
+  end
+end

data/test-unit-3.7.8/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/test-unit-3.7.8/lib/test/unit/process-worker.rb

@@ -0,0 +1,87 @@
+#--
+#
+# Author:: Tsutomu Katsube.
+# Copyright:: Copyright (c) 2025 Tsutomu Katsube. All rights reserved.
+# License:: Ruby license.
+
+require "optparse"
+require "socket"
+
+parser = OptionParser.new
+load_paths = []
+parser.on("--load-path=PATH") do |path|
+  load_paths << 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!
+$LOAD_PATH.unshift(*load_paths)
+
+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|
+      Marshal.dump(Process.pid, data_socket)
+      data_socket.flush
+      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/test-unit-3.7.8/lib/test/unit/runner/console.rb

@@ -0,0 +1,86 @@
+# Copyright (C) 2008-2023  Sutou Kouhei <kou@clear-code.com>
+
+module Test
+  module Unit
+    AutoRunner.register_runner(:console) do |auto_runner|
+      require_relative '../ui/console/testrunner'
+      Test::Unit::UI::Console::TestRunner
+    end
+
+    AutoRunner.setup_option do |auto_runner, opts|
+      require_relative '../ui/console/outputlevel'
+      require_relative '../ui/console/testrunner'
+
+      output_levels = [
+        ["silent", UI::Console::OutputLevel::SILENT],
+        ["progress", UI::Console::OutputLevel::PROGRESS_ONLY],
+        ["important-only", UI::Console::OutputLevel::IMPORTANT_FAULTS_ONLY],
+        ["normal", UI::Console::OutputLevel::NORMAL],
+        ["verbose", UI::Console::OutputLevel::VERBOSE],
+      ]
+      opts.on('-v', '--verbose=[LEVEL]', output_levels,
+              "Set the output level (default is normal).",
+              "(#{auto_runner.keyword_display(output_levels)})") do |level|
+        level ||= output_levels.assoc("verbose")[1]
+        auto_runner.runner_options[:output_level] = level
+      end
+
+      use_color_options = [
+        [:auto, :auto],
+        ["-", false],
+        ["no", false],
+        ["false", false],
+        ["+", true],
+        ["yes", true],
+        ["true", true],
+      ]
+      opts.on("--[no-]use-color=[auto]", use_color_options,
+              "Uses color output",
+              "(default is auto)") do |use_color|
+        case use_color
+        when nil
+          use_color = true
+        when :auto
+          use_color = nil
+        end
+        auto_runner.runner_options[:use_color] = use_color
+      end
+
+      opts.on("--progress-row-max=MAX", Integer,
+              "Uses MAX as max terminal width for progress mark",
+              "(default is auto)") do |max|
+        auto_runner.runner_options[:progress_row_max] = max
+      end
+
+      progress_styles = [
+        ["inplace", :inplace],
+        ["mark", :mark],
+        ["fault-only", :fault_only],
+      ]
+      opts.on("--progress-style=STYLE", progress_styles,
+              "Uses STYLE as progress style",
+              "(#{auto_runner.keyword_display(progress_styles)})") do |style|
+        auto_runner.runner_options[:progress_style] = style
+      end
+
+      opts.on("--no-show-detail-immediately",
+              "Shows not passed test details immediately.",
+              "(default is yes)") do |boolean|
+        auto_runner.runner_options[:show_detail_immediately] = boolean
+      end
+
+      opts.on("--[no-]reverse-output",
+              "Shows fault details in reverse.",
+              "(default is yes for tty output, no otherwise)") do |boolean|
+        auto_runner.runner_options[:reverse_output] = boolean
+      end
+
+      n_report_slow_tests = UI::Console::TestRunner::N_REPORT_SLOW_TESTS
+      opts.on("--[no-]report-slow-tests",
+              "Shows the top #{n_report_slow_tests} slow tests in the summary output",
+              "(false)") do |boolean|
+        auto_runner.runner_options[:report_slow_tests] = boolean
+      end
+    end
+  end
+end

data/test-unit-3.7.8/lib/test/unit/runner/emacs.rb

@@ -0,0 +1,8 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:emacs) do |auto_runner|
+      require_relative '../ui/emacs/testrunner'
+      Test::Unit::UI::Emacs::TestRunner
+    end
+  end
+end

data/test-unit-3.7.8/lib/test/unit/runner/xml.rb

@@ -0,0 +1,15 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:xml) do |auto_runner|
+      require_relative '../ui/xml/testrunner'
+      Test::Unit::UI::XML::TestRunner
+    end
+
+    AutoRunner.setup_option do |auto_runner, opts|
+      opts.on("--output-file-descriptor=FD", Integer,
+              "Outputs to file descriptor FD") do |fd|
+        auto_runner.runner_options[:output_file_descriptor] = fd
+      end
+    end
+  end
+end

data/test-unit-3.7.8/lib/test/unit/sub-test-result.rb

@@ -0,0 +1,59 @@
+#--
+#
+# Author:: Tsutomu Katsube.
+# Copyright:: Copyright (c) 2024 Tsutomu Katsube. All rights reserved.
+# License:: Ruby license.
+
+module Test
+  module Unit
+    class SubTestResult
+      attr_accessor :stop_tag
+
+      def initialize(parent_test_result)
+        @parent_test_result = parent_test_result
+        @stop_tag = nil
+      end
+
+      def add_run(result=self)
+        @parent_test_result.add_run(result)
+      end
+
+      def add_pass
+        @parent_test_result.add_pass
+      end
+
+      # Records an individual assertion.
+      def add_assertion
+        @parent_test_result.add_assertion
+      end
+
+      def add_error(error)
+        @parent_test_result.add_error(error)
+      end
+
+      def add_failure(failure)
+        @parent_test_result.add_failure(failure)
+      end
+
+      def add_pending(pending)
+        @parent_test_result.add_pending(pending)
+      end
+
+      def add_omission(omission)
+        @parent_test_result.add_omission(omission)
+      end
+
+      def add_notification(notification)
+        @parent_test_result.add_notification(notification)
+      end
+
+      def passed?
+        @parent_test_result.passed?
+      end
+
+      def stop
+        throw @stop_tag
+      end
+    end
+  end
+end

data/test-unit-3.7.8/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/test-unit-3.7.8/lib/test/unit/test-run-context.rb

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