pathname2 1.8.2

data/test/windows/test_each.rb

@@ -0,0 +1,28 @@
+########################################################################
+# test_each.rb
+#
+# Test suite for the Pathname#each method.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Each < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:/Users/foo/bar")
+  end
+
+  test "each basic functionality" do
+    assert_respond_to(@path, :each)
+    assert_nothing_raised{ @path.each{} }
+  end
+
+  test "each returns the expected results" do
+    arr = []
+    @path.each{ |e| arr << e }
+    assert_equal(['C:', 'Users', 'foo', 'bar'], arr)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_facade.rb

@@ -0,0 +1,64 @@
+########################################################################
+# test_facade.rb
+#
+# Test suite for the various facade methods.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Facade < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:/Program Files")
+  end
+
+  test "file facade methods are defined" do
+    File.methods(false).each{ |m| assert_respond_to(@path, m.to_sym) }
+  end
+
+  test "dir facade methods are defined" do
+    Dir.methods(false).each{ |m| assert_respond_to(@path, m.to_sym) }
+  end
+
+  test "fileutils facade methods are defined" do
+    methods = FileUtils.public_instance_methods
+    methods -= File.methods(false)
+    methods -= Dir.methods(false)
+
+    # Ruby 1.9.x and 2.0 incorrectly made some of these methods public
+    methods.delete_if{ |m|
+      m =~ /stream|^ln|identical\?|mode_to_s|^sh|ruby|safe_ln|split_all/i
+    }
+
+    methods.each{ |method|
+      assert_respond_to(@path, method.to_sym)
+    }
+  end
+
+  test "find facade works as expected" do
+    assert_respond_to(@path, :find)
+    assert_nothing_raised{ @path.find{} }
+
+    Pathname.new(Dir.pwd).find{ |f|
+      Find.prune if f.match("git")
+      assert_kind_of(Pathname, f)
+    }
+  end
+
+  test "custom io methods are defined" do
+    assert_respond_to(@path, :foreach)
+    assert_respond_to(@path, :read)
+    assert_respond_to(@path, :readlines)
+    assert_respond_to(@path, :sysopen)
+  end
+
+  test "exist? facade works as expected" do
+    assert_respond_to(@path, :exist?)
+    assert_nothing_raised{ @path.exist? }
+    assert_true(Pathname.new("C:\\").exist?)
+    assert_false(Pathname.new("X:\\foo\\bar\\baz").exist?)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_is_absolute.rb

@@ -0,0 +1,47 @@
+########################################################################
+# test_is_absolute.rb
+#
+# Test suite for the Pathname#absolute method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_IsAbsolute < Test::Unit::TestCase
+  def setup
+    @abs_std = Pathname.new("C:/foo/bar/baz")
+    @abs_unc = Pathname.new("//foo/bar/baz")
+  end
+
+  test "absolute? basic functionality" do
+    assert_respond_to(@abs_std, :absolute?)
+    assert_nothing_raised{ @abs_std.absolute? }
+    assert_boolean(@abs_std.absolute?)
+  end
+
+  test "absolute? method returns true for absolute paths" do
+    assert_true(@abs_std.absolute?)
+    assert_true(@abs_unc.absolute?)
+  end
+
+  test "absolute? method returns false for non-absolute paths" do
+    assert_false(Pathname.new("foo").absolute?)
+    assert_false(Pathname.new("foo/bar").absolute?)
+  end
+
+  test "absolute? method returns false for empty path" do
+    assert_false(Pathname.new("").absolute?)
+  end
+
+  test "absolute? method is not destructive" do
+    str = 'C:/foo'
+    path = Pathname.new(str)
+    assert_nothing_raised{ path.absolute? }
+    assert_equal('C:\foo', path.to_s)
+    assert_equal('C:/foo', str)
+  end
+
+  def teardown
+    @std_absolute = nil
+    @unc_absolute = nil
+  end
+end

data/test/windows/test_is_relative.rb

@@ -0,0 +1,46 @@
+########################################################################
+# test_is_relative.rb
+#
+# Test suite for the Pathname#relative method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_IsRelative < Test::Unit::TestCase
+  def setup
+    @relative = Pathname.new("foo/bar")
+    @absolute = Pathname.new("C:/foo/bar")
+  end
+
+  test "relative? basic functionality" do
+    assert_respond_to(@relative, :relative?)
+    assert_nothing_raised{ @relative.relative? }
+    assert_boolean(@relative.relative?)
+  end
+
+  test "relative? method returns true for relative paths" do
+    assert_true(@relative.relative?)
+  end
+
+  test "relative? method returns false for non-relative paths" do
+    assert_false(@absolute.relative?)
+    assert_false(Pathname.new("//foo/bar").relative?)
+  end
+
+  test "relative? method returns true for empty path" do
+    assert_true(Pathname.new("").relative?)
+  end
+
+  test "relative? method is not destructive" do
+    str = 'C:/foo'
+    path = Pathname.new(str)
+    assert_nothing_raised{ path.relative? }
+    assert_equal('C:\foo', path.to_s)
+    assert_equal('C:/foo', str)
+  end
+
+  def teardown
+    @std_relative = nil
+    @unc_relative = nil
+  end
+end

data/test/windows/test_is_root.rb

