piko-max-mod 0.0.1

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

@@ -0,0 +1,104 @@
+module Test
+  module Unit
+    module Collector
+      def initialize
+        @filters = []
+      end
+
+      def filter=(filters)
+        @filters = case(filters)
+          when Proc
+            [filters]
+          when Array
+            filters
+        end
+      end
+
+      def add_suite(destination, suite)
+        to_delete = suite.tests.find_all do |test|
+          test.is_a?(TestCase) and !include?(test)
+        end
+        suite.delete_tests(to_delete)
+        destination << suite unless suite.empty?
+      end
+
+      def add_test_cases(suite, test_cases)
+        children_map = {}
+        test_cases.each do |test_case|
+          ancestor_classes = test_case.ancestors.find_all do |ancestor|
+            ancestor.is_a?(Class)
+          end
+          parent = ancestor_classes[1]
+          children_map[parent] ||= []
+          children_map[parent] << test_case
+        end
+
+        root_test_cases = children_map.keys - test_cases
+        root_test_cases.each do |root_test_case|
+          add_test_case(suite, root_test_case, children_map)
+        end
+      end
+
+      def include?(test)
+        return true if(@filters.empty?)
+        @filters.each do |filter|
+          return false if filter[test] == false
+        end
+        true
+      end
+
+      def sort(suites)
+        suites.sort_by do |suite|
+          [suite.priority, suite.name || suite.to_s]
+        end
+      end
+
+      private
+      def add_test_case(suite, test_case, children_map)
+        children = children_map[test_case]
+        return if children.nil?
+
+        sub_suites = []
+        children.each do |child|
+          sub_suite = child.suite
+          add_test_case(sub_suite, child, children_map)
+          add_suite(sub_suites, sub_suite)
+        end
+        sort(sub_suites).each do |sub_suite|
+          suite << sub_suite
+        end
+      end
+
+      def adjust_ractor_tests(suite)
+        return if suite.nil?
+        ractor_suites = extract_ractor_tests(suite)
+        ractor_suites.each do |ractor_suite|
+          suite << ractor_suite
+        end
+      end
+
+      def extract_ractor_tests(suite)
+        ractor_suites = []
+        ractor_tests = []
+        suite.tests.each do |test|
+          case test
+          when TestSuite
+            ractor_suites.concat(extract_ractor_tests(test))
+          else
+            next unless test[:ractor]
+            ractor_tests << test
+          end
+        end
+        unless ractor_tests.empty?
+          suite.delete_tests(ractor_tests)
+          ractor_suite = TestSuite.new(suite.name, suite.test_case)
+          ractor_tests.each do |ractor_test|
+            ractor_suite << ractor_test
+          end
+          ractor_suites << ractor_suite
+        end
+        ractor_suites
+      end
+    end
+  end
+end

data/test-unit-3.7.8/lib/test/unit/color-scheme.rb

