activesambaldap 0.0.6 → 0.0.7

data/test-unit/test/test-color-scheme.rb

@@ -0,0 +1,56 @@
+class TestUnitColorScheme < Test::Unit::TestCase
+  def test_default
+    assert_equal({
+                   "success" => color("green", :bold => true),
+                   "failure" => color("red", :bold => true),
+                   "pending" => color("magenta", :bold => true),
+                   "omission" => color("blue", :bold => true),
+                   "notification" => color("cyan", :bold => true),
+                   "error" => color("yellow", :bold => true) +
+                              color("black", :foreground => false),
+                 },
+                 Test::Unit::ColorScheme.default.to_hash)
+  end
+
+  def test_register
+    inverted_scheme_spec = {
+      "success" => {:name => "red"},
+      "failure" => {:name => "green"},
+    }
+    Test::Unit::ColorScheme["inverted"] = inverted_scheme_spec
+    assert_equal({
+                   "success" => color("red"),
+                   "failure" => color("green"),
+                 },
+                 Test::Unit::ColorScheme["inverted"].to_hash)
+  end
+
+  def test_new_with_colors
+    scheme = Test::Unit::ColorScheme.new(:success => color("blue"),
+                                         "failure" => color("green",
+                                                            :underline => true))
+    assert_equal({
+                   "success" => color("blue"),
+                   "failure" => color("green", :underline => true),
+                 },
+                 scheme.to_hash)
+  end
+
+  def test_new_with_spec
+    scheme = Test::Unit::ColorScheme.new(:success => {
+                                           :name => "blue",
+                                           :bold => true
+                                         },
+                                         "failure" => {:name => "green"})
+    assert_equal({
+                   "success" => color("blue", :bold => true),
+                   "failure" => color("green"),
+                 },
+                 scheme.to_hash)
+  end
+
+  private
+  def color(name, options={})
+    Test::Unit::Color.new(name, options)
+  end
+end

data/test-unit/test/{test_color.rb → test-color.rb}

@@ -20,6 +20,16 @@ class TestUnitColor < Test::Unit::TestCase
                            color("none", :underline => true))
   end
 
+  def test_equal
+    red = color("red")
+    red_bold = color("red", :bold => true)
+
+    assert_operator(red, :==, red)
+    assert_not_equal(red, nil)
+    assert_equal(red, color("red"))
+    assert_not_equal(red, red_bold)
+  end
+
   private
   def color(name, options={})
     Test::Unit::Color.new(name, options)

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

