activeldap 1.0.0 → 1.0.1

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

@@ -0,0 +1,116 @@
+require 'test/unit/util/backtracefilter'
+
+module Test
+  module Unit
+    class Notification
+      include Util::BacktraceFilter
+      attr_reader :test_name, :location, :message
+
+      SINGLE_CHARACTER = 'N'
+      LABEL = "Notification"
+
+      # Creates a new Notification 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 notification.
+      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
+        backtrace = filter_backtrace(location).join("\n")
+        "#{label}: #{@message}\n#{@test_name}\n#{backtrace}"
+      end
+
+      # Overridden to return long_display.
+      def to_s
+        long_display
+      end
+    end
+
+    class NotifiedError < StandardError
+    end
+
+
+    module TestCaseNotificationSupport
+      class << self
+        def included(base)
+          base.class_eval do
+            include NotificationHandler
+          end
+        end
+      end
+
+      def notify(message, &block)
+        notification = Notification.new(name, filter_backtrace(caller), message)
+        add_notification(notification)
+      end
+
+      private
+      def add_notification(notification)
+        current_result.add_notification(notification)
+      end
+    end
+
+    module NotificationHandler
+      class << self
+        def included(base)
+          base.exception_handler(:handle_Notified_error)
+        end
+      end
+
+      private
+      def handle_Notified_error(exception)
+        return false unless exception.is_a?(NotifiedError)
+        notification = Notification.new(name,
+                                filter_backtrace(exception.backtrace),
+                                exception.message)
+        add_notification(notification)
+        true
+      end
+    end
+
+    module TestResultNotificationSupport
+      attr_reader :notifications
+
+      # Records a Test::Unit::Notification.
+      def add_notification(notification)
+        @notifications << notification
+        notify_fault(notification)
+        notify_changed
+      end
+
+      # Returns the number of notifications this TestResult has
+      # recorded.
+      def notification_count
+        @notifications.size
+      end
+
+      private
+      def initialize_containers
+        super
+        @notifications = []
+        @summary_generators << :notification_summary
+      end
+
+      def notification_summary
+        "#{notification_count} notifications"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+require 'test/unit/util/backtracefilter'
+
+module Test
+  module Unit
+    class Omission
+      include Util::BacktraceFilter
+      attr_reader :test_name, :location, :message
+
+      SINGLE_CHARACTER = 'O'
+      LABEL = "Omission"
+
+      # Creates a new Omission 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 omission.
+      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
+        backtrace = filter_backtrace(location).join("\n")
+        "#{label}: #{@message}\n#{@test_name}\n#{backtrace}"
+      end
+
+      # Overridden to return long_display.
+      def to_s
+        long_display
+      end
+    end
+
+    class OmittedError < StandardError
+    end
+
+
+    module TestCaseOmissionSupport
+      class << self
+        def included(base)
+          base.class_eval do
+            include OmissionHandler
+          end
+        end
+      end
+
+      def omit(message=nil, &block)
+        message ||= "omitted."
+        if block_given?
+          omission = Omission.new(name, filter_backtrace(caller), message)
+          add_omission(omission)
+        else
+          raise OmittedError.new(message)
+        end
+      end
+
+      def omit_if(condition, *args, &block)
+        omit(*args, &block) if condition
+      end
+
+      def omit_unless(condition, *args, &block)
+        omit(*args, &block) unless condition
+      end
+
+      private
+      def add_omission(omission)
+        current_result.add_omission(omission)
+      end
+    end
+
+    module OmissionHandler
+      class << self
+        def included(base)
+          base.exception_handler(:handle_omitted_error)
+        end
+      end
+
+      private
+      def handle_omitted_error(exception)
+        return false unless exception.is_a?(OmittedError)
+        omission = Omission.new(name,
+                                filter_backtrace(exception.backtrace),
+                                exception.message)
+        add_omission(omission)
+        true
+      end
+    end
+
+    module TestResultOmissionSupport
+      attr_reader :omissions
+
+      # Records a Test::Unit::Omission.
+      def add_omission(omission)
+        @omissions << omission
+        notify_fault(omission)
+        notify_changed
+      end
+
+      # Returns the number of omissions this TestResult has
+      # recorded.
+      def omission_count
+        @omissions.size
+      end
+
+      private
+      def initialize_containers
+        super
+        @omissions = []
+        @summary_generators << :omission_summary
+      end
+
+      def omission_summary
+        "#{omission_count} omissions"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+require 'test/unit/util/backtracefilter'
+
+module Test
+  module Unit
+    class Pending
+      include Util::BacktraceFilter
+      attr_reader :test_name, :location, :message
+
+      SINGLE_CHARACTER = 'P'
+      LABEL = "Pending"
+
+      # Creates a new Pending 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 pending.
+      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
+        backtrace = filter_backtrace(location).join("\n")
+        "#{label}: #{@message}\n#{@test_name}\n#{backtrace}"
+      end
+
+      # Overridden to return long_display.
+      def to_s
+        long_display
+      end
+    end
+
+    class PendedError < StandardError
+    end
+
+
+    module TestCasePendingSupport
+      class << self
+        def included(base)
+          base.class_eval do
+            include PendingHandler
+          end
+        end
+      end
+
+      def pend(message=nil, &block)
+        message ||= "pended."
+        if block_given?
+          pending = nil
+          begin
+            yield
+          rescue Exception
+            pending = Pending.new(name, filter_backtrace(caller), message)
+            add_pending(pending)
+          end
+          unless pending
+            flunk("Pending block should not be passed: #{message}")
+          end
+        else
+          raise PendedError.new(message)
+        end
+      end
+
+      private
+      def add_pending(pending)
+        problem_occurred
+        current_result.add_pending(pending)
+      end
+    end
+
+    module PendingHandler
+      class << self
+        def included(base)
+          base.exception_handler(:handle_pended_error)
+        end
+      end
+
+      private
+      def handle_pended_error(exception)
+        return false unless exception.is_a?(PendedError)
+        pending = Pending.new(name,
+                                filter_backtrace(exception.backtrace),
+                                exception.message)
+        add_pending(pending)
+        true
+      end
+    end
+
+    module TestResultPendingSupport
+      attr_reader :pendings
+
+      # Records a Test::Unit::Pending.
+      def add_pending(pending)
+        @pendings << pending
+        notify_fault(pending)
+        notify_changed
+      end
+
+      # Returns the number of pendings this TestResult has
+      # recorded.
+      def pending_count
+        @pendings.size
+      end
+
+      private
+      def initialize_containers
+        super
+        @pendings = []
+        @summary_generators << :pending_summary
+      end
+
+      def pending_summary
+        "#{pending_count} pendings"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+require "fileutils"
+require "tmpdir"
+
+module Test
+  module Unit
+    module Priority
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+
+          base.class_eval do
+            setup :priority_setup, :before => :prepend
+            teardown :priority_teardown, :after => :append
+          end
+        end
+      end
+
+      class Checker
+        class << self
+          def have_priority?(name)
+            singleton_class = (class << self; self; end)
+            singleton_class.method_defined?(priority_check_method_name(name))
+          end
+
+          def need_to_run?(test)
+            priority = test[:priority] || :normal
+            if have_priority?(priority)
+              send(priority_check_method_name(priority), test)
+            else
+              true
+            end
+          end
+
+          def run_priority_must?(test)
+            true
+          end
+
+          def run_priority_important?(test)
+            rand > 0.1
+          end
+
+          def run_priority_high?(test)
+            rand > 0.3
+          end
+
+          def run_priority_normal?(test)
+            rand > 0.5
+          end
+
+          def run_priority_low?(test)
+            rand > 0.75
+          end
+
+          def run_priority_never?(test)
+            false
+          end
+
+          private
+          def priority_check_method_name(priority_name)
+            "run_priority_#{priority_name}?"
+          end
+        end
+
+        attr_reader :test
+        def initialize(test)
+          @test = test
+        end
+
+        def setup
+          FileUtils.rm_f(passed_file)
+        end
+
+        def teardown
+          if @test.send(:passed?)
+            FileUtils.touch(passed_file)
+          else
+            FileUtils.rm_f(passed_file)
+          end
+        end
+
+        def need_to_run?
+          !previous_test_success? or self.class.need_to_run?(@test)
+        end
+
+        private
+        def previous_test_success?
+          File.exist?(passed_file)
+        end
+
+        def result_dir
+          components = [".test-result",
+                        @test.class.name || "AnonymousTestCase",
+                        @test.method_name.to_s]
+          parent_directories = [File.dirname($0), Dir.pwd]
+          if Process.respond_to?(:uid)
+            parent_directories << File.join(Dir.tmpdir, Process.uid.to_s)
+          end
+          parent_directories.each do |parent_directory|
+            dir = File.expand_path(File.join(parent_directory, *components))
+            begin
+              FileUtils.mkdir_p(dir)
+              return dir
+            rescue Errno::EACCES
+            end
+          end
+
+          raise Errno::EACCES, parent_directories.join(", ")
+        end
+
+        def passed_file
+          File.join(result_dir, "passed")
+        end
+
+        def escaped_method_name
+          @method_name.to_s.gsub(/[!?=]$/) do |matched|
+            case matched
+            when "!"
+              ".destructive"
+            when "?"
+              ".predicate"
+            when "="
+              ".equal"
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        def priority(name, *tests)
+          unless Checker.have_priority?(name)
+            raise ArgumentError, "unknown priority: #{name}"
+          end
+          attribute(:priority, name, {:keep => true}, *tests)
+        end
+      end
+
+      def priority_setup
+        Checker.new(self).setup
+      end
+
+      def priority_teardown
+        Checker.new(self).teardown
+      end
+    end
+  end
+end