pathname2 1.0.0 → 1.1.0

data/test/tc_pathname.rb

@@ -1,182 +1,192 @@
-##############################################
-# tc_pathname.rb
-#
-# Test suite for the pathname package (Unix)
-##############################################
-Dir.chdir ".." if File.basename(Dir.pwd) == "test"
-$LOAD_PATH.unshift Dir.pwd
-$LOAD_PATH.unshift Dir.pwd + "/lib"
-
-require "pathname2"
-require "test/unit"
-
-class TC_Pathname < Test::Unit::TestCase
-   def setup
-      @path = Pathname.new("/usr/local/bin")
-   end
-   
-   # Convenience method for test_plus
-   def assert_pathname_plus(a, b, c)
-      a = Pathname.new(a)
-      b = Pathname.new(b)
-      c = Pathname.new(c)
-      assert_equal(a, b + c)
-   end
-
-   # Convenience method for test_spaceship operator
-   def assert_pathname_cmp(int, s1, s2)
-      p1 = Pathname.new(s1)
-      p2 = Pathname.new(s2)
-      result = p1 <=> p2
-      assert_equal(int, result)
-   end
-
-   def test_version
-      assert_equal("1.0.0", Pathname::VERSION)
-   end
-
-   def test_unc
-      assert_raises(NotImplementedError){ @path.unc? }
-   end
-
-   def test_enumerable
-      assert_respond_to(@path, :each)
-   end
-   
-   def test_root
-      assert_respond_to(@path, :root)
-      assert_nothing_raised{ @path.root }
-      assert_equal("/", @path.root)
-
-      path1 = Pathname.new("foo")
-      path2 = Pathname.new("foo/bar/baz")
-      assert_equal(".", path1.root)
-      assert_equal(".", path2.root)
-   end
-
-   def test_root?
-      assert_respond_to(@path, :root?)
-      assert_nothing_raised{ @path.root? }
-
-      path1 = Pathname.new("/")
-      path2 = Pathname.new("a")
-      assert_equal(true, path1.root?)
-      assert_equal(false, path2.root?)
-   end
-
-   def test_absolute
-      assert_respond_to(@path, :absolute?)
-      assert_nothing_raised{ @path.absolute? }
-      assert_equal(true, Pathname.new("/usr/bin/ruby").absolute?)
-      assert_equal(false, Pathname.new("foo").absolute?)
-      assert_equal(false, Pathname.new("foo/bar").absolute?)
-      assert_equal(false, Pathname.new("../foo/bar").absolute?)
-   end
-
-   def test_relative
-      assert_respond_to(@path, :relative?)
-      assert_nothing_raised{ @path.relative? }
-      assert_equal(false, Pathname.new("/usr/bin/ruby").relative?)
-      assert_equal(true, Pathname.new("foo").relative?)
-      assert_equal(true, Pathname.new("foo/bar").relative?)
-      assert_equal(true, Pathname.new("../foo/bar").relative?)
-   end
-   
-   def test_to_a
-      assert_respond_to(@path, :to_a)
-      assert_nothing_raised{ @path.to_a }
-      assert_kind_of(Array, @path.to_a)
-      assert_equal(%w/usr local bin/, @path.to_a)
-   end
-
-   def test_spaceship_operator
-      assert_respond_to(@path, :<=>)
-
-      assert_pathname_cmp( 0, "/foo/bar", "/foo/bar")
-      assert_pathname_cmp(-1, "/foo/bar", "/foo/zap")
-      assert_pathname_cmp( 1, "/foo/zap", "/foo/bar")
-      assert_pathname_cmp(-1, "foo", "foo/")
-      assert_pathname_cmp(-1, "foo/", "foo/bar")
-   end
-
-   def test_plus_operator
-      assert_respond_to(@path, :+)
-
-      # Standard stuff
-      assert_pathname_plus("/foo/bar", "/foo", "bar")
-      assert_pathname_plus("foo/bar", "foo", "bar")
-      assert_pathname_plus("foo", "foo", ".")
-      assert_pathname_plus("foo", ".", "foo")
-      assert_pathname_plus("/foo", "bar", "/foo")
-      assert_pathname_plus("foo", "foo/bar", "..")
-      assert_pathname_plus("/foo", "/", "../foo")
-      assert_pathname_plus("foo/zap", "foo/bar", "../zap")
-      assert_pathname_plus(".", "foo", "..")
-      assert_pathname_plus("foo", "..", "foo")     # Auto clean
-      assert_pathname_plus("foo", "..", "../foo")  # Auto clean
-
-      # Edge cases
-      assert_pathname_plus(".", ".", ".")
-      assert_pathname_plus("/", "/", "..")
-      assert_pathname_plus(".", "..",  "..")
-      assert_pathname_plus(".", "foo", "..")
-   end
-
-   # Any tests marked with "***" mean that this behavior is different than
-   # the current implementation.  It also means I disagree with the current
-   # implementation.
-   def test_cleanpath
-      # Standard stuff
-      assert_equal("/a/b/c", Pathname.new("/a/b/c").cleanpath)
-      assert_equal("b/c", Pathname.new("./b/c").cleanpath)
-      assert_equal("a", Pathname.new("a/.").cleanpath)         # ***
-      assert_equal("a/c", Pathname.new("a/./c").cleanpath)
-      assert_equal("a/b", Pathname.new("a/b/.").cleanpath)     # ***
-      assert_equal(".", Pathname.new("a/../.").cleanpath)      # ***
-      assert_equal("/a", Pathname.new("/a/b/..").cleanpath)
-      assert_equal("/b", Pathname.new("/a/../b").cleanpath)
-      assert_equal("d", Pathname.new("a/../../d").cleanpath)   # ***
-
-      # Edge cases
-      assert_equal("", Pathname.new("").cleanpath)
-      assert_equal(".", Pathname.new(".").cleanpath)
-      assert_equal("..", Pathname.new("..").cleanpath)
-      assert_equal('/', Pathname.new('/').cleanpath)
-      assert_equal('/', Pathname.new('//').cleanpath)
-   end
-
-   def test_facade_io
-      assert_respond_to(@path, :foreach)
-      assert_respond_to(@path, :read)
-      assert_respond_to(@path, :readlines)
-      assert_respond_to(@path, :sysopen)
-   end
-
-   def test_facade_file
-      File.methods(false).each{ |method|
-         assert_respond_to(@path, method.to_sym)
-      }
-   end
-
-   def test_facade_dir
-      Dir.methods(false).each{ |method|
-         assert_respond_to(@path, method.to_sym)
-      }
-   end
-
-   def test_facade_fileutils
-      methods = FileUtils.public_instance_methods
-      methods -= File.methods(false)
-      methods -= Dir.methods(false)
-      methods.delete_if{ |m| m =~ /stream/ }
-      methods.delete("identical?")
-
-      methods.each{ |method|
-         assert_respond_to(@path, method.to_sym)
-      }
-   end
-   
-   def teardown
-      @path = nil
-   end
-end
+##############################################
+# tc_pathname.rb
+#
+# Test suite for the pathname package (Unix)
+##############################################
+Dir.chdir ".." if File.basename(Dir.pwd) == "test"
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + "/lib"
+
+require "pathname2"
+require "test/unit"
+
+class TC_Pathname < Test::Unit::TestCase
+   def setup
+      @path = Pathname.new("/usr/local/bin")
+   end
+   
+   # Convenience method for test_plus
+   def assert_pathname_plus(a, b, c)
+      a = Pathname.new(a)
+      b = Pathname.new(b)
+      c = Pathname.new(c)
+      assert_equal(a, b + c)
+   end
+
+   # Convenience method for test_spaceship operator
+   def assert_pathname_cmp(int, s1, s2)
+      p1 = Pathname.new(s1)
+      p2 = Pathname.new(s2)
+      result = p1 <=> p2
+      assert_equal(int, result)
+   end
+
+   def test_version
+      assert_equal("1.1.0", Pathname::VERSION)
+   end
+
+   def test_unc
+      assert_raises(NotImplementedError){ @path.unc? }
+   end
+
+   def test_enumerable
+      assert_respond_to(@path, :each)
+   end
+   
+   def test_root
+      assert_respond_to(@path, :root)
+      assert_nothing_raised{ @path.root }
+      assert_equal("/", @path.root)
+
+      path1 = Pathname.new("foo")
+      path2 = Pathname.new("foo/bar/baz")
+      assert_equal(".", path1.root)
+      assert_equal(".", path2.root)
+   end
+
+   def test_root?
+      assert_respond_to(@path, :root?)
+      assert_nothing_raised{ @path.root? }
+
+      path1 = Pathname.new("/")
+      path2 = Pathname.new("a")
+      assert_equal(true, path1.root?)
+      assert_equal(false, path2.root?)
+   end
+
+   def test_absolute
+      assert_respond_to(@path, :absolute?)
+      assert_nothing_raised{ @path.absolute? }
+      assert_equal(true, Pathname.new("/usr/bin/ruby").absolute?)
+      assert_equal(false, Pathname.new("foo").absolute?)
+      assert_equal(false, Pathname.new("foo/bar").absolute?)
+      assert_equal(false, Pathname.new("../foo/bar").absolute?)
+   end
+
+   def test_relative
+      assert_respond_to(@path, :relative?)
+      assert_nothing_raised{ @path.relative? }
+      assert_equal(false, Pathname.new("/usr/bin/ruby").relative?)
+      assert_equal(true, Pathname.new("foo").relative?)
+      assert_equal(true, Pathname.new("foo/bar").relative?)
+      assert_equal(true, Pathname.new("../foo/bar").relative?)
+   end
+   
+   def test_to_a
+      assert_respond_to(@path, :to_a)
+      assert_nothing_raised{ @path.to_a }
+      assert_kind_of(Array, @path.to_a)
+      assert_equal(%w/usr local bin/, @path.to_a)
+   end
+
+   def test_spaceship_operator
+      assert_respond_to(@path, :<=>)
+
+      assert_pathname_cmp( 0, "/foo/bar", "/foo/bar")
+      assert_pathname_cmp(-1, "/foo/bar", "/foo/zap")
+      assert_pathname_cmp( 1, "/foo/zap", "/foo/bar")
+      assert_pathname_cmp(-1, "foo", "foo/")
+      assert_pathname_cmp(-1, "foo/", "foo/bar")
+   end
+
+   def test_plus_operator
+      assert_respond_to(@path, :+)
+
+      # Standard stuff
+      assert_pathname_plus("/foo/bar", "/foo", "bar")
+      assert_pathname_plus("foo/bar", "foo", "bar")
+      assert_pathname_plus("foo", "foo", ".")
+      assert_pathname_plus("foo", ".", "foo")
+      assert_pathname_plus("/foo", "bar", "/foo")
+      assert_pathname_plus("foo", "foo/bar", "..")
+      assert_pathname_plus("/foo", "/", "../foo")
+      assert_pathname_plus("foo/zap", "foo/bar", "../zap")
+      assert_pathname_plus(".", "foo", "..")
+      assert_pathname_plus("foo", "..", "foo")     # Auto clean
+      assert_pathname_plus("foo", "..", "../foo")  # Auto clean
+
+      # Edge cases
+      assert_pathname_plus(".", ".", ".")
+      assert_pathname_plus("/", "/", "..")
+      assert_pathname_plus(".", "..",  "..")
+      assert_pathname_plus(".", "foo", "..")
+   end
+
+   # Any tests marked with "***" mean that this behavior is different than
+   # the current implementation.  It also means I disagree with the current
+   # implementation.
+   def test_cleanpath
+      # Standard stuff
+      assert_equal("/a/b/c", Pathname.new("/a/b/c").cleanpath)
+      assert_equal("b/c", Pathname.new("./b/c").cleanpath)
+      assert_equal("a", Pathname.new("a/.").cleanpath)         # ***
+      assert_equal("a/c", Pathname.new("a/./c").cleanpath)
+      assert_equal("a/b", Pathname.new("a/b/.").cleanpath)     # ***
+      assert_equal(".", Pathname.new("a/../.").cleanpath)      # ***
+      assert_equal("/a", Pathname.new("/a/b/..").cleanpath)
+      assert_equal("/b", Pathname.new("/a/../b").cleanpath)
+      assert_equal("d", Pathname.new("a/../../d").cleanpath)   # ***
+
+      # Edge cases
+      assert_equal("", Pathname.new("").cleanpath)
+      assert_equal(".", Pathname.new(".").cleanpath)
+      assert_equal("..", Pathname.new("..").cleanpath)
+      assert_equal('/', Pathname.new('/').cleanpath)
+      assert_equal('/', Pathname.new('//').cleanpath)
+   end
+
+   def test_facade_io
+      assert_respond_to(@path, :foreach)
+      assert_respond_to(@path, :read)
+      assert_respond_to(@path, :readlines)
+      assert_respond_to(@path, :sysopen)
+   end
+
+   def test_facade_file
+      File.methods(false).each{ |method|
+         assert_respond_to(@path, method.to_sym)
+      }
+   end
+
+   def test_facade_dir
+      Dir.methods(false).each{ |method|
+         assert_respond_to(@path, method.to_sym)
+      }
+   end
+
+   def test_facade_fileutils
+      methods = FileUtils.public_instance_methods
+      methods -= File.methods(false)
+      methods -= Dir.methods(false)
+      methods.delete_if{ |m| m =~ /stream/ }
+      methods.delete("identical?")
+
+      methods.each{ |method|
+         assert_respond_to(@path, method.to_sym)
+      }
+   end
+
+   def test_facade_find
+      assert_respond_to(@path, :find)
+      assert_nothing_raised{ @path.find{} }
+
+      Pathname.new(Dir.pwd).find{ |f|
+         Find.prune if f.match("CVS")
+         assert_kind_of(Pathname, f)
+      }
+   end
+   
+   def teardown
+      @path = nil
+   end
+end

