activeldap 1.0.1 → 1.0.2

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_assertions.rb

@@ -1,5 +1,6 @@
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+#             Copyright (c) 2009 Kouhei Sutou.
 # License:: Ruby license.
 
 require 'test/unit'
@@ -7,6 +8,10 @@ require 'test/unit'
 module Test
   module Unit
     class TC_Assertions < TestCase
+      backtrace_pre  = "---Backtrace---"
+      backtrace_post = "---------------"
+      BACKTRACE_RE = /#{backtrace_pre}\n.+\n#{backtrace_post}/m
+
       def check(value, message="")
         add_assertion
         raise AssertionFailedError.new(message) unless value
@@ -116,9 +121,6 @@ module Test
         check_nothing_fails {
           assert_equal("string1", "string1")
         }
-        check_nothing_fails {
-          assert_equal( "string1", "string1", "successful assert_equal")
-        }
         check_nothing_fails {
           assert_equal("string1", "string1", "successful assert_equal")
         }
@@ -166,6 +168,47 @@ EOM
         end
       end
 
+      def test_assert_equal_with_long_line
+        expected = ["0123456789",
+                    "1123456789",
+                    "2123456789",
+                    "3123456789",
+                    "4123456789",
+                    "5123456789",
+                    "6123456789",
+                    "7123456789",
+                    "8123456789"].join
+        actual =   ["0000000000",
+                    "1123456789",
+                    "2123456789",
+                    "3123456789",
+                    "4123456789",
+                    "5123456789",
+                    "6123456789",
+                    "7123456789",
+                    "8123456789"].join
+        message = <<-EOM.chomp
+<"#{expected}"> expected but was
+<"#{actual}">.
+
+diff:
+- #{expected}
+?  ^^^^^^^^^
++ #{actual}
+?  ^^^^^^^^^
+
+folded diff:
+- 012345678911234567892123456789312345678941234567895123456789612345678971234567
+?  ^^^^^^^^^
++ 000000000011234567892123456789312345678941234567895123456789612345678971234567
+?  ^^^^^^^^^
+  898123456789
+EOM
+        check_fails(message) do
+          assert_equal(expected, actual)
+        end
+      end
+
       def test_assert_equal_for_too_small_difference
         message = <<-EOM.chomp
 <1> expected but was
@@ -203,85 +246,191 @@ EOM
         end
       end
 
-      def test_assert_raise
+      def test_assert_raise_success
         return_value = nil
