activeldap 1.0.0 → 1.0.1

data/test-unit/test/test_attribute.rb

@@ -0,0 +1,86 @@
+class TestUnitAttribute < Test::Unit::TestCase
+  class TestStack < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    class Stack
+      def initialize
+        @data = []
+      end
+
+      def push(data)
+        @data.push(data)
+      end
+
+      def peek
+        @data[-2]
+      end
+
+      def empty?
+        @data.empty?
+      end
+
+      def size
+        @data.size + 11
+      end
+    end
+
+    def setup
+      @stack = Stack.new
+    end
+
+    attribute :category, :accessor
+    def test_peek
+      @stack.push(1)
+      @stack.push(2)
+      assert_equal(2, @stack.peek)
+    end
+
+    attribute :bug, 1234
+    def test_bug_1234
+      assert_equal(0, @stack.size)
+    end
+
+    def test_no_attributes
+      assert(@stack.empty?)
+      @stack.push(1)
+      assert(!@stack.empty?)
+      assert_equal(1, @stack.size)
+    end
+  end
+
+  def test_set_attributes
+    test_for_accessor_category = TestStack.new("test_peek")
+    assert_equal({"category" => :accessor},
+                 test_for_accessor_category.attributes)
+
+    test_for_bug_1234 = TestStack.new("test_bug_1234")
+    assert_equal({"bug" => 1234}, test_for_bug_1234.attributes)
+
+    test_no_attributes = TestStack.new("test_no_attributes")
+    assert_equal({}, test_no_attributes.attributes)
+  end
+
+  def test_callback
+    changed_attributes = []
+    observer = Proc.new do |test_case, key, old_value, value, method_name|
+      changed_attributes << [test_case, key, old_value, value, method_name]
+    end
+
+    test_case = Class.new(TestStack) do
+      register_attribute_observer(:bug, &observer)
+      attribute("bug", 9876, "test_bug_1234")
+      attribute(:description, "Test for peek", "test_peek")
+      attribute(:bug, 29, "test_peek")
+    end
+
+    assert_equal([
+                  [test_case, "bug", 1234, 9876, "test_bug_1234"],
+                  [test_case, "bug", nil, 29, "test_peek"],
+                 ],
+                 changed_attributes)
+  end
+end

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

@@ -1,6 +1,4 @@
-require 'test-unit-ext'
-
-class TestColor < Test::Unit::TestCase
+class TestUnitColor < Test::Unit::TestCase
   def test_color_escape_sequence
     assert_escape_sequence(["31"], color("red"))
     assert_escape_sequence(["32", "1"], color("green", :bold => true))
@@ -24,11 +22,11 @@ class TestColor < Test::Unit::TestCase
 
   private
   def color(name, options={})
-    Test::Color.new(name, options)
+    Test::Unit::Color.new(name, options)
   end
 
   def mix_color(colors)
-    Test::MixColor.new(colors)
+    Test::Unit::MixColor.new(colors)
   end
 
   def assert_escape_sequence(expected, color)

data/{test-unit-ext → test-unit}/test/test_diff.rb

@@ -1,4 +1,4 @@
-class TestDiff < Test::Unit::TestCase
+class TestUnitDiff < Test::Unit::TestCase
   def test_to_indexes
     assert_to_indexes({"abc def" => [0, 2], "abc" => [1]},
                       ["abc def", "abc", "abc def"])
@@ -388,14 +388,14 @@ class TestDiff < Test::Unit::TestCase
 
   private
   def assert_to_indexes(expected, to, &junk_predicate)
-    matcher = Test::Diff::SequenceMatcher.new([""], to, &junk_predicate)
+    matcher = Test::Unit::Diff::SequenceMatcher.new([""], to, &junk_predicate)
     assert_equal(expected, matcher.instance_variable_get("@to_indexes"))
   end
 
   def assert_find_best_match_position(expected, from, to,
                                       from_start, from_end,
                                       to_start, to_end, &junk_predicate)
-    matcher = Test::Diff::SequenceMatcher.new(from, to, &junk_predicate)
+    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
     assert_equal(expected, matcher.send(:find_best_match_position,
                                         from_start, from_end,
                                         to_start, to_end))
@@ -404,70 +404,72 @@ class TestDiff < Test::Unit::TestCase
   def assert_longest_match(expected, from, to,
                            from_start, from_end,
                            to_start, to_end, &junk_predicate)
