cairo 1.8.5-x86-mingw32 → 1.10.0-x86-mingw32

data/test-unit/lib/test/unit/ui/console/outputlevel.rb

@@ -1,14 +0,0 @@
-module Test
-  module Unit
-    module UI
-      module Console
-        module OutputLevel
-          SILENT = 0
-          PROGRESS_ONLY = 1
-          NORMAL = 2
-          VERBOSE = 3
-        end
-      end
-    end
-  end
-end

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

@@ -1,195 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/color'
-require 'test/unit/ui/testrunner'
-require 'test/unit/ui/testrunnermediator'
-require 'test/unit/ui/console/outputlevel'
-
-module Test
-  module Unit
-    module UI
-      module Console
-
-        # Runs a Test::Unit::TestSuite on the console.
-        class TestRunner < UI::TestRunner
-          include OutputLevel
-
-          COLOR_SCHEMES = {
-            :default => {
-              "success" => Color.new("green", :bold => true),
-              "failure" => Color.new("red", :bold => true),
-              "pending" => Color.new("magenta", :bold => true),
-              "omission" => Color.new("blue", :bold => true),
-              "notification" => Color.new("cyan", :bold => true),
-              "error" => Color.new("yellow", :bold => true),
-            },
-          }
-
-          # Creates a new TestRunner for running the passed
-          # suite. If quiet_mode is true, the output while
-          # running is limited to progress dots, errors and
-          # failures, and the final result. io specifies
-          # where runner output should go to; defaults to
-          # STDOUT.
-          def initialize(suite, options={})
-            super
-            @output_level = @options[:output_level] || NORMAL
-            @output = @options[:output] || STDOUT
-            @use_color = @options[:use_color]
-            @use_color = guess_color_availability if @use_color.nil?
-            @color_scheme = COLOR_SCHEMES[:default]
-            @reset_color = Color.new("reset")
-            @already_outputted = false
-            @faults = []
-          end
-
-          # Begins the test run.
-          def start
-            setup_mediator
-            attach_to_mediator
-            return start_mediator
-          end
-
-          private
-          def setup_mediator
-            @mediator = create_mediator(@suite)
-            output_setup_end
-          end
-
-          def output_setup_end
-            suite_name = @suite.to_s
-            suite_name = @suite.name if @suite.kind_of?(Module)
-            output("Loaded suite #{suite_name}")
-          end
-
-          def create_mediator(suite)
-            return TestRunnerMediator.new(suite)
-          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
-            return @mediator.run_suite
-          end
-          
-          def add_fault(fault)
-            @faults << fault
-            output_single(fault.single_character_display,
-                          fault_color(fault),
-                          PROGRESS_ONLY)
-            @already_outputted = true
-          end
-          
-          def started(result)
-            @result = result
-            output_started
-          end
-
-          def output_started
-            output("Started")
-          end
-
-          def finished(elapsed_time)
-            nl if output?(NORMAL) and !output?(VERBOSE)
-            nl
-            output("Finished in #{elapsed_time} seconds.")
-            @faults.each_with_index do |fault, index|
-              nl
-              output_single("%3d) " % (index + 1))
-              label, detail = format_fault(fault).split(/\r?\n/, 2)
-              output(label, fault_color(fault))
-              output(detail)
-            end
-            nl
-            output(@result, result_color)
-          end
-
-          def format_fault(fault)
-            fault.long_display
-          end
-          
-          def test_started(name)
-            output_single(name + ": ", nil, VERBOSE)
-          end
-          
-          def test_finished(name)
-            unless @already_outputted
-              output_single(".", @color_scheme["success"], PROGRESS_ONLY)
-            end
-            nl(VERBOSE)
-            @already_outputted = false
-          end
-          
-          def nl(level=NORMAL)
-            output("", nil, level)
-          end
-          
-          def output(something, color=nil, level=NORMAL)
-            return unless output?(level)
-            output_single(something, color, level)
-            @output.puts
-          end
-          
-          def output_single(something, color=nil, level=NORMAL)
-            return unless output?(level)
-            if @use_color and color
-              something = "%s%s%s" % [color.escape_sequence,
-                                      something,
-                                      @reset_color.escape_sequence]
-            end
-            @output.write(something)
-            @output.flush
-          end
-          
-          def output?(level)
-            level <= @output_level
-          end
-
-          def fault_color(fault)
-            @color_scheme[fault.class.name.split(/::/).last.downcase]
-          end
-
-          def result_color
-            if @result.passed?
-              if @result.pending_count > 0
-                @color_scheme["pending"]
-              elsif @result.omission_count > 0
-                @color_scheme["omission"]
-              elsif @result.notification_count > 0
-                @color_scheme["notification"]
-              else
-                @color_scheme["success"]
-              end
-            elsif @result.error_count > 0
-              @color_scheme["error"]
-            elsif @result.failure_count > 0
-              @color_scheme["failure"]
-            end
-          end
-
-          def guess_color_availability
-            return false unless @output.tty?
-            term = ENV["TERM"]
-            return true if term and (/term\z/ =~ term or term == "screen")
-            return true if ENV["EMACS"] == "t"
-            false
-          end
-        end
-      end
-    end
-  end
-end
-
-if __FILE__ == $0
-  Test::Unit::UI::Console::TestRunner.start_command_line_test
-end

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

@@ -1,20 +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
-      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/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