activeldap 1.2.1 → 1.2.2

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.6'
+    VERSION = '2.1.0'
   end
 end

data/test-unit/test/collector/test-descendant.rb

@@ -66,7 +66,7 @@ class TestUnitCollectorDescendant < Test::Unit::TestCase
       collector.filter = [Proc.new {false}, Proc.new {true}]
     end
 
-    assert_collect(full_suite) do |collector|
+    assert_collect(empty_suite) do |collector|
       collector.filter = [Proc.new {true}, Proc.new {false}]
     end
 
@@ -90,13 +90,11 @@ class TestUnitCollectorDescendant < Test::Unit::TestCase
       end
     end
 
-    expected = empty_suite
     suite1 = Test::Unit::TestSuite.new(@test_case1.name)
     suite1 << @test_case1.new("test_1")
     suite2 = Test::Unit::TestSuite.new(@test_case2.name)
     suite2 << @test_case2.new("test_0")
-    expected << suite1 << suite2
-    assert_collect(expected) do |collector|
+    assert_collect(empty_suite) do |collector|
       filters = [Proc.new {|test| test.method_name == 'test_1' ? true : nil},
                  Proc.new {|test| test.method_name == 'test_0' ? true : nil},
                  Proc.new {false}]

data/test-unit/test/collector/test-load.rb

@@ -13,8 +13,9 @@ class TestUnitCollectorLoad < Test::Unit::TestCase
     ::Object.const_set(@temporary_test_cases_module_name, Module.new)
 
     @test_dir = Pathname(Dir.tmpdir) + "test-unit"
-    @test_dir.rmtree if @test_dir.exist?
-    @test_dir.mkpath
+    @extra_test_dir = Pathname(Dir.tmpdir) + "test-unit-extra"
+    ensure_clean_directory(@test_dir)
+    ensure_clean_directory(@extra_test_dir)
   end
 
   setup
@@ -196,6 +197,72 @@ EOT
     end
   end
 
+  setup
+  def setup_sub_git_test_cases
+    @sub_git_test_dir = @sub_test_dir + ".git"
+    @sub_git_test_dir.mkpath
+
+    @sub_git_test_case11 = @sub_git_test_dir + "test_case11.rb"
+
+    @sub_git_test_case11.open("w") do |test_case|
+      test_case.puts(<<-EOT)
+module #{@temporary_test_cases_module_name}
+  class SubGitTestCase11 < Test::Unit::TestCase
+    def test11
+    end
+  end
+end
+EOT
+    end
+  end
+
+  setup
+  def setup_extra_top_level_test_cases
+    @test_cases12 = @extra_test_dir + "test_cases12.rb"
+    @test_cases12.open("w") do |test_case|
+      test_case.puts(<<-EOT)
+module #{@temporary_test_cases_module_name}
+  class TestCase121 < Test::Unit::TestCase
+    def test121_1
+    end
+
+    def test121_2
+    end
+  end
+
+  class TestCase122 < Test::Unit::TestCase
+    def test122_1
+    end
+
+    def test122_2
+    end
+  end
+end
+EOT
+    end
+  end
+
+  setup
+  def setup_sub_level_extra_test_cases
+    @sub_extra_test_dir = @extra_test_dir + "sub"
+    @sub_extra_test_dir.mkpath
+
+    @cases13_test = @sub_extra_test_dir + "13cases_test.rb"
+    @cases13_test.open("w") do |test_case|
+      test_case.puts(<<-EOT)
+module #{@temporary_test_cases_module_name}
+  class SubTestCase13 < Test::Unit::TestCase
+    def test13_1
+    end
+
+    def test13_2
+    end
+  end
+end
+EOT
+    end
+  end
+
   def teardown
     @test_dir.rmtree if @test_dir.exist?
     ::Object.send(:remove_const, @temporary_test_cases_module_name)
@@ -212,6 +279,21 @@ EOT
                    @sub_test_dir.to_s)
   end
 
