pathname2 1.8.4 → 2.0.0

data/test/windows/test_descend.rb

@@ -1,14 +1,14 @@
 ########################################################################
 # test_descend.rb
 #
-# Test suite for the Pathname#descend method.
+# Test suite for the Pathname2#descend method.
 ########################################################################
 require 'pathname2'
 require 'test-unit'
 
-class TC_Pathname_Descend < Test::Unit::TestCase
+class TC_Pathname2_Descend < Test::Unit::TestCase
   def setup
-    @path = Pathname.new("C:\\foo\\bar\\baz")
+    @path = Pathname2.new("C:\\foo\\bar\\baz")
   end
 
   test "descend basic functionality" do
@@ -27,14 +27,14 @@ class TC_Pathname_Descend < Test::Unit::TestCase
 
   test "descend works as expected on a UNC path" do
     array = []
-    Pathname.new('//foo/bar/baz').descend{ |e| array << e }
+    Pathname2.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 }
+    Pathname2.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])

data/test/windows/test_drive_number.rb

@@ -1,16 +1,16 @@
 ########################################################################
 # test_drive_number.rb
 #
-# Test suite for the Pathname#drive_number method
+# Test suite for the Pathname2#drive_number method
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_DriveNumber < Test::Unit::TestCase
+class TC_Pathname2_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")
+    @abs_path = Pathname2.new("C:\\Program Files")
+    @unc_path = Pathname2.new("\\\\foo\\bar\\baz")
+    @rel_path = Pathname2.new("foo\\bar\\baz")
   end
 
   test "drive_number method returns expected results for absolute paths" do
@@ -18,13 +18,13 @@ class TC_Pathname_DriveNumber < Test::Unit::TestCase
   end
 
   test "drive_number method returns expected results for paths with forward slashes" do
-    assert_equal(2, Pathname.new("C:/Program Files").drive_number)
+    assert_equal(2, Pathname2.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)
+    assert_nil(Pathname2.new("\\\\foo").drive_number)
+    assert_nil(Pathname2.new("\\\\").drive_number)
   end
 
   test "drive_number method returns dot for relative paths" do
@@ -32,21 +32,21 @@ class TC_Pathname_DriveNumber < Test::Unit::TestCase
   end
 
   test "drive_number method returns expected result for root path" do
-    assert_equal(25, Pathname.new("Z:\\").drive_number)
+    assert_equal(25, Pathname2.new("Z:\\").drive_number)
   end
 
   test "drive_number method returns expected result for empty string" do
-    assert_nil(Pathname.new("").drive_number)
+    assert_nil(Pathname2.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)
+    assert_nil(Pathname2.new(".").drive_number)
+    assert_nil(Pathname2.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_nothing_raised{ Pathname2.new(str).drive_number }
     assert_equal('C:/Program Files', str)
   end
 

data/test/windows/test_each.rb

@@ -1,14 +1,14 @@
 ########################################################################
 # test_each.rb
 #
-# Test suite for the Pathname#each method.
+# Test suite for the Pathname2#each method.
 ########################################################################
 require 'pathname2'
 require 'test-unit'
 
-class TC_Pathname_Each < Test::Unit::TestCase
+class TC_Pathname2_Each < Test::Unit::TestCase
   def setup
-    @path = Pathname.new("C:/Users/foo/bar")
+    @path = Pathname2.new("C:/Users/foo/bar")
   end
 
   test "each basic functionality" do

data/test/windows/test_facade.rb

@@ -6,9 +6,9 @@
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_Facade < Test::Unit::TestCase
+class TC_Pathname2_Facade < Test::Unit::TestCase
   def setup
-    @path = Pathname.new("C:/Program Files")
+    @path = Pathname2.new("C:/Program Files")
   end
 
   test "file facade methods are defined" do
@@ -38,9 +38,9 @@ class TC_Pathname_Facade < Test::Unit::TestCase
     assert_respond_to(@path, :find)
     assert_nothing_raised{ @path.find{} }
 
-    Pathname.new(Dir.pwd).find{ |f|
+    Pathname2.new(Dir.pwd).find{ |f|
       Find.prune if f.match("git")
-      assert_kind_of(Pathname, f)
+      assert_kind_of(Pathname2, f)
     }
   end
 
@@ -54,8 +54,8 @@ class TC_Pathname_Facade < Test::Unit::TestCase
   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?)
+    assert_true(Pathname2.new("C:\\").exist?)
+    assert_false(Pathname2.new("X:\\foo\\bar\\baz").exist?)
   end
 
   def teardown

data/test/windows/test_is_absolute.rb

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

data/test/windows/test_is_relative.rb

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

data/test/windows/test_is_root.rb

@@ -1,15 +1,15 @@
 ########################################################################
 # test_is_root.rb
 #
-# Test suite for the Pathname#root method
+# Test suite for the Pathname2#root method
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_IsRoot < Test::Unit::TestCase
+class TC_Pathname2_IsRoot < Test::Unit::TestCase
   def setup
-    @std_root = Pathname.new("C:\\")
-    @unc_root = Pathname.new("\\\\foo\\bar")
+    @std_root = Pathname2.new("C:\\")
+    @unc_root = Pathname2.new("\\\\foo\\bar")
   end
 
   test "root? basic functionality" do
@@ -24,14 +24,14 @@ class TC_Pathname_IsRoot < Test::Unit::TestCase
   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?)
