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

data/test-unit/lib/test/unit/error.rb

@@ -1,124 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/util/backtracefilter'
-
-module Test
-  module Unit
-
-    # Encapsulates an error in a test. Created by
-    # Test::Unit::TestCase when it rescues an exception thrown
-    # during the processing of a test.
-    class Error
-      include Util::BacktraceFilter
-
-      attr_reader(:test_name, :exception)
-
-      SINGLE_CHARACTER = 'E'
-      LABEL = "Error"
-
-      # Creates a new Error with the given test_name and
-      # exception.
-      def initialize(test_name, exception)
-        @test_name = test_name
-        @exception = exception
-      end
-
-      # Returns a single character representation of an error.
-      def single_character_display
-        SINGLE_CHARACTER
-      end
-
-      def label
-        LABEL
-      end
-
-      # Returns the message associated with the error.
-      def message
-        "#{@exception.class.name}: #{@exception.message}"
-      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_display = backtrace.join("\n    ")
-        "#{label}:\n#@test_name:\n#{message}\n    #{backtrace_display}"
-      end
-
-      def backtrace
-        filter_backtrace(@exception.backtrace)
-      end
-
-      # Overridden to return long_display.
-      def to_s
-        long_display
-      end
-    end
-
-    module ErrorHandler
-      class << self
-        def included(base)
-          base.exception_handler(:handle_all_exception)
-        end
-      end
-
-      PASS_THROUGH_EXCEPTIONS = [NoMemoryError, SignalException, Interrupt,
-                                 SystemExit]
-      private
-      def handle_all_exception(exception)
-        case exception
-        when *PASS_THROUGH_EXCEPTIONS
-          false
-        else
-          problem_occurred
-          add_error(exception)
-          true
-        end
-      end
-
-      def add_error(exception)
-        current_result.add_error(Error.new(name, exception))
-      end
-    end
-
-    module TestResultErrorSupport
-      attr_reader :errors
-
-      # Records a Test::Unit::Error.
-      def add_error(error)
-        @errors << error
-        notify_fault(error)
-        notify_changed
-      end
-
-      # Returns the number of errors this TestResult has
-      # recorded.
-      def error_count
-        @errors.size
-      end
-
-      def error_occurred?
-        not @errors.empty?
-      end
-
-      private
-      def initialize_containers
-        super
-        @errors = []
-        @summary_generators << :error_summary
-        @problem_checkers << :error_occurred?
-      end
-
-      def error_summary
-        "#{error_count} errors"
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/exceptionhandler.rb

@@ -1,39 +0,0 @@
-module Test
-  module Unit
-    module ExceptionHandler
-      @@exception_handlers = []
-      class << self
-        def exception_handlers
-          @@exception_handlers
-	end
-
-        def included(base)
-          base.extend(ClassMethods)
-
-          observer = Proc.new do |test_case, _, _, value, method_name|
-            if value
-              @@exception_handlers.unshift(method_name)
-            else
-              @@exception_handlers -= [method_name]
-            end
-          end
-          base.register_attribute_observer(:exception_handler, &observer)
-        end
-      end
-
-      module ClassMethods
-        def exception_handlers
-          ExceptionHandler.exception_handlers
-        end
-
-        def exception_handler(*method_names)
-          attribute(:exception_handler, true, *method_names)
-        end
-
-        def unregister_exception_handler(*method_names)
-          attribute(:exception_handler, false, *method_names)
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/failure.rb

@@ -1,110 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-module Test
-  module Unit
-
-    # Encapsulates a test failure. Created by Test::Unit::TestCase
-    # when an assertion fails.
-    class Failure
-      attr_reader :test_name, :location, :message
-      
-      SINGLE_CHARACTER = 'F'
-      LABEL = "Failure"
-
-      # Creates a new Failure with the given location and
-      # message.
-      def initialize(test_name, location, message)
-        @test_name = test_name
-        @location = location
-        @message = message
-      end
-      
-      # Returns a single character representation of a failure.
-      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
-        if location.size == 1
-          location_display = location[0].sub(/\A(.+:\d+).*/, ' [\\1]')
-        else
-          location_display = "\n    [#{location.join("\n     ")}]"
-        end
-        "#{label}:\n#@test_name#{location_display}:\n#@message"
-      end
-
-      # Overridden to return long_display.
-      def to_s
-        long_display
-      end
-    end
-
-    module FailureHandler
-      class << self
-        def included(base)
-          base.exception_handler(:handle_assertion_failed_error)
-        end
-      end
-
-      private
-      def handle_assertion_failed_error(exception)
-        return false unless exception.is_a?(AssertionFailedError)
-        problem_occurred
-        add_failure(exception.message, exception.backtrace)
-        true
-      end
-
-      def add_failure(message, backtrace)
-        failure = Failure.new(name, filter_backtrace(backtrace), message)
-        current_result.add_failure(failure)
-      end
-    end
-
-    module TestResultFailureSupport
-      attr_reader :failures
-
-      # Records a Test::Unit::Failure.
-      def add_failure(failure)
-        @failures << failure
-        notify_fault(failure)
-        notify_changed
-      end
-
-      # Returns the number of failures this TestResult has
-      # recorded.
-      def failure_count
-        @failures.size
-      end
-
-      def failure_occurred?
-        not @failures.empty?
-      end
-
-      private
-      def initialize_containers
-        super
-        @failures = []
-        @summary_generators << :failure_summary
-        @problem_checkers << :failure_occurred?
-      end
-
-      def failure_summary
-        "#{failure_count} failures"
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/fixture.rb

