pathname2 1.6.5-universal-mingw32 → 1.7.1-universal-mingw32

data/test/windows/test_parent.rb

@@ -0,0 +1,37 @@
+########################################################################
+# test_parent.rb
+#
+# Test suite for the Pathname#parent method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Parent < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:\\foo\\bar\\baz")
+  end
+
+  test "parent basic functionality" do
+    assert_respond_to(@path, :parent)
+    assert_nothing_raised{ @path.parent }
+    assert_kind_of(Pathname, @path.parent)
+  end
+
+  test "parent returns expected results for an absolute path" do
+    assert_equal("C:\\foo\\bar", Pathname.new("C:\\foo\\bar\\baz").parent)
+    assert_equal("C:\\", Pathname.new("C:\\foo").parent)
+  end
+
+  test "parent returns expected results for a relative path" do
+    assert_equal("foo", Pathname.new("foo\\bar").parent)
+  end
+
+  test "parent method returns root if already a root path" do
+    assert_equal("C:\\", Pathname.new("C:\\").parent)
+    assert_equal("\\\\foo\\bar", Pathname.new("//foo/bar").parent)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_pstrip.rb

@@ -0,0 +1,42 @@
+########################################################################
+# test_pstrip.rb
+#
+# Test suite for the Pathname#pstrip method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Pstrip < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:/Program Files////")
+  end
+
+  test "pstrip basic functionality" do
+    assert_respond_to(@path, :pstrip)
+    assert_nothing_raised{ @path.pstrip }
+    assert_kind_of(Pathname, @path.pstrip)
+  end
+
+  test "pstrip returns expected result for path with trailing slashes" do
+    assert_equal("C:\\Program Files", @path.pstrip)
+    assert_equal("C:\\Program Files", Pathname.new("C:\\Program Files\\\\").pstrip)
+    assert_equal("C:\\Program Files", Pathname.new("C:\\Program Files//\\").pstrip)
+  end
+
+  test "pstrip returns the path as is if it does not contain a trailing slash" do
+    assert_equal("C:\\Program Files", Pathname.new("C:\\Program Files").pstrip)
+    assert_equal("", Pathname.new("").pstrip)
+  end
+
+  test "pstrip method is not destructive" do
+    str = 'C:/Program Files////'
+    assert_nothing_raised{ Pathname.new(str).pstrip }
+    assert_equal('C:/Program Files////', str)
+  end
+
+  def teardown
+    @abs_path = nil
+    @unc_path = nil
+    @rel_path = nil
+  end
+end

data/test/windows/test_pstrip_bang.rb

@@ -0,0 +1,46 @@
+########################################################################
+# test_pstrip_bang.rb
+#
+# Test suite for the Pathname#pstrip! method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_PstripBang < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:/Program Files////")
+  end
+
+  test "pstrip! basic functionality" do
+    assert_respond_to(@path, :pstrip!)
+    assert_nothing_raised{ @path.pstrip! }
+    assert_kind_of(Pathname, @path.pstrip!)
+  end
+
+  test "pstrip! returns expected result for path with trailing slashes" do
+    assert_equal("C:\\Program Files", @path.pstrip!)
+    assert_equal("C:\\Program Files", Pathname.new("C:\\Program Files\\\\").pstrip!)
+    assert_equal("C:\\Program Files", Pathname.new("C:\\Program Files//\\").pstrip!)
+  end
+
+  test "pstrip! returns the path as is if it does not contain a trailing slash" do
+    assert_equal("C:\\Program Files", Pathname.new("C:\\Program Files").pstrip!)
+    assert_equal("", Pathname.new("").pstrip!)
+  end
+
+  test "pstrip! alters pathname object" do
+    path = Pathname.new('C:/Program Files////')
+    assert_nothing_raised{ path.pstrip! }
+    assert_equal('C:\Program Files', path.to_s)
+  end
+
+  test "pstrip! method does not modify original constructor argument" do
+    str = 'C:/Program Files////'
+    assert_nothing_raised{ Pathname.new(str).pstrip! }
+    assert_equal('C:/Program Files////', str)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_realpath.rb