+    assert_false(Pathname2.new("C:/foo").root?)
+    assert_false(Pathname2.new("//foo/bar/baz").root?)
+    assert_false(Pathname2.new("").root?)
   end
 
   test "root? method is not destructive" do
     str = 'C:/foo'
-    path = Pathname.new(str)
+    path = Pathname2.new(str)
     assert_nothing_raised{ path.root }
     assert_equal('C:\foo', path.to_s)
     assert_equal('C:/foo', str)

data/test/windows/test_is_unc.rb

@@ -1,16 +1,16 @@
 ########################################################################
 # test_is_unc.rb
 #
-# Test suite for the Pathname#unc? method
+# Test suite for the Pathname2#unc? method
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_IsUNC < Test::Unit::TestCase
+class TC_Pathname2_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")
+    @abs_path = Pathname2.new("C:\\Program Files")
+    @unc_path = Pathname2.new("\\\\foo\\bar\\baz")
+    @rel_path = Pathname2.new("foo\\bar\\baz")
   end
 
   test "unc? basic functionality" do
@@ -20,26 +20,26 @@ class TC_Pathname_IsUNC < Test::Unit::TestCase
   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?)
+    assert_false(Pathname2.new("C:\\").unc?)
+    assert_false(Pathname2.new("C:\\Program Files").unc?)
+    assert_false(Pathname2.new("C:\\\\Program Files").unc?)
+    assert_false(Pathname2.new("C:/Program Files/File.txt").unc?)
+    assert_false(Pathname2.new("C:\\Program Files\\File[12].txt").unc?)
+    assert_false(Pathname2.new("foo\\bar").unc?)
+    assert_false(Pathname2.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?)
+    assert_true(Pathname2.new("\\\\foo\\bar").unc?)
+    assert_true(Pathname2.new("//foo/bar").unc?)
+    assert_true(Pathname2.new("\\\\foo\\bar\\baz").unc?)
+    assert_true(Pathname2.new("\\\\foo").unc?)
+    assert_true(Pathname2.new("\\\\").unc?)
   end
 
   test "unc? method is not destructive" do
     str = '//foo/bar'
-    assert_nothing_raised{ Pathname.new(str).unc? }
+    assert_nothing_raised{ Pathname2.new(str).unc? }
     assert_equal('//foo/bar', str)
   end
 

data/test/windows/test_join.rb

@@ -1,20 +1,20 @@
 ########################################################################
 # test_join.rb
 #
-# Test suite for the Pathname#join method.
+# Test suite for the Pathname2#join method.
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_Join < Test::Unit::TestCase
+class TC_Pathname2_Join < Test::Unit::TestCase
   def setup