-    matcher = Test::Diff::SequenceMatcher.new(from, to, &junk_predicate)
+    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
     assert_equal(expected, matcher.longest_match(from_start, from_end,
                                                  to_start, to_end))
   end
 
   def assert_matches(expected, from, to, &junk_predicate)
-    matcher = Test::Diff::SequenceMatcher.new(from, to, &junk_predicate)
+    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
     assert_equal(expected, matcher.send(:matches))
   end
 
   def assert_blocks(expected, from, to, &junk_predicate)
-    matcher = Test::Diff::SequenceMatcher.new(from, to, &junk_predicate)
+    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
     assert_equal(expected, matcher.blocks)
   end
 
   def assert_operations(expected, from, to, &junk_predicate)
-    matcher = Test::Diff::SequenceMatcher.new(from, to, &junk_predicate)
+    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
     assert_equal(expected, matcher.operations)
   end
 
   def assert_grouped_operations(expected, from, to)
-    matcher = Test::Diff::SequenceMatcher.new(from, to)
+    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to)
     assert_equal(expected, matcher.grouped_operations)
   end
 
   def assert_ratio(expected, from, to)
-    matcher = Test::Diff::SequenceMatcher.new(from, to)
+    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to)
     assert_in_delta(expected, 0.001, matcher.ratio)
   end
 
   def assert_readable_diff(expected, from, to)
-    assert_equal(expected, Test::Diff.readable(from.join("\n"), to.join("\n")))
+    assert_equal(expected,
+                 Test::Unit::Diff.readable(from.join("\n"), to.join("\n")))
   end
 
   def assert_unified_diff(expected, from, to, from_label, to_label, options={})
     options = options.merge(:from_label => from_label,
                             :to_label => to_label)
-    assert_equal(expected, Test::Diff.unified(from.join("\n"), to.join("\n"),
-                                              options))
+    assert_equal(expected,
+                 Test::Unit::Diff.unified(from.join("\n"), to.join("\n"),
+                                          options))
   end
 
   def assert_diff_lines(expected, from, to,
                         from_start, from_end,
                         to_start, to_end)
-    differ = Test::Diff::ReadableDiffer.new(from, to)
+    differ = Test::Unit::Diff::ReadableDiffer.new(from, to)
     assert_equal(expected, differ.send(:diff_lines,
                                        from_start, from_end,
                                        to_start, to_end))
   end
 
   def assert_diff_line(expected, from_line, to_line)
-    differ = Test::Diff::ReadableDiffer.new([""], [""])
+    differ = Test::Unit::Diff::ReadableDiffer.new([""], [""])
     assert_equal(expected, differ.send(:diff_line, from_line, to_line))
   end
 
   def assert_format_diff_point(expected, from_line, to_line, from_tags, to_tags)
-    differ = Test::Diff::ReadableDiffer.new([""], [""])
+    differ = Test::Unit::Diff::ReadableDiffer.new([""], [""])
     assert_equal(expected, differ.send(:format_diff_point,
                                        from_line, to_line,
                                        from_tags, to_tags))
   end
 
   def assert_interesting_line(expected, from, to, from_start, to_start)
-    differ = Test::Diff::UnifiedDiffer.new(from, to)
+    differ = Test::Unit::Diff::UnifiedDiffer.new(from, to)
     assert_equal(expected, differ.send(:find_interesting_line,
                                        from_start, to_start,
                                        :define_line?))

