win32-api 1.10.0 → 1.10.1

data/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/lib/test/unit/error.rb

@@ -0,0 +1,158 @@
+#--
+#
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/util/backtracefilter'
+
+module Test
+  module Unit
+
+    # Encapsulates an error in a test. Created by
+    # Test::Unit::TestCase when it rescues an exception thrown
+    # during the processing of a test.
+    class Error
+      include Util::BacktraceFilter
+
+      attr_reader :test_name, :exception
+      attr_reader :method_name
+
+      SINGLE_CHARACTER = 'E'
+      LABEL = "Error"
+
+      # Creates a new Error with the given test_name and
+      # exception.
+      def initialize(test_name, exception, options={})
+        @test_name = test_name
+        @exception = exception
+        @method_name = options[:method_name]
+      end
+
+      # Returns a single character representation of an error.
+      def single_character_display
+        SINGLE_CHARACTER
+      end
+
+      def label
+        LABEL
+      end
+
+      # Returns the message associated with the error.
+      def message
+        "#{@exception.class.name}: #{@exception.message}"
+      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_display = location.join("\n    ")
+        "#{label}:\n#@test_name:\n#{message}\n    #{backtrace_display}"
+      end
+
+      def location
+        @location ||= filter_backtrace(@exception.backtrace)
+      end
+      alias_method :backtrace, :location # Deprecated
+
+      # Overridden to return long_display.
+      def to_s
+        long_display
+      end
+
+      def critical?
+        true
+      end
+    end
+
+    module ErrorHandler
+      class << self
+        def included(base)
+          base.exception_handler(:handle_all_exception)
+        end
+      end
+
+      NOT_PASS_THROUGH_EXCEPTIONS = []
+      NOT_PASS_THROUGH_EXCEPTION_NAMES = ["Timeout::Error"]
+      PASS_THROUGH_EXCEPTIONS = [
+        NoMemoryError,
+        SignalException,
+        Interrupt,
+        SystemExit,
+      ]
+      PASS_THROUGH_EXCEPTION_NAMES = []
+      private
+      def handle_all_exception(exception)
+        return false if pass_through_exception?(exception)
+
+        problem_occurred
+        add_error(exception)
+        true
+      end
+
+      def pass_through_exception?(exception)
+        case exception
+        when *NOT_PASS_THROUGH_EXCEPTIONS
+          return false
+        end
+        case exception.class.name
+        when *NOT_PASS_THROUGH_EXCEPTION_NAMES
+          return false
+        end
+
+        case exception
+        when *PASS_THROUGH_EXCEPTIONS
+          return true
+        end
+        case exception.class.name
+        when *PASS_THROUGH_EXCEPTION_NAMES
+          return true
+        end
+
+        false
+      end
+
+      def add_error(exception)
+        error = Error.new(name, exception, :method_name => @method_name)
+        current_result.add_error(error)
+      end
+    end
+
+    module TestResultErrorSupport
+      attr_reader :errors
+
+      # Records a Test::Unit::Error.
+      def add_error(error)
+        @errors << error
+        notify_fault(error)
+        notify_changed
+      end
+
+      # Returns the number of errors this TestResult has
+      # recorded.
+      def error_count
+        @errors.size
+      end
+
+      def error_occurred?
+        not @errors.empty?
+      end
+
+      private
+      def initialize_containers
+        super
+        @errors = []
+        @summary_generators << :error_summary
+        @problem_checkers << :error_occurred?
+      end
+
+      def error_summary
+        "#{error_count} errors"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/lib/test/unit/exception-handler.rb