-    @apath = Pathname.new("C:\\foo\\bar")
-    @rpath = Pathname.new("foo\\bar\\baz")
+    @apath = Pathname2.new("C:\\foo\\bar")
+    @rpath = Pathname2.new("foo\\bar\\baz")
   end
 
   def assert_pathname_join(final, initial, *rest)
-    a = Pathname.new(final)
-    b = Pathname.new(initial)
+    a = Pathname2.new(final)
+    b = Pathname2.new(initial)
     assert_equal(a, b.join(*rest))
   end
 
@@ -41,8 +41,8 @@ class TC_Pathname_Join < Test::Unit::TestCase
     assert_pathname_join("D:\\", "C:\\", "foo", "bar", "D:\\")
   end
 
-  test "join returns an instance of Pathname" do
-    assert_kind_of(Pathname, @apath.join("foo"))
+  test "join returns an instance of Pathname2" do
+    assert_kind_of(Pathname2, @apath.join("foo"))
   end
 
   def teardown

data/test/windows/test_long_path.rb

@@ -1,14 +1,14 @@
 ########################################################################
 # test_long_path.rb
 #
-# Test suite for the Pathname#long_path method
+# Test suite for the Pathname2#long_path method
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_LongPath < Test::Unit::TestCase
+class TC_Pathname2_LongPath < Test::Unit::TestCase
   def setup
-    @abs_path = Pathname.new("C:\\PROGRA~1")
+    @abs_path = Pathname2.new("C:\\PROGRA~1")
   end
 
   test "long_path basic functionality" do
@@ -22,16 +22,16 @@ class TC_Pathname_LongPath < Test::Unit::TestCase
   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)
+    assert_equal("C:\\Program Files", Pathname2.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 }
+    assert_raise(Errno::ESRCH){ Pathname2.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_nothing_raised{ Pathname2.new(str).long_path }
     assert_equal('C:/Program Files', str)
   end
 

data/test/windows/test_misc.rb

@@ -7,23 +7,23 @@
 require 'pathname2'
 require 'test-unit'
 
-class MyPathname < Pathname; end
+class MyPathname2 < Pathname2; end
 
-class TC_Pathname_Misc < Test::Unit::TestCase
+class TC_Pathname2_Misc < Test::Unit::TestCase
   def setup
-    @mypath = MyPathname.new(Dir.pwd)
+    @mypath = MyPathname2.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)
+    assert_kind_of(MyPathname2, @mypath)
+    assert_kind_of(MyPathname2, @mypath + MyPathname2.new('foo'))
+    assert_kind_of(MyPathname2, @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_kind_of(Pathname2, pn{'c:\foo'})
     assert_equal('c:\foo', pn{'c:\foo'})
   end
 

data/test/windows/test_parent.rb

@@ -1,34 +1,34 @@
 ########################################################################
 # test_parent.rb
 #
-# Test suite for the Pathname#parent method.
+# Test suite for the Pathname2#parent method.
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_Parent < Test::Unit::TestCase
+class TC_Pathname2_Parent < Test::Unit::TestCase
   def setup
-    @path = Pathname.new("C:\\foo\\bar\\baz")
+    @path = Pathname2.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)
+    assert_kind_of(Pathname2, @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)
+    assert_equal("C:\\foo\\bar", Pathname2.new("C:\\foo\\bar\\baz").parent)
+    assert_equal("C:\\", Pathname2.new("C:\\foo").parent)
   end
 
   test "parent returns expected results for a relative path" do
-    assert_equal("foo", Pathname.new("foo\\bar").parent)
+    assert_equal("foo", Pathname2.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)
+    assert_equal("C:\\", Pathname2.new("C:\\").parent)
+    assert_equal("\\\\foo\\bar", Pathname2.new("//foo/bar").parent)
   end
 
   def teardown

data/test/windows/test_pstrip.rb

@@ -1,36 +1,36 @@
 ########################################################################
 # test_pstrip.rb
 #
-# Test suite for the Pathname#pstrip method
+# Test suite for the Pathname2#pstrip method
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_Pstrip < Test::Unit::TestCase
+class TC_Pathname2_Pstrip < Test::Unit::TestCase
   def setup