@@ -0,0 +1,287 @@
+class TestUnitFixture < Test::Unit::TestCase
+  module EmptyModule
+  end
+
+  def test_setup_without_option
+    expected_setup_calls = [:setup,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :custom_setup_method3]
+    test_case = assert_setup(expected_setup_calls, [])
+    assert_inherited_setup(expected_setup_calls, test_case)
+
+    assert_inherited_setup([:setup], nil)
+    assert_called_fixtures(expected_setup_calls, test_case)
+  end
+
+  def test_setup_with_before_option
+    expected_setup_calls = [:custom_setup_method3,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :setup]
+    test_case = assert_setup(expected_setup_calls,
+                             [[{:before => :append}],
+                              [{:before => :append}],
+                              [{:before => :prepend}],
+                              [{:before => :prepend}]])
+    assert_inherited_setup(expected_setup_calls, test_case)
+
+    assert_inherited_setup([:setup], nil)
+    assert_called_fixtures(expected_setup_calls, test_case)
+  end
+
+  def test_setup_with_after_option
+    expected_setup_calls = [:setup,
+                            :custom_setup_method3,
+                            :custom_setup_method0,
+                            :custom_setup_method1]
+    test_case = assert_setup(expected_setup_calls,
+                             [[{:after => :append}],
+                              [{:after => :append}],
+                              [{:after => :prepend}],
+                              [{:after => :prepend}]])
+    assert_inherited_setup(expected_setup_calls, test_case)
+
+    assert_inherited_setup([:setup], nil)
+    assert_called_fixtures(expected_setup_calls, test_case)
+  end
+
+  def test_setup_with_invalid_option
+    assert_invalid_setup_option(:unknown => true)
+    assert_invalid_setup_option(:before => :unknown)
+    assert_invalid_setup_option(:after => :unknown)
+  end
+
+  def test_setup_with_option_to_inherited
+    expected_setup_calls = [:setup]
+    test_case = assert_setup(expected_setup_calls, nil)
+    assert_inherited_setup([:setup,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :custom_setup_method3],
+                           test_case,
+                           [])
+
+    assert_inherited_setup([:setup], nil)
+    assert_called_fixtures(expected_setup_calls, test_case)
+  end
+
+  def test_teardown_without_option
+    expected_teardown_calls = [:custom_teardown_method3,
+                               :custom_teardown_method1,
+                               :custom_teardown_method0,
+                               :teardown]
+    test_case = assert_teardown(expected_teardown_calls, [])
+    assert_inherited_teardown(expected_teardown_calls, test_case)
+
+    assert_inherited_teardown([:teardown], nil)
+    assert_called_fixtures(expected_teardown_calls, test_case)
+  end
+
+  def test_teardown_with_before_option
+    expected_teardown_calls = [:custom_teardown_method3,
+                               :custom_teardown_method0,
+                               :custom_teardown_method1,
+                               :teardown]
+    test_case = assert_teardown(expected_teardown_calls,
+                                [[{:before => :append}],
+                                 [{:before => :append}],
+                                 [{:before => :prepend}],
+                                 [{:before => :prepend}]])
+    assert_inherited_teardown(expected_teardown_calls, test_case)
+
+    assert_inherited_teardown([:teardown], nil)
+    assert_called_fixtures(expected_teardown_calls, test_case)
+  end
+
+  def test_teardown_with_after_option
+    expected_teardown_calls = [:teardown,
+                               :custom_teardown_method3,
+                               :custom_teardown_method0,
+                               :custom_teardown_method1]
+    test_case = assert_teardown(expected_teardown_calls,
+                                [[{:after => :append}],
+                                 [{:after => :append}],
+                                 [{:after => :prepend}],
+                                 [{:after => :prepend}]])
+    assert_inherited_teardown(expected_teardown_calls, test_case)
+
+    assert_inherited_teardown([:teardown], nil)
+    assert_called_fixtures(expected_teardown_calls, test_case)
+  end
+
+  def test_teardown_with_invalid_option
+    assert_invalid_teardown_option(:unknown => true)
+    assert_invalid_teardown_option(:before => :unknown)
+    assert_invalid_teardown_option(:after => :unknown)
+  end
+
+  def test_teardown_with_option_to_inherited
+    expected_teardown_calls = [:teardown]
+    test_case = assert_teardown(expected_teardown_calls, nil)
+    assert_inherited_teardown([:custom_teardown_method3,
+                               :custom_teardown_method1,
+                               :custom_teardown_method0,
+                               :teardown],
+                              test_case, [])
+
+    assert_inherited_teardown([:teardown], nil)
+    assert_called_fixtures(expected_teardown_calls, test_case)
+  end
+
+  private
+  def assert_called_fixtures(expected, test_case)
+    test = test_case.new("test_nothing")
+    test.run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, test.called_ids)
+  end
+
+  def assert_setup_customizable(expected, parent, options)
+    test_case = Class.new(parent || Test::Unit::TestCase) do
+      yield(self, :before) if block_given?
+
+      def called_ids
+        @called_ids ||= []
+      end
+
+      def called(id)
+        called_ids << id
+      end
+
+      def setup
+        called(:setup)
+      end
+
+      setup(*(options[0] || [])) if options
+      def custom_setup_method0
+        called(:custom_setup_method0)
+      end
+
+      def custom_setup_method1
+        called(:custom_setup_method1)
+      end
+      setup(*[:custom_setup_method1, *(options[1] || [])]) if options
+
+      setup(*(options[2] || [])) if options
+      def custom_setup_method2
+        called(:custom_setup_method2)
+      end
+      unregister_setup(:custom_setup_method2) if options
+
+      setup(*(options[3] || [])) if options
+      def custom_setup_method3
+        called(:custom_setup_method3)
+      end
+
+      def test_nothing
+      end
+
+      yield(self, :after) if block_given?
+    end
+
+    assert_called_fixtures(expected, test_case)
+    test_case
+  end
+
+  def assert_setup(expected, options)
+    _test_case = assert_setup_customizable(expected, nil, options)
+    assert_setup_customizable(expected, nil, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+    _test_case
+  end
+
+  def assert_inherited_setup(expected, parent, options=nil)
+    _test_case = assert_setup_customizable(expected, parent, options)
+    assert_setup_customizable(expected, parent, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+    _test_case
+  end
+
+  def assert_teardown_customizable(expected, parent, options)
+    test_case = Class.new(parent || Test::Unit::TestCase) do
+      yield(self, :before) if block_given?
+
+      def called_ids
+        @called_ids ||= []
+      end
+
+      def called(id)
+        called_ids << id
+      end
+
+      def teardown
+        called(:teardown)
+      end
+
+      teardown(*(options[0] || [])) if options
+      def custom_teardown_method0
+        called(:custom_teardown_method0)
+      end
+
+      def custom_teardown_method1
+        called(:custom_teardown_method1)
+      end
+      teardown(*[:custom_teardown_method1, *(options[1] || [])]) if options
+
+      teardown(*(options[2] || [])) if options
+      def custom_teardown_method2
+        called(:custom_teardown_method2)
+      end
+      unregister_teardown(:custom_teardown_method2) if options
+
+      teardown(*(options[3] || [])) if options
+      def custom_teardown_method3
+        called(:custom_teardown_method3)
+      end
+
+      def test_nothing
+      end
+
+      yield(self, :after) if block_given?
+    end
+
+    assert_called_fixtures(expected, test_case)
+    test_case
+  end
+
+  def assert_teardown(expected, options)
+    assert_teardown_customizable(expected, nil, options)
+    assert_teardown_customizable(expected, nil, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+  end
+
+  def assert_inherited_teardown(expected, parent, options=nil)
+    assert_teardown_customizable(expected, parent, options)
+    assert_teardown_customizable(expected, parent, options) do |test_case, tag|
+      test_case.send(:include, EmptyModule) if tag == :before
+    end
+  end
+
+  def assert_invalid_option(fixture_type, option)
+    exception = assert_raise(ArgumentError) do
+      Class.new(Test::Unit::TestCase) do
+        def test_nothing
+        end
+
+        send(fixture_type, option)
+        def fixture
+        end
+      end
+    end
+    assert_equal("must be {:before => :prepend}, {:before => :append}, " +
+                 "{:after => :prepend} or {:after => :append}" +
+                 ": #{option.inspect}",
+                 exception.message)
+  end
+
+  def assert_invalid_setup_option(option)
+    assert_invalid_option(:setup, option)
+  end
+
+  def assert_invalid_teardown_option(option)
+    assert_invalid_option(:teardown, option)
+  end
+end

data/test-unit/test/{test_notification.rb → test-notification.rb}

@@ -1,7 +1,7 @@
 require 'test/unit'
-require 'testunit_test_util'
+require 'testunit-test-util'
 
-class TestNotification < Test::Unit::TestCase
+class TestUnitNotification < Test::Unit::TestCase
   include TestUnitTestUtil
 
   class TestCase < Test::Unit::TestCase
@@ -18,7 +18,7 @@ class TestNotification < Test::Unit::TestCase
   end
 
   def test_notify
-    result = run_test("test_notify")
+    result = _run_test("test_notify")
     assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
                  "0 omissions, 2 notifications",
                  result.to_s)
@@ -27,7 +27,7 @@ class TestNotification < Test::Unit::TestCase
   end
 
   private
-  def run_test(name)
+  def _run_test(name)
     super(TestCase, name)
   end
 end

data/test-unit/test/{test_omission.rb → test-omission.rb}

@@ -1,5 +1,5 @@
 require 'test/unit'
-require 'testunit_test_util'
+require 'testunit-test-util'
 
 class TestUnitOmission < Test::Unit::TestCase
   include TestUnitTestUtil
@@ -43,7 +43,7 @@ class TestUnitOmission < Test::Unit::TestCase
   end
 
   def test_omit
-    result = run_test("test_omit")
+    result = _run_test("test_omit")
     assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
                  "1 omissions, 0 notifications",
                  result.to_s)
@@ -51,7 +51,7 @@ class TestUnitOmission < Test::Unit::TestCase
   end
 
   def test_omit_with_condition
-    result = run_test("test_omit_with_condition")
+    result = _run_test("test_omit_with_condition")
     assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
                  "1 omissions, 0 notifications",
                  result.to_s)