@@ -1,185 +0,0 @@
-module Test
-  module Unit
-    module Fixture
-      class << self
-        def included(base)
-          base.extend(ClassMethods)
-
-          [:setup, :teardown].each do |fixture|
-            observer = Proc.new do |test_case, _, _, value, method_name|
-              if value.nil?
-                test_case.send("unregister_#{fixture}_method", method_name)
-              else
-                test_case.send("register_#{fixture}_method", method_name,
-                               value)
-              end
-            end
-            base.register_attribute_observer(fixture, &observer)
-          end
-        end
-      end
-
-      module ClassMethods
-        def setup(*method_names)
-          register_fixture(:setup, *method_names)
-        end
-
-        def unregister_setup(*method_names)
-          unregister_fixture(:setup, *method_names)
-        end
-
-        def teardown(*method_names)
-          register_fixture(:teardown, *method_names)
-        end
-
-        def unregister_teardown(*method_names)
-          unregister_fixture(:teardown, *method_names)
-        end
-
-        def register_setup_method(method_name, options)
-          register_fixture_method(:setup, method_name, options, :after, :append)
-        end
-
-        def unregister_setup_method(method_name)
-          unregister_fixture_method(:setup, method_name)
-        end
-
-        def register_teardown_method(method_name, options)
-          register_fixture_method(:teardown, method_name, options,
-                                  :before, :prepend)
-        end
-
-        def unregister_teardown_method(method_name)
-          unregister_fixture_method(:teardown, method_name)
-        end
-
-        def before_setup_methods
-          collect_fixture_methods(:setup, :before)
-        end
-
-        def after_setup_methods
-          collect_fixture_methods(:setup, :after)
-        end
-
-        def before_teardown_methods
-          collect_fixture_methods(:teardown, :before)
-        end
-
-        def after_teardown_methods
-          collect_fixture_methods(:teardown, :after)
-        end
-
-        private
-        def register_fixture(fixture, *method_names)
-          options = {}
-          options = method_names.pop if method_names.last.is_a?(Hash)
-          attribute(fixture, options, *method_names)
-        end
-
-        def unregister_fixture(fixture, *method_names)
-          attribute(fixture, nil, *method_names)
-        end
-
-        def valid_register_fixture_options?(options)
-          return true if options.empty?
-          return false if options.size > 1
-
-          key = options.keys.first
-          [:before, :after].include?(key) and
-            [:prepend, :append].include?(options[key])
-        end
-
-        def add_fixture_method_name(how, variable_name, method_name)
-          unless self.instance_variable_defined?(variable_name)
-            self.instance_variable_set(variable_name, [])
-          end
-          methods = self.instance_variable_get(variable_name)
-
-          if how == :prepend
-            methods = [method_name] | methods
-          else
-            methods = methods | [method_name]
-          end
-          self.instance_variable_set(variable_name, methods)
-        end
-
-        def registered_methods_variable_name(fixture, order)
-          "@#{order}_#{fixture}_methods"
-        end
-
-        def unregistered_methods_variable_name(fixture)
-          "@unregistered_#{fixture}_methods"
-        end
-
-        def register_fixture_method(fixture, method_name, options,
-                                    default_order, default_how)
-          unless valid_register_fixture_options?(options)
-            message = "must be {:before => :prepend}, " +
-              "{:before => :append}, {:after => :prepend} or " +
-              "{:after => :append}: #{options.inspect}"
-            raise ArgumentError, message
-          end
-
-          if options.empty?
-            order, how = default_order, default_how
-          else
-            order, how = options.to_a.first
-          end
-          variable_name = registered_methods_variable_name(fixture, order)
-          add_fixture_method_name(how, variable_name, method_name)
-        end
-
-        def unregister_fixture_method(fixture, method_name)
-          variable_name = unregistered_methods_variable_name(fixture)
-          add_fixture_method_name(:append, variable_name, method_name)
-        end
-
-        def collect_fixture_methods(fixture, order)
-          methods_variable = registered_methods_variable_name(fixture, order)
-          unregistered_methods_variable =
-            unregistered_methods_variable_name(fixture)
-
-          base_index = ancestors.index(Fixture)
-          interested_ancestors = ancestors[0, base_index].reverse
-          interested_ancestors.inject([]) do |result, ancestor|
-            if ancestor.is_a?(Class)
-              ancestor.class_eval do
-                methods = []
-                unregistered_methods = []
-                if instance_variable_defined?(methods_variable)
-                  methods = instance_variable_get(methods_variable)
-                end
-                if instance_variable_defined?(unregistered_methods_variable)
-                  unregistered_methods =
-                    instance_variable_get(unregistered_methods_variable)
-                end
-                (result | methods) - unregistered_methods
-              end
-            else
-              result
-            end
-          end
-        end
-      end
-
-      private
-      def run_fixture(fixture)
-        [
-         self.class.send("before_#{fixture}_methods"),
-         fixture,
-         self.class.send("after_#{fixture}_methods")
-        ].flatten.each do |method_name|
-          send(method_name) if respond_to?(method_name, true)
-        end
-      end
-
-      def run_setup
-        run_fixture(:setup)
-      end
-
-      def run_teardown
-        run_fixture(:teardown)
-      end
-    end
-  end
-end