activeldap 1.0.0 → 1.0.1

data/test-unit-ext/lib/test-unit-ext/long-display-for-emacs.rb

@@ -1,25 +0,0 @@
-require 'test/unit/failure'
-require 'test/unit/error'
-
-module Test
-  module Unit
-    BACKTRACE_INFO_RE = /.+:\d+:in `.+?'/
-    class Failure
-      alias_method :original_long_display, :long_display
-      def long_display
-        extract_backtraces_re =
-          /^    \[(#{BACKTRACE_INFO_RE}(?:\n     #{BACKTRACE_INFO_RE})+)\]:$/
-        original_long_display.gsub(extract_backtraces_re) do |backtraces|
-          $1.gsub(/^     (#{BACKTRACE_INFO_RE})/, '\1') + ':'
-        end
-      end
-    end
-
-    class Error
-      alias_method :original_long_display, :long_display
-      def long_display
-        original_long_display.gsub(/^    (#{BACKTRACE_INFO_RE})/, '\1')
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-module Test
-  module Unit
-    class TestResult
-      attr_reader :notifications
-
-      alias_method(:initialize_without_notifications, :initialize)
-      def initialize
-        initialize_without_notifications
-        @notifications = []
-      end
-
-      def add_notification(notification)
-        @notifications << notification
-        notify_listeners(FAULT, notification)
-        notify_listeners(CHANGED, self)
-      end
-
-      def notification_count
-        @notifications.size
-      end
-
-      alias_method(:to_s_without_notifications, :to_s)
-      def to_s
-        to_s_without_notifications + ", #{notification_count} notifications"
-      end
-    end
-
-    class Notification
-      include Util::BacktraceFilter
-      attr_reader :test_name, :location, :message
-      
-      SINGLE_CHARACTER = 'N'
-
-      # 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
-
-      # 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
-        location_display = filter_backtrace(location)[0]
-        location_display = location_display.sub(/\A(.+:\d+).*/, ' [\\1]')
-        "Notification:\n#{@test_name}#{location_display}:\n#{@message}"
-      end
-
-      # Overridden to return long_display.
-      def to_s
-        long_display
-      end
-    end
-
-    class NotifiedError < StandardError
-    end
-
-    module AssertionsWithNotify
-      def notify(message)
-        notification = Notification.new(name, caller[0, 1], message)
-        @_result.add_notification(notification)
-      end
-    end
-
-    class TestCase
-      include AssertionsWithNotify
-    end
-  end
-end

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

@@ -1,96 +0,0 @@
-module Test
-  module Unit
-    class TestResult
-      attr_reader :omissions
-
-      alias_method(:initialize_without_omissions, :initialize)
-      def initialize
-        initialize_without_omissions
-        @omissions = []
-      end
-
-      def add_omission(omission)
-        @omissions << omission
-        notify_listeners(FAULT, omission)
-        notify_listeners(CHANGED, self)
-      end
-
-      def omission_count
-        @omissions.size
-      end
-
-      alias_method(:to_s_without_omissions, :to_s)
-      def to_s
-        to_s_without_omissions + ", #{omission_count} omissions"
-      end
-    end
-
-    class Omission
-      include Util::BacktraceFilter
-      attr_reader :test_name, :location, :message
-      
-      SINGLE_CHARACTER = 'O'
-
-      # 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
-
-      # 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")
-        "Omission:\n#{@test_name}\n#{@message}\n#{backtrace}"
-      end
-
-      # Overridden to return long_display.
-      def to_s
-        long_display
-      end
-    end
-
-    class OmittedError < StandardError
-    end
-
-    module AssertionsWithOmit
-      def omit(message="Omitted", &block)
-        if block_given?
-          begin
-            yield
-          rescue Exception
-            raise OmittedError, message, $!.backtrace
-          end
-          flunk("Omission block should not be passed: #{message}")
-        else
-          raise OmittedError.new(message)
-        end
-      end
-    end
-
-    class TestCase
-      include AssertionsWithOmit
-
-      alias_method(:add_error_without_omission, :add_error)
-      def add_error(exception)
-        if exception.is_a?(OmittedError)
-          omission = Omission.new(name, exception.backtrace, exception.message)
-          @_result.add_omission(omission)
-        else
-          add_error_without_omission(exception)
-        end
-      end
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-module Test
-  module Unit
-    class TestResult
-      attr_reader :pendings
-
-      alias_method(:initialize_without_pendings, :initialize)
-      def initialize
-        initialize_without_pendings
-        @pendings = []
-      end
-
-      def add_pending(pending)
-        @pendings << pending
-        notify_listeners(FAULT, pending)
-        notify_listeners(CHANGED, self)
-      end
-
-      def pending_count
-        @pendings.size
-      end
-
-      alias_method(:to_s_without_pendings, :to_s)
-      def to_s
-        to_s_without_pendings + ", #{pending_count} pendings"
-      end
-    end
-
-    class Pending
-      include Util::BacktraceFilter
-      attr_reader :test_name, :location, :message
-      
-      SINGLE_CHARACTER = 'P'
-
-      # 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
-
-      # 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
-        location_display = filter_backtrace(location)[0]
-        location_display = location_display.sub(/\A(.+:\d+).*/, ' [\\1]')
-        "Pending:\n#{@test_name}#{location_display}:\n#{@message}"
-      end
-
-      # Overridden to return long_display.
-      def to_s
-        long_display
-      end
-    end
-
-    class PendedError < StandardError
-    end
-
-    module AssertionsWithPend
-      def pend(message="Pended", &block)
-        if block_given?
-          begin
-            yield
-          rescue Exception
-            raise PendedError, message, $!.backtrace
-          end
-          flunk("Pending block should not be passed: #{message}")
-        else
-          raise PendedError.new(message)
-        end
-      end
-    end
-
-    class TestCase
-      include AssertionsWithPend
-
-      alias_method(:add_error_without_pending, :add_error)
-      def add_error(exception)
-        if exception.is_a?(PendedError)
-          pending = Pending.new(name, exception.backtrace, exception.message)
-          @_result.add_pending(pending)
-        else
-          add_error_without_pending(exception)
-        end
-      end
-    end
-  end
-end

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

@@ -1,158 +0,0 @@
-require "test/unit"
-
-require "fileutils"
-require "tmpdir"
-
-require "test-unit-ext/attributes"
-
-module Test
-  module Unit
-    class TestCase
-      class << self
-        def priority(name, *tests)
-          singleton_class = (class << self; self; end)
-          priority_check_method = priority_check_method_name(name)
-          unless singleton_class.private_method_defined?(priority_check_method)
-            raise ArgumentError, "unknown priority: #{name}"
-          end
-          attribute(:priority, name, {:keep => true}, *tests)
-        end
-
-        def need_to_run?(test_name)
-          priority = (attributes(test_name) || {})[:priority] || :normal
-          __send__(priority_check_method_name(priority), test_name)
-        end
-
-        private
-        def priority_check_method_name(priority_name)
-          "run_priority_#{priority_name}?"
-        end
-
-        def set_priority(name, priority=@current_priority)
-          @priority_table[normalize_test_name(name)] = priority
-        end
-
-        def run_priority_must?(test_name)
-          true
-        end
-
-        def run_priority_important?(test_name)
-          rand > 0.1
-        end
-
-        def run_priority_high?(test_name)
-          rand > 0.3
-        end
-
-        def run_priority_normal?(test_name)
-          rand > 0.5
-        end
-
-        def run_priority_low?(test_name)
-          rand > 0.75
-        end
-
-        def run_priority_never?(test_name)
-          false
-        end
-      end
-
-      def need_to_run?
-        !previous_test_success? or self.class.need_to_run?(@method_name)
-      end
-
-      alias_method :run_without_priority, :run
-      def run(result, &block)
-        run_without_priority(result, &block)
-      ensure
-        if passed?
-          FileUtils.touch(passed_file)
-        else
-          FileUtils.rm_f(passed_file)
-        end
-      end
-
-      private
-      def previous_test_success?
-        File.exist?(passed_file)
-      end
-
-      def result_dir
-        components = [".test-result", self.class.name, @method_name.to_s]
-        parent_directories = [File.dirname($0),
-                              File.join(File.dirname(__FILE__), ".."),
-                              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"
-          end
-        end
-      end
-    end
-
-    class TestSuite
-      @@priority_mode = false
-
-      class << self
-        def priority_mode=(bool)
-          @@priority_mode = bool
-        end
-      end
-
-      alias_method :run_without_priority_support, :run
-      def run(*args, &block)
-        priority_mode = @@priority_mode
-        if priority_mode
-          @original_tests = @tests
-          apply_priority
-        end
-        run_without_priority_support(*args, &block)
-      ensure
-        @tests = @original_tests if priority_mode
-      end
-
-      def apply_priority
-        @tests = @tests.reject {|test| !test.need_to_run?}
-      end
-
-      def need_to_run?
-        apply_priority
-        !@tests.empty?
-      end
-    end
-
-    class AutoRunner
-      alias_method :options_without_priority, :options
-      def options
-        opts = options_without_priority
-        opts.on("--[no-]priority", "use priority mode") do |bool|
-          TestSuite.priority_mode = bool
-        end
-        opts
-      end
-    end
-  end
-end