glib2 0.90.8-x86-mingw32 → 0.90.9-x86-mingw32

data/test-unit/lib/test/unit/ui/emacs/testrunner.rb

@@ -1,63 +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 output_fault_backtrace(fault)
-            backtrace = fault.location
-            if backtrace.size == 1
-              output(fault.test_name +
-                     backtrace[0].sub(/\A(.+:\d+).*/, ' [\\1]') +
-                     ":")
-            else
-              output(fault.test_name)
-              backtrace.each do |entry|
-                output(entry)
-              end
-            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/test-unit/lib/test/unit/ui/tap/testrunner.rb

@@ -1,82 +0,0 @@
-#--
-#
-# Author:: Kouhei Sutou.
-# Copyright:: Copyright (c) 2009-2010 Kouhei Sutou <kou@clear-code.com>.
-# License:: Ruby license.
-
-require 'test/unit/ui/testrunner'
-require 'test/unit/ui/testrunnermediator'
-
-module Test
-  module Unit
-    module UI
-      module Tap
-
-        # Runs a Test::Unit::TestSuite and outputs result
-        # as TAP format.
-        class TestRunner < UI::TestRunner
-          def initialize(suite, options={})
-            super
-            @output = @options[:output] || STDOUT
-            @n_tests = 0
-            @already_outputted = false
-          end
-
-          # Begins the test run.
-          def start
-            result = super
-            def result.passed?
-              true # for prove commend :<
-            end
-            result
-          end
-
-          private
-          def attach_to_mediator
-            @mediator.add_listener(TestResult::FAULT, &method(:add_fault))
-            @mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
-            @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
-            @mediator.add_listener(TestCase::STARTED, &method(:test_started))
-            @mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
-          end
-
-          def add_fault(fault)
-            puts("not ok #{@n_tests} - #{fault.short_display}")
-            fault.long_display.each_line do |line|
-              puts("# #{line}")
-            end
-            @already_outputted = true
-          end
-
-          def started(result)
-            @result = result
-            puts("1..#{@suite.size}")
-          end
-
-          def finished(elapsed_time)
-            puts("# Finished in #{elapsed_time} seconds.")
-            @result.to_s.each_line do |line|
-              puts("# #{line}")
-            end
-          end
-
-          def test_started(name)
-            @n_tests += 1
-          end
-
-          def test_finished(name)
-            unless @already_outputted
-              puts("ok #{@n_tests} - #{name}")
-            end
-            @already_outputted = false
-          end
-
-          def puts(*args)
-            @output.puts(*args)
-            @output.flush
-          end
-        end
-      end
-    end
-  end
-end

data/test-unit/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_suite
-        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/test-unit/lib/test/unit/ui/testrunnermediator.rb

@@ -1,86 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit'
-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_suite
-          Unit.run = true
-
-          result = create_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
-
-          start_time = Time.now
-          begin
-            notify_listeners(RESET, @suite.size)
-            notify_listeners(STARTED, result)
-
-            @suite.run(result) do |channel, value|
-              notify_listeners(channel, value)
-            end
-          ensure
-            elapsed_time = Time.now - start_time
-            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)
-            notify_listeners(FINISHED, elapsed_time)
-          end
-
-          result
-        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
-      end
-    end
-  end
-end

data/test-unit/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/test-unit/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