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/fixture.rb

@@ -1,295 +0,0 @@
-module Test
-  module Unit
-    module Fixture
-      class << self
-        def included(base)
-          base.extend(ClassMethods)
-
-          [:setup, :cleanup, :teardown].each do |type|
-            observer = lambda do |test_case, _, _, value, callback|
-              if value.nil?
-                test_case.fixture[type].unregister(callback)
-              else
-                test_case.fixture[type].register(callback, value)
-              end
-            end
-            base.register_attribute_observer(type, &observer)
-          end
-        end
-      end
-
-      class Fixture
-        attr_reader :setup
-        attr_reader :cleanup
-        attr_reader :teardown
-        def initialize(test_case)
-          @test_case = test_case
-          @setup = HookPoint.new(@test_case, :setup, :after => :append)
-          @cleanup = HookPoint.new(@test_case, :cleanup, :before => :prepend)
-          @teardown = HookPoint.new(@test_case, :teardown, :before => :prepend)
-          @cached_before_callbacks = {}
-          @cached_after_callbacks = {}
-        end
-
-        def [](type)
-          case type
-          when :setup
-            @setup
-          when :cleanup
-            @cleanup
-          when :teardown
-            @teardown
-          end
-        end
-
-        def before_callbacks(type)
-          @cached_before_callbacks[type] ||= collect_before_callbacks(type)
-        end
-
-        def after_callbacks(type)
-          @cached_after_callbacks[type] ||= collect_after_callbacks(type)
-        end
-
-        private
-        def target_test_cases
-          @cached_target_test_cases ||= collect_target_test_cases
-        end
-
-        def collect_before_callbacks(type)
-          prepend_callbacks = []
-          append_callbacks = []
-          target_test_cases.each do |ancestor|
-            prepend_callbacks << ancestor.fixture[type].before_prepend_callbacks
-            append_callbacks << ancestor.fixture[type].before_append_callbacks
-          end
-
-          merge_callbacks(prepend_callbacks, append_callbacks)
-        end
-
-        def collect_after_callbacks(type)
-          prepend_callbacks = []
-          append_callbacks = []
-          target_test_cases.each do |ancestor|
-            prepend_callbacks << ancestor.fixture[type].after_prepend_callbacks
-            append_callbacks << ancestor.fixture[type].after_append_callbacks
-          end
-
-          merge_callbacks(prepend_callbacks, append_callbacks)
-        end
-
-        def collect_target_test_cases
-          ancestors = @test_case.ancestors
-          base_index = ancestors.index(::Test::Unit::Fixture)
-          interested_ancestors = ancestors[0, base_index].find_all do |ancestor|
-            ancestor.is_a?(Class)
-          end
-          interested_ancestors.reverse
-        end
-
-        def merge_callbacks(prepend_callbacks, append_callbacks)
-          all_callbacks = []
-          prepend_callbacks.reverse_each do |callbacks|
-            all_callbacks.concat(callbacks)
-          end
-          append_callbacks.each do |callbacks|
-            all_callbacks.concat(callbacks)
-          end
-          all_callbacks
-        end
-      end
-
-      class HookPoint
-        def initialize(test_case, type, default_options)
-          @test_case = test_case
-          @type = type
-          @default_options = default_options
-          @before_prepend_callbacks = []
-          @before_append_callbacks = []
-          @after_prepend_callbacks = []
-          @after_append_callbacks = []
-          @unregistered_callbacks = []
-        end
-
-        def register(method_name_or_callback, options=nil)
-          options ||= {}
-          unless valid_register_options?(options)
-            message = "must be {:before => :prepend}, " +
-              "{:before => :append}, {:after => :prepend} or " +
-              "{:after => :append}: #{options.inspect}"
-            raise ArgumentError, message
-          end
-
-          if options.empty?
-            options = @default_options
-          end
-          before_how = options[:before]
-          after_how = options[:after]
-          if method_name_or_callback.respond_to?(:call)
-            callback = method_name_or_callback
-            method_name = callback_method_name(callback)
-            @test_case.__send__(:define_method, method_name, &callback)
-          else
-            method_name = method_name_or_callback
-          end
-          add_callback(method_name, before_how, after_how)
-        end
-
-        def unregister(method_name_or_callback)
-          if method_name_or_callback.respond_to?(:call)
-            callback = method_name_or_callback
-            method_name = callback_method_name(callback)
-          else
-            method_name = method_name_or_callback
-          end
-          @unregistered_callbacks << method_name
-        end
-
-        def before_prepend_callbacks
-          @before_prepend_callbacks - @unregistered_callbacks
-        end
-
-        def before_append_callbacks
-          @before_append_callbacks - @unregistered_callbacks
-        end
-
-        def after_prepend_callbacks
-          @after_prepend_callbacks - @unregistered_callbacks
-        end
-
-        def after_append_callbacks
-          @after_append_callbacks - @unregistered_callbacks
-        end
-
-        private
-        def valid_register_options?(options)
-          return true if options.empty?
-          return false if options.size > 1
-
-          key = options.keys.first
-          [:before, :after].include?(key) and
-            [:prepend, :append].include?(options[key])
-        end
-
-        def callback_method_name(callback)
-          "#{@type}_#{callback.object_id}"
-        end
-
-        def add_callback(method_name_or_callback, before_how, after_how)
-          case before_how
-          when :prepend
-            @before_prepend_callbacks =
-              [method_name_or_callback] | @before_prepend_callbacks
-          when :append
-            @before_append_callbacks |= [method_name_or_callback]
-          else
-            case after_how
-            when :prepend
-              @after_prepend_callbacks =
-                [method_name_or_callback] | @after_prepend_callbacks
-            when :append
-              @after_append_callbacks |= [method_name_or_callback]
-            end
-          end
-        end
-      end
-
-      module ClassMethods
-        def fixture
-          @fixture ||= Fixture.new(self)
-        end
-
-        def setup(*method_names, &callback)
-          register_fixture(:setup, *method_names, &callback)
-        end
-
-        def unregister_setup(*method_names_or_callbacks)
-          unregister_fixture(:setup, *method_names_or_callbacks)
-        end
-
-        def cleanup(*method_names, &callback)
-          register_fixture(:cleanup, *method_names, &callback)
-        end
-
-        def unregister_cleanup(*method_names_or_callbacks)
-          unregister_fixture(:cleanup, *method_names_or_callbacks)
-        end
-
-        def teardown(*method_names, &callback)
-          register_fixture(:teardown, *method_names, &callback)
-        end
-
-        def unregister_teardown(*method_names_or_callbacks)
-          unregister_fixture(:teardown, *method_names_or_callbacks)
-        end
-
-        private
-        def register_fixture(fixture, *method_names, &callback)
-          options = {}
-          options = method_names.pop if method_names.last.is_a?(Hash)
-          callbacks = method_names
-          callbacks << callback if callback
-          attribute(fixture, options, *callbacks)
-        end
-
-        def unregister_fixture(fixture, *method_names_or_callbacks)
-          attribute(fixture, nil, *method_names_or_callbacks)
-        end
-      end
-
-      private
-      def run_fixture(type, options={}, &block)
-        fixtures = [
-          self.class.fixture.before_callbacks(type),
-          type,
-          self.class.fixture.after_callbacks(type),
-        ].flatten
-        if block
-          runner = create_fixtures_runner(fixtures, options, &block)
-          runner.call
-        else
-          fixtures.each do |method_name|
-            run_fixture_callback(method_name, options)
-          end
-        end
-      end
-
-      def create_fixtures_runner(fixtures, options, &block)
-        if fixtures.empty?
-          block
-        else
-          last_fixture = fixtures.pop
-          create_fixtures_runner(fixtures, options) do
-            block_is_called = false
-            run_fixture_callback(last_fixture, options) do
-              block_is_called = true
-              block.call
-            end
-            block.call unless block_is_called
-          end
-        end
-      end
-
-      def run_fixture_callback(method_name, options, &block)
-        return unless respond_to?(method_name, true)
-        begin
-          __send__(method_name, &block)
-        rescue Exception
-          raise unless options[:handle_exception]
-          raise unless handle_exception($!)
-        end
-      end
-
-      def run_setup(&block)
-        run_fixture(:setup, &block)
-      end
-
-      def run_cleanup
-        run_fixture(:cleanup)
-      end
-
-      def run_teardown
-        run_fixture(:teardown, :handle_exception => true)
-      end
-    end
-  end
-end

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

