pathname2 1.8.2

data/test/test_version.rb

@@ -0,0 +1,17 @@
+########################################################################
+# test_version.rb
+#
+# Universal test file that tests for the proper version number.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Version < Test::Unit::TestCase
+  test "version is set to expected value" do
+    assert_equal('1.8.1', Pathname::VERSION)
+  end
+
+  test "version is frozen" do
+    assert_true(Pathname::VERSION.frozen?)
+  end
+end

data/test/windows/test_append.rb

@@ -0,0 +1,59 @@
+########################################################################
+# test_append.rb
+#
+# Test suite for the Pathname#append method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Append < Test::Unit::TestCase
+  def setup
+    @abs_path = Pathname.new("C:\\foo\\bar")
+    @rel_path = Pathname.new("foo\\bar\\baz")
+  end
+
+  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
+
+  test "appending a string to an absolute path works as expected" do
+    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")
+  end
+
+  test "appending a string to a UNC path works as expected" do
+    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
+
+  test "appending a plain string to a path works as expected" do
+    assert_nothing_raised{ @abs_path + "bar" }
+    assert_equal('C:\foo\bar\baz', @abs_path + 'baz')
+    assert_equal('C:\foo\bar', @abs_path)
+  end
+
+  test "appending an absolute path results in that absolute path" do
+    assert_pathname_plus('C:\foo\bar', @rel_path, @abs_path)
+  end
+
+  test "neither receiver nor argument are modified" do
+    assert_nothing_raised{ @abs_path + @rel_path }
+    assert_equal('C:\foo\bar\foo\bar\baz', @abs_path + @rel_path)
+    assert_equal('C:\foo\bar', @abs_path)
+    assert_equal('foo\bar\baz', @rel_path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_aref.rb

@@ -0,0 +1,37 @@
+########################################################################
+# test_aref.rb
+#
+# Test suite for the Pathname#[] method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Aref < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:/Program Files/Windows NT/Accessories")
+  end
+
+  test "[] with index works as expected" do
+    assert_equal("C:", @path[0])
+    assert_equal("Program Files", @path[1])
+    assert_equal("Accessories", @path[-1])
+    assert_nil(@path[10])
+  end
+
+  test "[] with range argument works as expected" do
+    assert_equal("C:\\Program Files", @path[0..1])
+    assert_equal("C:\\Program Files\\Windows NT", @path[0..2])
+    assert_equal("Program Files\\Windows NT", @path[1..2])
+    #assert_equal(@path, @path[0..-1]) # TODO: Spews tons of warnings
+  end
+
+  test "[] with index and length works as expected" do
+    assert_equal("C:", @path[0,1])
+    assert_equal("C:\\Program Files", @path[0,2])
+    assert_equal("Program Files\\Windows NT", @path[1,2])
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_ascend.rb

@@ -0,0 +1,51 @@
+########################################################################
+# test_ascend.rb
+#
+# Test suite for the Pathname#ascend method.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Ascend < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:\\foo\\bar\\baz")
+  end
+
+  test "ascend basic functionality" do
+    assert_respond_to(@path, :ascend)
+    assert_nothing_raised{ @path.ascend{} }
+  end
+
+  test "ascend works as expected on a standard absolute path" do
+    array = []
+    @path.ascend{ |e| array << e }
+    assert_equal('C:\foo\bar\baz', array[0])
+    assert_equal('C:\foo\bar', array[1])
+    assert_equal('C:\foo', array[2])
+    assert_equal('C:', array[3])
+  end
+
+  test "ascend works as expected on a UNC path" do
+    array = []
+    Pathname.new('//foo/bar/baz').ascend{ |e| array << e }
+    assert_equal("\\\\foo\\bar\\baz", array[0])
+    assert_equal("\\\\foo\\bar", array[1])
+  end
+
+  test "ascend works as expected on a relative path" do
+    array = []
+    Pathname.new('foo/bar/baz').ascend{ |e| array << e }
+    assert_equal('foo\bar\baz', array[0])
+    assert_equal('foo\bar', array[1])
+    assert_equal('foo', array[2])
+  end
+
+  test "ascend does not modify the receiver" do
+    @path.ascend{}
+    assert_equal('C:\foo\bar\baz', @path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_children.rb

@@ -0,0 +1,42 @@
+########################################################################
+# test_children.rb
+#
+# Test suite for the Pathname#children method.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Children < Test::Unit::TestCase
+  def setup
+    @dir  = 'foo'
+    @path = Pathname.new(File.dirname(File.dirname(__FILE__)))
+
+    Dir.mkdir(@dir)
+    Dir.chdir(@dir){
+      FileUtils.touch('alpha')
+      FileUtils.touch('beta')
+      FileUtils.touch('gamma')
+    }
+  end
+
+  test "children basic functionality" do
+    assert_respond_to(@path, :children)
+    assert_nothing_raised{ @path.children{} }
+    assert_kind_of(Array, @path.children)
+  end
+
+  test "children method returns expected results" do
+    path = Pathname.new(@dir)
+    assert_equal(%w[foo\alpha foo\beta foo\gamma], path.children)
+  end
+
+  test "each result of the children method is a Pathname object" do
+    path = Pathname.new(@dir)
+    assert_kind_of(Pathname, path.children.first)
+  end
+
+  def teardown
+    FileUtils.rm_rf(@dir) if File.exist?(@dir)
+    @path = nil
+  end
+end

data/test/windows/test_clean.rb

@@ -0,0 +1,50 @@
+########################################################################
+# test_clean.rb
+#
+# Test suite for the Pathname#clean method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Clean < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:\\foo\\..\\bar\\.\\baz")
+  end
+
+  test "clean basic functionality" do
+    assert_respond_to(@path, :clean)
+    assert_nothing_raised{ @path.clean }
+    assert_kind_of(Pathname, @path.clean)
+  end
+
+  test "clean returns expected results for unclean paths" do
+    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)
+  end
+
+  test "clean returns already clean paths unmodified" do
+    assert_equal("C:\\", Pathname.new("C:\\").clean)
+    assert_equal("C:\\a", Pathname.new("C:\\a").clean)
+    assert_equal("C:\\a\\", Pathname.new("C:\\a\\").clean)
+    assert_equal("\\\\foo\\bar", Pathname.new("\\\\foo\\bar").clean)
+    assert_equal("a", Pathname.new("a").clean)
+  end
+
+  test "clean returns a slash for . and .." do
+    assert_equal("\\", Pathname.new(".").clean)
+    assert_equal("\\", Pathname.new("..").clean)
+  end
+
+  test "clean does not modify receiver" do
+    @path.clean
+    assert_equal("C:\\foo\\..\\bar\\.\\baz", @path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_clean_bang.rb

@@ -0,0 +1,50 @@
+########################################################################
+# test_clean_bang.rb
+#
+# Test suite for the Pathname#clean! method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_CleanBang < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:\\foo\\..\\bar\\.\\baz")
+  end
+
+  test "clean basic functionality" do
+    assert_respond_to(@path, :clean!)
+    assert_nothing_raised{ @path.clean! }
+    assert_kind_of(Pathname, @path.clean!)
+  end
+
+  test "clean returns expected results for unclean paths" do
+    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!)
+  end
+
+  test "clean returns already clean paths unmodified" do
+    assert_equal("C:\\", Pathname.new("C:\\").clean!)
+    assert_equal("C:\\a", Pathname.new("C:\\a").clean!)
+    assert_equal("C:\\a\\", Pathname.new("C:\\a\\").clean!)
+    assert_equal("\\\\foo\\bar", Pathname.new("\\\\foo\\bar").clean!)
+    assert_equal("a", Pathname.new("a").clean!)
+  end
+
+  test "clean returns a slash for . and .." do
+    assert_equal("\\", Pathname.new(".").clean!)
+    assert_equal("\\", Pathname.new("..").clean!)
+  end
+
+  test "clean! modifies receiver" do
+    @path.clean!
+    assert_equal("C:\\bar\\baz", @path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_constructor.rb

@@ -0,0 +1,48 @@
+########################################################################
+# test_constructor.rb
+#
+# Various tests for the Pathname.new method.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Constructor < Test::Unit::TestCase
+  def setup
+    @abs_path = "C:/Users"
+    @rel_path = "Users"
+    @url_path = "file:///C:/Documents%20and%20Settings"
+  end
+
+  test "constructor handles absolute paths properly" do
+    assert_nothing_raised{ Pathname.new(@abs_path) }
+    assert_equal("C:\\Users", Pathname.new(@abs_path).to_s)
+  end
+
+  test "constructor handles relative paths properly" do
+    assert_nothing_raised{ Pathname.new(@rel_path) }
+    assert_equal("Users", Pathname.new(@rel_path).to_s)
+  end
+
+  test "constructor handles file URL's properly" do
+    assert_nothing_raised{ Pathname.new(@url_path) }
+    assert_equal("C:\\Documents and Settings", Pathname.new(@url_path).to_s)
+  end
+
+  test "constructor returns a Pathname object" do
+    assert_kind_of(Pathname, Pathname.new(@abs_path))
+  end
+
+  test "constructor handles frozen arguments without issue" do
+    assert_nothing_raised{ Pathname.new(@abs_path.freeze) }
+  end
+
+  test "constructor raises an error if string argument is too long" do
+    assert_raise(ArgumentError){ Pathname.new("foo" * 1000) }
+  end
+
+  def teardown
+    @url_path = nil
+    @rel_path = nil
+    @abs_path = nil
+  end
+end

data/test/windows/test_descend.rb

@@ -0,0 +1,51 @@
+########################################################################
+# test_descend.rb
+#
+# Test suite for the Pathname#descend method.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Descend < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:\\foo\\bar\\baz")
+  end
+
+  test "descend basic functionality" do
+    assert_respond_to(@path, :descend)
+    assert_nothing_raised{ @path.descend{} }
+  end
+
+  test "descend works as expected on a standard absolute path" do
+    array = []
+    @path.descend{ |e| array << e }
+    assert_equal('C:', array[0])
+    assert_equal('C:\foo', array[1])
+    assert_equal('C:\foo\bar', array[2])
+    assert_equal('C:\foo\bar\baz', array[3])
+  end
+
+  test "descend works as expected on a UNC path" do
+    array = []
+    Pathname.new('//foo/bar/baz').descend{ |e| array << e }
+    assert_equal("\\\\foo\\bar", array[0])
+    assert_equal("\\\\foo\\bar\\baz", array[1])
+  end
+
+  test "descend works as expected on a relative path" do
+    array = []
+    Pathname.new('foo/bar/baz').descend{ |e| array << e }
+    assert_equal('foo', array[0])
+    assert_equal('foo\bar', array[1])
+    assert_equal('foo\bar\baz', array[2])
+  end
+
+  test "descend does not modify the receiver" do
+    @path.descend{}
+    assert_equal('C:\foo\bar\baz', @path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_drive_number.rb

@@ -0,0 +1,58 @@
+########################################################################
+# test_drive_number.rb
+#
+# Test suite for the Pathname#drive_number method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_DriveNumber < Test::Unit::TestCase
+  def setup
+    @abs_path = Pathname.new("C:\\Program Files")
+    @unc_path = Pathname.new("\\\\foo\\bar\\baz")
+    @rel_path = Pathname.new("foo\\bar\\baz")
+  end
+
+  test "drive_number method returns expected results for absolute paths" do
+    assert_equal(2, @abs_path.drive_number)
+  end
+
+  test "drive_number method returns expected results for paths with forward slashes" do
+    assert_equal(2, Pathname.new("C:/Program Files").drive_number)
+  end
+
+  test "drive_number method returns expected results for unc paths" do
+    assert_nil(@unc_path.drive_number)
+    assert_nil(Pathname.new("\\\\foo").drive_number)
+    assert_nil(Pathname.new("\\\\").drive_number)
+  end
+
+  test "drive_number method returns dot for relative paths" do
+    assert_nil(@rel_path.drive_number)
+  end
+
+  test "drive_number method returns expected result for root path" do
+    assert_equal(25, Pathname.new("Z:\\").drive_number)
+  end
+
+  test "drive_number method returns expected result for empty string" do
+    assert_nil(Pathname.new("").drive_number)
+  end
+
+  test "drive_number method returns expected result for dot and dotdot" do
+    assert_nil(Pathname.new(".").drive_number)
+    assert_nil(Pathname.new("..").drive_number)
+  end
+
+  test "drive_number method is not destructive" do
+    str = 'C:/Program Files'
+    assert_nothing_raised{ Pathname.new(str).drive_number }
+    assert_equal('C:/Program Files', str)
+  end
+
+  def teardown
+    @abs_path = nil
+    @unc_path = nil
+    @rel_path = nil
+  end
+end