@@ -0,0 +1,39 @@
+########################################################################
+# test_realpath.rb
+#
+# Test suite for the Pathname#realpath method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Realpath < Test::Unit::TestCase
+  def setup
+    @cwd  = Dir.pwd.tr('/', "\\")
+    @path = Pathname.new(Dir.pwd)
+  end
+
+  test "realpath basic functionality" do
+    assert_respond_to(@path, :realpath)
+    assert_nothing_raised{ @path.realpath }
+    assert_kind_of(String, @path.realpath)
+  end
+
+  test "realpath returns the expected result" do
+    assert_equal(@cwd, @path.realpath)
+  end
+
+  test "realpath fails if the path does not exist" do
+    assert_raise(Errno::ENOENT){ Pathname.new("C:/Bogus/AlsoBogus").realpath }
+  end
+
+  test "realpath method is not destructive" do
+    str = 'C:/Program Files'
+    assert_nothing_raised{ Pathname.new(str).realpath }
+    assert_equal('C:/Program Files', str)
+  end
+
+  def teardown
+    @cwd  = nil
+    @path = nil
+  end
+end

data/test/windows/test_relative_path_from.rb

@@ -0,0 +1,60 @@
+########################################################################
+# test_relative_path_from.rb
+#
+# Test suite for the Pathname#relative_path_from method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_RelativePathFrom < Test::Unit::TestCase
+  def assert_relpath(result, dest, base)
+    assert_equal(result, Pathname.new(dest).relative_path_from(base))
+  end
+
+  def assert_relative_path_error(to, from)
+    assert_raise(ArgumentError){ Pathname.new(to).relative_path_from(from) }
+  end
+
+  test "relative_path_from works as expected between two relative paths" do
+    assert_relpath("..\\a", 'a', 'b')
+    assert_relpath("..\\a", 'a', 'b/')
+    assert_relpath("..\\a", 'a/', 'b')
+    assert_relpath("..\\a", 'a/', 'b/')
+    assert_relpath("..\\b", "a\\b", "a\\c")
+    assert_relpath("..\\a", "..\\a", "..\\b")
+    assert_relpath("..\\b\\c", "a\\b\\c", "a\\d")
+    assert_relpath("..", "a\\..", "a")
+    assert_relpath(".", "a\\..\\b", "b")
+    assert_relpath("a", "a", "b\\..")
+    assert_relpath("b\\c", "b\\c", "b\\..")
+  end
+
+  test "relative_path_from works as expected between two absolute paths" do
+    assert_relpath("..\\a", "c:\\a", "c:\\b")
+    assert_relpath("..\\a", "c:\\a", "c:\\b\\")
+    assert_relpath("..\\a", "c:\\a\\", "c:\\b")
+    assert_relpath("..\\a", "c:\\a\\", "c:\\b\\")
+    assert_relpath("c\\d", "c:\\a\\b\\c\\d", "c:\\a\\b")
+    assert_relpath("..\\..", "c:\\a\\b", "c:\\a\\b\\c\\d")
+    assert_relpath("..\\..\\..\\..\\e", "c:\\e", "c:\\a\\b\\c\\d")
+    assert_relpath("..\\a", "c:\\..\\a", "c:\\b")
+    assert_relpath(".", "c:\\a\\..\\..\\b", "c:\\b")
+  end
+
+  test "relative_path_from works as expected between for . and .." do
+    assert_relpath("a", "a", ".")
+    assert_relpath("..", ".", "a")
+    assert_relpath(".", ".", ".")
+    assert_relpath(".", "..", "..")
+    assert_relpath("..", "..", ".")
+  end
+
+  test "relative_path_from is not allowed between relative and absolute paths" do
+    assert_relative_path_error("c:\\", ".")
+    assert_relative_path_error(".", "c:\\")
+    assert_relative_path_error("a", "..")
+    assert_relative_path_error(".", "..")
+    assert_relative_path_error("C:\\Temp", "D:\\Temp")
+    assert_relative_path_error("\\\\Server\\Temp", "D:\\Temp")
+  end
+end

data/test/windows/test_root.rb

