rroonga 0.9.3 → 0.9.4

data/test-unit/lib/test/unit/notification.rb

@@ -1,129 +0,0 @@
-require 'test/unit/util/backtracefilter'
-
-module Test
-  module Unit
-    class Notification
-      include Util::BacktraceFilter
-      attr_reader :test_name, :location, :message
-
-      SINGLE_CHARACTER = 'N'
-      LABEL = "Notification"
-
-      # Creates a new Notification with the given location and
-      # message.
-      def initialize(test_name, location, message)
-        @test_name = test_name
-        @location = location
-        @message = message
-      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
-      def notify(message, &block)
-        notification = Notification.new(name, filter_backtrace(caller), message)
-        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/test-unit/lib/test/unit/omission.rb

@@ -1,191 +0,0 @@
-require 'test/unit/util/backtracefilter'
-
-module Test
-  module Unit
-    class Omission
-      include Util::BacktraceFilter
-      attr_reader :test_name, :location, :message
-
-      SINGLE_CHARACTER = 'O'
-      LABEL = "Omission"
-
-      # Creates a new Omission with the given location and
-      # message.
-      def initialize(test_name, location, message)
-        @test_name = test_name
-        @location = location
-        @message = message
-      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)
-          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)
-        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

data/test-unit/lib/test/unit/pending.rb

@@ -1,150 +0,0 @@
-require 'test/unit/util/backtracefilter'
-
-module Test
-  module Unit
-    class Pending
-      include Util::BacktraceFilter
-      attr_reader :test_name, :location, :message
-
-      SINGLE_CHARACTER = 'P'
-      LABEL = "Pending"
-
-      # Creates a new Pending with the given location and
-      # message.
-      def initialize(test_name, location, message)
-        @test_name = test_name
-        @location = location
-        @message = message
-      end
-
-      # Returns a single character representation of a pending.
-      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 PendedError < StandardError
-    end
-
-
-    module TestCasePendingSupport
-      class << self
-        def included(base)
-          base.class_eval do
-            include PendingHandler
-          end
-        end
-      end
-
-      # Marks the test or part of the test is pending.
-      #
-      # Example:
-      #   def test_pending
-      #     pend
-      #     # Not reached here
-      #   end
-      #
-      #   def test_pending_with_here
-      #     pend do
-      #       # Ran here
-      #       # Fails if the block doesn't raise any error.
-      #       # Because it means the block is passed unexpectedly.
-      #     end
-      #     # Reached here
-      #   end
-      def pend(message=nil, &block)
-        message ||= "pended."
-        if block_given?
-          pending = nil
-          begin
-            yield
-          rescue Exception
-            pending = Pending.new(name, filter_backtrace(caller), message)
-            add_pending(pending)
-          end
-          unless pending
-            flunk("Pending block should not be passed: #{message}")
-          end
-        else
-          raise PendedError.new(message)
-        end
-      end
-
-      private
-      def add_pending(pending)
-        problem_occurred
-        current_result.add_pending(pending)
-      end
-    end
-
-    module PendingHandler
-      class << self
-        def included(base)
-          base.exception_handler(:handle_pended_error)
-        end
-      end
-
-      private
-      def handle_pended_error(exception)
-        return false unless exception.is_a?(PendedError)
-        pending = Pending.new(name,
-                                filter_backtrace(exception.backtrace),
-                                exception.message)
-        add_pending(pending)
-        true
-      end
-    end
-
-    module TestResultPendingSupport
-      attr_reader :pendings
-
-      # Records a Test::Unit::Pending.
-      def add_pending(pending)
-        @pendings << pending
-        notify_fault(pending)
-        notify_changed
-      end
-
-      # Returns the number of pendings this TestResult has
-      # recorded.
-      def pending_count
-        @pendings.size
-      end
-
-      private
-      def initialize_containers
-        super
-        @pendings = []
-        @summary_generators << :pending_summary
-      end
-
-      def pending_summary
-        "#{pending_count} pendings"
-      end
-    end
-  end
-end