@@ -59,7 +59,7 @@ class TestUnitOmission < Test::Unit::TestCase
   end
 
   def test_omit_with_block
-    result = run_test("test_omit_with_block")
+    result = _run_test("test_omit_with_block")
     assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
                  "1 omissions, 0 notifications",
                  result.to_s)
@@ -67,7 +67,7 @@ class TestUnitOmission < Test::Unit::TestCase
   end
 
   def test_omit_with_condition_and_block
-    result = run_test("test_omit_with_block_and_condition")
+    result = _run_test("test_omit_with_block_and_condition")
     assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
                  "1 omissions, 0 notifications",
                  result.to_s)
@@ -75,7 +75,7 @@ class TestUnitOmission < Test::Unit::TestCase
   end
 
   private
-  def run_test(name)
+  def _run_test(name)
     super(TestCase, name)
   end
 end

data/test-unit/test/{test_pending.rb → test-pending.rb}

@@ -1,5 +1,5 @@
 require 'test/unit'
-require 'testunit_test_util'
+require 'testunit-test-util'
 
 class TestUnitPending < Test::Unit::TestCase
   include TestUnitTestUtil
@@ -33,32 +33,38 @@ class TestUnitPending < Test::Unit::TestCase
   end
 
   def test_pend
-    result = run_test("test_pend")
+    test = nil
+    result = _run_test("test_pend") {|t| test = t}
     assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 1 pendings, " \
                  "0 omissions, 0 notifications",
                  result.to_s)
     assert_fault_messages(["1st pend"], result.pendings)