@@ -1,136 +0,0 @@
-require 'test/unit/util/backtracefilter'
-
-module Test
-  module Unit
-    class Notification
-      include Util::BacktraceFilter
-      attr_reader :test_name, :location, :message
-      attr_reader :method_name
-
-      SINGLE_CHARACTER = 'N'
-      LABEL = "Notification"
-
-      # Creates a new Notification 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 notification.
-      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?
-        false
-      end
-    end
-
-    class NotifiedError < StandardError
-    end
-
-
-    module TestCaseNotificationSupport
-      class << self
-        def included(base)
-          base.class_eval do
-            include NotificationHandler
-          end
-        end
-      end
-
-      # Notify some information.
-      #
-      # Example:
-      #   def test_notification
-      #     notify("I'm here!")
-      #     # Reached here
-      #     notify("Special!") if special_case?
-      #     # Reached here too
-      #   end
-      #
-      # options:
-      #   :backtrace override backtrace.
-      def notify(message, options={}, &block)
-        backtrace = filter_backtrace(options[:backtrace] || caller)
-        notification = Notification.new(name, backtrace, message,
-                                        :method_name => @method_name)
-        add_notification(notification)
-      end
-
-      private
-      def add_notification(notification)
-        current_result.add_notification(notification)
-      end
-    end
-
-    module NotificationHandler
-      class << self
-        def included(base)
-          base.exception_handler(:handle_notified_error)
-        end
-      end
-
-      private
-      def handle_notified_error(exception)
-        return false unless exception.is_a?(NotifiedError)
-        notification = Notification.new(name,
-                                        filter_backtrace(exception.backtrace),
-                                        exception.message)
-        add_notification(notification)
-        true
-      end
-    end
-
-    module TestResultNotificationSupport
-      attr_reader :notifications
-
-      # Records a Test::Unit::Notification.
-      def add_notification(notification)
-        @notifications << notification
-        notify_fault(notification)
-        notify_changed
-      end
-
-      # Returns the number of notifications this TestResult has
-      # recorded.
-      def notification_count
-        @notifications.size
-      end
-
-      private
-      def initialize_containers
-        super
-        @notifications = []
-        @summary_generators << :notification_summary
-      end
-
-      def notification_summary
-        "#{notification_count} notifications"
-      end
-    end
-  end
-end

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

