activesambaldap 0.0.6 → 0.0.7

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

@@ -1,7 +1,9 @@
 #--
 #
 # Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+# Copyright::
+#   * Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+#   * Copyright (c) 2008-2009 Kouhei Sutou <tt><kou@clear-code.com></tt>
 # License:: Ruby license.
 
 require 'test/unit/attribute'
@@ -17,6 +19,7 @@ require 'test/unit/priority'
 require 'test/unit/testsuite'
 require 'test/unit/assertionfailederror'
 require 'test/unit/util/backtracefilter'
+require 'test/unit/util/method-owner-finder'
 
 module Test
   module Unit
@@ -26,6 +29,47 @@ module Test
     # wrapping those tests into a suite. It also does the
     # nitty-gritty of actually running an individual test and
     # collecting its results into a Test::Unit::TestResult object.
+    #
+    # You can run two hooks before/after a TestCase run.
+    #
+    # Example:
+    #   class TestMyClass < Test::Unit::TestCase
+    #     class << self
+    #       def startup
+    #         ...
+    #       end
+    #
+    #       def shutdown
+    #         ...
+    #       end
+    #     end
+    #
+    #     def setup
+    #       ...
+    #     end
+    #
+    #     def teardown
+    #       ...
+    #     end
+    #
+    #     def test_my_method1
+    #       ...
+    #     end
+    #
+    #     def test_my_method2
+    #       ...
+    #     end
+    #   end
+    #
+    # Here is a call order:
+    # * startup
+    # * setup
+    # * test_my_method1
+    # * teardown
+    # * setup
+    # * test_my_method2
+    # * teardown
+    # * shutdown
     class TestCase
       include Attribute
       include Fixture
@@ -39,24 +83,29 @@ module Test
       include Assertions
       include Util::BacktraceFilter
 
-      STARTED = name + "::STARTED"
-      FINISHED = name + "::FINISHED"
+      STARTED = name + "::STARTED" # :nodoc:
+      FINISHED = name + "::FINISHED" # :nodoc:
 
-      DESCENDANTS = []
+      DESCENDANTS = [] # :nodoc:
+      AVAILABLE_ORDERS = [:alphabetic, :random, :defined] # :nodoc:
 
       class << self
-        def inherited(sub_class)
+        def inherited(sub_class) # :nodoc:
           DESCENDANTS << sub_class
         end
 
+        @@added_methods = []
+        def method_added(name) # :nodoc:
+          super
+          @@added_methods << name.to_s
+        end
+
         # Rolls up all of the test* methods in the fixture into
         # one suite, creating a new instance of the fixture for
         # each method.
         def suite
-          method_names = public_instance_methods(true).collect {|name| name.to_s}
-          tests = method_names.delete_if {|method_name| method_name !~ /^test./}
           suite = TestSuite.new(name, self)
-          tests.sort.each do |test|
+          collect_test_names.each do |test|
             catch(:invalid_test) do
               suite << new(test)
             end
@@ -68,6 +117,137 @@ module Test
           end
           suite
         end