+    assert_true(test.interrupted?)
   end
 
   def test_pend_with_failure_in_block
-    result = run_test("test_pend_with_failure_in_block")
+    test = nil
+    result = _run_test("test_pend_with_failure_in_block") {|t| test = t}
     assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 1 pendings, " \
                  "0 omissions, 0 notifications",
                  result.to_s)
     assert_fault_messages(["Wait a minute"], result.pendings)
+    assert_false(test.interrupted?)
   end
 
   def test_pend_with_no_failure_in_block
-    result = run_test("test_pend_with_no_failure_in_block")
+    test = nil
+    result = _run_test("test_pend_with_no_failure_in_block") {|t| test = t}
     assert_equal("1 tests, 1 assertions, 1 failures, 0 errors, 0 pendings, " \
                  "0 omissions, 0 notifications",
                  result.to_s)
     assert_fault_messages(["Pending block should not be passed: Wait a minute."],
                           result.failures)
+    assert_true(test.interrupted?)
   end
 
   private
-  def run_test(name)
-    super(TestCase, name)
+  def _run_test(name, &block)
+    super(TestCase, name, &block)
   end
 end

data/test-unit/test/{test_priority.rb → test-priority.rb}

@@ -86,4 +86,34 @@ class TestUnitPriority < Test::Unit::TestCase
     end
     assert_in_delta(expected, n_need_to_run.to_f / n, delta)
   end
