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/ui/emacs/testrunner.rb

@@ -1,49 +0,0 @@
-require 'test/unit/ui/console/testrunner'
-
-module Test
-  module Unit
-    module UI
-      module Emacs
-        class TestRunner < Console::TestRunner
-          private
-          def output_setup_end
-          end
-
-          def output_started
-          end
-
-          def format_fault(fault)
-            return super unless fault.respond_to?(:label)
-            format_method_name = "format_fault_#{fault.label.downcase}"
-            if respond_to?(format_method_name, true)
-              __send__(format_method_name, fault)
-            else
-              super
-            end
-          end
-
-          def format_fault_failure(failure)
-            if failure.location.size == 1
-              location = failure.location[0]
-              location_display = location.sub(/\A(.+:\d+).*/, ' [\\1]')
-            else
-              location_display = "\n" + failure.location.join("\n")
-            end
-            result = "#{failure.label}:\n"
-            result << "#{failure.test_name}#{location_display}:\n"
-            result << failure.message
-            result
-          end
-
-          def format_fault_error(error)
-            result = "#{error.label}:\n"
-            result << "#{error.test_name}:\n"
-            result << "#{error.message}\n"
-            result << error.backtrace.join("\n")
-            result
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-require 'test/unit/ui/testrunnerutilities'
-
-module Test
-  module Unit
-    module UI
-      class TestRunner
-        extend TestRunnerUtilities
-
-        attr_reader :listeners
-        def initialize(suite, options={})
-          if suite.respond_to?(:suite)
-            @suite = suite.suite
-          else
-            @suite = suite
-          end
-          @options = options
-          @listeners = @options[:listeners] || []
-        end
-
-        # Begins the test run.
-        def start
-          setup_mediator
-          attach_to_mediator
-          attach_listeners
-          start_mediator
-        end
-
-        private
-        def setup_mediator
-          @mediator = TestRunnerMediator.new(@suite)
-        end
-
-        def attach_listeners
-          @listeners.each do |listener|
-            listener.attach_to_mediator(@mediator)
-          end
-        end
-
-        def start_mediator
-          @mediator.run
-        end
-
-        def diff_target_string?(string)
-          Assertions::AssertionMessage.diff_target_string?(string)
-        end
-
-        def prepare_for_diff(from, to)
-          Assertions::AssertionMessage.prepare_for_diff(from, to)
-        end
-      end
-    end
-  end
-end

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

