rroonga 0.9.2-x86-mingw32

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

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

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

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