data/test-unit/test/test_emacs_runner.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'test/unit/ui/emacs/testrunner'
+
+class TestUnitEmacsRunner < Test::Unit::TestCase
+  def test_format_failure_with_a_location
+    runner = create_runner
+    test_name = "test_failure"
+    file = "/home/user/test_xxx.rb"
+    line = "3"
+    info = "in `xxx'"
+    location = "#{file}:#{line}: #{info}"
+    message = "FAIL!!!"
+    failure = Test::Unit::Failure.new(test_name, [location], message)
+    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
+Failure:
+#{test_name} [#{file}:#{line}]:
+#{message}
+EOM
+  end
+
+  def test_format_failure_with_locations
+    runner = create_runner
+    test_name = "test_failure"
+    locations = ["/home/user/test_xxx.rb:3: in `xxx'",
+                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
+                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
+    message = "Many backtrace!!!"
+    failure = Test::Unit::Failure.new(test_name, locations, message)
+    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
+Failure:
+#{test_name}
+#{locations.join("\n")}:
+#{message}
+EOM
+  end
+
+  def test_format_error
+    runner = create_runner
+    test_name = "test_error"
+    message = "Error Message!!!"
+    backtrace = ["/home/user/test_xxx.rb:3: in `xxx'",
+                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
+                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
+    exception = RuntimeError.new(message)
+    exception.set_backtrace(backtrace)
+    error = Test::Unit::Error.new(test_name, exception)
+    assert_equal(<<-EOM.chomp, runner.send(:format_fault, error))
+Error:
+#{test_name}:
+#{exception.class.name}: #{message}
+#{backtrace.join("\n")}
+EOM
+  end
+
+  private
+  def create_runner(suite=nil)
+    suite ||= Test::Unit::TestSuite.new
+    Test::Unit::UI::Emacs::TestRunner.new(suite)
+  end
+end

data/test-unit/test/test_error.rb

@@ -0,0 +1,26 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+
+module Test
+  module Unit
+    class TC_Error < TestCase
+      TF_Exception = Struct.new('TF_Exception', :message, :backtrace)
+      def test_display
+        ex = TF_Exception.new("message1\nmessage2", ['line1', 'line2'])
+        e = Error.new("name", ex)
+        assert_equal("name: #{TF_Exception.name}: message1", e.short_display)
+        assert_equal(<<EOM.strip, e.long_display)
+Error:
+name:
+Struct::TF_Exception: message1
+message2
+    line1
+    line2
+EOM
+      end
+    end
+  end
+end

data/test-unit/test/test_failure.rb

@@ -0,0 +1,33 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2003 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+require 'test/unit/failure'
+
+module Test::Unit
+  class TestFailure < TestCase
+    def test_display
+      f = Failure.new("name", [%q{location:1 in 'l'}], "message1\nmessage2")
+      assert_equal("name: message1", f.short_display)
+      assert_equal(<<EOM.strip, f.long_display)
+Failure:
+name [location:1]:
+message1
+message2
+EOM
+
+      f = Failure.new("name", [%q{location1:2 in 'l1'}, 'location2:1', %q{location3:3 in 'l3'}], "message1\nmessage2")
+      assert_equal("name: message1", f.short_display)
+      assert_equal(<<EOM.strip, f.long_display)
+Failure:
+name
+    [location1:2 in 'l1'
+     location2:1
+     location3:3 in 'l3']:
+message1
+message2
+EOM
+    end
+  end
+end

data/test-unit/test/test_fixture.rb

@@ -0,0 +1,275 @@
+class TestUnitFixture < Test::Unit::TestCase
+  def test_setup_without_option
+    test_case = assert_setup([:setup,
+                              :custom_setup_method0,
+                              :custom_setup_method1,
+                              :custom_setup_method3],
+                             [])
+    assert_inherited_setup([:setup,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :custom_setup_method3],
+                           test_case)
+    assert_inherited_setup([:setup], nil)
+  end
+
+  def test_setup_with_before_option
+    test_case = assert_setup([:custom_setup_method3,
+                              :custom_setup_method0,
+                              :custom_setup_method1,
+                              :setup],
+                             [[{:before => :append}],
+                              [{:before => :append}],
+                              [{:before => :prepend}],
+                              [{:before => :prepend}]])
+    assert_inherited_setup([:custom_setup_method3,
+                            :custom_setup_method0,
+                            :custom_setup_method1,
+                            :setup],
+                           test_case)
+    assert_inherited_setup([:setup], nil)
+  end
+
+  def test_setup_with_after_option
+    test_case = assert_setup([:setup,
+                              :custom_setup_method3,
+                              :custom_setup_method0,
+                              :custom_setup_method1],
+                             [[{:after => :append}],
+                              [{:after => :append}],
+                              [{:after => :prepend}],
+                              [{:after => :prepend}]])
+    assert_inherited_setup([:setup,
+                            :custom_setup_method3,
+                            :custom_setup_method0,
+                            :custom_setup_method1],
+                           test_case)
+    assert_inherited_setup([:setup], nil)
+  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_teardown_without_option
+    test_case = assert_teardown([:custom_teardown_method3,
+                                 :custom_teardown_method1,
+                                 :custom_teardown_method0,
+                                 :teardown],
+                                [])
+    assert_inherited_teardown([:custom_teardown_method3,
+                               :custom_teardown_method1,
+                               :custom_teardown_method0,
+                               :teardown],
+                              test_case)
+    assert_inherited_teardown([:teardown], nil)
+  end
+
+  def test_teardown_with_before_option
+    test_case = assert_teardown([:custom_teardown_method3,
+                                 :custom_teardown_method0,
+                                 :custom_teardown_method1,
+                                 :teardown],
+                                [[{:before => :append}],
+                                 [{:before => :append}],
+                                 [{:before => :prepend}],
+                                 [{:before => :prepend}]])
+    assert_inherited_teardown([:custom_teardown_method3,
+                               :custom_teardown_method0,
+                               :custom_teardown_method1,
+                               :teardown],
+                              test_case)
+    assert_inherited_teardown([:teardown], nil)
+  end
+
+  def test_teardown_with_after_option
+    test_case = assert_teardown([:teardown,
+                                 :custom_teardown_method3,
+                                 :custom_teardown_method0,
+                                 :custom_teardown_method1],
+                                [[{:after => :append}],
+                                 [{:after => :append}],
+                                 [{:after => :prepend}],
+                                 [{:after => :prepend}]])
+    assert_inherited_teardown([:teardown,
+                               :custom_teardown_method3,
+                               :custom_teardown_method0,
+                               :custom_teardown_method1],
+                              test_case)
+    assert_inherited_teardown([:teardown], nil)
+  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
+
+  private
+  def assert_setup(expected, setup_options)
+    called = []
+    test_case = Class.new(Test::Unit::TestCase) do
+      @@called = called
+      def setup
+        @@called << :setup
+      end
+
+      setup(*(setup_options[0] || []))
+      def custom_setup_method0
+        @@called << :custom_setup_method0
+      end
+
+      def custom_setup_method1
+        @@called << :custom_setup_method1
+      end
+      setup(*[:custom_setup_method1, *(setup_options[1] || [])])
+
+      setup(*(setup_options[2] || []))
+      def custom_setup_method2
+        @@called << :custom_setup_method2
+      end
+      unregister_setup(:custom_setup_method2)
+
+      setup(*(setup_options[3] || []))
+      def custom_setup_method3
+        @@called << :custom_setup_method3
+      end
+
+      def test_nothing
+      end
+    end
+
+    test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, called)
+    test_case
+  end
+
+  def assert_inherited_setup(expected, parent)
+    called = []
+    inherited_test_case = Class.new(parent || Test::Unit::TestCase) do
+      @@called = called
+      def setup
+        @@called << :setup
+      end
+
+      def custom_setup_method0
+        @@called << :custom_setup_method0
+      end
+
+      def custom_setup_method1
+        @@called << :custom_setup_method1
+      end
+
+      def custom_setup_method2
+        @@called << :custom_setup_method2
+      end
+
+      def custom_setup_method3
+        @@called << :custom_setup_method3
+      end
+
+      def test_nothing
+      end
+    end
+
+    inherited_test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, called)
+  end
+
+  def assert_teardown(expected, teardown_options)
+    called = []
+    test_case = Class.new(Test::Unit::TestCase) do
+      @@called = called
+      def teardown
+        @@called << :teardown
+      end
+
+      teardown(*(teardown_options[0] || []))
+      def custom_teardown_method0
+        @@called << :custom_teardown_method0
+      end
+
+      def custom_teardown_method1
+        @@called << :custom_teardown_method1
+      end
+      teardown(*[:custom_teardown_method1, *(teardown_options[1] || [])])
+
+      teardown(*(teardown_options[2] || []))
+      def custom_teardown_method2
+        @@called << :custom_teardown_method2
+      end
+      unregister_teardown(:custom_teardown_method2)
+
+      teardown(*(teardown_options[3] || []))
+      def custom_teardown_method3
+        @@called << :custom_teardown_method3
+      end
+
+      def test_nothing
+      end
+    end
+
+    test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, called)
+    test_case
+  end
+
+  def assert_inherited_teardown(expected, parent)
+    called = []
+    inherited_test_case = Class.new(parent || Test::Unit::TestCase) do
+      @@called = called
+      def teardown
+        @@called << :teardown
+      end
+
+      def custom_teardown_method0
+        @@called << :custom_teardown_method0
+      end
+
+      def custom_teardown_method1
+        @@called << :custom_teardown_method1
+      end
+
+      def custom_teardown_method2
+        @@called << :custom_teardown_method2
+      end
+
+      def custom_teardown_method3
+        @@called << :custom_teardown_method3
+      end
+
+      def test_nothing
+      end
+    end
+
+    inherited_test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
+    assert_equal(expected, called)
+  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