+  def test_simple_collect_test_suffix
+    assert_collect([:suite, {:name => @extra_test_dir.basename.to_s},
+                    [:suite, {:name => _test_case_name("TestCase121")},
+                     [:test, {:name => "test121_1"}],
+                     [:test, {:name => "test121_2"}]],
+                    [:suite, {:name => _test_case_name("TestCase122")},
+                     [:test, {:name => "test122_1"}],
+                     [:test, {:name => "test122_2"}]],
+                    [:suite, {:name => @sub_extra_test_dir.basename.to_s},
+                     [:suite, {:name => _test_case_name("SubTestCase13")},
+                      [:test, {:name => "test13_1"}],
+                      [:test, {:name => "test13_2"}]]]],
+                   @extra_test_dir.to_s)
+  end
+
   def test_multilevel_collect
     assert_collect([:suite, {:name => "."},
                     [:suite, {:name => _test_case_name("TestCase1")},
@@ -234,13 +316,39 @@ EOT
   end
 
   def test_collect_file
-    assert_collect([:suite, {:name => @test_case1.basename.to_s},
-                    [:suite, {:name => _test_case_name("TestCase1")},
-                     [:test, {:name => "test1_1"}],
-                     [:test, {:name => "test1_2"}]]],
+    assert_collect([:suite, {:name => _test_case_name("TestCase1")},
+                    [:test, {:name => "test1_1"}],
+                    [:test, {:name => "test1_2"}]],
                    @test_case1.to_s)
+  end
 
-    assert_collect(nil, @no_load_sub_test_case5.to_s)
+  def test_collect_file_no_pattern_match_file_name
+    assert_collect([:suite, {:name => _test_case_name("NoLoadSubTestCase5")},
+                    [:test, {:name => "test5_1"}],
+                    [:test, {:name => "test5_2"}]],
+                   @no_load_sub_test_case5.to_s)
+  end
+
+  def test_collect_file_test_cases
+    assert_collect([:suite, {:name => "[#{@test_cases12}]"},
+                    [:suite, {:name => _test_case_name("TestCase121")},
+                     [:test, {:name => "test121_1"}],
+                     [:test, {:name => "test121_2"}]],
+                    [:suite, {:name => _test_case_name("TestCase122")},
+                     [:test, {:name => "test122_1"}],
+                     [:test, {:name => "test122_2"}]]],
+                   @test_cases12.to_s)
+  end
+
+  def test_collect_files
+    assert_collect([:suite,
+                    {:name => "[#{@test_case1}, #{@test_case2}]"},
+                    [:suite, {:name => _test_case_name("TestCase1")},
+                     [:test, {:name => "test1_1"}],
+                     [:test, {:name => "test1_2"}]],
+                    [:suite, {:name => _test_case_name("TestCase2")},
+                     [:test, {:name => "test2"}]]],
+                   @test_case1.to_s, @test_case2.to_s)
   end
 
   def test_nil_pattern
@@ -278,7 +386,7 @@ EOT
                       [:test, {:name => "test4_2"}]],
                      [:suite, {:name => _test_case_name("SubTestCase6")},
                       [:test, {:name => "test6"}]]],
-                   [:suite, {:name => @sub2_test_dir.basename.to_s},
+                    [:suite, {:name => @sub2_test_dir.basename.to_s},
                      [:suite, {:name => _test_case_name("Sub2TestCase8")},
                       [:test, {:name => "test8_1"}],
                       [:test, {:name => "test8_2"}]],
@@ -299,6 +407,11 @@ EOT
     end
   end
 
+  def ensure_clean_directory(directory)
+    directory.rmtree if directory.exist?
+    directory.mkpath
+  end
+
   def keep_required_files
     required_files = $".dup
     yield

data/test-unit/test/collector/test_objectspace.rb

@@ -72,7 +72,7 @@ module Test
           assert_equal(empty_suite, @c.collect)
 
           @c.filter = [proc{true}, proc{false}]
-          assert_equal(full_suite, @c.collect)
+          assert_equal(empty_suite, @c.collect)
 
           @c.filter = [proc{nil}, proc{false}]
           assert_equal(empty_suite, @c.collect)
@@ -87,10 +87,12 @@ module Test
           assert_equal(expected, @c.collect)
 
           expected = TestSuite.new(ObjectSpace::NAME)
-          expected << (TestSuite.new(@tc1.name) << @tc1.new('test_1'))
-          expected << (TestSuite.new(@tc2.name) << @tc2.new('test_0'))
-          @c.filter = [proc{|t| t.method_name == 'test_1' ? true : nil}, proc{|t| t.method_name == 'test_0' ? true : nil}, proc{false}]
-          assert_equal(expected, @c.collect)
+          TestSuite.new(@tc1.name) << @tc1.new('test_1')
+          TestSuite.new(@tc2.name) << @tc2.new('test_0')
+          @c.filter = [proc{|t| t.method_name == 'test_1' ? true : nil},
+                       proc{|t| t.method_name == 'test_0' ? true : nil},
+                       proc{false}]
+          assert_equal(empty_suite, @c.collect)
         end
       end
     end

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

@@ -1,8 +1,10 @@
 class TestUnitColorScheme < Test::Unit::TestCase
   def test_default
     assert_equal({
-                   "success" => color("green", :bold => true),
-                   "failure" => color("red", :bold => true),
+                   "success" => color("green", :foreground => false) +
+                                color("white", :bold => true),
+                   "failure" => color("red", :foreground => false) +
+                                color("white", :bold => true),
                    "pending" => color("magenta", :bold => true),
                    "omission" => color("blue", :bold => true),
                    "notification" => color("cyan", :bold => true),

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

@@ -7,6 +7,7 @@ require 'test/unit'
 module Test
   module Unit
     class TestTestCase < TestCase
+      self.test_order = :random
       def test_creation
         tc = Class.new(TestCase) do
           def test_with_arguments(arg1, arg2)
@@ -469,52 +470,68 @@ module Test
       end
 
       def test_defined_order
-        keep_test_order do
-          test_case = Class.new(Test::Unit::TestCase) do
-            def test_z
-            end
+        test_case = Class.new(Test::Unit::TestCase) do
+          def test_z
+          end
 
-            def test_1
-            end
+          def test_1
+          end
 
-            def test_a
-            end
+          def test_a
           end
+        end
 
-          assert_equal(["test_1", "test_a", "test_z"],
-                       test_case.suite.tests.collect {|test| test.method_name})
+        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
+        test_case.test_order = :defined
+        assert_equal(["test_z", "test_1", "test_a"],
+                     test_case.suite.tests.collect {|test| test.method_name})
       end
 
       def test_declarative_style
-        keep_test_order do
-          test_case = Class.new(Test::Unit::TestCase) do
-            test "declarative style test definition" do
-            end
+        test_case = Class.new(Test::Unit::TestCase) do
+          test "declarative style test definition" do
+          end
 
-            test "include parenthesis" do
-            end
+          test "include parenthesis" do
+          end
 
-            test "1 + 2 = 3" do
-            end
+          test "1 + 2 = 3" do
           end
+        end
 
-          test_case.test_order = :defined
+        test_case.test_order = :defined
 
-          assert_equal(["test_declarative_style_test_definition",
-                        "test_include_parenthesis",
-                        "test_1_2_3"],
-                       test_case.suite.tests.collect {|test| test.method_name})
+        assert_equal(["test_declarative_style_test_definition",
+                      "test_include_parenthesis",
+                      "test_1_2_3"],
+                     test_case.suite.tests.collect {|test| test.method_name})
+
+        assert_equal(["declarative style test definition",
+                      "include parenthesis",
+                      "1 + 2 = 3"],
+                     test_case.suite.tests.collect {|test| test.description})
+      end
+
+      def test_redefine_method
+        test_case = Class.new(Test::Unit::TestCase) do
+          def test_name
+          end
+          alias_method :test_name2, :test_name
 
-          assert_equal(["declarative style test definition",
-                        "include parenthesis",
-                        "1 + 2 = 3"],
-                       test_case.suite.tests.collect {|test| test.description})
+          def test_name
+          end
         end
+
+        suite = test_case.suite
+        assert_equal(["test_name", "test_name2"],
+                     suite.tests.collect {|test| test.method_name})
+        result = TestResult.new
+        suite.run(result) {}
+        assert_equal("2 tests, 0 assertions, 0 failures, " +
+                     "0 errors, 0 pendings, 0 omissions, 1 notifications",
+                     result.summary)
       end
 
       private
@@ -522,13 +539,6 @@ module Test
         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

data/test-unit/test/test_assertions.rb

@@ -1,6 +1,8 @@
+# -*- coding: utf-8 -*-
+#
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-#             Copyright (c) 2009 Kouhei Sutou.
+#             Copyright (c) 2009-2010 Kouhei Sutou. All rights reserved.
 # License:: Ruby license.
 
 require 'test/unit'
@@ -275,6 +277,57 @@ EOM
         end
       end
 
+      def test_assert_equal_with_max_diff_target_string_size
+        key = "TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"
+        before_value = ENV[key]
+        ENV[key] = "100"
+        begin
+          message = <<-EOM.chomp
+<#{("a\n" + "x" * 97).inspect}> expected but was
+<#{"x".inspect}>.
+
+diff:
++ x
+- a
+- #{"x" * 97}
+
+folded diff:
++ x
+- a
+#{(["- " + ("x" * 78)]).join("\n")}
+- #{"x" * 19}
+EOM
+          check_fails(message) do
+            assert_equal("a\n" + "x" * 97, "x")
+          end
+
+          message = <<-EOM.chomp
+<#{("a\n" + "x" * 98).inspect}> expected but was
+<#{"x".inspect}>.
+EOM
+          check_fails(message) do
+            assert_equal("a\n" + "x" * 98, "x")
+          end
+        ensure
+          ENV[key] = before_value
+        end
+      end
+
+      def test_assert_equal_with_different_encoding
+        utf8_string = "こんにちは"
+        unless utf8_string.respond_to?(:force_encoding)
+          omit("encoding test is for Ruby >= 1.9")
+        end
+        ascii_8bit_string = utf8_string.dup.force_encoding("ascii-8bit")
+        message = <<-EOM.chomp
+<"こんにちは">("UTF-8") expected but was
+<#{ascii_8bit_string.inspect}>("ASCII-8BIT").
+EOM
+        check_fails(message) do
+          assert_equal(utf8_string, ascii_8bit_string)
+        end
+      end
+
       def test_assert_raise_success
         return_value = nil
         check_nothing_fails(true) do
@@ -775,13 +828,19 @@ EOM
           end
           assert_in_delta(0.1, float_thing, 0.1)
         }
-        check_fails("message.\n<0.5> and\n<0.4> expected to be within\n<0.05> of each other.") {
+        check_fails("message.\n" +
+                    "<0.5> expected but was\n" +
+                    "<0.4> (tolerance <0.05>).\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<<0.4> < <0.5>-<0.05>(0.45) <= <0.5>+<0.05>(0.55)>") {
           assert_in_delta(0.5, 0.4, 0.05, "message")
         }
         object = Object.new
+        inspected_object = AssertionMessage.convert(object)
         check_fails("The arguments must respond to to_f; " +
                     "the first float did not.\n" +
-                    "<#{object.inspect}>.respond_to?(:to_f) expected\n" +
+                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                     "(Class: <Object>)") {
           assert_in_delta(object, 0.4, 0.1)
         }
@@ -1085,17 +1144,40 @@ EOM
           assert_alias_method(object, :other, :original_method)
         end
 
-        check_fails("<#{object.inspect}>.nonexistent doesn't exist\n" +
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("<#{inspected_object}>.nonexistent doesn't exist\n" +
                     "(Class: <Object>)") do
           assert_alias_method(object, :nonexistent, :original_method)
         end
 
-        check_fails("<#{object.inspect}>.nonexistent doesn't exist\n" +
+        check_fails("<#{inspected_object}>.nonexistent doesn't exist\n" +
                     "(Class: <Object>)") do
           assert_alias_method(object, :alias_method, :nonexistent)
         end
       end
 
+      def test_assert_path_exist
+        check_nothing_fails do
+          assert_path_exist(__FILE__)
+        end
+
+        nonexistent_file = __FILE__ + ".nonexistent"
+        check_fails("<#{nonexistent_file.inspect}> expected to exist") do
+          assert_path_exist(nonexistent_file)
+        end
+      end
+
+      def test_assert_path_not_exist
+        nonexistent_file = __FILE__ + ".nonexistent"
+        check_nothing_fails do
+          assert_path_not_exist(nonexistent_file)
+        end
+
+        check_fails("<#{__FILE__.inspect}> expected to not exist") do
+          assert_path_not_exist(__FILE__)
+        end
+      end
+
       private
       def add_failure(message, location=caller, options=nil)
         unless @catch_assertions