rroonga 1.0.1 → 1.0.2

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

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

@@ -0,0 +1,180 @@
+module Test
+  module Unit
+    module Priority
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+
+          base.class_eval do
+            setup :priority_setup, :before => :prepend
+            teardown :priority_teardown, :after => :append
+          end
+        end
+
+        @@enabled = false
+        def enabled?
+          @@enabled
+        end
+
+        def enable
+          require "fileutils"
+          require "tmpdir"
+          @@enabled = true
+        end
+
+        def disable
+          @@enabled = false
+        end
+
+        @@default = :normal
+        def default
+          @@default || :normal
+        end
+
+        def default=(default)
+          @@default = default
+        end
+
+        def available_values
+          Checker.available_priorities
+        end
+      end
+
+      class Checker
+        class << self
+          def have_priority?(name)
+            singleton_class = (class << self; self; end)
+            singleton_class.method_defined?(priority_check_method_name(name))
+          end
+
+          def need_to_run?(test)
+            priority = test[:priority] || Priority.default
+            if have_priority?(priority)
+              send(priority_check_method_name(priority), test)
+            else
+              true
+            end
+          end
+
+          def available_priorities
+            methods(false).collect do |name|
+              /\Arun_priority_(.+)\?\z/ =~ name.to_s
+              $1
+            end.compact
+          end
+
+          def run_priority_must?(test)
+            true
+          end
+
+          def run_priority_important?(test)
+            rand > 0.1
+          end
+
+          def run_priority_high?(test)
+            rand > 0.3
+          end
+
+          def run_priority_normal?(test)
+            rand > 0.5
+          end
+
+          def run_priority_low?(test)
+            rand > 0.75
+          end
+
+          def run_priority_never?(test)
+            false
+          end
+
+          private
+          def priority_check_method_name(priority_name)
+            "run_priority_#{priority_name}?"
+          end
+        end
+
+        attr_reader :test
+        def initialize(test)
+          @test = test
+        end
+
+        def setup
+          FileUtils.rm_f(passed_file)
+        end
+
+        def teardown
+          if @test.send(:passed?)
+            FileUtils.touch(passed_file)
+          else
+            FileUtils.rm_f(passed_file)
+          end
+        end
+
+        def need_to_run?
+          !previous_test_success? or self.class.need_to_run?(@test)
+        end
+
+        private
+        def previous_test_success?
+          File.exist?(passed_file)
+        end
+
+        def result_dir
+          components = [".test-result",
+                        @test.class.name || "AnonymousTestCase",
+                        escaped_method_name]
+          parent_directories = [File.dirname($0), Dir.pwd]
+          if Process.respond_to?(:uid)
+            parent_directories << File.join(Dir.tmpdir, Process.uid.to_s)
+          end
+          parent_directories.each do |parent_directory|
+            dir = File.expand_path(File.join(parent_directory, *components))
+            begin
+              FileUtils.mkdir_p(dir)
+              return dir
+            rescue Errno::EACCES
+            end
+          end
+
+          raise Errno::EACCES, parent_directories.join(", ")
+        end
+
+        def passed_file
+          File.join(result_dir, "passed")
+        end
+
+        def escaped_method_name
+          @test.method_name.to_s.gsub(/[!?=]$/) do |matched|
+            case matched
+            when "!"
+              ".destructive"
+            when "?"
+              ".predicate"
+            when "="
+              ".equal"
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        def priority(name, *tests)
+          unless Checker.have_priority?(name)
+            raise ArgumentError, "unknown priority: #{name}"
+          end
+          attribute(:priority, name, {:keep => true}, *tests)
+        end
+      end
+
+      def priority_setup
+        return unless Priority.enabled?
+        Checker.new(self).setup
+      end
+
+      def priority_teardown
+        return unless Priority.enabled?
+        Checker.new(self).teardown
+      end
+    end
+  end
+end

data/test-unit/lib/test/unit/runner/console.rb

@@ -0,0 +1,52 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:console) do |auto_runner|
+      require 'test/unit/ui/console/testrunner'
+      Test::Unit::UI::Console::TestRunner
+    end
+
+    AutoRunner.setup_option do |auto_runner, opts|
+      require 'test/unit/ui/console/outputlevel'
+
+      output_levels = [
+        [:silent, UI::Console::OutputLevel::SILENT],
+        [:progress, UI::Console::OutputLevel::PROGRESS_ONLY],
+        [:normal, UI::Console::OutputLevel::NORMAL],
+        [:verbose, UI::Console::OutputLevel::VERBOSE],
+      ]
+      opts.on('-v', '--verbose=[LEVEL]', output_levels,
+              "Set the output level (default is verbose).",
+              "(#{auto_runner.keyword_display(output_levels)})") do |level|
+        level ||= output_levels.assoc(:verbose)[1]
+        auto_runner.runner_options[:output_level] = level
+      end
+
+      use_color_options = [
+        [:auto, :auto],
+        ["-", false],
+        ["no", false],
+        ["false", false],
+        ["+", true],
+        ["yes", true],
+        ["true", true],
+      ]
+      opts.on("--[no-]use-color=[auto]", use_color_options,
+              "Uses color output",
+              "(default is auto)") do |use_color|
+        case use_color
+        when nil
+          use_color = true
+        when :auto
+          use_color = nil
+        end
+        auto_runner.runner_options[:use_color] = use_color
+      end
+
+      opts.on("--progress-row-max=MAX", Integer,
+              "Uses MAX as max terminal width for progress mark",
+              "(default is auto)") do |max|
+        auto_runner.runner_options[:progress_row_max] = max
+      end
+    end
+  end
+end

data/test-unit/lib/test/unit/runner/emacs.rb

@@ -0,0 +1,8 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:emacs) do |auto_runner|
+      require 'test/unit/ui/emacs/testrunner'
+      Test::Unit::UI::Emacs::TestRunner
+    end
+  end
+end

data/test-unit/lib/test/unit/runner/tap.rb

@@ -0,0 +1,8 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:tap) do |auto_runner|
+      require 'test/unit/ui/tap/testrunner'
+      Test::Unit::UI::Tap::TestRunner
+    end
+  end
+end