rroonga 0.9.3-x86-mingw32 → 0.9.4-x86-mingw32

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

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

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

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

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

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