win32-api 1.6.0-universal-mingw32 → 1.6.1.beta1-universal-mingw32

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

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

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

@@ -1,59 +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],
-        ["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

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

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

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