activeldap 1.0.0 → 1.0.1

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

@@ -0,0 +1,124 @@
+#--
+#
+# 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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,110 @@
+#--
+#
+# 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

@@ -0,0 +1,185 @@
+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
+              []
+            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