rroonga 0.9.5-x86-mingw32 → 1.0.1-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,92 +0,0 @@
-#--
-#
-# Author:: Kouhei Sutou.
-# Copyright:: Copyright (c) 2009 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
-            setup_mediator
-            result = start_mediator
-            def result.passed?
-              true # for prove commend :<
-            end
-            result
-          end
-
-          private
-          def setup_mediator
-            @mediator = TestRunnerMediator.new(@suite)
-            attach_to_mediator
-          end
-
-          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 start_mediator
-            @mediator.run_suite
-          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,28 +0,0 @@
-require 'test/unit/ui/testrunnerutilities'
-
-module Test
-  module Unit
-    module UI
-      class TestRunner
-        extend TestRunnerUtilities
-
-        def initialize(suite, options={})
-          if suite.respond_to?(:suite)
-            @suite = suite.suite
-          else
-            @suite = suite
-          end
-          @options = options
-        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,77 +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
-          result_listener = result.add_listener(TestResult::CHANGED) do |*args|
-            notify_listeners(TestResult::CHANGED, *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, result_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/util/backtracefilter.rb

@@ -1,41 +0,0 @@
-module Test
-  module Unit
-    module Util
-      module BacktraceFilter
-        TESTUNIT_FILE_SEPARATORS = %r{[\\/:]}
-        TESTUNIT_PREFIX = __FILE__.split(TESTUNIT_FILE_SEPARATORS)[0..-3]
-        TESTUNIT_RB_FILE = /\.rb\Z/
-
-        module_function
-        def filter_backtrace(backtrace, prefix=nil)
-          return ["No backtrace"] unless(backtrace)
-          split_p = if(prefix)
-            prefix.split(TESTUNIT_FILE_SEPARATORS)
-          else
-            TESTUNIT_PREFIX
-          end
-          match = proc do |e|
-            split_e = e.split(TESTUNIT_FILE_SEPARATORS)[0, split_p.size]
-            next false unless(split_e[0..-2] == split_p[0..-2])
-            split_e[-1].sub(TESTUNIT_RB_FILE, '') == split_p[-1]
-          end
-          return backtrace unless(backtrace.detect(&match))
-          found_prefix = false
-          new_backtrace = backtrace.reverse.reject do |e|
-            if(match[e])
-              found_prefix = true
-              true
-            elsif(found_prefix)
-              false
-            else
-              true
-            end
-          end.reverse
-          new_backtrace = (new_backtrace.empty? ? backtrace : new_backtrace)
-          new_backtrace = new_backtrace.reject(&match)
-          new_backtrace.empty? ? backtrace : new_backtrace
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/util/method-owner-finder.rb

@@ -1,28 +0,0 @@
-module Test
-  module Unit
-    module Util
-      module MethodOwnerFinder
-        module_function
-        def find(object, method_name)
-          method = object.method(method_name)
-          return method.owner if method.respond_to?(:owner)
-
-          if /\((.+?)\)\#/ =~ method.to_s
-            owner_name = $1
-            if /\A#</ =~ owner_name
-              ObjectSpace.each_object(Module) do |mod|
-                return mod if mod.to_s == owner_name
-              end
-            else
-              owner_name.split(/::/).inject(Object) do |parent, name|
-                parent.const_get(name)
-              end
-            end
-          else
-            object.class
-          end
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/util/observable.rb

@@ -1,90 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/util/procwrapper'
-
-module Test
-  module Unit
-    module Util
-
-      # This is a utility class that allows anything mixing
-      # it in to notify a set of listeners about interesting
-      # events.
-      module Observable
-        # We use this for defaults since nil might mean something
-        NOTHING = "NOTHING/#{__id__}"
-
-        # Adds the passed proc as a listener on the
-        # channel indicated by channel_name. listener_key
-        # is used to remove the listener later; if none is
-        # specified, the proc itself is used.
-        #
-        # Whatever is used as the listener_key is
-        # returned, making it very easy to use the proc
-        # itself as the listener_key:
-        #
-        #  listener = add_listener("Channel") { ... }
-        #  remove_listener("Channel", listener)
-        def add_listener(channel_name, listener_key=NOTHING, &listener) # :yields: value
-          unless(block_given?)
-            raise ArgumentError.new("No callback was passed as a listener")
-          end
-      
-          key = listener_key
-          if (listener_key == NOTHING)
-            listener_key = listener
-            key = ProcWrapper.new(listener)
-          end
-      
-          channels[channel_name] ||= {}
-          channels[channel_name][key] = listener
-          return listener_key
-        end
-
-        # Removes the listener indicated by listener_key
-        # from the channel indicated by
-        # channel_name. Returns the registered proc, or
-        # nil if none was found.
-        def remove_listener(channel_name, listener_key)
-          channel = channels[channel_name]
-          return nil unless (channel)
-          key = listener_key
-          if (listener_key.instance_of?(Proc))
-            key = ProcWrapper.new(listener_key)
-          end
-          if (channel.has_key?(key))
-            return channel.delete(key)
-          end
-          return nil
-        end
-
-        # Calls all the procs registered on the channel
-        # indicated by channel_name. If value is
-        # specified, it is passed in to the procs,
-        # otherwise they are called with no arguments.
-        #
-        #--
-        #
-        # Perhaps this should be private? Would it ever
-        # make sense for an external class to call this
-        # method directly?
-        def notify_listeners(channel_name, *arguments)
-          channel = channels[channel_name]
-          return 0 unless (channel)
-          listeners = channel.values
-          listeners.each { |listener| listener.call(*arguments) }
-          return listeners.size
-        end
-
-        private
-        def channels
-          @channels ||= {}
-          return @channels
-        end
-      end
-    end
-  end
-end