+
+        # Called before every test case runs. Can be used
+        # to set up fixture information used in test case
+        # scope.
+        #
+        # Here is an example test case:
+        #   class TestMyClass < Test::Unit::TestCase
+        #     class << self
+        #       def startup
+        #         ...
+        #       end
+        #     end
+        #
+        #     def setup
+        #       ...
+        #     end
+        #
+        #     def test_my_class1
+        #       ...
+        #     end
+        #
+        #     def test_my_class2
+        #       ...
+        #     end
+        #   end
+        #
+        # Here is a call order:
+        # * startup
+        # * setup
+        # * test_my_class1 (or test_my_class2)
+        # * setup
+        # * test_my_class2 (or test_my_class1)
+        #
+        # Note that you should not assume test order. Tests
+        # should be worked in any order.
+        def startup
+        end
+
+        # Called after every test case runs. Can be used to tear
+        # down fixture information used in test case scope.
+        #
+        # Here is an example test case:
+        #   class TestMyClass < Test::Unit::TestCase
+        #     class << self
+        #       def shutdown
+        #         ...
+        #       end
+        #     end
+        #
+        #     def teardown
+        #       ...
+        #     end
+        #
+        #     def test_my_class1
+        #       ...
+        #     end
+        #
+        #     def test_my_class2
+        #       ...
+        #     end
+        #   end
+        #
+        # Here is a call order:
+        # * test_my_class1 (or test_my_class2)
+        # * teardown
+        # * test_my_class2 (or test_my_class1)
+        # * teardown
+        # * shutdown
+        #
+        # Note that you should not assume test order. Tests
+        # should be worked in any order.
+        def shutdown
+        end
+
+        @@test_order = AVAILABLE_ORDERS.first
+
+        # Returns the current test order. This returns
+        # +:alphabetic+ by default.
+        def test_order
+          @@test_order
+        end
+
+        # Sets the current test order.
+        #
+        # Here are the available _order_:
+        # [:alphabetic]
+        #   Default. Tests are sorted in alphabetic order.
+        # [:random]
+        #   Tests are sorted in random order.
+        # [:defined]
+        #   Tests are sorted in defined order.
+        def test_order=(order)
+          @@test_order = order
+        end
+
+        # :stopdoc:
+        private
+        def collect_test_names
+          method_names = public_instance_methods(true).collect do |name|
+            name.to_s
+          end
+          test_names = method_names.find_all do |method_name|
+            method_name =~ /^test./
+          end
+          send("sort_test_names_in_#{test_order}_order", test_names)
+        end
+
+        def sort_test_names_in_alphabetic_order(test_names)
+          test_names.sort
+        end
+
+        def sort_test_names_in_random_order(test_names)
+          test_names.sort_by {rand(test_names.size)}
+        end
+
+        def sort_test_names_in_defined_order(test_names)
+          test_names.sort do |test1, test2|
+            test1_defined_order = @@added_methods.index(test1)
+            test2_defined_order = @@added_methods.index(test2)
+            if test1_defined_order and test2_defined_order
+              test1_defined_order <=> test2_defined_order
+            elsif test1_defined_order
+              1
+            elsif test2_defined_order
+              -1
+            else
+              test1 <=> test2
+            end
+          end
+        end
+        # :startdoc:
       end
 
       attr_reader :method_name
@@ -76,9 +256,15 @@ module Test
       # test represented by test_method_name.
       def initialize(test_method_name)
         throw :invalid_test unless respond_to?(test_method_name)
-        throw :invalid_test if method(test_method_name).arity > 0
+        test_method = method(test_method_name)
+        throw :invalid_test if test_method.arity > 0
+        owner = Util::MethodOwnerFinder.find(self, test_method_name)
+        if owner.class != Module and self.class != owner
+          throw :invalid_test
+        end
         @method_name = test_method_name
         @test_passed = true
+        @interrupted = false
       end
 
       # Runs the individual test method represented by this
@@ -90,8 +276,9 @@ module Test
           yield(STARTED, name)
           begin
             run_setup
-            __send__(@method_name)
+            run_test
           rescue Exception
+            @interrupted = true
             raise unless handle_exception($!)
           ensure
             begin
@@ -103,20 +290,76 @@ module Test
           result.add_run
           yield(FINISHED, name)
         ensure
-          @_result = nil
+          # @_result = nil # For test-spec's after_all :<
         end
       end
 
       # Called before every test method runs. Can be used
       # to set up fixture information.
+      #
+      # You can add additional setup tasks by the following
+      # code:
+      #   class TestMyClass < Test::Unit::TestCase
+      #     def setup
+      #       ...
+      #     end
+      #
+      #     setup
+      #     def my_setup1
+      #       ...
+      #     end
+      #
+      #     setup
+      #     def my_setup2
+      #       ...
+      #     end
+      #
+      #     def test_my_class
+      #       ...
+      #     end
+      #   end
+      #
+      # Here is a call order:
+      # * setup
+      # * my_setup1
+      # * my_setup2
+      # * test_my_class
       def setup
       end
 
       # Called after every test method runs. Can be used to tear
       # down fixture information.
