postfinancecheckout-ruby-sdk 3.0.2 → 3.3.0

data/vendor/bundle/ruby/2.7.0/gems/test-unit-3.2.9/lib/test/unit/collector/dir.rb

@@ -0,0 +1,108 @@
+require 'test/unit/testsuite'
+require 'test/unit/collector'
+
+module Test
+  module Unit
+    module Collector
+      class Dir
+        include Collector
+
+        attr_reader :pattern, :exclude
+        attr_accessor :base
+
+        def initialize(dir=::Dir, file=::File, object_space=::ObjectSpace, req=nil)
+          super()
+          @dir = dir
+          @file = file
+          @object_space = object_space
+          @req = req
+          @pattern = [/\btest_.*\.rb\Z/m]
+          @exclude = []
+          @base = nil
+        end
+
+        def collect(*from)
+          basedir = @base
+          $:.push(basedir) if basedir
+          if(from.empty?)
+            recursive_collect('.', find_test_cases)
+          elsif(from.size == 1)
+            recursive_collect(from.first, find_test_cases)
+          else
+            suites = []
+            from.each do |f|
+              suite = recursive_collect(f, find_test_cases)
+              suites << suite unless(suite.tests.empty?)
+            end
+            suite = TestSuite.new("[#{from.join(', ')}]")
+            sort(suites).each{|s| suite << s}
+            suite
+          end
+        ensure
+          $:.delete_at($:.rindex(basedir)) if basedir
+        end
+
+        def find_test_cases(ignore=[])
+          cases = []
+          @object_space.each_object(Class) do |c|
+            cases << c if(c < TestCase && !ignore.include?(c))
+          end
+          ignore.concat(cases)
+          cases
+        end
+
+        def recursive_collect(name, already_gathered)
+          sub_suites = []
+          path = realdir(name)
+          if @file.directory?(path)
+            dir_name = name unless name == '.'
+            @dir.entries(path).each do |e|
+              next if(e == '.' || e == '..')
+              e_name = dir_name ? @file.join(dir_name, e) : e
+              if @file.directory?(realdir(e_name))
+                next if /\A(?:CVS|\.svn|\.git)\z/ =~ e
+                sub_suite = recursive_collect(e_name, already_gathered)
+                sub_suites << sub_suite unless(sub_suite.empty?)
+              else
+                next if /~\z/ =~ e_name or /\A\.\#/ =~ e
+                if @pattern and !@pattern.empty?
+                  next unless @pattern.any? {|pat| pat =~ e_name}
+                end
+                if @exclude and !@exclude.empty?
+                  next if @exclude.any? {|pat| pat =~ e_name}
+                end
+                collect_file(e_name, sub_suites, already_gathered)
+              end
+            end
+          else
+            collect_file(name, sub_suites, already_gathered)
+          end
+          suite = TestSuite.new(@file.basename(name))
+          sort(sub_suites).each{|s| suite << s}
+          suite
+        end
+
+        def collect_file(name, suites, already_gathered)
+          dir = @file.dirname(@file.expand_path(name, @base))
+          $:.unshift(dir)
+          if(@req)
+            @req.require(name)
+          else
+            require(name)
+          end
+          find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
+        ensure
+          $:.delete_at($:.rindex(dir)) if(dir)
+        end
+
+        def realdir(path)
+          if @base
+            @file.join(@base, path)
+          else
+            path
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/test-unit-3.2.9/lib/test/unit/collector/load.rb

