activesambaldap 0.0.8 → 0.0.9

data/test-unit/test/test_error.rb

@@ -1,26 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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_testresult.rb

@@ -1,113 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/testcase'
-require 'test/unit/testresult'
-
-module Test
-  module Unit
-    class TC_TestResult < TestCase
-      def setup
-        @my_result = TestResult.new
-        @my_result.add_assertion()
-        @failure = "failure"
-        @my_result.add_failure(@failure)
-        @error = "error"
-        @my_result.add_error(@error)
-      end
-
-      def test_result_changed_notification
-        called1 = false
-        @my_result.add_listener(TestResult::CHANGED) do |result|
-          assert_equal(@my_result, result)
-          called1 = true
-        end
-        @my_result.add_assertion
-        assert_true(called1)
-
-        called1, called2 = false, false
-        @my_result.add_listener(TestResult::CHANGED) do |result|
-          assert_equal(@my_result, result)
-          called2 = true
-        end
-        @my_result.add_assertion
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_failure("")
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_error("")
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_run
-        assert_equal([true, true], [called1, called2])
-      end
-
-      def test_fault_notification
-        called1 = false
-        fault = "fault"
-        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
-          assert_equal(fault, passed_fault)
-          called1 = true
-        end
-
-        @my_result.add_assertion
-        assert_false(called1)
-
-        @my_result.add_failure(fault)
-        assert_true(called1)
-
-        called1, called2 = false, false
-        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
-          assert_equal(fault, passed_fault)
-          called2 = true
-        end
-
-        @my_result.add_assertion
-        assert_equal([false, false], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_failure(fault)
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_error(fault)
-        assert_equal([true, true], [called1, called2])
-
-        called1, called2 = false, false
-        @my_result.add_run
-        assert_equal([false, false], [called1, called2])
-      end
-
-      def test_passed?
-        result = TestResult.new
-        assert_true(result.passed?)
-
-        result.add_assertion
-        assert_true(result.passed?)
-
-        result.add_run
-        assert_true(result.passed?)
-
-        result.add_failure("")
-        assert_false(result.passed?)
-
-        result = TestResult.new
-        result.add_error("")
-        assert_false(result.passed?)
-      end
-
-      def test_faults
-        assert_equal([@failure, @error], @my_result.faults)
-
-        notification = "notification"
-        @my_result.add_notification(notification)
-        assert_equal([@failure, @error, notification], @my_result.faults)
-      end
-    end
-  end
-end

data/test-unit/test/test_testsuite.rb

@@ -1,129 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit'
-
-module Test
-  module Unit
-    class TC_TestSuite < TestCase
-      def setup
-        @testcase1 = Class.new(TestCase) do
-          def test_succeed1
-            assert_block { true }
-          end
-          def test_fail
-            assert_block { false }
-          end
-        end
-
-        @testcase2 = Class.new(TestCase) do
-          def test_succeed2
-            assert_block { true }
-          end
-          def test_error
-            raise
-          end
-        end
-      end
-
-      def test_add
-        s = TestSuite.new
-        assert_equal(s, s << self.class.new("test_add"))
-      end
-
-      def test_delete
-        s = TestSuite.new
-        t1 = self.class.new("test_delete")
-        s << t1
-        t2 = self.class.new("test_add")
-        s << t2
-        assert_equal(t1, s.delete(t1))
-        assert_nil(s.delete(t1))
-        assert_equal(TestSuite.new << t2, s)
-      end
-
-      def test_size
-        suite = TestSuite.new
-        suite2 = TestSuite.new
-        suite2 << self.class.new("test_size")
-        suite << suite2
-        suite << self.class.new("test_size")
-        assert_equal(2, suite.size, "The count should be correct")
-      end
-      
-      def test_run
-        progress = []
-        suite = @testcase1.suite
-        result = TestResult.new
-        suite.run(result) { |*values| progress << values }
-  
-        assert_equal(2, result.run_count, "Should have had four test runs")
-        assert_equal(1, result.failure_count, "Should have had one test failure")
-        assert_equal(0, result.error_count, "Should have had one test error")
-        assert_equal([[TestSuite::STARTED, suite.name],
-                [TestCase::STARTED, "test_fail(#{suite.name})"],
-                [TestCase::FINISHED, "test_fail(#{suite.name})"],
-                [TestCase::STARTED, "test_succeed1(#{suite.name})"],
-                [TestCase::FINISHED, "test_succeed1(#{suite.name})"],
-                [TestSuite::FINISHED, suite.name]],
-                progress, "Should have had the correct progress")
-        
-        suite = TestSuite.new
-        suite << @testcase1.suite
-        suite << @testcase2.suite
-        result = TestResult.new
-        progress = []
-        suite.run(result) { |*values| progress << values }
-  
-        assert_equal(4, result.run_count, "Should have had four test runs")
-        assert_equal(1, result.failure_count, "Should have had one test failure")
-        assert_equal(1, result.error_count, "Should have had one test error")
-        assert_equal(14, progress.size, "Should have had the correct number of progress calls")
-      end
-      
-      def test_empty?
-        assert(TestSuite.new.empty?, "A new test suite should be empty?")
-        assert(!@testcase2.suite.empty?, "A test suite with tests should not be empty")
-      end
-      
-      def test_equality
-        suite1 = TestSuite.new
-        suite2 = TestSuite.new
-        assert_equal(suite1, suite2)
-        assert_equal(suite2, suite1)
-        
-        suite1 = TestSuite.new('name')
-        assert_not_equal(suite1, suite2)
-        assert_not_equal(suite2, suite1)
-        
-        suite2 = TestSuite.new('name')
-        assert_equal(suite1, suite2)
-        assert_equal(suite2, suite1)
-        
-        suite1 << 'test'
-        assert_not_equal(suite1, suite2)
-        assert_not_equal(suite2, suite1)
-        
-        suite2 << 'test'
-        assert_equal(suite1, suite2)
-        assert_equal(suite2, suite1)
-        
-        suite2 = Object.new
-        class << suite2
-          def name
-            'name'
-          end
-          def tests
-            ['test']
-          end
-        end
-        assert_not_equal(suite1, suite2)
-        assert_not_equal(suite2, suite1)
-
-        assert_not_equal(suite1, Object.new)
-        assert_not_equal(Object.new, suite1)
-      end
-    end
-  end
-end

data/test-unit/test/testunit-test-util.rb

@@ -1,14 +0,0 @@
-module TestUnitTestUtil
-  private
-  def assert_fault_messages(expected, faults)
-    assert_equal(expected, faults.collect {|fault| fault.message})
-  end
-
-  def _run_test(test_case, name)
-    result = Test::Unit::TestResult.new
-    test = test_case.new(name)
-    yield(test) if block_given?
-    test.run(result) {}
-    result
-  end
-end

data/test-unit/test/ui/test_testrunmediator.rb

@@ -1,20 +0,0 @@
-require 'test/unit/ui/testrunnermediator'
-
-class TestUnitUIMediator < Test::Unit::TestCase
-  def test_run_suite_with_interrupt_exception
-    test_case = Class.new(Test::Unit::TestCase) do
-      def test_raise_interrupt
-        raise Interrupt, "from test"
-      end
-    end
-    mediator = Test::Unit::UI::TestRunnerMediator.new(test_case.suite)
-    finished = false
-    mediator.add_listener(Test::Unit::UI::TestRunnerMediator::FINISHED) do
-      finished = true
-    end
-    assert_raise(Interrupt) do
-      mediator.run_suite
-    end
-    assert(finished)
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'test/unit'
-
-require 'test/unit/util/method-owner-finder'
-
-class TestUnitMethodOwnerFinder < Test::Unit::TestCase
-  def test_find
-    assert_equal(Exception, find(RuntimeError.new, :inspect))
-    assert_equal(Exception, find(Exception.new, :inspect))
-
-    anonymous_class = Class.new do
-    end
-    assert_equal(Kernel, find(anonymous_class.new, :inspect))
-
-    anonymous_parent_class = Class.new do
-      def inspect
-        super + " by anonymous parent class"
-      end
-    end
-    anonymous_sub_class = Class.new(anonymous_parent_class) do
-    end
-    assert_equal(anonymous_parent_class, find(anonymous_sub_class.new, :inspect))
-
-    anonymous_module = Module.new do
-      def inspect
-        super + " by anonymous module"
-      end
-    end
-    anonymous_include_class = Class.new do
-      include anonymous_module
-    end
-    assert_equal(anonymous_module, find(anonymous_include_class.new, :inspect))
-  end
-
-  private
-  def find(object, method_name)
-    Test::Unit::Util::MethodOwnerFinder.find(object, method_name)
-  end
-end

data/test-unit/test/util/test_backtracefilter.rb

@@ -1,41 +0,0 @@
-require 'test/unit'
-
-require 'test/unit/util/backtracefilter'
-
-module Test::Unit::Util
-  class TestBacktraceFilter < Test::Unit::TestCase
-    include BacktraceFilter
-    
-    def test_filter_backtrace
-      backtrace = [%q{C:\some\old\path/test/unit/assertions.rb:44:in 'assert'},
-        %q{tc_thing.rb:4:in 'a'},
-        %q{tc_thing.rb:4:in 'test_stuff'},
-        %q{C:\some\old\path/test/unit/testcase.rb:44:in 'send'},
-        %q{C:\some\old\path\test\unit\testcase.rb:44:in 'run'},
-        %q{C:\some\old\path\test\unit.rb:44:in 'run'},
-        %q{tc_thing.rb:3}]
-      assert_equal(backtrace[1..2], filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Should filter out all TestUnit-specific lines")
-
-backtrace = [%q{tc_thing.rb:4:in 'a'},
-        %q{tc_thing.rb:4:in 'test_stuff'},
-        %q{tc_thing.rb:3}]
-      assert_equal(backtrace, filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Shouldn't filter too much")
-
-      backtrace = [%q{C:\some\old\path/test/unit/assertions.rb:44:in 'assert'},
-        %q{tc_thing.rb:4:in 'a'},
-        %q{tc_thing.rb:4:in 'test_stuff'},
-        %q{tc_thing.rb:3}]
-      assert_equal(backtrace[1..3], filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Should filter out all TestUnit-specific lines")
-      
-      backtrace = [%q{C:\some\old\path/test/unit/assertions.rb:44:in 'assert'},
-        %q{C:\some\old\path/test/unit/testcase.rb:44:in 'send'},
-        %q{C:\some\old\path\test\unit\testcase.rb:44:in 'run'},
-        %q{C:\some\old\path\test\unit.rb:44:in 'run'}]
-      assert_equal(backtrace, filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Should filter out all TestUnit-specific lines")
-    end
-
-    def test_nil_backtrace
-      assert_equal(["No backtrace"], filter_backtrace(nil))
-    end
-  end
-end

data/test-unit/test/util/test_observable.rb

@@ -1,102 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/util/observable'
-
-module Test
-  module Unit
-    module Util
-      class TC_Observable < TestCase
-      
-        class TF_Observable
-          include Observable
-        end
-        
-        def setup
-          @observable = TF_Observable.new
-        end
-        
-        def test_simple_observation
-          assert_raises(ArgumentError, "add_listener should throw an exception if no callback is supplied") do
-            @observable.add_listener(:property, "a")
-          end
-      
-          heard = false
-          callback = proc { heard = true }
-          assert_equal("a", @observable.add_listener(:property, "a", &callback), "add_listener should return the listener that was added")
-      
-          count = 0
-          @observable.instance_eval do
-            count = notify_listeners(:property)
-          end
-          assert_equal(1, count, "notify_listeners should have returned the number of listeners that were notified")
-          assert(heard, "Should have heard the property changed")
-      
-          heard = false
-          assert_equal(callback, @observable.remove_listener(:property, "a"), "remove_listener should return the callback")
-          
-          count = 1
-          @observable.instance_eval do
-            count = notify_listeners(:property)
-          end
-          assert_equal(0, count, "notify_listeners should have returned the number of listeners that were notified")
-          assert(!heard, "Should not have heard the property change")
-        end
-        
-        def test_value_observation
-          value = nil
-          @observable.add_listener(:property, "a") do |passed_value|
-            value = passed_value
-          end
-          count = 0
-          @observable.instance_eval do
-            count = notify_listeners(:property, "stuff")
-          end
-          assert_equal(1, count, "Should have update the correct number of listeners")
-          assert_equal("stuff", value, "Should have received the value as an argument to the listener")
-        end
-        
-        def test_multiple_value_observation
-          values = []
-          @observable.add_listener(:property, "a") do |first_value, second_value|
-            values = [first_value, second_value]
-          end
-          count = 0
-          @observable.instance_eval do
-            count = notify_listeners(:property, "stuff", "more stuff")
-          end
-          assert_equal(1, count, "Should have update the correct number of listeners")
-          assert_equal(["stuff", "more stuff"], values, "Should have received the value as an argument to the listener")
-        end
-        
-        def test_add_remove_with_default_listener
-          assert_raises(ArgumentError, "add_listener should throw an exception if no callback is supplied") do
-            @observable.add_listener(:property)
-          end
-      
-          heard = false
-          callback = proc { heard = true }
-          assert_equal(callback, @observable.add_listener(:property, &callback), "add_listener should return the listener that was added")
-      
-          count = 0
-          @observable.instance_eval do
-            count = notify_listeners(:property)
-          end
-          assert_equal(1, count, "notify_listeners should have returned the number of listeners that were notified")
-          assert(heard, "Should have heard the property changed")
-      
-          heard = false
-          assert_equal(callback, @observable.remove_listener(:property, callback), "remove_listener should return the callback")
-      
-          count = 1
-          @observable.instance_eval do
-            count = notify_listeners(:property)
-          end
-          assert_equal(0, count, "notify_listeners should have returned the number of listeners that were notified")
-          assert(!heard, "Should not have heard the property change")
-        end
-      end
-    end
-  end
-end