+      #
+      # You can add additional teardown tasks by the following
+      # code:
+      #   class TestMyClass < Test::Unit::TestCase
+      #     def teardown
+      #       ...
+      #     end
+      #
+      #     teardown
+      #     def my_teardown1
+      #       ...
+      #     end
+      #
+      #     teardown
+      #     def my_teardown2
+      #       ...
+      #     end
+      #
+      #     def test_my_class
+      #       ...
+      #     end
+      #   end
+      #
+      # Here is a call order:
+      # * test_my_class
+      # * my_teardown2
+      # * my_teardown1
+      # * teardown
       def teardown
       end
-      
+
       def default_test
         flunk("No tests were specified")
       end
@@ -143,11 +386,19 @@ module Test
         self.class == other.class
       end
 
+      def interrupted?
+        @interrupted
+      end
+
       private
       def current_result
         @_result
       end
 
+      def run_test
+        __send__(@method_name)
+      end
+
       def handle_exception(exception)
         self.class.exception_handlers.each do |handler|
           return true if send(handler, exception)

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

@@ -4,7 +4,7 @@
 # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
 # License:: Ruby license.
 
-require 'test/unit/color'
+require 'test/unit/color-scheme'
 require 'test/unit/ui/testrunner'
 require 'test/unit/ui/testrunnermediator'
 require 'test/unit/ui/console/outputlevel'
@@ -18,17 +18,6 @@ module Test
         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
@@ -41,8 +30,11 @@ module Test
             @output = @options[:output] || STDOUT
             @use_color = @options[:use_color]
             @use_color = guess_color_availability if @use_color.nil?
-            @color_scheme = COLOR_SCHEMES[:default]
+            @color_scheme = @options[:color_scheme] || ColorScheme.default
             @reset_color = Color.new("reset")
+            @progress_row = 0
+            @progress_row_max = @options[:progress_row_max]
+            @progress_row_max ||= guess_progress_row_max
             @already_outputted = false
             @faults = []
           end
@@ -84,9 +76,7 @@ module Test
           
           def add_fault(fault)
             @faults << fault
-            output_single(fault.single_character_display,
-                          fault_color(fault),
-                          PROGRESS_ONLY)
+            output_progress(fault.single_character_display, fault_color(fault))
             @already_outputted = true
           end
           
@@ -124,7 +114,7 @@ module Test
           
           def test_finished(name)
             unless @already_outputted
-              output_single(".", @color_scheme["success"], PROGRESS_ONLY)
+              output_progress(".", color("success"))
             end
             nl(VERBOSE)
             @already_outputted = false
@@ -141,7 +131,7 @@ module Test
           end
           
           def output_single(something, color=nil, level=NORMAL)
