activesambaldap 0.0.5 → 0.0.6

data/test-unit/lib/test/unit/util/procwrapper.rb

@@ -0,0 +1,48 @@
+#--
+#
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+module Test
+  module Unit
+    module Util
+
+      # Allows the storage of a Proc passed through '&' in a
+      # hash.
+      #
+      # Note: this may be inefficient, since the hash being
+      # used is not necessarily very good. In Observable,
+      # efficiency is not too important, since the hash is
+      # only accessed when adding and removing listeners,
+      # not when notifying.
+
+      class ProcWrapper
+
+        # Creates a new wrapper for a_proc.
+        def initialize(a_proc)
+          @a_proc = a_proc
+          @hash = a_proc.inspect.sub(/^(#<#{a_proc.class}:)/){''}.sub(/(>)$/){''}.hex
+        end
+
+        def hash
+          return @hash
+        end
+
+        def ==(other)
+          case(other)
+            when ProcWrapper
+              return @a_proc == other.to_proc
+            else
+              return super
+          end
+        end
+        alias :eql? :==
+
+        def to_proc
+          return @a_proc
+        end
+      end
+    end
+  end
+end

data/test-unit/lib/test/unit/version.rb

@@ -0,0 +1,7 @@
+
+# HACK: quick and dirty to get integrated into the new project - ryan
+module Test
+  module Unit
+    VERSION = '2.0.0'
+  end
+end

data/test-unit/sample/adder.rb

@@ -0,0 +1,13 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+class Adder
+  def initialize(number)
+    @number = number
+  end
+  def add(number)
+    return @number + number
+  end
+end
+

data/test-unit/sample/subtracter.rb

@@ -0,0 +1,12 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+class Subtracter
+  def initialize(number)
+    @number = number
+  end
+  def subtract(number)
+    return @number - number
+  end
+end

data/test-unit/sample/tc_adder.rb

@@ -0,0 +1,18 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+require 'adder'
+
+class TC_Adder < Test::Unit::TestCase
+  def setup
+    @adder = Adder.new(5)
+  end
+  def test_add
+    assert_equal(7, @adder.add(2), "Should have added correctly")
+  end
+  def teardown
+    @adder = nil
+  end
+end

data/test-unit/sample/tc_subtracter.rb

@@ -0,0 +1,18 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+require 'subtracter'
+
+class TC_Subtracter < Test::Unit::TestCase
+  def setup
+    @subtracter = Subtracter.new(5)
+  end
+  def test_subtract
+    assert_equal(3, @subtracter.subtract(2), "Should have subtracted correctly")
+  end
+  def teardown
+    @subtracter = nil
+  end
+end

data/test-unit/sample/ts_examples.rb

@@ -0,0 +1,7 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+require 'tc_adder'
+require 'tc_subtracter'

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

@@ -0,0 +1,135 @@
+require 'test/unit'
+require 'test/unit/collector/descendant'
+
+class TestUnitCollectorDescendant < Test::Unit::TestCase
+  def setup
+    @previous_descendants = Test::Unit::TestCase::DESCENDANTS.dup
+    Test::Unit::TestCase::DESCENDANTS.clear
+
+    @test_case1 = Class.new(Test::Unit::TestCase) do
+      def self.name
+        "test-case1"
+      end
+
+      def test_1
+      end
+
+      def test_2
+      end
+    end
+
+    @test_case2 = Class.new(Test::Unit::TestCase) do
+      def self.name
+        "test-case2"
+      end
+
+      def test_0
+      end
+    end
+
+    @no_test_case = Class.new do
+      def self.name
+        "no-test-case"
+      end
+
+      def test_4
+      end
+    end
+  end
+
+  def teardown
+    Test::Unit::TestCase::DESCENDANTS.replace(@previous_descendants)
+  end
+
+  def test_basic_collection
+    assert_collect(full_suite("name"), "name")
+
+    assert_collect(full_suite("name"), "name") do |collector|
+      collector.filter = []
+    end
+  end
+
+  def test_filtered_collection
+    assert_collect(empty_suite) do |collector|
+      collector.filter = Proc.new {false}
+    end
+
+    assert_collect(full_suite) do |collector|
+      collector.filter = Proc.new {true}
+    end
+
+    assert_collect(full_suite) do |collector|
+      collector.filter = Proc.new {nil}
+    end
+
+    assert_collect(empty_suite) do |collector|
+      collector.filter = [Proc.new {false}, Proc.new {true}]
+    end
+
+    assert_collect(full_suite) do |collector|
+      collector.filter = [Proc.new {true}, Proc.new {false}]
+    end
+
+    assert_collect(empty_suite) do |collector|
+      collector.filter = [Proc.new {nil}, Proc.new {false}]
+    end
+
+    assert_collect(full_suite) do |collector|
+      collector.filter = [Proc.new {nil}, Proc.new {true}]
+    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|
+      collector.filter = Proc.new do |test|
+        ['test_1', 'test_0'].include?(test.method_name)
+      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|
+      filters = [Proc.new {|test| test.method_name == 'test_1' ? true : nil},
+                 Proc.new {|test| test.method_name == 'test_0' ? true : nil},
+                 Proc.new {false}]
+      collector.filter = filters
+    end
+  end
+
+  private
+  def assert_collect(expected, *collect_args)
+    collector = Test::Unit::Collector::Descendant.new
+    yield(collector) if block_given?
+    assert_equal(expected, collector.send(:collect, *collect_args))
+  end
+
+  def default_name
+    Test::Unit::Collector::Descendant::NAME
+  end
+
+  def empty_suite(name=nil)
+    Test::Unit::TestSuite.new(name || default_name)
+  end
+
+  def full_suite(name=nil)
+    sub_suite1 = Test::Unit::TestSuite.new(@test_case1.name)
+    sub_suite1 << @test_case1.new('test_1')
+    sub_suite1 << @test_case1.new('test_2')
+
+    sub_suite2 = Test::Unit::TestSuite.new(@test_case2.name)
+    sub_suite2 << @test_case2.new('test_0')
+
+    suite = empty_suite(name)
+    suite << sub_suite1
+    suite << sub_suite2
+    suite
+  end
+end

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

@@ -0,0 +1,406 @@
+require 'test/unit'
+require 'test/unit/collector/dir'
+require 'pp'
+
+module Test
+  module Unit
+    module Collector
+      class TestDir < TestCase
+        class FileSystem
+          class Directory
+            def initialize(name, fs, parent=self, &block)
+              @name = name
+              @fs = fs
+              @parent = parent
+              @contents = {'.' => self, '..' => parent}
+              instance_eval(&block) if(block)
+            end
+            
+            def file(name, contents)
+              @contents[name] = contents
+            end
+
+            def dir(name, &block)
+              @contents[name] = self.class.new(name, @fs, self, &block)
+            end
+
+            def entries
+              @contents.keys
+            end
+
+            def directory?(name)
+              return true if(name.nil? || name.empty?)
+              return false unless(@contents.include?(name))
+              @contents[name].kind_of?(self.class)
+            end
+
+            def file?(name)
+              return false unless(@contents.include?(name))
+              !directory?(name)
+            end
+
+            def exist?(name)
+              @contents.include?(name)
+            end
+
+            def [](name)
+              raise Errno::ENOENT, name unless(@contents.include?(name))
+              @contents[name]
+            end
+
+            def path_to(name=nil)
+              if(!name)
+                @parent.path_to(@name)
+              elsif(@parent == self)
+                @fs.join('/', name)
+              else
+                @fs.join(@parent.path_to(@name), name)
+              end
+            end
+          end
+
+          class ObjectSpace
+            def initialize
+              @objects = []
+            end
+
+            def each_object(klass, &block)
+              @objects.find_all{|o| o.kind_of?(klass)}.each(&block)
+            end
+
+            def <<(object)
+              @objects << object
+            end
+          end
+
+          attr_reader :object_space
+          
+          def initialize(&block)
+            @root = Directory.new('/', self, &block)
+            @pwd = @root
+            @object_space = ObjectSpace.new
+            @required = []
+          end
+
+          def entries(dir)
+            e = find(dir)
+            require_directory(dir)
+            e.entries
+          end
+
+          def directory?(name)
+            return true if (base = basename(name)) == '/'
+            e = find(dirname(name))
+            return false unless(e)
+            e.directory?(base)
+          end
+
+          def find(path)
+            if(/\A\// =~ path)
+              thing = @root
+            else
+              thing = @pwd
+            end
+            path.scan(/[^\/]+/) do |e|
+              break thing = false unless(thing.kind_of?(Directory))
+              thing = thing[e]
+            end
+            thing
+          end
+
+          def dirname(name)
+            if (name = name.tr_s('/', '/')) == '/'
+              name
+            else
+              name[%r"\A.+(?=/[^/]+/?\z)|\A/"] || "."
+            end
+          end
+
+          def basename(name)
+            name[%r"(\A/|[^/]+)/*\z", 1]
+          end
+
+          def split(name)
+            [dirname(name), basename(name)]
+          end
+
+          def join(*parts)
+            parts.join('/').gsub(%r{/+}, '/')
+          end
+
+          def file?(name)
+            e = find(dirname(name))
+            return false unless(e)
+            e.file?(basename(name))
+          end
+
+          def pwd
+            @pwd.path_to
+          end
+
+          def chdir(to)
+            e = find(to)
+            require_directory(to)
+            @pwd = e
+          end
+
+          def expand_path(path, base = nil)
+            until /\A\// =~ path
+              base ||= pwd
+              path = join(base, path)
+              base = nil
+            end
+            path.gsub!(%r"(?:/\.)+(?=/)", '')
+            nil while path.sub!(%r"/(?!\.\./)[^/]+/\.\.(?=/)", '')
+            path.sub!(%r"\A(?:/\.\.)+(?=/)", '')
+            path.sub!(%r"(?:\A(/)|/)\.\.?\z", '\1')
+            path
+          end
+
+          def require_directory(path)
+            raise Errno::ENOTDIR, path unless(directory?(path))
+          end
+
+          def require(file)
+            return false if(@required.include?(file))
+            begin
+              e = find(file)
+            rescue Errno::ENOENT => e
+              if(/\.rb\Z/ =~ file)
+                raise LoadError, file
+              end
+              e = find(file + '.rb')
+            end
+            @required << file
+            @object_space << e
+            true
+          rescue Errno::ENOENT
+            raise LoadError, file
+          end
+        end
+
+        def test_dir
+          inner_dir = nil
+          dirs = FileSystem::Directory.new('/', nil) do
+            file 'a', nil
+            inner_dir = dir 'b'
+          end
+          assert_equal(inner_dir, dirs['b'])
+        end
+
+        def test_fs
+          fs = FileSystem.new do
+            file 'a', nil
+            dir 'b'
+          end
+          assert_equal(['.', '..', 'a', 'b'].sort, fs.entries('/').sort)
+          assert(fs.directory?('/'))
+          assert(!fs.directory?('/a'))
+          assert(!fs.directory?('/bogus'))
+          assert(fs.file?('/a'))
+          assert(!fs.file?('/'))
+          assert(!fs.file?('/bogus'))
+          assert(fs.directory?('/b'))
+          assert(fs.file?('a'))
+          assert(fs.directory?('b'))
+        end
+
+        def test_fs_sub
+          fs = FileSystem.new do
+            dir 'a' do
+              file 'b', nil
+              dir 'c' do
+                file 'd', nil
+              end
+            end
+          end
+          assert(fs.file?('/a/b'))
+          assert(!fs.file?('/a/b/c/d'))
+          assert(fs.file?('/a/c/d'))
+        end
+
+        def test_fs_pwd
+          fs = FileSystem.new do
+            file 'a', nil
+            dir 'b' do
+              file 'c', nil
+              dir 'd' do
+                file 'e', nil
+              end
+            end
+          end
+          assert_equal('/', fs.pwd)
+          assert_raises(Errno::ENOENT) do
+            fs.chdir('bogus')
+          end
+          assert_raises(Errno::ENOTDIR) do
+            fs.chdir('a')
+          end
+          fs.chdir('b')
+          assert_equal('/b', fs.pwd)
+          fs.chdir('d')
+          assert_equal('/b/d', fs.pwd)
+          fs.chdir('..')
+          assert_equal('/b', fs.pwd)
+          fs.chdir('..')
+          assert_equal('/', fs.pwd)
+        end
+
+        def test_fs_entries
+          fs = FileSystem.new do
+            file 'a', nil
+            dir 'b' do
+              file 'c', nil
+              file 'd', nil
+            end
+            file 'e', nil
+            dir 'f' do
+              file 'g', nil
+              dir 'h' do
+                file 'i', nil
+              end
+            end
+          end
+          assert_equal(['.', '..', 'a', 'b', 'e', 'f'], fs.entries('/').sort)
+          assert_equal(['.', '..', 'a', 'b', 'e', 'f'], fs.entries('.').sort)
+          assert_equal(['.', '..', 'a', 'b', 'e', 'f'], fs.entries('b/..').sort)
+          assert_equal(['.', '..', 'c', 'd'], fs.entries('b').sort)
+          assert_raises(Errno::ENOENT) do
+            fs.entries('z')
+          end
+          assert_raises(Errno::ENOTDIR) do
+            fs.entries('a')
+          end
+          fs.chdir('f')
+          assert_equal(['.', '..', 'i'], fs.entries('h').sort)
+        end
+
+        class TestClass1
+        end
+        class TestClass2
+        end
+        def test_fs_require
+          fs = FileSystem.new do
+            file 'test_class1.rb', TestClass1
+            dir 'dir' do
+              file 'test_class2.rb', TestClass2
+            end
+          end
+          c = []
+          fs.object_space.each_object(Class) do |o|
+            c << o
+          end
+          assert_equal([], c)
+
+          assert_raises(LoadError) do
+            fs.require('bogus')
+          end
+          
+          assert(fs.require('test_class1.rb'))
+          assert(!fs.require('test_class1.rb'))
+          c = []
+          fs.object_space.each_object(Class) do |o|
+            c << o
+          end
+          assert_equal([TestClass1], c)
+
+          fs.require('dir/test_class2')
+          c = []
+          fs.object_space.each_object(Class) do |o|
+            c << o
+          end
+          assert_equal([TestClass1, TestClass2], c)
+
+          c = []
+          fs.object_space.each_object(Time) do |o|
+            c << o
+          end
+          assert_equal([], c)
+        end
+
+        def setup
+          @t1 = t1 = create_test(1)
+          @t2 = t2 = create_test(2)
+          @t3 = t3 = create_test(3)
+          @t4 = t4 = create_test(4)
+          @t5 = t5 = create_test(5)
+          @t6 = t6 = create_test(6)
+          fs = FileSystem.new do
+            file 'test_1.rb', t1
+            file 'test_2.rb', t2
+            dir 'd1' do
+              file 'test_3.rb', t3
+            end
+            file 't4.rb', t4
+            dir 'd2' do
+              file 'test_5', t5
+              file 'test_6.rb', Time
+            end
+            file 't6.rb', t6
+          end
+          fs.require('t6')
+          @c = Dir.new(fs, fs, fs.object_space, fs)
+        end
+
+        def create_test(name)
+          t = Class.new(TestCase)
+          t.class_eval <<-EOC
+            def self.name
+              "T\#{#{name}}"
+            end
+            def test_#{name}a
+            end
+            def test_#{name}b
+            end
+          EOC
+          t
+        end
+
+        def test_simple_collect
+          expected = TestSuite.new('d1')
+          expected << (@t3.suite)
+          assert_equal(expected, @c.collect('d1'))
+        end
+
+        def test_multilevel_collect
+          expected = TestSuite.new('.')
+          expected << @t1.suite << @t2.suite
+          expected << (TestSuite.new('d1') << @t3.suite)
+          assert_equal(expected, @c.collect)
+        end
+
+        def test_collect_file
+          expected = TestSuite.new('test_1.rb')
+          expected << @t1.suite
+          assert_equal(expected, @c.collect('test_1.rb'))
+          
+          expected = TestSuite.new('t4.rb')
+          expected << @t4.suite
+          assert_equal(expected, @c.collect('t4.rb'))
+        end
+
+        def test_nil_pattern
+          expected = TestSuite.new('d2')
+          expected << @t5.suite
+          @c.pattern.clear
+          assert_equal(expected, @c.collect('d2'))
+        end
+
+        def test_filtering
+          expected = TestSuite.new('.')
+          expected << @t1.suite
+          @c.filter = proc{|t| t.method_name == 'test_1a' || t.method_name == 'test_1b'}
+          assert_equal(expected, @c.collect)
+        end
+
+        def test_collect_multi
+          expected = TestSuite.new('[d1, d2]')
+          expected << (TestSuite.new('d1') << @t3.suite)
+          expected << (TestSuite.new('d2') << @t5.suite)
+          @c.pattern.replace([/\btest_/])
+          assert_equal(expected, @c.collect('d1', 'd2'))
+        end
+      end
+    end
+  end
+end