windows-pr 1.2.4 → 1.2.5

data/vendor/bundle/ruby/2.2.0/gems/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/fixture.rb

@@ -0,0 +1,295 @@
+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/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/notification.rb

@@ -0,0 +1,136 @@
+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/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/omission.rb

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