data/test/tc_pathname_win.rb

@@ -1,227 +1,237 @@
-############################################
-# tc_pathname.rb
-#
-# Test suite for the pathname package.
-############################################
-Dir.chdir ".." if File.basename(Dir.pwd) == "test"
-$LOAD_PATH.unshift Dir.pwd
-$LOAD_PATH.unshift Dir.pwd + "/lib"
-
-require "pathname2"
-require "test/unit"
-
-class TC_Pathname < Test::Unit::TestCase
-   def setup
-      @fpath = Pathname.new("C:/Program Files/Windows NT/Accessories")
-      @bpath = Pathname.new("C:\\Program Files\\Windows NT\\Accessories")
-      @upath = Pathname.new("\\\\foo\\bar\\baz")
-      @npath = Pathname.new("foo\\bar\\baz")
-      @rpath = Pathname.new("Z:\\")
-      @xpath = Pathname.new("\\\\foo\\bar")
-      @ypath = Pathname.new("\\\\foo")
-      @zpath = Pathname.new("\\\\")
-      @epath = Pathname.new("")
-   end
-   
-   def test_version
-      assert_equal("1.0.0", Pathname::VERSION)
-   end
-   
-   # Convenience method for test_plus
-   def assert_pathname_plus(a, b, c)
-      a = Pathname.new(a)
-      b = Pathname.new(b)
-      c = Pathname.new(c)
-      assert_equal(a, b + c)
-   end
-
-   # Convenience method for test_spaceship operator
-   def assert_pathname_cmp(int, s1, s2)
-      p1 = Pathname.new(s1)
-      p2 = Pathname.new(s2)
-      result = p1 <=> p2
-      assert_equal(int, result)
-   end
-   
-   def test_each
-      assert_respond_to(@fpath, :each)
-      assert_nothing_raised{ @fpath.each{ |e| } }
-   end
-   
-   # Fails due to PathIsURL for some reason
-   #def test_immutability
-   #   path = "C:\\Program Files\\foo\\bar".freeze
-   #   assert_equal(true, path.frozen?)
-   #   assert_nothing_raised{ Pathname.new(path) }
-   #   assert_nothing_raised{ Pathname.new(path).root }
-   #end
-   
-   def test_plus_operator
-      # Standard stuff
-      assert_pathname_plus("C:\\a\\b", "C:\\a", "b")
-      assert_pathname_plus("C:\\b", "a", "C:\\b")
-      assert_pathname_plus("a\\b", "a", "b")
-      assert_pathname_plus("C:\\b", "C:\\a", "..\\b")
-      assert_pathname_plus("C:\\a\\b", "C:\\a\\.", "\\b")
-      assert_pathname_plus("C:\\a\\b.txt", "C:\\a", "b.txt")
-      
-      # UNC paths
-      assert_pathname_plus("\\\\foo\\bar", "\\\\foo", "bar")
-      assert_pathname_plus("\\\\foo", "\\\\", "foo")
-      assert_pathname_plus("\\\\", "\\\\", "")
-      assert_pathname_plus("\\\\foo\\baz", "\\\\foo\\bar", "\\..\\baz")
-      assert_pathname_plus("\\\\", "\\\\", "..\\..\\..\\..")
-   end
-   
-   def test_clean
-      # Our preset stuff
-      assert_equal("C:\\Program Files\\Windows NT\\Accessories", @fpath.clean)
-      assert_equal("C:\\Program Files\\Windows NT\\Accessories", @bpath.clean)
-      assert_equal("\\\\foo\\bar\\baz", @upath.clean)
-      assert_equal("foo\\bar\\baz", @npath.clean)
-      assert_equal("Z:\\", @rpath.clean)
-      assert_equal("\\\\foo\\bar", @xpath.clean)
-      assert_equal("\\\\foo", @ypath.clean)
-      assert_equal("\\\\", @zpath.clean)
-      assert_equal("", @epath.clean)
-
-      # Standard stuff
-      assert_equal("C:\\a\\c", Pathname.new("C:\\a\\.\\b\\..\\c").clean)
-      assert_equal("C:\\a", Pathname.new("C:\\.\\a").clean)
-      assert_equal("C:\\a\\b", Pathname.new("C:\\a\\.\\b").clean)
-      assert_equal("C:\\b", Pathname.new("C:\\a\\..\\b").clean)
-      assert_equal("C:\\a", Pathname.new("C:\\a\\.").clean)
-      assert_equal("C:\\d", Pathname.new("C:\\..\\..\\..\\d").clean)
-      assert_equal("C:\\a\\", Pathname.new("C:\\a\\").clean)
-      
-      # Edge cases
-      assert_equal("\\", Pathname.new(".").clean)
-      assert_equal("\\", Pathname.new("..").clean)
-   end
-  
-   def test_absolute
-      assert_equal(true, @fpath.absolute?)
-      assert_equal(true, @bpath.absolute?)
-      assert_equal(true, @upath.absolute?)
-      assert_equal(false, @npath.absolute?)
-      assert_equal(true, @rpath.absolute?)
-      assert_equal(true, @xpath.absolute?)
-      assert_equal(true, @ypath.absolute?)
-      assert_equal(true, @zpath.absolute?)
-      assert_equal(false, @epath.absolute?)
-   end
-   
-   def test_relative
-      assert_equal(false, @fpath.relative?)
-      assert_equal(false, @bpath.relative?)
-      assert_equal(false, @upath.relative?)
-      assert_equal(true, @npath.relative?)
-      assert_equal(false, @rpath.relative?)
-      assert_equal(false, @xpath.relative?)
-      assert_equal(false, @ypath.relative?)
-      assert_equal(false, @zpath.relative?)
-      assert_equal(true, @epath.relative?)
-   end
-   
-   def test_root
-      assert_equal("C:\\", @fpath.root)
-      assert_equal("C:\\", @bpath.root)
-      assert_equal("\\\\foo\\bar", @upath.root)
-      assert_equal(".", @npath.root)
-      assert_equal("Z:\\", @rpath.root)
-      assert_equal("\\\\foo\\bar", @xpath.root)
-      assert_equal("\\\\foo", @ypath.root)
-      assert_equal("\\\\", @zpath.root)
-      assert_equal(".", @epath.root)
-      
-      # Edge cases
-      assert_equal(".", Pathname.new("..").root)
-      assert_equal(".", Pathname.new(".").root)
-   end
-   
-   def test_drive_number
-      assert_equal(2, @fpath.drive_number)
-      assert_equal(2, @bpath.drive_number)
-      assert_equal(nil, @upath.drive_number)
-      assert_equal(nil, @npath.drive_number)
-      assert_equal(25, @rpath.drive_number)
-      assert_equal(nil, @xpath.drive_number)
-      assert_equal(nil, @ypath.drive_number)
-      assert_equal(nil, @zpath.drive_number)
-      assert_equal(nil, @epath.drive_number)
-      
-      # Edge cases
-      assert_equal(nil, Pathname.new("..").drive_number)
-      assert_equal(nil, Pathname.new(".").drive_number)
-   end
-        
-   def test_to_a
-      expected = ["C:", "Program Files", "Windows NT", "Accessories"]
-      assert_equal(expected, @fpath.to_a)
-      assert_equal(expected, @bpath.to_a)
-      assert_equal(["foo","bar","baz"], @upath.to_a)
-      assert_equal(["foo","bar","baz"], @npath.to_a)
-      assert_equal(["Z:"], @rpath.to_a)
-      assert_equal(["foo","bar"], @xpath.to_a)
-      assert_equal(["foo"], @ypath.to_a)
-      assert_equal([], @zpath.to_a)
-      assert_equal([], @epath.to_a)
-   end
- 
-   def test_is_root
-      assert_equal(false, @fpath.root?)
-      assert_equal(false, @bpath.root?)
-      assert_equal(false, @upath.root?)
-      assert_equal(false, @npath.root?)
-      assert_equal(true, @rpath.root?)
-      assert_equal(true, @xpath.root?)
-      assert_equal(true, @ypath.root?)
-      assert_equal(true, @zpath.root?)
-      assert_equal(false, @epath.root?)
-   end
-   
-   def test_facade_io
-      assert_respond_to(@fpath, :foreach)
-      assert_respond_to(@fpath, :read)
-      assert_respond_to(@fpath, :readlines)
-      assert_respond_to(@fpath, :sysopen)
-   end
-
-   def test_facade_file
-      File.methods(false).each{ |method|
-         assert_respond_to(@fpath, method.to_sym)
-      }
-      assert_respond_to(@fpath, :catname) # ftools check
-   end
-
-   def test_facade_dir
-      Dir.methods(false).each{ |method|
-         assert_respond_to(@fpath, method.to_sym)
-      }
-   end
-   
-   def test_facade_fileutils
-      methods = FileUtils.public_instance_methods
-      methods -= File.methods(false)
-      methods -= Dir.methods(false)
-      methods.delete_if{ |m| m =~ /stream/ }
-      methods.delete_if{ |m| m =~ /^ln/ }
-      methods.delete("identical?")
-
-      methods.each{ |method|
-         assert_respond_to(@fpath, method.to_sym)
-      }
-   end
-   
-   def teardown
-      @fpath = nil
-      @bpath = nil
-      @upath = nil
-      @npath = nil
-      @rpath = nil
-      @xpath = nil
-      @ypath = nil
-      @zpath = nil
-      @epath = nil
-   end
-end
+############################################
+# tc_pathname.rb
+#
+# Test suite for the pathname package.
+############################################
+Dir.chdir ".." if File.basename(Dir.pwd) == "test"
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + "/lib"
+
+require "pathname2"
+require "test/unit"
+
+class TC_Pathname < Test::Unit::TestCase
+   def setup
+      @fpath = Pathname.new("C:/Program Files/Windows NT/Accessories")
+      @bpath = Pathname.new("C:\\Program Files\\Windows NT\\Accessories")
+      @upath = Pathname.new("\\\\foo\\bar\\baz")
+      @npath = Pathname.new("foo\\bar\\baz")
+      @rpath = Pathname.new("Z:\\")
+      @xpath = Pathname.new("\\\\foo\\bar")
+      @ypath = Pathname.new("\\\\foo")
+      @zpath = Pathname.new("\\\\")
+      @epath = Pathname.new("")
+   end
+   
+   def test_version
+      assert_equal("1.1.0", Pathname::VERSION)
+   end
+   
+   # Convenience method for test_plus
+   def assert_pathname_plus(a, b, c)
+      a = Pathname.new(a)
+      b = Pathname.new(b)
+      c = Pathname.new(c)
+      assert_equal(a, b + c)
+   end
+
+   # Convenience method for test_spaceship operator
+   def assert_pathname_cmp(int, s1, s2)
+      p1 = Pathname.new(s1)
+      p2 = Pathname.new(s2)
+      result = p1 <=> p2
+      assert_equal(int, result)
+   end
+   
+   def test_each
+      assert_respond_to(@fpath, :each)
+      assert_nothing_raised{ @fpath.each{ |e| } }
+   end
+   
+   # Fails due to PathIsURL for some reason
+   #def test_immutability
+   #   path = "C:\\Program Files\\foo\\bar".freeze
+   #   assert_equal(true, path.frozen?)
+   #   assert_nothing_raised{ Pathname.new(path) }
+   #   assert_nothing_raised{ Pathname.new(path).root }
+   #end
+   
+   def test_plus_operator
+      # Standard stuff
+      assert_pathname_plus("C:\\a\\b", "C:\\a", "b")
+      assert_pathname_plus("C:\\b", "a", "C:\\b")
+      assert_pathname_plus("a\\b", "a", "b")
+      assert_pathname_plus("C:\\b", "C:\\a", "..\\b")
+      assert_pathname_plus("C:\\a\\b", "C:\\a\\.", "\\b")
+      assert_pathname_plus("C:\\a\\b.txt", "C:\\a", "b.txt")
+      
+      # UNC paths
+      assert_pathname_plus("\\\\foo\\bar", "\\\\foo", "bar")
+      assert_pathname_plus("\\\\foo", "\\\\", "foo")
+      assert_pathname_plus("\\\\", "\\\\", "")
+      assert_pathname_plus("\\\\foo\\baz", "\\\\foo\\bar", "\\..\\baz")
+      assert_pathname_plus("\\\\", "\\\\", "..\\..\\..\\..")
+   end
+   
+   def test_clean
+      # Our preset stuff
+      assert_equal("C:\\Program Files\\Windows NT\\Accessories", @fpath.clean)
+      assert_equal("C:\\Program Files\\Windows NT\\Accessories", @bpath.clean)
+      assert_equal("\\\\foo\\bar\\baz", @upath.clean)
+      assert_equal("foo\\bar\\baz", @npath.clean)
+      assert_equal("Z:\\", @rpath.clean)
+      assert_equal("\\\\foo\\bar", @xpath.clean)
+      assert_equal("\\\\foo", @ypath.clean)
+      assert_equal("\\\\", @zpath.clean)
+      assert_equal("", @epath.clean)
+
+      # Standard stuff
+      assert_equal("C:\\a\\c", Pathname.new("C:\\a\\.\\b\\..\\c").clean)
+      assert_equal("C:\\a", Pathname.new("C:\\.\\a").clean)
+      assert_equal("C:\\a\\b", Pathname.new("C:\\a\\.\\b").clean)
+      assert_equal("C:\\b", Pathname.new("C:\\a\\..\\b").clean)
+      assert_equal("C:\\a", Pathname.new("C:\\a\\.").clean)
+      assert_equal("C:\\d", Pathname.new("C:\\..\\..\\..\\d").clean)
+      assert_equal("C:\\a\\", Pathname.new("C:\\a\\").clean)
+      
+      # Edge cases
+      assert_equal("\\", Pathname.new(".").clean)
+      assert_equal("\\", Pathname.new("..").clean)
+   end
+  
+   def test_absolute
+      assert_equal(true, @fpath.absolute?)
+      assert_equal(true, @bpath.absolute?)
+      assert_equal(true, @upath.absolute?)
+      assert_equal(false, @npath.absolute?)
+      assert_equal(true, @rpath.absolute?)
+      assert_equal(true, @xpath.absolute?)
+      assert_equal(true, @ypath.absolute?)
+      assert_equal(true, @zpath.absolute?)
+      assert_equal(false, @epath.absolute?)
+   end
+   
+   def test_relative
+      assert_equal(false, @fpath.relative?)
+      assert_equal(false, @bpath.relative?)
+      assert_equal(false, @upath.relative?)
+      assert_equal(true, @npath.relative?)
+      assert_equal(false, @rpath.relative?)
+      assert_equal(false, @xpath.relative?)
+      assert_equal(false, @ypath.relative?)
+      assert_equal(false, @zpath.relative?)
+      assert_equal(true, @epath.relative?)
+   end
+   
+   def test_root
+      assert_equal("C:\\", @fpath.root)
+      assert_equal("C:\\", @bpath.root)
+      assert_equal("\\\\foo\\bar", @upath.root)
+      assert_equal(".", @npath.root)
+      assert_equal("Z:\\", @rpath.root)
+      assert_equal("\\\\foo\\bar", @xpath.root)
+      assert_equal("\\\\foo", @ypath.root)
+      assert_equal("\\\\", @zpath.root)
+      assert_equal(".", @epath.root)
+      
+      # Edge cases
+      assert_equal(".", Pathname.new("..").root)
+      assert_equal(".", Pathname.new(".").root)
+   end
+   
+   def test_drive_number
+      assert_equal(2, @fpath.drive_number)
+      assert_equal(2, @bpath.drive_number)
+      assert_equal(nil, @upath.drive_number)
+      assert_equal(nil, @npath.drive_number)
+      assert_equal(25, @rpath.drive_number)
+      assert_equal(nil, @xpath.drive_number)
+      assert_equal(nil, @ypath.drive_number)
+      assert_equal(nil, @zpath.drive_number)
+      assert_equal(nil, @epath.drive_number)
+      
+      # Edge cases
+      assert_equal(nil, Pathname.new("..").drive_number)
+      assert_equal(nil, Pathname.new(".").drive_number)
+   end
+        
+   def test_to_a
+      expected = ["C:", "Program Files", "Windows NT", "Accessories"]
+      assert_equal(expected, @fpath.to_a)
+      assert_equal(expected, @bpath.to_a)
+      assert_equal(["foo","bar","baz"], @upath.to_a)
+      assert_equal(["foo","bar","baz"], @npath.to_a)
+      assert_equal(["Z:"], @rpath.to_a)
+      assert_equal(["foo","bar"], @xpath.to_a)
+      assert_equal(["foo"], @ypath.to_a)
+      assert_equal([], @zpath.to_a)
+      assert_equal([], @epath.to_a)
+   end
+ 
+   def test_is_root
+      assert_equal(false, @fpath.root?)
+      assert_equal(false, @bpath.root?)
+      assert_equal(false, @upath.root?)
+      assert_equal(false, @npath.root?)
+      assert_equal(true, @rpath.root?)
+      assert_equal(true, @xpath.root?)
+      assert_equal(true, @ypath.root?)
+      assert_equal(true, @zpath.root?)
+      assert_equal(false, @epath.root?)
+   end
+   
+   def test_facade_io
+      assert_respond_to(@fpath, :foreach)
+      assert_respond_to(@fpath, :read)
+      assert_respond_to(@fpath, :readlines)
+      assert_respond_to(@fpath, :sysopen)
+   end
+
+   def test_facade_file
+      File.methods(false).each{ |method|
+         assert_respond_to(@fpath, method.to_sym)
+      }
+      assert_respond_to(@fpath, :catname) # ftools check
+   end
+
+   def test_facade_dir
+      Dir.methods(false).each{ |method|
+         assert_respond_to(@fpath, method.to_sym)
+      }
+   end
+   
+   def test_facade_fileutils
+      methods = FileUtils.public_instance_methods
+      methods -= File.methods(false)
+      methods -= Dir.methods(false)
+      methods.delete_if{ |m| m =~ /stream/ }
+      methods.delete_if{ |m| m =~ /^ln/ }
+      methods.delete("identical?")
+
+      methods.each{ |method|
+         assert_respond_to(@fpath, method.to_sym)
+      }
+   end
+   
+   def test_facade_find
+      assert_respond_to(@fpath, :find)
+      assert_nothing_raised{ @fpath.find{} }
+
+      Pathname.new(Dir.pwd).find{ |f|
+         Find.prune if f.match("CVS")
+         assert_kind_of(Pathname, f)
+      }
+   end
+   
+   def teardown
+      @fpath = nil
+      @bpath = nil
+      @upath = nil
+      @npath = nil
+      @rpath = nil
+      @xpath = nil
+      @ypath = nil
+      @zpath = nil
+      @epath = nil
+   end
+end