@@ -1,114 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/util/observable'
-require 'test/unit/testresult'
-
-module Test
-  module Unit
-    module UI
-
-      # Provides an interface to write any given UI against,
-      # hopefully making it easy to write new UIs.
-      class TestRunnerMediator
-        RESET = name + "::RESET"
-        STARTED = name + "::STARTED"
-        FINISHED = name + "::FINISHED"
-
-        include Util::Observable
-
-        # Creates a new TestRunnerMediator initialized to run
-        # the passed suite.
-        def initialize(suite)
-          @suite = suite
-        end
-
-        # Runs the suite the TestRunnerMediator was created
-        # with.
-        def run
-          AutoRunner.need_auto_run = false
-
-          result = create_result
-
-          Test::Unit.run_at_start_hooks
-          start_time = Time.now
-          begin
-            catch do |stop_tag|
-              result.stop_tag = stop_tag
-              with_listener(result) do
-                notify_listeners(RESET, @suite.size)
-                notify_listeners(STARTED, result)
-
-                run_suite(result)
-              end
-            end
-          ensure
-            elapsed_time = Time.now - start_time
-            notify_listeners(FINISHED, elapsed_time)
-          end
-          Test::Unit.run_at_exit_hooks
-
-          result
-        end
-
-        # Just for backward compatibility for NetBeans.
-        # NetBeans should not use monkey patching. NetBeans
-        # should use runner change public API.
-        #
-        # See GitHub#38
-        #   https://github.com/test-unit/test-unit/issues/38
-        def run_suite(result=nil)
-          if result.nil?
-            run
-          else
-            @suite.run(result) do |channel, value|
-              notify_listeners(channel, value)
-            end
-          end
-        end
-
-        private
-        # A factory method to create the result the mediator
-        # should run with. Can be overridden by subclasses if
-        # one wants to use a different result.
-        def create_result
-          TestResult.new
-        end
-
-        def measure_time
-          begin_time = Time.now
-          yield
-          Time.now - begin_time
-        end
-
-        def with_listener(result)
-          finished_listener = result.add_listener(TestResult::FINISHED) do |*args|
-            notify_listeners(TestResult::FINISHED, *args)
-          end
-          changed_listener = result.add_listener(TestResult::CHANGED) do |*args|
-            notify_listeners(TestResult::CHANGED, *args)
-          end
-          pass_assertion_listener = result.add_listener(TestResult::PASS_ASSERTION) do |*args|
-            notify_listeners(TestResult::PASS_ASSERTION, *args)
-          end
-          fault_listener = result.add_listener(TestResult::FAULT) do |*args|
-            notify_listeners(TestResult::FAULT, *args)
-          end
-
-          begin
-            yield
-          ensure
-            result.remove_listener(TestResult::FAULT, fault_listener)
-            result.remove_listener(TestResult::CHANGED, changed_listener)
-            result.remove_listener(TestResult::FINISHED, finished_listener)
-            result.remove_listener(TestResult::PASS_ASSERTION,
-                                   pass_assertion_listener)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-module Test
-  module Unit
-    module UI
-
-      # Provides some utilities common to most, if not all,
-      # TestRunners.
-      #
-      #--
-      #
-      # Perhaps there ought to be a TestRunner superclass? There
-      # seems to be a decent amount of shared code between test
-      # runners.
-
-      module TestRunnerUtilities
-
-        # Creates a new TestRunner and runs the suite.
-        def run(suite, options={})
-          return new(suite, options).start
-        end
-
-        # Takes care of the ARGV parsing and suite
-        # determination necessary for running one of the
-        # TestRunners from the command line.
-        def start_command_line_test
-          if ARGV.empty?
-            puts "You should supply the name of a test suite file to the runner"
-            exit
-          end
-          require ARGV[0].gsub(/.+::/, '')
-          new(eval(ARGV[0])).start
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/ui/xml/testrunner.rb