-        check_nothing_fails(true) {
-          return_value = assert_raise(RuntimeError) {
+        check_nothing_fails(true) do
+          return_value = assert_raise(RuntimeError) do
             raise "Error"
-          }
-        }
-        check(return_value.kind_of?(Exception), "Should have returned the exception from a successful assert_raise")
-        check(return_value.message == "Error", "Should have returned the correct exception from a successful assert_raise")
-        check_nothing_fails(true) {
-          assert_raise(ArgumentError, "successful assert_raise") {
+          end
+        end
+        check(return_value.kind_of?(Exception),
+              "Should have returned the exception " +
+              "from a successful assert_raise")
+        check(return_value.message == "Error",
+              "Should have returned the correct exception " +
+              "from a successful assert_raise")
+
+        check_nothing_fails(true) do
+          assert_raise(ArgumentError, "successful assert_raise") do
             raise ArgumentError.new("Error")
-          }
-        }
-        check_nothing_fails(true) {
-          assert_raise(RuntimeError) {
+          end
+        end
+
+        check_nothing_fails(true) do
+          assert_raise(RuntimeError) do
             raise "Error"
-          }
-        }
-        check_nothing_fails(true) {
-          assert_raise(RuntimeError, "successful assert_raise") {
+          end
+        end
+
+        check_nothing_fails(true) do
+          assert_raise(RuntimeError, "successful assert_raise") do
             raise "Error"
-          }
-        }
-        check_fails("<RuntimeError> exception expected but none was thrown.") {
-          assert_raise(RuntimeError) {
+          end
+        end
+
+        check_nothing_fails(true) do
+          assert_raise do
+            raise Exception, "Any exception"
+          end
+        end
+      end
+
+      def test_assert_raise_fail
+        check_fails("<RuntimeError> exception expected but none was thrown.") do
+          assert_raise(RuntimeError) do
             1 + 1
-          }
-        }
-        check_fails(%r{\Afailed assert_raise.\n<ArgumentError> exception expected but was\nClass: <RuntimeError>\nMessage: <"Error">\n---Backtrace---\n.+\n---------------\Z}m) {
-          assert_raise(ArgumentError, "failed assert_raise") {
+          end
+        end
+
+        message = <<-EOM
+failed assert_raise.
+<ArgumentError> exception expected but was
+Class: <RuntimeError>
+Message: <"Error">
+EOM
+        check_fails(/\A#{message}#{BACKTRACE_RE}\Z/m) do
+          assert_raise(ArgumentError, "failed assert_raise") do
             raise "Error"
-          }
-        }
-        check_fails("Should expect a class of exception, Object.\n<false> is not true.") {
-          assert_nothing_raised(Object) {
+          end
+        end
+
+        message = <<-EOM
+Should expect a class of exception, Object.
+<false> is not true.
+EOM
+        check_fails(message.chomp) do
+          assert_nothing_raised(Object) do
             1 + 1
-          }
-        }
+          end
+        end
+      end
 
+      def test_assert_raise_module
         exceptions = [ArgumentError, TypeError]
         modules = [Math, Comparable]
         rescues = exceptions + modules
+
         exceptions.each do |exc|
-          check_nothing_fails(true) {
-            return_value = assert_raise(*rescues) {
+          return_value = nil
+          check_nothing_fails(true) do
+            return_value = assert_raise(*rescues) do
               raise exc, "Error"
-            }
-          }
-          check(return_value.instance_of?(exc), "Should have returned #{exc} but was #{return_value.class}")
-          check(return_value.message == "Error", "Should have returned the correct exception from a successful assert_raise")
+            end
+          end
+          check(return_value.instance_of?(exc),
+                "Should have returned #{exc} but was #{return_value.class}")
+          check(return_value.message == "Error",
+                "Should have returned the correct exception " +
+                "from a successful assert_raise")
         end
+
         modules.each do |mod|
-          check_nothing_fails(true) {
-            return_value = assert_raise(*rescues) {
+          return_value = nil
+          check_nothing_fails(true) do
+            return_value = assert_raise(*rescues) do
               raise Exception.new("Error").extend(mod)
-            }
-          }
-          check(mod === return_value, "Should have returned #{mod}")
-          check(return_value.message == "Error", "Should have returned the correct exception from a successful assert_raise")
+            end
+          end
+          check(mod === return_value,
+                "Should have returned #{mod}")
+          check(return_value.message == "Error",
+                "Should have returned the correct exception " +
+                "from a successful assert_raise")
         end
-        check_fails("<[ArgumentError, TypeError, Math, Comparable]> exception expected but none was thrown.") {
-          assert_raise(*rescues) {
+
+        check_fails("<[ArgumentError, TypeError, Math, Comparable]> exception " +
+                    "expected but none was thrown.") do
+          assert_raise(*rescues) do
             1 + 1
-          }
-        }
-        check_fails(%r{\Afailed assert_raise.
-<\[ArgumentError, TypeError\]> exception expected but was
+          end
+        end
+
+        message = <<-EOM
+failed assert_raise.
+<[ArgumentError, TypeError]> exception expected but was
 Class: <RuntimeError>
 Message: <"Error">
----Backtrace---
-.+
----------------\Z}m) {
-          assert_raise(ArgumentError, TypeError, "failed assert_raise") {
+EOM
+        message = Regexp.escape(message)
+        check_fails(/\A#{message}#{BACKTRACE_RE}\z/m) do
+          assert_raise(ArgumentError, TypeError, "failed assert_raise") do
             raise "Error"
-          }
-        }
+          end
+        end
       end
-      
+
+      def test_assert_raise_instance
+        return_value = nil
+        check_nothing_fails(true) do
+          return_value = assert_raise(RuntimeError.new("Error")) do
+            raise "Error"
+          end
+        end
+        check(return_value.kind_of?(Exception),
+              "Should have returned the exception " +
+              "from a successful assert_raise")
+        check(return_value.message == "Error",
+              "Should have returned the correct exception " +
+              "from a successful assert_raise")
+
+        message = <<-EOM
+<RuntimeError("XXX")> exception expected but was
+Class: <RuntimeError>
+Message: <"Error">
+EOM
+        message = Regexp.escape(message)
+        check_fails(/\A#{message}#{BACKTRACE_RE}\z/) do
+          return_value = assert_raise(RuntimeError.new("XXX")) do
+            raise "Error"
+          end
+        end
+
+        different_error_class = Class.new(StandardError)
+        message = <<-EOM
+<\#<Class:0x[a-f\\d]+>\\("Error"\\)> exception expected but was
+Class: <RuntimeError>
+Message: <"Error">
+EOM
+        check_fails(/\A#{message}#{BACKTRACE_RE}\z/) do
+          assert_raise(different_error_class.new("Error")) do
+            raise "Error"
+          end
+        end
+
+        different_error = different_error_class.new("Error")
+        def different_error.inspect
+          "DifferentError: \"Error\""
+        end
+        message = <<-EOM
+<\DifferentError: \\"Error\\"> exception expected but was
+Class: <RuntimeError>
+Message: <"Error">
+EOM
+        check_fails(/\A#{message}#{BACKTRACE_RE}\z/) do
+          assert_raise(different_error) do
+            raise "Error"
+          end
+        end
+
+        check_nothing_fails(true) do
+          assert_raise(different_error_class.new("Error"),
+                       RuntimeError.new("Error"),
+                       RuntimeError.new("XXX")) do
+            raise "Error"
+          end
+        end
+      end
+
       def test_assert_instance_of
         check_nothing_fails {
           assert_instance_of(String, "string")
@@ -496,9 +645,9 @@ Message: <"Error">
         end
       end
       
-      def test_assert_throws
+      def test_assert_throw
         check_nothing_fails do
-          assert_throws(:thing, "message") do
+          assert_throw(:thing, "message") do
             throw :thing
           end
         end
@@ -507,13 +656,13 @@ Message: <"Error">
         check_fails("message.\n" +
                     "<:thing> expected to be thrown but\n" +
                     "<#{inspect_tag(tag)}> was thrown.") do
-          assert_throws(:thing, "message") do
+          assert_throw(:thing, "message") do
             throw :thing2
           end
         end
         check_fails("message.\n" +
                     "<:thing> should have been thrown.") do
-          assert_throws(:thing, "message") do
+          assert_throw(:thing, "message") do
             1 + 1
           end
         end
@@ -555,10 +704,13 @@ Message: <"Error">
         check_nothing_fails {
           assert_respond_to("thing", "to_s", "message")
         }
-        check_fails("<0.15>\ngiven as the method name argument to #assert_respond_to must be a Symbol or #respond_to?(:to_str).") {
+        check_fails("<0.15>.kind_of?(Symbol) or\n" +
+                    "<0.15>.respond_to?(:to_str) expected") {
           assert_respond_to("thing", 0.15)
         }
-        check_fails("message.\n<:symbol>\nof type <Symbol>\nexpected to respond_to?<:non_existent>.") {
+        check_fails("message.\n" +
+                    "<:symbol>.respond_to?(:non_existent) expected\n" +
+                    "(Class: <Symbol>)") {
           assert_respond_to(:symbol, :non_existent, "message")
         }
       end
@@ -580,10 +732,15 @@ Message: <"Error">
         check_fails("message.\n<0.5> and\n<0.4> expected to be within\n<0.05> of each other.") {
           assert_in_delta(0.5, 0.4, 0.05, "message")
         }
-        check_fails(%r{The arguments must respond to to_f; the first float did not\.\n<.+>\nof type <Object>\nexpected to respond_to\?<:to_f>.}) {
-          assert_in_delta(Object.new, 0.4, 0.1)
-        }
-        check_fails("The delta should not be negative.\n<-0.1> expected to be\n>=\n<0.0>.") {
+        object = Object.new
+        check_fails("The arguments must respond to to_f; " +
+                    "the first float did not.\n" +
+                    "<#{object.inspect}>.respond_to?(:to_f) expected\n" +
+                    "(Class: <Object>)") {
+          assert_in_delta(object, 0.4, 0.1)
+        }
+        check_fails("The delta should not be negative.\n" +
+                    "<-0.1> expected to be\n>=\n<0.0>.") {
           assert_in_delta(0.5, 0.4, -0.1, "message")
         }
       end
@@ -675,6 +832,190 @@ Message: <"Error">
         end
       end
 
+      def test_assert_compare
+        check_nothing_fails do
+          assert_compare(1.4, "<", 10.0)
+        end
+
+        check_nothing_fails do
+          assert_compare(2, "<=", 2)
+        end
+
+        check_nothing_fails do
+          assert_compare(14, ">=", 10.0)
+        end
+
+        check_nothing_fails do
+          assert_compare(14, ">", 13.9)
+        end
+
+        expected_message = <<-EOM
+<15> < <10> should be true
+<15> expected less than
+<10>.
+EOM
+        check_fails(expected_message.chomp) do
+          assert_compare(15, "<", 10)
+        end
+
+        expected_message = <<-EOM
+<15> <= <10> should be true
+<15> expected less than or equal to
+<10>.
+EOM
+        check_fails(expected_message.chomp) do
+          assert_compare(15, "<=", 10)
+        end
+
+        expected_message = <<-EOM
+<10> > <15> should be true
+<10> expected greater than
+<15>.
+EOM
+        check_fails(expected_message.chomp) do
+          assert_compare(10, ">", 15)
+        end
+
+        expected_message = <<-EOM
+<10> >= <15> should be true
+<10> expected greater than or equal to
+<15>.
+EOM
+        check_fails(expected_message.chomp) do
+          assert_compare(10, ">=", 15)
+        end
+      end
+
+      def test_assert_fail_assertion
+        check_nothing_fails do
+          assert_fail_assertion do
+            flunk
+          end
+        end
+
+        check_fails("Failed assertion was expected.") do
+          assert_fail_assertion do
+          end
+        end
+      end
+
+      def test_assert_raise_message
+        check_nothing_fails do
+          assert_raise_message("Raise!") do
+            raise "Raise!"
+          end
+        end
+
+        check_nothing_fails do
+          assert_raise_message("Raise!") do
+            raise Exception, "Raise!"
+          end
+        end
+
+        check_nothing_fails do
+          assert_raise_message(/raise/i) do
+            raise "Raise!"
+          end
+        end
+
+        expected_message = <<-EOM
+<"Expected message"> exception message expected but was
+<"Actual message">.
+EOM
+        check_fails(expected_message.chomp) do
+          assert_raise_message("Expected message") do
+            raise "Actual message"
+          end
+        end
+
+        expected_message = <<-EOM
+<"Expected message"> exception message expected but none was thrown.
+EOM
+        check_fails(expected_message.chomp) do
+          assert_raise_message("Expected message") do
+          end
+        end
+      end
+
+      def test_assert_raise_kind_of
+        check_nothing_fails(true) do
+          assert_raise_kind_of(SystemCallError) do
+            raise Errno::EACCES
+          end
+        end
+
+        expected_message = <<-EOM
+<SystemCallError> family exception expected but was
+Class: <RuntimeError>
+Message: <"XXX">
+---Backtrace---
+EOM
+        check_fails(/\A#{Regexp.escape(expected_message)}(?m).+\z/) do
+          assert_raise_kind_of(SystemCallError) do
+            raise RuntimeError, "XXX"
+          end
+        end
+      end
+
+      def test_assert_const_defined
+        check_nothing_fails do
+          assert_const_defined(Test, :Unit)
+        end
+
+        check_nothing_fails do
+          assert_const_defined(Test, "Unit")
+        end
+
+        check_fails("<Test>.const_defined?(<:Nonexistence>) expected.") do
+          assert_const_defined(Test, :Nonexistence)
+        end
+      end
+
+      def test_assert_not_const_defined
+        check_nothing_fails do
+          assert_not_const_defined(Test, :Nonexistence)
+        end
+
+        check_fails("!<Test>.const_defined?(<:Unit>) expected.") do
+          assert_not_const_defined(Test, :Unit)
+        end
+
+        check_fails("!<Test>.const_defined?(<\"Unit\">) expected.") do
+          assert_not_const_defined(Test, "Unit")
+        end
+      end
+
+      def test_assert_predicate
+        check_nothing_fails do
+          assert_predicate([], :empty?)
+        end
+
+        check_fails("<[1]>.empty? is true value expected but was\n<false>") do
+          assert_predicate([1], :empty?)
+        end
+
+        check_fails("<[1]>.respond_to?(:nonexistent?) expected\n" +
+                    "(Class: <Array>)") do
+          assert_predicate([1], :nonexistent?)
+        end
+      end
+
+      def test_assert_not_predicate
+        check_nothing_fails do
+          assert_not_predicate([1], :empty?)
+        end
+
+        check_fails("<[]>.empty? is false value expected but was\n<true>") do
+          assert_not_predicate([], :empty?)
+        end
+
+        check_fails("<[]>.respond_to?(:nonexistent?) expected\n" +
+                    "(Class: <Array>)") do
+          assert_not_predicate([], :nonexistent?)
+        end
+      end
+
+      private
       def add_failure(message, location=caller)
         unless @catch_assertions
           super
@@ -691,3 +1032,4 @@ Message: <"Error">
     end
   end
 end
+p