@@ -0,0 +1,44 @@
+########################################################################
+# test_is_root.rb
+#
+# Test suite for the Pathname#root method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_IsRoot < Test::Unit::TestCase
+  def setup
+    @std_root = Pathname.new("C:\\")
+    @unc_root = Pathname.new("\\\\foo\\bar")
+  end
+
+  test "root? basic functionality" do
+    assert_respond_to(@std_root, :root?)
+    assert_nothing_raised{ @std_root.root? }
+    assert_boolean(@std_root.root?)
+  end
+
+  test "root? method returns true for root paths" do
+    assert_true(@std_root.root?)
+    assert_true(@unc_root.root?)
+  end
+
+  test "root? method returns false for non-root paths" do
+    assert_false(Pathname.new("C:/foo").root?)
+    assert_false(Pathname.new("//foo/bar/baz").root?)
+    assert_false(Pathname.new("").root?)
+  end
+
+  test "root? method is not destructive" do
+    str = 'C:/foo'
+    path = Pathname.new(str)
+    assert_nothing_raised{ path.root }
+    assert_equal('C:\foo', path.to_s)
+    assert_equal('C:/foo', str)
+  end
+
+  def teardown
+    @std_root = nil
+    @unc_root = nil
+  end
+end

data/test/windows/test_is_unc.rb

@@ -0,0 +1,51 @@
+########################################################################
+# test_is_unc.rb
+#
+# Test suite for the Pathname#unc? method
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_IsUNC < 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 "unc? basic functionality" do
+    assert_respond_to(@unc_path, :unc?)
+    assert_nothing_raised{ @unc_path.unc? }
+    assert_boolean(@unc_path.unc?)
+  end
+
+  test "unc? method returns false for non-unc paths" do
+    assert_false(Pathname.new("C:\\").unc?)
+    assert_false(Pathname.new("C:\\Program Files").unc?)
+    assert_false(Pathname.new("C:\\\\Program Files").unc?)
+    assert_false(Pathname.new("C:/Program Files/File.txt").unc?)
+    assert_false(Pathname.new("C:\\Program Files\\File[12].txt").unc?)
+    assert_false(Pathname.new("foo\\bar").unc?)
+    assert_false(Pathname.new(".").unc?)
+  end
+
+  test "unc? method returns true for unc paths" do
+    assert_true(Pathname.new("\\\\foo\\bar").unc?)
+    assert_true(Pathname.new("//foo/bar").unc?)
+    assert_true(Pathname.new("\\\\foo\\bar\\baz").unc?)
+    assert_true(Pathname.new("\\\\foo").unc?)
+    assert_true(Pathname.new("\\\\").unc?)
+  end
+
+  test "unc? method is not destructive" do
+    str = '//foo/bar'
+    assert_nothing_raised{ Pathname.new(str).unc? }
+    assert_equal('//foo/bar', str)
+  end
+
+  def teardown
+    @abs_path = nil
+    @unc_path = nil
+    @rel_path = nil
+  end
+end

data/test/windows/test_join.rb

@@ -0,0 +1,52 @@
+########################################################################
+# test_join.rb
+#
+# Test suite for the Pathname#join method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Join < Test::Unit::TestCase
+  def setup
+    @apath = Pathname.new("C:\\foo\\bar")
+    @rpath = Pathname.new("foo\\bar\\baz")
+  end
+
+  def assert_pathname_join(final, initial, *rest)
+    a = Pathname.new(final)
+    b = Pathname.new(initial)
+    assert_equal(a, b.join(*rest))
+  end
+
+  test "join method accepts one or more arguments" do
+    assert_nothing_raised{ @apath.join("foo") }
+    assert_nothing_raised{ @apath.join("foo", "bar") }
+    assert_nothing_raised{ @apath.join("foo", "bar", "baz") }
+  end
+
+  test "join method returns expected results when joining relative paths to an absolute path" do
+    assert_pathname_join("C:\\foo", "C:\\", "foo")
+    assert_pathname_join("C:\\foo\\bar", "C:\\foo", "bar")
+    assert_pathname_join("C:\\foo\\bar\\baz", "C:\\foo", "bar", "baz")
+  end
+
+  test "join method returns expected results when joining relative paths to a relative path" do
+    assert_pathname_join("foo\\bar", "foo", "bar")
+    assert_pathname_join("foo\\bar\\baz", "foo", "bar", "baz")
+  end
+
+  test "join method returns expected results when joining an absolute path to an absolute path" do
+    assert_pathname_join("D:\\", "C:\\", "D:\\")
+    assert_pathname_join("D:\\foo", "C:\\", "D:\\", "foo")
+    assert_pathname_join("D:\\", "C:\\", "foo", "bar", "D:\\")
+  end
+
+  test "join returns an instance of Pathname" do
+    assert_kind_of(Pathname, @apath.join("foo"))
+  end
+
+  def teardown
+    @apath = nil
+    @rpath = nil
+  end
+end

data/test/windows/test_long_path.rb

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

data/test/windows/test_misc.rb

@@ -0,0 +1,33 @@
+########################################################################
+# test_misc.rb
+#
+# Test suite for miscellaneous items that didn't warrant their own
+# test file.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class MyPathname < Pathname; end
+
+class TC_Pathname_Misc < Test::Unit::TestCase
+  def setup
+    @mypath = MyPathname.new(Dir.pwd)
+  end
+
+  test "subclasses return instances of that subclass" do
+    assert_kind_of(MyPathname, @mypath)
+    assert_kind_of(MyPathname, @mypath + MyPathname.new('foo'))
+    assert_kind_of(MyPathname, @mypath.realpath)
+  end
+
+  test "custom pn method works as expected" do
+    assert_respond_to(Kernel, :pn)
+    assert_nothing_raised{ pn{'c:\foo'} }
+    assert_kind_of(Pathname, pn{'c:\foo'})
+    assert_equal('c:\foo', pn{'c:\foo'})
+  end
+
+  def teardown
+    @mypath = nil
+  end
+end

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