@@ -1,224 +0,0 @@
-#--
-#
-# Author:: Kouhei Sutou
-# Copyright::
-#   * Copyright (c) 2011 Kouhei Sutou <kou@clear-code.com>
-# License:: Ruby license.
-
-require 'erb'
-require 'time'
-require 'test/unit/ui/testrunner'
-require 'test/unit/ui/testrunnermediator'
-
-module Test
-  module Unit
-    module UI
-      module XML
-
-        # Runs a Test::Unit::TestSuite and outputs XML.
-        class TestRunner < UI::TestRunner
-          include ERB::Util
-
-          # Creates a new TestRunner for running the passed
-          # suite. :output option specifies where runner
-          # output should go to; defaults to STDOUT.
-          def initialize(suite, options={})
-            super
-            @output = @options[:output] || STDOUT
-            if @options[:output_file_descriptor]
-              @output = IO.new(@options[:output_file_descriptor], "w")
-            end
-            @already_outputted = false
-            @indent = 0
-            @top_level = true
-            @current_test = nil
-            @current_test_suite = nil
-            @already_outputted = false
-          end
-
-          private
-          def attach_to_mediator
-            @mediator.add_listener(TestResult::PASS_ASSERTION,
-                                   &method(:result_pass_assertion))
-            @mediator.add_listener(TestResult::FAULT,
-                                   &method(:result_fault))
-            @mediator.add_listener(TestRunnerMediator::STARTED,
-                                   &method(:started))
-            @mediator.add_listener(TestRunnerMediator::FINISHED,
-                                   &method(:finished))
-            @mediator.add_listener(TestCase::STARTED_OBJECT,
-                                   &method(:test_started))
-            @mediator.add_listener(TestCase::FINISHED_OBJECT,
-                                   &method(:test_finished))
-            @mediator.add_listener(TestSuite::STARTED_OBJECT,
-                                   &method(:test_suite_started))
-            @mediator.add_listener(TestSuite::FINISHED_OBJECT,
-                                   &method(:test_suite_finished))
-          end
-
-          def result_pass_assertion(result)
-            open_tag("pass-assertion") do
-              output_test(@current_test)
-            end
-          end
-
-          def result_fault(fault)
-            open_tag("test-result") do
-              open_tag("result") do
-                output_test_suite(@current_test_suite)
-                output_test(@current_test)
-                open_tag("backtrace") do
-                  fault.location.each do |entry|
-                    file, line, info = entry.split(/:/, 3)
-                    open_tag("entry") do
-                      add_content("file", file)
-                      add_content("line", line)
-                      add_content("info", info)
-                    end
-                  end
-                end
-                if fault.respond_to?(:expected)
-                  add_content("expected", fault.expected)
-                end
-                if fault.respond_to?(:actual)
-                  add_content("actual", fault.actual)
-                end
-                add_content("detail", fault.message)
-                add_content("status", fault.label.downcase)
-              end
-            end
-            @already_outputted = true if fault.critical?
-          end
-
-          def started(result)
-            @result = result
-            output_started
-          end
-
-          def output_started
-            open_tag("stream")
-          end
-
-          def finished(elapsed_time)
-            add_content("success", @result.passed?)
-            close_tag("stream")
-          end
-
-          def test_started(test)
-            @already_outputted = false
-            @current_test = test
-            open_tag("start-test") do
-              output_test(test)
-            end
-          end
-
-          def test_finished(test)
-            unless @already_outputted
-              open_tag("test-result") do
-                output_test(test)
-                open_tag("result") do
-                  output_test_suite(@current_test_suite)
-                  output_test(test)
-                  add_content("status", "success")
-                end
-              end
-            end
-
-            open_tag("complete-test") do
-              output_test(test)
-              add_content("success", test.passed?)
-            end
-            @current_test = nil
-          end
-
-          def test_suite_started(suite)
-            @current_test_suite = suite
-            if suite.test_case.nil?
-              open_tag("ready-test-suite") do
-                add_content("n-tests", suite.size)
-              end
-              open_tag("start-test-suite") do
-                output_test_suite(suite)
-              end
-            else
-              open_tag("ready-test-case") do
-                output_test_suite(suite)
-                add_content("n-tests", suite.size)
-              end
-              open_tag("start-test-case") do
-                output_test_suite(suite)
-              end
-            end
-          end
-
-          def test_suite_finished(suite)
-            if suite.test_case.nil?
-              open_tag("complete-test-suite") do
-                output_test_suite(suite)
-                add_content("success", suite.passed?)
-              end
-            else
-              open_tag("complete-test-case") do
-                output_test_suite(suite)
-                add_content("success", suite.passed?)
-              end
-            end
-            @current_test_suite = nil
-          end
-
-          def indent
-            " " * @indent
-          end
-
-          def open_tag(name)
-            @output.puts("#{indent}<#{name}>")
-            @indent += 2
-            if block_given?
-              yield
-              close_tag(name)
-            end
-          end
-
-          def add_content(name, content)
-            return if content.nil?
-            case content
-            when Time
-              content = content.iso8601
-            end
-            @output.puts("#{indent}<#{name}>#{h(content)}</#{name}>")
-          end
-
-          def close_tag(name)
-            @indent -= 2
-            @output.puts("#{indent}</#{name}>")
-          end
-
-          def output_test(test)
-            open_tag("test") do
-              add_content("name", test.method_name)
-              add_content("start-time", test.start_time)
-              add_content("elapsed", test.elapsed_time)
-            end
-          end
-
-          def output_test_suite(test_suite)
-            test_case = test_suite.test_case
-            if test_case.nil?
-              open_tag("test-suite") do
-                add_content("name", test_suite.name)
-                add_content("start-time", test_suite.start_time)
-                add_content("elapsed", test_suite.elapsed_time)
-              end
-            else
-              open_tag("test-case") do
-                add_content("name", test_suite.name)
-                add_content("start-time", test_suite.start_time)
-                add_content("elapsed", test_suite.elapsed_time)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end