@@ -0,0 +1,59 @@
+########################################################################
+# test_root.rb
+#
+# Test suite for the Pathname#root method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Root < 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 "root method returns expected results for absolute paths" do
+    assert_equal("C:\\", @abs_path.root)
+  end
+
+  test "root method returns expected results for paths with forward slashes" do
+    assert_equal("C:\\", Pathname.new("C:/Program Files").root)
+  end
+
+  test "root method returns expected results for unc paths" do
+    assert_equal("\\\\foo\\bar", @unc_path.root)
+    assert_equal("\\\\foo", Pathname.new("\\\\foo").root)
+    assert_equal("\\\\", Pathname.new("\\\\").root)
+  end
+
+  test "root method returns dot for relative paths" do
+    assert_equal('.', @rel_path.root)
+  end
+
+  test "root method returns expected result for root path" do
+    assert_equal("Z:\\", Pathname.new("Z:\\").root)
+    assert_equal("\\\\foo\\bar", Pathname.new("\\\\foo\\bar").root)
+  end
+
+  test "root method returns expected result for empty string" do
+    assert_equal(".", Pathname.new("").root)
+  end
+
+  test "root method returns expected result for dot and dotdot" do
+    assert_equal(".", Pathname.new("..").root)
+    assert_equal(".", Pathname.new(".").root)
+  end
+
+  test "root method is not destructive" do
+    str = 'C:/Program Files'
+    assert_nothing_raised{ Pathname.new(str).root }
+    assert_equal('C:/Program Files', str)
+  end
+
+  def teardown
+    @abs_path = nil
+    @unc_path = nil
+    @rel_path = nil
+  end
+end

data/test/windows/test_short_path.rb

@@ -0,0 +1,41 @@
+########################################################################
+# test_short_path.rb
+#
+# Test suite for the Pathname#short_path method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_ShortPath < Test::Unit::TestCase
+  def setup
+    @abs_path = Pathname.new("C:\\Program Files")
+  end
+
+  test "short_path basic functionality" do
+    assert_respond_to(@abs_path, :short_path)
+    assert_nothing_raised{ @abs_path.short_path }
+    assert_kind_of(String, @abs_path.short_path)
+  end
+
+  test "short_path returns the expected result" do
+    assert_equal("C:\\PROGRA~1", @abs_path.short_path)
+  end
+
+  test "short_path returns the same string if it's already short" do
+    assert_equal("C:\\", Pathname.new("C:/").short_path)
+  end
+
+  test "short_path fails if the path does not exist" do
+    assert_raise(Errno::ESRCH){ Pathname.new("C:/Bogus/AlsoBogus").short_path }
+  end
+
+  test "short_path method is not destructive" do
+    str = 'C:/Program Files'
+    assert_nothing_raised{ Pathname.new(str).short_path }
+    assert_equal('C:/Program Files', str)
+  end
+
+  def teardown
+    @abs_path = nil
+  end
+end

data/test/windows/test_to_a.rb