-    @path = Pathname.new("C:/Program Files////")
+    @path = Pathname2.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)
+    assert_kind_of(Pathname2, @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)
+    assert_equal("C:\\Program Files", Pathname2.new("C:\\Program Files\\\\").pstrip)
+    assert_equal("C:\\Program Files", Pathname2.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)
+    assert_equal("C:\\Program Files", Pathname2.new("C:\\Program Files").pstrip)
+    assert_equal("", Pathname2.new("").pstrip)
   end
 
   test "pstrip method is not destructive" do
     str = 'C:/Program Files////'
-    assert_nothing_raised{ Pathname.new(str).pstrip }
+    assert_nothing_raised{ Pathname2.new(str).pstrip }
     assert_equal('C:/Program Files////', str)
   end
 

data/test/windows/test_pstrip_bang.rb

@@ -1,42 +1,42 @@
 ########################################################################
 # test_pstrip_bang.rb
 #
-# Test suite for the Pathname#pstrip! method
+# Test suite for the Pathname2#pstrip! method
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_PstripBang < Test::Unit::TestCase
+class TC_Pathname2_PstripBang < Test::Unit::TestCase
   def setup
-    @path = Pathname.new("C:/Program Files////")
+    @path = Pathname2.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!)
+    assert_kind_of(Pathname2, @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!)
+    assert_equal("C:\\Program Files", Pathname2.new("C:\\Program Files\\\\").pstrip!)
+    assert_equal("C:\\Program Files", Pathname2.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!)
+    assert_equal("C:\\Program Files", Pathname2.new("C:\\Program Files").pstrip!)
+    assert_equal("", Pathname2.new("").pstrip!)
   end
 
   test "pstrip! alters pathname object" do
-    path = Pathname.new('C:/Program Files////')
+    path = Pathname2.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_nothing_raised{ Pathname2.new(str).pstrip! }
     assert_equal('C:/Program Files////', str)
   end
 

data/test/windows/test_realpath.rb

@@ -1,15 +1,15 @@
 ########################################################################
 # test_realpath.rb
 #
-# Test suite for the Pathname#realpath method
+# Test suite for the Pathname2#realpath method
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_Realpath < Test::Unit::TestCase
+class TC_Pathname2_Realpath < Test::Unit::TestCase
   def setup
     @cwd  = Dir.pwd.tr('/', "\\")
-    @path = Pathname.new(Dir.pwd)
+    @path = Pathname2.new(Dir.pwd)
   end
 
   test "realpath basic functionality" do
@@ -23,12 +23,12 @@ class TC_Pathname_Realpath < Test::Unit::TestCase
   end
 
   test "realpath fails if the path does not exist" do
-    assert_raise(Errno::ENOENT){ Pathname.new("C:/Bogus/AlsoBogus").realpath }
+    assert_raise(Errno::ENOENT){ Pathname2.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_nothing_raised{ Pathname2.new(str).realpath }
     assert_equal('C:/Program Files', str)
   end
 

data/test/windows/test_relative_path_from.rb

@@ -1,18 +1,18 @@
 ########################################################################
 # test_relative_path_from.rb
 #
-# Test suite for the Pathname#relative_path_from method.
+# Test suite for the Pathname2#relative_path_from method.
 ########################################################################
 require 'test-unit'
 require 'pathname2'
 
-class TC_Pathname_RelativePathFrom < Test::Unit::TestCase
+class TC_Pathname2_RelativePathFrom < Test::Unit::TestCase
   def assert_relpath(result, dest, base)
-    assert_equal(result, Pathname.new(dest).relative_path_from(base))
+    assert_equal(result, Pathname2.new(dest).relative_path_from(base))
   end
 
   def assert_relative_path_error(to, from)
-    assert_raise(ArgumentError){ Pathname.new(to).relative_path_from(from) }
+    assert_raise(ArgumentError){ Pathname2.new(to).relative_path_from(from) }
   end
 
   test "relative_path_from works as expected between two relative paths" do