+
+  class SpecialNameTestCase < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    def test_question?
+    end
+
+    def test_exclamation!
+    end
+
+    def test_equal=
+    end
+  end
+
+  def test_escaped?
+    assert_escaped_name("test_question.predicate", "test_question?")
+    assert_escaped_name("test_exclamation.destructive", "test_exclamation!")
+    assert_escaped_name("test_equal.equal", "test_equal=")
+  end
+
+  def assert_escaped_name(expected, test_method_name)
+    checker = Checker.new(SpecialNameTestCase.new(test_method_name))
+    passed_file = checker.send(:passed_file)
+    method_name_component = File.basename(File.dirname(passed_file))
+    assert_equal(expected, method_name_component)
+  end
 end

data/test-unit/test/{test_testcase.rb → test-testcase.rb}

@@ -6,7 +6,7 @@ require 'test/unit'
 
 module Test
   module Unit
-    class TC_TestCase < TestCase
+    class TestTestCase < TestCase
       def test_creation
         tc = Class.new(TestCase) do
           def test_with_arguments(arg1, arg2)
@@ -267,7 +267,7 @@ module Test
       def test_re_raise_exception
         test_case = Class.new(TestCase) do
           def test_raise_interrupt
-            raise Interrupt
+            raise Interrupt, "from test"
           end
         end
 
@@ -342,7 +342,7 @@ module Test
         test_case = Class.new(TestCase) do
           class << self
             def startup
-              raise Interrupt
+              raise Interrupt, "from startup"
             end
           end
 
@@ -383,7 +383,7 @@ module Test
         test_case = Class.new(TestCase) do
           class << self
             def shutdown
-              raise Interrupt
+              raise Interrupt, "from shutdown"
             end
           end
 
@@ -401,11 +401,107 @@ module Test
         end
       end
 
+      def test_interrupted
+        test_case = Class.new(TestCase) do
+          def test_fail
+            flunk
+          end
+
+          def test_nothing
+          end
+        end
+
+        failed_test = test_case.new(:test_fail)
+        failed_test.run(TestResult.new) {}
+        check("Should be interrupted", failed_test.interrupted?)
+
+        success_test = test_case.new(:test_nothing)
+        success_test.run(TestResult.new) {}
+        check("Should not be interrupted", !success_test.interrupted?)
+      end
+
+      def test_inherited_test_should_be_ignored
+        test_case = Class.new(TestCase) do
+          def test_nothing
+          end
+        end
+
+        sub_test_case = Class.new(test_case) do
+          def test_fail
+            flunk
+          end
+        end
+
+        assert_nothing_thrown do
+          test_case.new("test_nothing")
+        end
+
+        assert_nothing_thrown do
+          sub_test_case.new("test_fail")
+        end
+
+        assert_throw(:invalid_test) do
+          sub_test_case.new("test_nothing")
+        end
+      end
+
+      def test_mixin_test_should_not_be_ignored
+        test_module = Module.new do
+          def test_nothing
+          end
+        end
+
+        test_case = Class.new(Test::Unit::TestCase) do
+          include test_module
+
+          def test_fail
+            flunk
+          end
+        end
+
+        assert_nothing_thrown do
+          test_case.new("test_nothing")
+        end
+
+        assert_nothing_thrown do
+          test_case.new("test_fail")
+        end
+      end
+
+      def test_defined_order
+        keep_test_order do
+          test_case = Class.new(Test::Unit::TestCase) do
+            def test_z
+            end
+
+            def test_1
+            end
+
+            def test_a
+            end
+          end
+
+          assert_equal(["test_1", "test_a", "test_z"],
+                       test_case.suite.tests.collect {|test| test.method_name})
+
+          test_case.test_order = :defined
+          assert_equal(["test_z", "test_1", "test_a"],
+                       test_case.suite.tests.collect {|test| test.method_name})
+        end
+      end
+
       private
       def check(message, passed)
         add_assertion
         raise AssertionFailedError.new(message) unless passed
       end
+
+      def keep_test_order
+        order = TestCase.test_order
+        yield
+      ensure
+        TestCase.test_order = order
+      end
     end
   end
 end