-            return unless output?(level)
+            return false unless output?(level)
             if @use_color and color
               something = "%s%s%s" % [color.escape_sequence,
                                       something,
@@ -149,40 +139,78 @@ module Test
             end
             @output.write(something)
             @output.flush
+            true
           end
-          
+
+          def output_progress(mark, color=nil)
+            if output_single(mark, color, PROGRESS_ONLY)
+              return unless @progress_row_max > 0
+              @progress_row += mark.size
+              if @progress_row >= @progress_row_max
+                nl unless @output_level == VERBOSE
+                @progress_row = 0
+              end
+            end
+          end
+
           def output?(level)
             level <= @output_level
           end
 
+          def color(name)
+            @color_scheme[name] || ColorScheme.default[name]
+          end
+
           def fault_color(fault)
-            @color_scheme[fault.class.name.split(/::/).last.downcase]
+            color(fault.class.name.split(/::/).last.downcase)
           end
 
           def result_color
             if @result.passed?
               if @result.pending_count > 0
-                @color_scheme["pending"]
+                color("pending")
               elsif @result.omission_count > 0
-                @color_scheme["omission"]
+                color("omission")
               elsif @result.notification_count > 0
-                @color_scheme["notification"]
+                color("notification")
               else
-                @color_scheme["success"]
+                color("success")
               end
             elsif @result.error_count > 0
-              @color_scheme["error"]
+              color("error")
             elsif @result.failure_count > 0
-              @color_scheme["failure"]
+              color("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
+            case ENV["TERM"]
+            when /term(?:-color)?\z/, "screen"
+              true
+            else
+              return true if ENV["EMACS"] == "t"
+              false
+            end
+          end
+
+          def guess_progress_row_max
+            term_width = guess_term_width
+            if term_width.zero?
+              if ENV["EMACS"] == "t"
+                -1
+              else
+                79
+              end
+            else
+              term_width
+            end
+          end
+
+          def guess_term_width
+            Integer(ENV["TERM_WIDTH"] || 0)
+          rescue ArgumentError
+            0
           end
         end
       end

data/test-unit/lib/test/unit/util/method-owner-finder.rb

@@ -0,0 +1,28 @@
+module Test
+  module Unit
+    module Util
+      module MethodOwnerFinder
+        module_function
+        def find(object, method_name)
+          method = object.method(method_name)
+          return method.owner if method.respond_to?(:owner)
+
+          if /\((.+?)\)\#/ =~ method.to_s
+            owner_name = $1
+            if /\A#</ =~ owner_name
+              ObjectSpace.each_object(Module) do |mod|
+                return mod if mod.to_s == owner_name
+              end
+            else
+              owner_name.split(/::/).inject(Object) do |parent, name|
+                parent.const_get(name)
+              end
+            end
+          else
+            object.class
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,6 @@
 # HACK: quick and dirty to get integrated into the new project - ryan
 module Test
   module Unit
-    VERSION = '2.0.0'
+    VERSION = '2.0.3'
   end
 end

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

@@ -253,6 +253,68 @@ module Test # :nodoc:
   # the dynamic suite using the console TestRunner.
   #
   #
+  # == Configuration file
+  #
+  # Test::Unit reads 'test-unit.yml' in the current working
+  # directory as Test::Unit's configuration file. It can
+  # contain the following configurations:
+  #
+  # * color scheme definitions
+  # * test runner to be used
+  # * test runner options
+  # * test collector to be used
+  #
+  # Except color scheme definitions, all of them are
+  # specified by command line option.
+  #
+  # Here are sample color scheme definitions:
+  #
+  #   color_schemes:
+  #     inverted:
+  #       success:
+  #         name: red
+  #         bold: true
+  #       failure:
+  #         name: green
+  #         bold: true
+  #     other_scheme:
+  #       ...
+  #
+  # Here are the syntax of color scheme definitions:
+  #
+  #  color_schemes:
+  #    SCHEME_NAME:
+  #      EVENT_NAME:
+  #        name: COLOR_NAME
+  #        intensity: BOOLEAN
+  #        bold: BOOLEAN
+  #        italic: BOOLEAN
+  #        underline: BOOLEAN
+  #      ...
+  #    ...
+  #
+  # SCHEME_NAME:: the name of the color scheme
+  # EVENT_NAME:: one of [success, failure, pending,
+  #              omission, notification, error]
+  # COLOR_NAME:: one of [black, red, green, yellow, blue,
+  #              magenta, cyan, white]
+  # BOOLEAN:: true or false
+  #
+  # You can use the above 'inverted' color scheme with the
+  # following configuration:
+  #
+  #   runner: console
+  #   console_options:
+  #     color_scheme: inverted
+  #   color_schemes:
+  #     inverted:
+  #       success:
+  #         name: red
+  #         bold: true
+  #       failure:
+  #         name: green
+  #         bold: true
+  #
   # == Questions?
   #
   # I'd really like to get feedback from all levels of Ruby

data/test-unit/sample/test_user.rb

@@ -0,0 +1,22 @@
+# nested test case example.
+
+class UserTest < Test::Unit::TestCase
+  def setup
+    @user = "me"
+  end
+
+  def test_full_name
+    assert_equal("me", @user)
+  end
+
+  class ProfileTest < UserTest
+    setup
+    def setup_profile
+      @user += ": profile"
+    end
+
+    def test_has_profile
+      assert_match(/: profile/, @user)
+    end
+  end
+end

data/test-unit/test/collector/{test_load.rb → test-load.rb}

@@ -268,7 +268,7 @@ EOT
                      [:test, {:name => "test1_1"}],
                      [:test, {:name => "test1_2"}]]]) do |collector|
       collector.filter = Proc.new do |test|
-        not /\Atest1/.match(test.method_name).nil?
+        !/\Atest1/.match(test.method_name).nil?
       end
     end
   end