@@ -0,0 +1,225 @@
+require_relative 'color'
+
+module Test
+  module Unit
+    class ColorScheme
+      include Enumerable
+
+      TERM_256 = /
+        [+-]256color|
+        \A(?:
+          alacritty|
+          iTerm\s?\d*\.app|
+          kitty|
+          mintty|
+          ms-terminal|
+          nsterm-build\d+|
+          nsterm|
+          terminator|
+          terminology(?:-[0-9.]+)?|
+          termite|
+          vscode
+        )\z/x
+
+      class << self
+        def default
+          if available_colors >= 256
+            default_for_256_colors
+          else
+            default_for_8_colors
+          end
+        end
+
+        @@default_for_8_colors = nil
+        def default_for_8_colors
+          @@default_for_8_colors ||=
+            new("pass" => Color.new("green", :background => true) +
+                          Color.new("white", :bold => true),
+                "pass-marker" => Color.new("green", :bold => true),
+                "failure" => Color.new("red", :background => true) +
+                             Color.new("white", :bold => true),
+                "failure-marker" => Color.new("red"),
+                "pending" => Color.new("magenta", :background => true) +
+                             Color.new("white", :bold => true),
+                "pending-marker" => Color.new("magenta"),
+                "omission" => Color.new("blue", :background => true) +
+                             Color.new("white", :bold => true),
+                "omission-marker" => Color.new("blue"),
+                "notification" => Color.new("cyan", :background => true) +
+                                  Color.new("white", :bold => true),
+                "notification-marker" => Color.new("cyan"),
+                "error" => Color.new("black", :background => true) +
+                           Color.new("yellow", :bold => true),
+                "error-marker" => Color.new("yellow"),
+                "case" => Color.new("blue", :background => true) +
+                          Color.new("white", :bold => true),
+                "suite" => Color.new("green", :background => true) +
+                           Color.new("white", :bold => true),
+                "diff-inserted-tag" => Color.new("red", :background => true) +
+                                       Color.new("black", :bold => true),
+                "diff-deleted-tag" => Color.new("green", :background => true) +
+                                      Color.new("black", :bold => true),
+                "diff-difference-tag" => Color.new("cyan", :background => true) +
+                                         Color.new("white", :bold => true),
+                "diff-inserted" => Color.new("red", :background => true) +
+                                   Color.new("white", :bold => true),
+                "diff-deleted" =>  Color.new("green", :background => true) +
+                                   Color.new("white", :bold => true))
+        end
+
+        @@default_for_256_colors = nil
+        def default_for_256_colors
+          @@default_for_256_colors ||=
+            new("pass" => Color.new("030", :background => true) +
+                          Color.new("555", :bold => true),
+                "pass-marker" => Color.new("050", :bold => true),
+                "failure" => Color.new("300", :background => true) +
+                             Color.new("555", :bold => true),
+                "failure-marker" => Color.new("500"),
+                "pending" => Color.new("303", :background => true) +
+                              Color.new("555", :bold => true),
+                "pending-marker" => Color.new("303"),
+                "omission" => Color.new("001", :background => true) +
+                              Color.new("555", :bold => true),
+                "omission-marker" => Color.new("001"),
+                "notification" => Color.new("011", :background => true) +
+                                  Color.new("555", :bold => true),
+                "notification-marker" => Color.new("011"),
+                "error" => Color.new("000", :background => true) +
+                           Color.new("550", :bold => true),
+                "error-marker" => Color.new("550"),
+                "case" => Color.new("220", :background => true) +
+                          Color.new("555", :bold => true),
+                "suite" => Color.new("110", :background => true) +
+                           Color.new("555", :bold => true),
+                "diff-inserted-tag" => Color.new("500", :background => true) +
+                                       Color.new("000", :bold => true),
+                "diff-deleted-tag" => Color.new("050", :background => true) +
+                                      Color.new("000", :bold => true),
+                "diff-difference-tag" => Color.new("005", :background => true) +
+                                         Color.new("555", :bold => true),
+                "diff-inserted" => Color.new("300", :background => true) +
+                                   Color.new("555", :bold => true),
+                "diff-deleted" =>  Color.new("030", :background => true) +
+                                   Color.new("555", :bold => true))
+        end
+
+        @@schemes = {}
+        def all
+          @@schemes.merge("default" => default)
+        end
+
+        def [](id)
+          @@schemes[id.to_s]
+        end
+
+        def []=(id, scheme_or_spec)
+          if scheme_or_spec.is_a?(self)
+            scheme = scheme_or_spec
+          else
+            scheme = new(scheme_or_spec)
+          end
+          @@schemes[id.to_s] = scheme
+        end
+
+        def available_colors
+          guess_available_colors_from_vte_version_env ||
+            guess_available_colors_from_colorterm_env ||
+            guess_available_colors_from_term_env ||
+            guess_available_colors_from_github_actions_env ||
+            8
+        end
+
+        private
+        def guess_available_colors_from_vte_version_env
+          vte_version = ENV["VTE_VERSION"]
+          return nil if vte_version.nil?
+
+          major = 0
+          minor = 13
+          micro = 0
+          packed_version = major * 10000 + minor * 100 + micro
+          if vte_version.to_i >= packed_version
+            256
+          else
+            8
+          end
+        end
+
+        def guess_available_colors_from_colorterm_env
+          case ENV["COLORTERM"]
+          when "gnome-terminal", "xfce4-terminal"
+            256
+          else
+            nil
+          end
+        end
+
+        def guess_available_colors_from_term_env
+          case ENV["TERM"]
+          when /[+-]direct/
+            2 ** 24
+          when TERM_256
+            256
+          else
+            nil
+          end
+        end
+
+        def guess_available_colors_from_github_actions_env
+          if ENV["GITHUB_ACTIONS"] == "true"
+            2 ** 24
+          else
+            nil
+          end
+        end
+      end
+
+      def initialize(scheme_spec)
+        @scheme = {}
+        scheme_spec.each do |key, color_spec|
+          self[key] = color_spec
+        end
+      end
+
+      def [](name)
+        @scheme[name.to_s]
+      end
+
+      def []=(name, color_spec)
+        @scheme[name.to_s] = make_color(color_spec)
+      end
+
+      def each(&block)
+        @scheme.each(&block)
+      end
+
+      def to_hash
+        hash = {}
+        @scheme.each do |key, color|
+          hash[key] = color
+        end
+        hash
+      end
+
+      private
+      def make_color(color_spec)
+        if color_spec.is_a?(Color) or color_spec.is_a?(MixColor)
+          color_spec
+        else
+          color_name = nil
+          normalized_color_spec = {}
+          color_spec.each do |key, value|
+            key = key.to_sym
+            if key == :name
+              color_name = value
+            else
+              normalized_color_spec[key] = value
+            end
+          end
+          Color.new(color_name, normalized_color_spec)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+module Test
+  module Unit
+    class Color
+      class Error < StandardError
+      end
+
+      class ParseError < Error
+      end
+
+      class << self
+        def parse_256_color(string)
+          case string
+          when /\A([0-5])([0-5])([0-5])\z/
+            red, green, blue = $1, $2, $3
+            red.to_i * 36 + green.to_i * 6 + blue.to_i + 16
+          else
+            message = "must be 'RGB' format and R, G and B " +
+              "are in 0-5: #{string.inspect}"
+            raise ParseError, message
+          end
+        end
+      end
+
+      NAMES = ["black", "red", "green", "yellow",
+               "blue", "magenta", "cyan", "white"]
+
+      attr_reader :name
+      def initialize(name, options={})
+        @name = name
+        if options.has_key?(:foreground)
+          if options[:foreground].nil?
+            @background = false
+          else
+            @background = !options[:foreground]
+          end
+        else
+          @background = options[:background]
+        end
+        @intensity = options[:intensity]
+        @bold = options[:bold]
+        @italic = options[:italic]
+        @underline = options[:underline]
+      end
+
+      def foreground?
+        not background?
+      end
+
+      def background?
+        @background
+      end
+
+      def intensity?
+        @intensity
+      end
+
+      def bold?
+        @bold
+      end
+
+      def italic?
+        @italic
+      end
+
+      def underline?
+        @underline
+      end
+
+      def ==(other)
+        self.class === other and
+          [name, background?, intensity?,
+           bold?, italic?, underline?] ==
+          [other.name, other.background?, other.intensity?,
+           other.bold?, other.italic?, other.underline?]
+      end
+
+      def sequence
+        sequence = []
+        if @name == "none"
+        elsif @name == "reset"
+          sequence << "0"
+        else
+          if NAMES.include?(@name)
+            color_parameter = foreground? ? 3 : 4
+            color_parameter += 6 if intensity?
+            color = NAMES.index(@name)
+            sequence << "#{color_parameter}#{color}"
+          else
+            sequence << (foreground? ? "38" : "48")
+            sequence << "5"
+            sequence << self.class.parse_256_color(@name).to_s
+          end
+        end
+        sequence << "1" if bold?
+        sequence << "3" if italic?
+        sequence << "4" if underline?
+        sequence
+      end
+
+      def escape_sequence
+        "\e[#{sequence.join(';')}m"
+      end
+
+      def +(other)
+        MixColor.new([self, other])
+      end
+    end
+
+    class MixColor
+      attr_reader :colors
+      def initialize(colors)
+        @colors = colors
+      end
+
+      def sequence
+        @colors.inject([]) do |result, color|
+          result + color.sequence
+        end
+      end
+
+      def escape_sequence
+        "\e[#{sequence.join(';')}m"
+      end
+
+      def +(other)
+        self.class.new([self, other])
+      end
+
+      def ==(other)
+        self.class === other and colors == other.colors
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+module Test
+  module Unit
+    class DataSets
+      def initialize
+        @variables = []
+        @procs = []
+        @value_sets = []
+      end
+
+      def add(data_set, options=nil)
+        options ||= {}
+        if data_set.respond_to?(:call)
+          @procs << [data_set, options]
+        elsif data_set.is_a?(Array)
+          @variables << [data_set, options]
+        else
+          @value_sets << [data_set, options]
+        end
+      end
+
+      def <<(data_set)
+        add(data_set)
+      end
+
+      def have_keep?
+        each_data_set do |_, options|
+          return true if options[:keep]
+        end
+        false
+      end
+
+      def keep
+        new_data_sets = self.class.new
+        each_data_set do |data_set, options|
+          next if options.nil?
+          next unless options[:keep]
+          new_data_sets.add(data_set, options)
+        end
+        new_data_sets
+      end
+
+      def each
+        variables = @variables
+        value_sets = @value_sets
+        @procs.each do |proc, options|
+          data_set = proc.call
+          case data_set
+          when Array
+            variables += [[data_set, options]]
+          else
+            value_sets += [[data_set, options]]
+          end
+        end
+
+        value_sets.each do |values, _options|
+          values.each do |label, data|
+            yield(label, data)
+          end
+        end
+
+        each_pattern(variables) do |label, data|
+          yield(label, data)
+        end
+      end
+
+      def ==(other)
+        @variables == other.instance_variable_get(:@variables) and
+          @procs == other.instance_variable_get(:@procs) and
+          @value_sets == other.instance_variable_get(:@value_sets)
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        [@variables, @procs, @value_sets].hash
+      end
+
+      private
+      def each_data_set(&block)
+        @procs.each(&block)
+        @variables.each(&block)
+        @value_sets.each(&block)
+      end
+
+      def each_pattern(variables)
+        grouped_variables = variables.group_by do |_, options|
+          options[:group]
+        end
+        grouped_variables.each do |group, group_variables|
+          each_raw_pattern(group_variables) do |cell|
+            label = String.new
+            label << "group: #{group.inspect}" unless group.nil?
+            data = {}
+            cell.each do |variable, pattern, pattern_label|
+              label << ", " unless label.empty?
+              label << "#{variable}: #{pattern_label}"
+              data[variable] = pattern
+            end
+            yield(label, data)
+          end
+        end
+      end
+
+      def each_raw_pattern(variables, &block)
+        return if variables.empty?
+
+        sorted_variables = variables.sort_by do |(variable, _), _|
+          variable
+        end
+        all_patterns = sorted_variables.collect do |(variable, patterns), _|
+          if patterns.is_a?(Hash)
+            patterns.collect do |pattern_label, pattern|
+              [variable, pattern, pattern_label]
+            end
+          else
+            patterns.collect do |pattern|
+              [variable, pattern, pattern.inspect]
+            end
+          end
+        end
+        all_patterns[0].product(*all_patterns[1..-1], &block)
+      end
+    end
+  end
+end