win32-api 1.5.3-universal-mingw32 → 1.6.0-universal-mingw32

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/pending.rb

@@ -0,0 +1,154 @@
+require 'test/unit/util/backtracefilter'
+
+module Test
+  module Unit
+    class Pending
+      include Util::BacktraceFilter
+      attr_reader :test_name, :location, :message
+      attr_reader :method_name
+
+      SINGLE_CHARACTER = 'P'
+      LABEL = "Pending"
+
+      # Creates a new Pending 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 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,
+                                  :method_name => @method_name)
+            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,
+                              :method_name => @method_name)
+        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/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/priority.rb

@@ -0,0 +1,192 @@
+require "fileutils"
+
+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",
+            escape_class_name(@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 escape_class_name(class_name)
+          class_name.gsub(/(?:[: \\\/])/, "_")
+        end
+
+        def escaped_method_name
+          @test.method_name.to_s.gsub(/(?:[: ]|[!?=]$)/) do |matched|
+            case matched
+            when ":"
+              "_colon_"
+            when " "
+              "_"
+            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/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/runner/console.rb

@@ -0,0 +1,59 @@
+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],
+        ["important-only", UI::Console::OutputLevel::IMPORTANT_FAULTS_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
+
+      opts.on("--no-show-detail-immediately",
+              "Shows not passed test details immediately.",
+              "(default is yes)") do |boolean|
+        auto_runner.runner_options[:show_detail_immediately] = boolean
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/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/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/runner/xml.rb

@@ -0,0 +1,15 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:xml) do |auto_runner|
+      require 'test/unit/ui/xml/testrunner'
+      Test::Unit::UI::XML::TestRunner
+    end
+
+    AutoRunner.setup_option do |auto_runner, opts|
+      opts.on("--output-file-descriptor=FD", Integer,
+              "Outputs to file descriptor FD") do |fd|
+        auto_runner.runner_options[:output_file_descriptor] = fd
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/test-suite-creator.rb

@@ -0,0 +1,89 @@
+#--
+#
+# Author:: Kouhei Sutou
+# Copyright::
+#   * Copyright (c) 2011 Kouhei Sutou <tt><kou@clear-code.com></tt>
+# License:: Ruby license.
+
+module Test
+  module Unit
+    class TestSuiteCreator # :nodoc:
+      class << self
+        def test_method?(test_case, method_name)
+          /\Atest./ =~ method_name.to_s or
+            test_case.find_attribute(method_name, :test)
+        end
+      end
+
+      def initialize(test_case)
+        @test_case = test_case
+      end
+
+      def create
+        suite = TestSuite.new(@test_case.name, @test_case)
+        collect_test_names.each do |test_name|
+          data_sets = @test_case.find_attribute(test_name, :data,
+                                                :recursive => false)
+          if data_sets
+            data_sets.each do |data_set|
+              data_set = data_set.call if data_set.respond_to?(:call)
+              data_set.each do |label, data|
+                append_test(suite, test_name) do |test|
+                  test.assign_test_data(label, data)
+                end
+              end
+            end
+          else
+            append_test(suite, test_name)
+          end
+        end
+        append_test(suite, "default_test") if suite.empty?
+        suite
+      end
+
+      private
+      def append_test(suite, test_name)
+        test = @test_case.new(test_name)
+        yield(test) if block_given?
+        suite << test if test.valid?
+      end
+
+      def collect_test_names
+        methods = @test_case.public_instance_methods(true)
+        super_test_case = @test_case.superclass
+        methods -= super_test_case.public_instance_methods(true)
+        methods |= @test_case.public_instance_methods(false)
+        method_names = methods.collect(&:to_s)
+        test_names = method_names.find_all do |method_name|
+          self.class.test_method?(@test_case, method_name)
+        end
+        __send__("sort_test_names_in_#{@test_case.test_order}_order", test_names)
+      end
+
+      def sort_test_names_in_alphabetic_order(test_names)
+        test_names.sort
+      end
+
+      def sort_test_names_in_random_order(test_names)
+        test_names.sort_by {rand(test_names.size)}
+      end
+
+      def sort_test_names_in_defined_order(test_names)
+        added_method_names = @test_case.added_method_names
+        test_names.sort do |test1, test2|
+          test1_defined_order = added_method_names.index(test1)
+          test2_defined_order = added_method_names.index(test2)
+          if test1_defined_order and test2_defined_order
+            test1_defined_order <=> test2_defined_order
+          elsif test1_defined_order
+            1
+          elsif test2_defined_order
+            -1
+          else
+            test1 <=> test2
+          end
+        end
+      end
+    end
+  end
+end