win32-api 1.6.0-universal-mingw32 → 1.6.1.beta1-universal-mingw32

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/error.rb

@@ -1,158 +0,0 @@
-#--
-#
-# 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/2.2.0/gems/test-unit-3.1.9/lib/test/unit/exception-handler.rb

@@ -1,82 +0,0 @@
-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/2.2.0/gems/test-unit-3.1.9/lib/test/unit/failure.rb

@@ -1,169 +0,0 @@
-#--
-#
-# 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/2.2.0/gems/test-unit-3.1.9/lib/test/unit/fault-location-detector.rb

@@ -1,100 +0,0 @@
-# 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