@@ -0,0 +1,46 @@
+########################################################################
+# test_to_a.rb
+#
+# Test suite for the Pathname#to_a method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_ToA < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new('C:/Program Files/foo')
+  end
+
+  test "to_a basic functionality" do
+    assert_respond_to(@path, :to_a)
+    assert_nothing_raised{ @path.to_a }
+    assert_kind_of(Array, @path.to_a)
+  end
+
+  test "to_a returns the expected results for standard paths" do
+    assert_equal(['C:'], Pathname.new('C:/').to_a)
+    assert_equal(['C:', 'Program Files'], Pathname.new('C:/Program Files').to_a)
+    assert_equal(['C:', 'Program Files', 'Stuff'], Pathname.new('C:/Program Files/Stuff').to_a)
+    assert_equal(['C:', 'Users'], Pathname.new("C:\\Users").to_a)
+  end
+
+  test "to_a returns the expected results for unc paths" do
+    assert_equal(['foo', 'bar', 'baz'], Pathname.new('//foo/bar/baz').to_a)
+    assert_equal(['foo', 'bar'], Pathname.new('//foo/bar').to_a)
+    assert_equal(['foo'], Pathname.new('//foo').to_a)
+  end
+
+  test "to_a returns the expected results for empty strings and empty unc paths" do
+    assert_equal([], Pathname.new('').to_a)
+    assert_equal([], Pathname.new('//').to_a)
+  end
+
+  test "to_a does not modify receiver" do
+    @path.to_a
+    assert_equal('C:\Program Files\foo', @path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_undecorate.rb

@@ -0,0 +1,47 @@
+########################################################################
+# test_undecorate.rb
+#
+# Test suite for the Pathname#undecorate method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Undecorate < Test::Unit::TestCase
+  def setup
+    @std = Pathname.new('C:/Path/File.txt')
+  end
+
+  test "undecorate basic functionality" do
+    assert_respond_to(@std, :undecorate)
+    assert_nothing_raised{ @std.undecorate }
+  end
+
+  test "undecorate returns a Pathname object" do
+    assert_kind_of(Pathname, @std.undecorate)
+  end
+
+  test "undecorate method returns an already undecorated path unchanged" do
+    assert_equal('C:\Path\File.txt', Pathname.new('C:\Path\File.txt').undecorate)
+    assert_equal('\\foo\bar', Pathname.new('\\foo\bar').undecorate)
+  end
+
+  test "undecorate returns expected result for standard path" do
+    assert_equal('C:\Path\File', Pathname.new('C:\Path\File[12]').undecorate)
+    assert_equal('C:\Path\[3].txt', Pathname.new('C:\Path\[3].txt').undecorate)
+  end
+
+  test "undecorate returns expected result for UNC path" do
+    assert_equal('\\foo\bar.txt',Pathname.new('\\foo\bar[5].txt').undecorate)
+    assert_equal('\\foo\bar', Pathname.new('\\foo\bar[5]').undecorate)
+  end
+
+  test "undecorate does not modify the original string" do
+    str = 'C:/Path/File.txt'
+    assert_nothing_raised{ Pathname.new(str).undecorate }
+    assert_equal('C:/Path/File.txt', str)
+  end
+
+  def teardown
+    @std = nil
+  end
+end

data/test/windows/test_undecorate_bang.rb

@@ -0,0 +1,53 @@
+########################################################################
+# test_undecorate_bang.rb
+#
+# Test suite for the Pathname#undecorate! method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_UndecorateBang < Test::Unit::TestCase
+  def setup
+    @std = Pathname.new('C:/Path/File.txt')
+  end
+
+  test "undecorate! basic functionality" do
+    assert_respond_to(@std, :undecorate!)
+    assert_nothing_raised{ @std.undecorate! }
+  end
+
+  test "undecorate! returns a Pathname object" do
+    assert_kind_of(Pathname, @std.undecorate!)
+  end
+
+  test "undecorate! method returns an already undecorated path unchanged" do
+    assert_equal('C:\Path\File.txt', Pathname.new('C:\Path\File.txt').undecorate!)
+    assert_equal('\\foo\bar', Pathname.new('\\foo\bar').undecorate!)
+  end
+
+  test "undecorate! returns expected result for standard path" do
+    assert_equal('C:\Path\File', Pathname.new('C:\Path\File[12]').undecorate!)
+    assert_equal('C:\Path\[3].txt', Pathname.new('C:\Path\[3].txt').undecorate!)
+  end
+
+  test "undecorate! returns expected result for UNC path" do
+    assert_equal('\\foo\bar.txt',Pathname.new('\\foo\bar[5].txt').undecorate!)
+    assert_equal('\\foo\bar', Pathname.new('\\foo\bar[5]').undecorate!)
+  end
+
+  test "undecorate! does not modify the original string" do
+    str = 'C:/Path/File.txt'
+    assert_nothing_raised{ Pathname.new(str).undecorate }
+    assert_equal('C:/Path/File.txt', str)
+  end
+
+  test "undecorate does modify the object itself" do
+    path = Pathname.new('C:\Path\File[12]')
+    assert_nothing_raised{ path.undecorate! }
+    assert_equal('C:\Path\File', path)
+  end
+
+  def teardown
+    @std = nil
+  end
+end