@@ -0,0 +1,199 @@
+require 'pathname'
+
+require 'test/unit/testsuite'
+require 'test/unit/collector'
+
+module Test
+  module Unit
+    module Collector
+      class Load
+        include Collector
+
+        attr_reader :patterns, :excludes, :base
+        attr_reader :default_test_paths
+
+        def initialize
+          super
+          @system_excludes = [/~\z/, /\A\.\#/]
+          @system_directory_excludes = [/\A(?:CVS|\.svn|\.git)\z/]
+          @patterns = [/\Atest[_\-].+\.rb\z/m, /[_\-]test\.rb\z/]
+          @excludes = []
+          @base = nil
+          @default_test_paths = []
+          @require_failed_infos = []
+        end
+
+        def base=(base)
+          base = Pathname(base) unless base.nil?
+          @base = base
+        end
+
+        def default_test_paths=(paths)
+          @default_test_paths = paths.collect do |path|
+            Pathname(path)
+          end
+        end
+
+        def collect(*froms)
+          add_load_path(@base) do
+            froms = @default_test_paths if froms.empty?
+            froms = ["."] if froms.empty?
+            test_suites = []
+            already_gathered = find_test_cases
+            froms.each do |from|
+              from = resolve_path(from)
+              if from.directory?
+                test_suite = collect_recursive(from, already_gathered)
+                test_suites << test_suite unless test_suite.tests.empty?
+              else
+                collect_file(from, test_suites, already_gathered)
+              end
+            end
+            add_require_failed_test_suite(test_suites)
+
+            if test_suites.size > 1
+              test_suite = TestSuite.new("[#{froms.join(', ')}]")
+              sort(test_suites).each do |sub_test_suite|
+                test_suite << sub_test_suite
+              end
+            else
+              test_suite = test_suites.first
+            end
+
+            test_suite
+          end
+        end
+
+        def find_test_cases(ignore=[])
+          test_cases = []
+          TestCase::DESCENDANTS.each do |test_case|
+            test_cases << test_case unless ignore.include?(test_case)
+          end
+          ignore.concat(test_cases)
+          test_cases
+        end
+
+        private
+        def collect_recursive(path, already_gathered)
+          sub_test_suites = []
+
+          if path.directory?
+            directories, files = path.children.partition do |child|
+              child.directory?
+            end
+
+            files.each do |child|
+              next if excluded_file?(child.basename.to_s)
+              collect_file(child, sub_test_suites, already_gathered)
+            end
+
+            directories.each do |child|
+              next if excluded_directory?(child.basename.to_s)
+              sub_test_suite = collect_recursive(child, already_gathered)
+              sub_test_suites << sub_test_suite unless sub_test_suite.empty?
+            end
+          else
+            unless excluded_file?(path.basename.to_s)
+              collect_file(path, sub_test_suites, already_gathered)
+            end
+          end
+
+          test_suite = TestSuite.new(path.basename.to_s)
+          sort(sub_test_suites).each do |sub_test_suite|
+            test_suite << sub_test_suite
+          end
+          test_suite
+        end
+
+        def collect_file(path, test_suites, already_gathered)
+          @program_file ||= File.expand_path($0)
+          expanded_path = path.expand_path
+          return if @program_file == expanded_path.to_s
+          add_load_path(expanded_path.dirname) do
+            begin
+              require(path.basename.to_s)
+            rescue LoadError
+              @require_failed_infos << {:path => expanded_path, :exception => $!}
+            end
+            add_test_cases(test_suites, find_test_cases(already_gathered))
+          end
+        end
+
+        def resolve_path(path)
+          if @base
+            @base + path
+          else
+            Pathname(path)
+          end
+        end
+
+        def add_load_path(path)
+          return yield if path.nil?
+
+          path = path.to_s
+          return yield if $LOAD_PATH.index(path)
+
+          begin
+            $LOAD_PATH.unshift(path)
+            yield
+          ensure
+            index = $LOAD_PATH.index(path)
+            $LOAD_PATH.delete_at(index) if index
+          end
+        end
+
+        def excluded_directory?(base)
+          @system_directory_excludes.any? {|pattern| pattern =~ base}
+        end
+
+        def excluded_file?(base)
+          return true if @system_excludes.any? {|pattern| pattern =~ base}
+
+          patterns = @patterns || []
+          unless patterns.empty?
+            return true unless patterns.any? {|pattern| pattern =~ base}
+          end
+
+          excludes = @excludes || []
+          unless excludes.empty?
+            return true if excludes.any? {|pattern| pattern =~ base}
+          end
+
+          false
+        end
+
+        def add_require_failed_test_suite(test_suites)
+          return if @require_failed_infos.empty?
+
+          require_failed_infos = @require_failed_infos
+          require_failed_errors = Class.new(Test::Unit::TestCase)
+          require_failed_errors.class_eval do
+            class << self
+              def name
+                "RequireFailedErrors"
+              end
+            end
+
+            require_failed_infos.each do |info|
+              path = info[:path]
+              normalized_path = path.to_s.gsub(/[^a-z0-9\_]+/i, '_')
+              normalized_path = normalized_path.gsub(/\A_+/, '')
+              exception = info[:exception]
+              define_method("test_require_#{normalized_path}") do
+                raise(exception.class,
+                      "failed to load <#{path}>: #{exception.message}",
+                      exception.backtrace)
+              end
+            end
+
+            def priority
+              100
+            end
+          end
+
+          add_suite(test_suites, require_failed_errors.suite)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/test-unit-3.2.9/lib/test/unit/collector/objectspace.rb

@@ -0,0 +1,34 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/collector'
+
+module Test
+  module Unit
+    module Collector
+      class ObjectSpace
+        include Collector
+
+        NAME = 'collected from the ObjectSpace'
+
+        def initialize(source=::ObjectSpace)
+          super()
+          @source = source
+        end
+
+        def collect(name=NAME)
+          suite = TestSuite.new(name)
+          sub_suites = []
+          @source.each_object(Class) do |klass|
+            if(Test::Unit::TestCase > klass)
+              add_suite(sub_suites, klass.suite)
+            end
+          end
+          sort(sub_suites).each{|s| suite << s}
+          suite
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/test-unit-3.2.9/lib/test/unit/collector/xml.rb

@@ -0,0 +1,249 @@
+#--
+#
+# Author:: Kouhei Sutou
+# Copyright::
+#   * Copyright (c) 2011 Kouhei Sutou <kou@clear-code.com>
+# License:: Ruby license.
+
+# just test!!! don't use it yet!!!
+
+require 'test/unit/collector'
+
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+module Test
+  module Unit
+    module Collector
+      class XML
+        include Collector
+
+        def collect(xml_log_path)
+          listener = Listener.new
+          File.open(xml_log_path) do |xml_log|
+            parser = REXML::Parsers::StreamParser.new(xml_log, listener)
+            parser.parse
+          end
+          suite = TestSuite.new("tests in #{xml_log_path}")
+          suites = listener.test_suites
+          sort(suites).each {|s| add_suite(suite, s)}
+          suite
+        end
+
+        class Listener
+          include REXML::StreamListener
+
+          attr_reader :test_suites
+          def initialize
+            @ns_stack = [{"xml" => :xml}]
+            @tag_stack = [["", :root]]
+            @text_stack = ['']
+            @state_stack = [:root]
+            @values = {}
+            @test_suites = []
+          end
+
+          def tag_start(name, attributes)
+            @text_stack.push('')
+
+            ns = @ns_stack.last.dup
+            attrs = {}
+            attributes.each do |n, v|
+              if /\Axmlns(?:\z|:)/ =~ n
+                ns[$POSTMATCH] = v
+              else
+                attrs[n] = v
+              end
+            end
+            @ns_stack.push(ns)
+
+            _parent_tag = parent_tag
+            prefix, local = split_name(name)
+            uri = _ns(ns, prefix)
+            @tag_stack.push([uri, local])
+
+            state = next_state(@state_stack.last, uri, local)
+            @state_stack.push(state)
+            @values = {}
+            case state
+            when :test_suite, :test_case
+              # do nothing
+            when :test
+              @n_pass_assertions = 0 if _parent_tag == "start-test"
+            when :backtrace
+              @backtrace = []
+              @values_backup = @values
+            end
+          end
+
+          def tag_end(name)
+            state = @state_stack.pop
+            text = @text_stack.pop
+            uri, local = @tag_stack.pop
+            no_action_states = [:root, :stream]
+            case state
+            when *no_action_states
+              # do nothing
+            when :test_suite
+              test_suite_end
+            when :complete_test_case
+              @test_suites.last << @test_case.suite
+            when :test_case
+              test_case_end
+            when :result
+              @result = @values
+            when :test
+              test_end
+            when :pass_assertion
+              @n_pass_assertions += 1
+            when :backtrace
+              @values = @values_backup
+              @values["backtrace"] = @backtrace
+            when :entry
+              file = @values['file']
+              line = @values['line']
+              info = @values['info']
+              @backtrace << "#{file}:#{line}: #{info}"
+              @values = {}
+            else
+              local = normalize_local(local)
+              @values[local] = text
+            end
+            @ns_stack.pop
+          end
+
+          def text(data)
+            @text_stack.last << data
+          end
+
+          private
+          def _ns(ns, prefix)
+            ns.fetch(prefix, "")
+          end
+
+          NAME_SPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/
+          def split_name(name)
+            name =~ NAME_SPLIT
+            [$1 || '', $2]
+          end
+
+          STATE_TABLE = {
+            :root => [:stream],
+            :stream => [:ready_test_suite,
+                        :start_test_suite,
+                        :ready_test_case,
+                        :start_test_case,
+                        :start_test,
+                        :pass_assertion,
+                        :test_result,
+                        :complete_test,
+                        :complete_test_case,
+                        :complete_test_suite,
+                        :success],
+            :ready_test_suite => [:n_tests],
+            :start_test_suite => [:test_suite],
+            :ready_test_case => [:test_case,
+                                 :n_tests],
+            :start_test_case => [:test_case],
+            :start_test => [:test],
+            :pass_assertion => [:test],
+            :complete_test => [:test, :success],
+            :complete_test_case => [:test_case,
+                                    :elapsed,
+                                    :success],
+            :complete_test_suite => [:test_suite,
+                                     :success],
+            :test_suite => [:start_time,
+                            :elapsed],
+            :test_case => [:name,
+                           :start_time,
+                           :elapsed],
+            :test => [:name,
+                      :start_time,
+                      :elapsed],
+            :test_result => [:test,
+                             :result],
+            :result => [:test_case,
+                        :test,
+                        :status,
+                        :backtrace,
+                        :detail],
+            :backtrace => [:entry],
+            :entry => [:file,
+                       :line,
+                       :info],
+          }
+          def next_state(current_state, uri, local)
+            local = normalize_local(local)
+            valid_elements = STATE_TABLE[current_state]
+            if valid_elements.nil?
+              raise "unexpected element: #{current_path}"
+            end
+            next_state = local.to_sym
+            unless valid_elements.include?(next_state)
+              raise "unexpected element: #{current_path}"
+            end
+            next_state
+          end
+
+          def current_path
+            locals = @tag_stack.collect do |uri, local|
+              local
+            end
+            ["", *locals].join("/")
+          end
+
+          def normalize_local(local)
+            local.gsub(/-/, "_")
+          end
+
+          def parent_tag
+            @tag_stack.last[1]
+          end
+
+          def test_suite_end
+            return unless parent_tag == "start-test-suite"
+            suite = TestSuite.new
+            ["start_time", "elapsed_time", "n_tests"].each do |key|
+              if @values.has_key?(key)
+                suite.instance_variable_set("@#{key}", @values[key])
+              end
+            end
+            @test_suites << suite
+          end
+
+          def test_case_end
+            return unless parent_tag == "start-test-case"
+            name = @values["name"]
+            @test_case = Class.new(TestCase) do
+              define_method(:name) do
+                name
+              end
+            end
+          end
+
+          def test_end
+            return unless parent_tag == "complete-test"
+            name = @values["name"]
+            n_pass_assertions = @n_pass_assertions
+            result = @result
+            @test_case.module_eval do
+              test
+              define_method(name) do
+                n_pass_assertions.times do
+                  add_assertion
+                end
+                case result["status"]
+                when "omission"
+                  add_omission(Omission.new(name,
+                                            result["backtrace"],
+                                            result["detail"]))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/test-unit-3.2.9/lib/test/unit/collector.rb

@@ -0,0 +1,73 @@
+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
+    end
+  end
+end