@@ -0,0 +1,82 @@
+module Test
+  module Unit
+    module ExceptionHandler
+      @@exception_handlers = []
+      class << self
+        def exception_handlers
+          @@exception_handlers
+        end
+
+        def included(base)
+          base.extend(ClassMethods)
+
+          observer = Proc.new do |test_case, _, _, value, method_name|
+            if value
+              @@exception_handlers.unshift(method_name)
+            else
+              @@exception_handlers.delete(method_name)
+            end
+          end
+          base.register_attribute_observer(:exception_handler, &observer)
+        end
+      end
+
+      module ClassMethods
+        def exception_handlers
+          ExceptionHandler.exception_handlers
+        end
+
+        # @overload exception_handler(method_name)
+        #   Add an exception handler method.
+        #
+        #   @param method_name [Symbol]
+        #      The method name that handles exception raised in tests.
+        #   @return [void]
+        #
+        # @overload exception_handler(&callback)
+        #   Add an exception handler.
+        #
+        #   @yield [test, exception]
+        #     Gives the test and the exception.
+        #   @yieldparam test [Test::Unit::TestCase]
+        #      The test where the exception is raised.
+        #   @yieldparam exception [Exception]
+        #      The exception that is raised in running the test.
+        #   @yieldreturn [Boolean]
+        #      Whether the handler handles the exception or not.
+        #      The handler must return _true_ if the handler handles
+        #      test exception, _false_ otherwise.
+        #   @return [void]
+        #
+        # This is a public API for developers who extend test-unit.
+        def exception_handler(*method_name_or_handlers, &block)
+          if block_given?
+            exception_handlers.unshift(block)
+          else
+            method_name_or_handlers.each do |method_name_or_handler|
+              if method_name_or_handler.respond_to?(:call)
+                handler = method_name_or_handler
+                exception_handlers.unshift(handler)
+              else
+                method_name = method_name_or_handler
+                attribute(:exception_handler, true, {}, method_name)
+              end
+            end
+          end
+        end
+
+        def unregister_exception_handler(*method_name_or_handlers)
+          method_name_or_handlers.each do |method_name_or_handler|
+            if method_name_or_handler.respond_to?(:call)
+              handler = method_name_or_handler
+              exception_handlers.delete(handler)
+            else
+              method_name = method_name_or_handler
+              attribute(:exception_handler, false, {}, method_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/lib/test/unit/failure.rb

@@ -0,0 +1,169 @@
+#--
+#
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+module Test
+  module Unit
+
+    # Encapsulates a test failure. Created by Test::Unit::TestCase
+    # when an assertion fails.
+    class Failure
+      attr_reader :test_name, :location, :message
+      attr_reader :method_name, :source_location
+      attr_reader :expected, :actual, :user_message
+      attr_reader :inspected_expected, :inspected_actual
+
+      SINGLE_CHARACTER = 'F'
+      LABEL = "Failure"
+
+      # Creates a new Failure 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]
+        @source_location = options[:source_location]
+        @expected = options[:expected]
+        @actual = options[:actual]
+        @inspected_expected = options[:inspected_expected]
+        @inspected_actual = options[:inspected_actual]
+        @user_message = options[:user_message]
+      end
+      
+      # Returns a single character representation of a failure.
+      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
+        if location.size == 1
+          location_display = location[0].sub(/\A(.+:\d+).*/, ' [\\1]')
+        else
+          location_display = "\n    [#{location.join("\n     ")}]"
+        end
+        "#{label}:\n#@test_name#{location_display}:\n#@message"
+      end
+
+      # Overridden to return long_display.
+      def to_s
+        long_display
+      end
+
+      def critical?
+        true
+      end
+
+      def diff
+        @diff ||= compute_diff
+      end
+
+      private
+      def compute_diff
+        Assertions::AssertionMessage.delayed_diff(@expected, @actual).inspect
+      end
+    end
+
+    module FailureHandler
+      class << self
+        def included(base)
+          base.exception_handler(:handle_assertion_failed_error)
+        end
+      end
+
+      # Report a failure.
+      #
+      # This is a public API for developers who extend test-unit.
+      #
+      # @param message [String] The description about the failure.
+      # @param backtrace [Array<String>] The backtrace for the failure.
+      # @option options [Object] :expected
+      #   The expected value of the assertion.
+      # @option options [Object] :actual
+      #   The actual value of the assertion.
+      # @option options [String] :inspected_expected
+      #   The inspected expected value of the assertion.
+      #   It is used for diff between expected and actual of the failure.
+      # @option options [String] :inspected_actual
+      #   The inspected actual value of the assertion.
+      #   It is used for diff between expected and actual of the failure.
+      # @option options [String] :user_message
+      #   The message of the assertion from user.
+      # @option options [String] :method_name (@method_name)
+      #   The method name of the test.
+      # @option options [Array<String, Integer>] :source_location
+      #   The location where the test is defined. It is the same
+      #   format as Proc#source_location. That is, it's an array of
+      #   path and and line number where the test definition is
+      #   started.
+      # @return [void]
+      def add_failure(message, backtrace, options={})
+        default_options = {
+          :method_name => @method_name,
+          :source_location => self[:source_location],
+        }
+        failure = Failure.new(name, filter_backtrace(backtrace), message,
+                              default_options.merge(options))
+        current_result.add_failure(failure)
+      end
+
+      private
+      def handle_assertion_failed_error(exception)
+        return false unless exception.is_a?(AssertionFailedError)
+        problem_occurred
+        add_failure(exception.message, exception.backtrace,
+                    :expected => exception.expected,
+                    :actual => exception.actual,
+                    :inspected_expected => exception.inspected_expected,
+                    :inspected_actual => exception.inspected_actual,
+                    :user_message => exception.user_message)
+        true
+      end
+    end
+
+    module TestResultFailureSupport
+      attr_reader :failures
+
+      # Records a Test::Unit::Failure.
+      def add_failure(failure)
+        @failures << failure
+        notify_fault(failure)
+        notify_changed
+      end
+
+      # Returns the number of failures this TestResult has
+      # recorded.
+      def failure_count
+        @failures.size
+      end
+
+      def failure_occurred?
+        not @failures.empty?
+      end
+
+      private
+      def initialize_containers
+        super
+        @failures = []
+        @summary_generators << :failure_summary
+        @problem_checkers << :failure_occurred?
+      end
+
+      def failure_summary
+        "#{failure_count} failures"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/lib/test/unit/fault-location-detector.rb

@@ -0,0 +1,100 @@
+# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+#
+# License: Ruby's
+
+require "English"
+
+module Test
+  module Unit
+    class FaultLocationDetector
+      def initialize(fault, code_snippet_fetcher)
+        @fault = fault
+        @code_snippet_fetcher = code_snippet_fetcher
+        extract_fault_information
+      end
+
+      def split_backtrace_entry(entry)
+        match_data = /\A(.+):(\d+)(?::(.*))?\z/.match(entry)
+        return nil if match_data.nil?
+        file, line_number, context = match_data.to_a[1..-1]
+        line_number = line_number.to_i
+        if /\Ain `(.+?)'/ =~ context
+          method_name = $1
+          if /\Ablock (?:\(.+?\) )?in / =~ method_name
+            method_name = $POSTMATCH
+          end
+        else
+          method_name = nil
+        end
+        [file, line_number, context, method_name]
+      end
+
+      def target?(backtrace_entry)
+        file, line_number, context, method_name =
+          split_backtrace_entry(backtrace_entry)
+        _ = context
+        return false if file.nil?
+
+        if @fault_source_location
+          target_source_location?(file, line_number, method_name)
+        elsif @fault_method_name
+          target_method?(method_name)
+        else
+          true
+        end
+      end
+
+      private
+      def target_source_location?(file, line_number, method_name)
+        fault_file, fault_line_number = @fault_source_location
+        return false unless file.end_with?(fault_file)
+
+        return false if line_number < fault_line_number
+
+        lines = @code_snippet_fetcher.source(file)
+        return false if lines.nil?
+
+        base_indent_level = nil
+        fault_line_number.step(lines.size) do |current_line_number|
+          line = lines[current_line_number - 1]
+          current_indent_level = guess_indent_level(line)
+          base_indent_level ||= current_indent_level
+          return true if current_line_number == line_number
+
+          if current_line_number == fault_line_number
+            break if /(?:\send|\})\s*$/ =~ line
+          else
+            break if current_indent_level == base_indent_level
+          end
+        end
+        false
+      end
+
+      def target_method?(method_name)
+        @fault_method_name == method_name
+      end
+
+      def guess_indent_level(line)
+        if /\A(\s*)/ =~ line
+          $1.sub(/\t/, " " * 8).count(" ")
+        else
+          0
+        end
+      end
+
+      def extract_fault_information
+        if @fault.respond_to?(:source_location)
+          @fault_source_location = @fault.source_location
+        else
+          @fault_source_location = nil
+        end
+
+        if @fault.respond_to?(:method_name)
+          @fault_method_name = @fault.method_name
+        else
+          @fault_method_name = nil
+        end
+      end
+    end
+  end
+end