@@ -1,195 +0,0 @@
-require 'test/unit/util/backtracefilter'
-
-module Test
-  module Unit
-    class Omission
-      include Util::BacktraceFilter
-      attr_reader :test_name, :location, :message
-      attr_reader :method_name
-
-      SINGLE_CHARACTER = 'O'
-      LABEL = "Omission"
-
-      # Creates a new Omission 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 omission.
-      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 OmittedError < StandardError
-    end
-
-
-    module TestCaseOmissionSupport
-      class << self
-        def included(base)
-          base.class_eval do
-            include OmissionHandler
-          end
-        end
-      end
-
-      # Omit the test or part of the test.
-      #
-      # Example:
-      #   def test_omission
-      #     omit
-      #     # Not reached here
-      #   end
-      #
-      #   def test_omission_with_here
-      #     omit do
-      #       # Not ran here
-      #     end
-      #     # Reached here
-      #   end
-      def omit(message=nil, &block)
-        message ||= "omitted."
-        if block_given?
-          omission = Omission.new(name, filter_backtrace(caller), message,
-                                  :method_name => @method_name)
-          add_omission(omission)
-        else
-          raise OmittedError.new(message)
-        end
-      end
-
-      # Omit the test or part of the test if _condition_ is
-      # true.
-      #
-      # Example:
-      #   def test_omission
-      #     omit_if("".empty?)
-      #     # Not reached here
-      #   end
-      #
-      #   def test_omission_with_here
-      #     omit_if(true) do
-      #       # Not ran here
-      #     end
-      #     omit_if(false) do
-      #       # Reached here
-      #     end
-      #     # Reached here too
-      #   end
-      def omit_if(condition, *args, &block)
-        if condition
-          omit(*args, &block)
-        else
-          block.call if block
-        end
-      end
-
-      # Omit the test or part of the test if _condition_ is
-      # not true.
-      #
-      # Example:
-      #   def test_omission
-      #     omit_unless("string".empty?)
-      #     # Not reached here
-      #   end
-      #
-      #   def test_omission_with_here
-      #     omit_unless(true) do
-      #       # Reached here
-      #     end
-      #     omit_unless(false) do
-      #       # Not ran here
-      #     end
-      #     # Reached here too
-      #   end
-      def omit_unless(condition, *args, &block)
-        if condition
-          block.call if block
-        else
-          omit(*args, &block)
-        end
-      end
-
-      private
-      def add_omission(omission)
-        current_result.add_omission(omission)
-      end
-    end
-
-    module OmissionHandler
-      class << self
-        def included(base)
-          base.exception_handler(:handle_omitted_error)
-        end
-      end
-
-      private
-      def handle_omitted_error(exception)
-        return false unless exception.is_a?(OmittedError)
-        omission = Omission.new(name,
-                                filter_backtrace(exception.backtrace),
-                                exception.message,
-                                :method_name => @method_name)
-        add_omission(omission)
-        true
-      end
-    end
-
-    module TestResultOmissionSupport
-      attr_reader :omissions
-
-      # Records a Test::Unit::Omission.
-      def add_omission(omission)
-        @omissions << omission
-        notify_fault(omission)
-        notify_changed
-      end
-
-      # Returns the number of omissions this TestResult has
-      # recorded.
-      def omission_count
-        @omissions.size
-      end
-
-      private
-      def initialize_containers
-        super
-        @omissions = []
-        @summary_generators << :omission_summary
-      end
-
-      def omission_summary
-        "#{omission_count} omissions"
-      end
-    end
-  end
-end