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

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

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 "exists? facade works as expected" do
+    assert_respond_to(@path, :exists?)
+    assert_nothing_raised{ @path.exists? }
+    assert_true(Pathname.new("C:\\").exists?)
+    assert_false(Pathname.new("X:\\foo\\bar\\baz").exists?)
+  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_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