win32-file 0.6.7 → 0.6.8

data/test/test_win32_file_attributes.rb

@@ -26,21 +26,21 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal('0.6.7', File::WIN32_FILE_VERSION)
+      assert_equal('0.6.8', File::WIN32_FILE_VERSION)
    end
-   
+
    def test_is_directory
       assert_true(File.directory?(Dir.pwd))
       assert_false(File.directory?(@@file))
-      assert_false(File.directory?('C:/aaabbbccc'))      
+      assert_false(File.directory?('C:/aaabbbccc'))
    end
-   
+
    def test_temporary
       assert_respond_to(File, :temporary?)
-      assert_nothing_raised{ File.temporary?(@@file) }    
+      assert_nothing_raised{ File.temporary?(@@file) }
       assert_equal(false, File.temporary?(@@file))
    end
-   
+
    def test_temporary_instance
       assert_respond_to(@fh, :temporary=)
       assert_nothing_raised{ @fh.temporary = true }
@@ -51,13 +51,13 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_raises(ArgumentError){ File.temporary? }
       assert_raises(ArgumentError){ File.temporary?(@@file, 'foo') }
    end
-   
+
    def test_system
       assert_respond_to(File, :system?)
-      assert_nothing_raised{ File.system?(@@file) }    
+      assert_nothing_raised{ File.system?(@@file) }
       assert_equal(false, File.system?(@@file))
    end
-   
+
    def test_system_instance
       assert_respond_to(@fh, :system=)
       assert_nothing_raised{ @fh.system = true }
@@ -68,13 +68,13 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_raises(ArgumentError){ File.system? }
       assert_raises(ArgumentError){ File.system?(@@file, 'foo') }
    end
-   
+
    def test_sparse
       assert_respond_to(File, :sparse?)
-      assert_nothing_raised{ File.sparse?(@@file) }    
+      assert_nothing_raised{ File.sparse?(@@file) }
       assert_equal(false, File.sparse?(@@file))
    end
-   
+
    # I don't actually test assignment here since making a file a sparse
    # file can't be undone.
    def test_sparse_instance
@@ -85,10 +85,10 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_raises(ArgumentError){ File.sparse? }
       assert_raises(ArgumentError){ File.sparse?(@@file, 'foo') }
    end
-   
+
    def test_reparse_point
       assert_respond_to(File, :reparse_point?)
-      assert_nothing_raised{ File.reparse_point?(@@file) }    
+      assert_nothing_raised{ File.reparse_point?(@@file) }
       assert_equal(false, File.reparse_point?(@@file))
    end
 
@@ -96,10 +96,10 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_raises(ArgumentError){ File.reparse_point? }
       assert_raises(ArgumentError){ File.reparse_point?(@@file, 'foo') }
    end
-   
+
    def test_readonly
       assert_respond_to(File, :readonly?)
-      assert_nothing_raised{ File.readonly?(@@file) }    
+      assert_nothing_raised{ File.readonly?(@@file) }
       assert_equal(false, File.readonly?(@@file))
    end
 
@@ -107,7 +107,7 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_respond_to(File, :read_only?)
       assert_equal(true, File.method(:readonly?) == File.method(:read_only?))
    end
-   
+
    def test_readonly_instance
       assert_respond_to(@fh, :readonly=)
       assert_nothing_raised{ @fh.readonly = true }
@@ -118,13 +118,13 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_raises(ArgumentError){ File.read_only? }
       assert_raises(ArgumentError){ File.read_only?(@@file, 'foo') }
    end
-   
+
    def test_offline
       assert_respond_to(File, :offline?)
-      assert_nothing_raised{ File.offline?(@@file) }    
+      assert_nothing_raised{ File.offline?(@@file) }
       assert_equal(false, File.offline?(@@file))
    end
-   
+
    def test_offline_instance
       assert_respond_to(@fh, :offline=)
       assert_nothing_raised{ @fh.offline =  true }
@@ -135,13 +135,13 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_raises(ArgumentError){ File.offline? }
       assert_raises(ArgumentError){ File.offline?(@@file, 'foo') }
    end
-   
+
    def test_normal
       assert_respond_to(File, :normal?)
-      assert_nothing_raised{ File.normal?(@@file) }    
+      assert_nothing_raised{ File.normal?(@@file) }
       assert_equal(false, File.normal?(@@file))
    end
-   
+
    def test_normal_instance
       assert_respond_to(@fh, :normal=)
       assert_nothing_raised{ @fh.normal = true }
@@ -153,13 +153,13 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_raises(ArgumentError){ File.normal?(@@file, 'foo') }
       assert_raises(ArgumentError){ @fh.normal = false }
    end
-   
+
    def test_hidden
       assert_respond_to(File, :hidden?)
-      assert_nothing_raised{ File.hidden?(@@file) }    
+      assert_nothing_raised{ File.hidden?(@@file) }
       assert_equal(false, File.hidden?(@@file))
    end
-   
+
    def test_hidden_instance
       assert_respond_to(@fh, :hidden=)
       assert_nothing_raised{ @fh.hidden = true }
@@ -169,22 +169,22 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
    def test_hidden_expected_errors
       assert_raises(ArgumentError){ File.hidden? }
       assert_raises(ArgumentError){ File.hidden?(@@file, 'foo') }
-   end 
+   end
 
    def test_encrypted
       assert_respond_to(File, :encrypted?)
-      assert_nothing_raised{ File.encrypted?(@@file) }    
+      assert_nothing_raised{ File.encrypted?(@@file) }
       assert_equal(false, File.encrypted?(@@file))
    end
 
    def test_encrypted_expected_errors
       assert_raises(ArgumentError){ File.encrypted? }
       assert_raises(ArgumentError){ File.encrypted?(@@file, 'foo') }
-   end    
+   end
 
    def test_indexed
       assert_respond_to(File, :indexed?)
-      assert_nothing_raised{ File.indexed?(@@file) }    
+      assert_nothing_raised{ File.indexed?(@@file) }
       assert_equal(true, File.indexed?(@@file))
    end
 
@@ -192,7 +192,7 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_respond_to(File, :content_indexed?)
       assert(File.method(:content_indexed?) == File.method(:indexed?))
    end
-   
+
    def test_indexed_instance
       assert_respond_to(@fh, :indexed=)
       assert_nothing_raised{ @fh.indexed = true }
@@ -202,14 +202,14 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
    def test_indexed_expected_errors
       assert_raises(ArgumentError){ File.indexed? }
       assert_raises(ArgumentError){ File.indexed?(@@file, 'foo') }
-   end    
+   end
 
    def test_compressed
       assert_respond_to(File, :compressed?)
-      assert_nothing_raised{ File.compressed?(@@file) }    
+      assert_nothing_raised{ File.compressed?(@@file) }
       assert_equal(false, File.compressed?(@@file))
    end
-   
+
    # We have to explicitly reset the compressed attribute to false as
    # the last of these assertions.
    def test_compressed_instance
@@ -226,31 +226,31 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
    def test_compressed_expected_errors
       assert_raises(ArgumentError){ File.compressed? }
       assert_raises(ArgumentError){ File.compressed?(@@file, 'foo') }
-   end    
-   
+   end
+
    def test_archive
       assert_respond_to(File, :archive?)
-      assert_nothing_raised{ File.archive?(@@file) }    
+      assert_nothing_raised{ File.archive?(@@file) }
       assert_equal(true, File.archive?(@@file))
    end
-   
+
    def test_archive_instance
       assert_respond_to(@fh, :archive=)
       assert_nothing_raised{ @fh.archive = false }
       assert_equal(false, File.archive?(@@file))
    end
-   
+
    def test_archive_expected_errors
       assert_raises(ArgumentError){ File.archive? }
       assert_raises(ArgumentError){ File.archive?(@@file, 'foo') }
    end
-   
+
    def test_attributes
       assert_respond_to(File, :attributes)
       assert_kind_of(Array, File.attributes(@@file))
       assert_equal(['archive', 'indexed'], File.attributes(@@file))
    end
-   
+
    def test_set_attributes
       assert_respond_to(File, :set_attributes)
       assert_nothing_raised{ File.set_attributes(@@file, File::HIDDEN) }
@@ -261,12 +261,12 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
       assert_respond_to(File, :set_attr)
       assert(File.method(:set_attr) == File.method(:set_attributes))
    end
-   
+
    def test_remove_attributes
       assert_respond_to(File, :remove_attributes)
       assert_nothing_raised{ File.remove_attributes(@@file, File::ARCHIVE) }
       assert_equal(false, File.archive?(@@file))
-   end   
+   end
 
    def test_unset_attr_alias
       assert_respond_to(File, :unset_attr)

data/test/test_win32_file_path.rb

@@ -1,256 +1,256 @@
-#############################################################################
-# test_win32_file_path.rb
-#
-# Test case for the path related methods of win32-file. You should run this
-# test via the 'rake test' or 'rake test_path' task.
-#############################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
-require 'win32/file'
-
-class TC_Win32_File_Path < Test::Unit::TestCase
-  def self.startup
-    Dir.chdir(File.dirname(File.expand_path(File.basename(__FILE__))))
-    @@file = File.join(Dir.pwd, 'path_test.txt')
-    File.open(@@file, 'w'){ |fh| fh.puts "This is a path test." }
-  end
-
-  def setup
-    @long_file  = File.join(Dir.pwd, 'path_test.txt')      
-    @short_file = File.join(Dir.pwd, 'PATH_T~1.TXT')
-  end
-   
-  test "basename method basic functionality" do
-    assert_respond_to(File, :basename)
-    assert_nothing_raised{ File.basename("C:\\foo") }
-    assert_kind_of(String, File.basename("C:\\foo"))
-  end
-      
-  test "basename method handles standard paths" do
-    assert_equal("baz.txt", File.basename("C:\\foo\\bar\\baz.txt"))
-    assert_equal("baz", File.basename("C:\\foo\\bar\\baz.txt", ".txt"))
-    assert_equal("baz.txt", File.basename("C:\\foo\\bar\\baz.txt", ".zip"))
-    assert_equal("bar", File.basename("C:\\foo\\bar"))
-    assert_equal("bar", File.basename("C:\\foo\\bar\\"))
-    assert_equal("foo", File.basename("C:\\foo"))
-    assert_equal("C:\\", File.basename("C:\\"))
-  end
-      
-  test "basename method handles unc paths" do
-    assert_equal("baz.txt", File.basename("\\\\foo\\bar\\baz.txt"))
-    assert_equal("baz", File.basename("\\\\foo\\bar\\baz"))
-    assert_equal("\\\\foo", File.basename("\\\\foo"))
-    assert_equal("\\\\foo\\bar", File.basename("\\\\foo\\bar"))
-  end
- 
-  test "basename method handles forward slashes in standard unix paths" do
-    assert_equal("bar", File.basename("/foo/bar"))
-    assert_equal("bar.txt", File.basename("/foo/bar.txt"))
-    assert_equal("bar.txt", File.basename("bar.txt"))
-    assert_equal("bar", File.basename("/bar"))
-    assert_equal("bar", File.basename("/bar/"))
-    assert_equal("baz", File.basename("//foo/bar/baz"))
-  end
-
-  test "basename method handles forward slashes in unc unix paths" do
-    assert_equal("\\\\foo", File.basename("//foo"))
-    assert_equal("\\\\foo\\bar", File.basename("//foo/bar"))
-  end
-      
-  test "basename method handles forward slashes in windows paths" do
-    assert_equal("bar", File.basename("C:/foo/bar"))
-    assert_equal("bar", File.basename("C:/foo/bar/"))
-    assert_equal("foo", File.basename("C:/foo"))
-    assert_equal("C:\\", File.basename("C:/"))
-    assert_equal("bar", File.basename("C:/foo/bar//"))
-  end
-         
-  test "basename handles edge cases as expected" do
-    assert_equal("", File.basename(""))
-    assert_equal(".", File.basename("."))
-    assert_equal("..", File.basename(".."))
-    assert_equal("foo", File.basename("//foo/"))
-  end
- 
-  test "basename handles path names with suffixes" do
-    assert_equal("bar", File.basename("bar.txt", ".txt"))
-    assert_equal("bar", File.basename("/foo/bar.txt", ".txt"))
-    assert_equal("bar.txt", File.basename("bar.txt", ".exe"))
-    assert_equal("bar.txt", File.basename("bar.txt.exe", ".exe"))
-    assert_equal("bar.txt.exe", File.basename("bar.txt.exe", ".txt"))
-    assert_equal("bar", File.basename("bar.txt", ".*"))
-    assert_equal("bar.txt", File.basename("bar.txt.exe", ".*"))
-  end
-      
-  test "basename method does not modify its argument" do
-    path = "C:\\foo\\bar"
-    assert_nothing_raised{ File.basename(path) }
-    assert_equal("C:\\foo\\bar", path)    
-  end
-
-  test "basename removes all trailing slashes" do
-    assert_equal("foo.txt", File.basename("C:/foo.txt/"))
-    assert_equal("foo.txt", File.basename("C:/foo.txt//"))
-    assert_equal("foo.txt", File.basename("C:/foo.txt///"))
-    assert_equal("foo.txt", File.basename("C:\\foo.txt\\"))
-    assert_equal("foo.txt", File.basename("C:\\foo.txt\\\\"))
-    assert_equal("foo.txt", File.basename("C:\\foo.txt\\\\\\"))
-    assert_equal("foo.txt", File.basename("foo.txt\\\\\\"))
-  end
-   
-  test "dirname basic functionality" do
-    assert_respond_to(File, :dirname)
-    assert_nothing_raised{ File.dirname("C:\\foo") }
-    assert_kind_of(String, File.dirname("C:\\foo"))
-  end
-     
-  test "dirname handles standard windows paths as expected" do
-    assert_equal("C:\\foo", File.dirname("C:\\foo\\bar.txt"))
-    assert_equal("C:\\foo", File.dirname("C:\\foo\\bar"))
-    assert_equal("C:\\", File.dirname("C:\\foo"))
-    assert_equal("C:\\", File.dirname("C:\\"))
-    assert_equal(".", File.dirname("foo"))
-  end
-      
-  test "dirname handles unc windows paths as expected" do
-    assert_equal("\\\\foo\\bar", File.dirname("\\\\foo\\bar\\baz"))
-    assert_equal("\\\\foo\\bar", File.dirname("\\\\foo\\bar"))
-    assert_equal("\\\\foo", File.dirname("\\\\foo"))
-    assert_equal("\\\\", File.dirname("\\\\"))
-  end
-    
-  test "dirname handles forward slashes in standard windows path names" do
-    assert_equal("C:\\foo", File.dirname("C:/foo/bar.txt"))
-    assert_equal("C:\\foo", File.dirname("C:/foo/bar"))
-    assert_equal("C:\\", File.dirname("C:/foo"))
-    assert_equal("C:\\", File.dirname("C:/"))
-  end
-
-  test "dirname handles forward slashes in unc windows path names" do
-    assert_equal("\\\\foo\\bar", File.dirname("//foo/bar/baz"))
-    assert_equal("\\\\foo\\bar", File.dirname("//foo/bar"))
-    assert_equal("\\\\foo", File.dirname("//foo"))
-    assert_equal("\\\\", File.dirname("//"))
-  end
-
-  test "dirname handles forward slashes in relative path names" do
-    assert_equal(".", File.dirname("./foo"))
-    assert_equal(".\\foo", File.dirname("./foo/bar"))
-  end
-    
-  test "dirname handles various edge cases as expected" do
-    assert_equal(".", File.dirname(""))
-    assert_equal(".", File.dirname("."))
-    assert_equal(".", File.dirname(".."))
-    assert_equal(".", File.dirname("./"))
-  end
-      
-  test "dirname method does not modify its argument" do
-    path = "C:\\foo\\bar"
-    assert_nothing_raised{ File.dirname(path) }
-    assert_equal("C:\\foo\\bar", path)
-  end
-
-  test "dirname method ignores trailing slashes" do
-    assert_equal("C:\\foo\\bar", File.dirname("C:/foo/bar/baz/"))
-    assert_equal("C:\\foo\\bar", File.dirname("C:/foo/bar/baz//"))
-    assert_equal("C:\\foo\\bar", File.dirname("C:/foo/bar/baz///"))
-    assert_equal("C:\\foo\\bar", File.dirname("C:\\foo\\bar\\baz\\"))
-    assert_equal("\\\\foo\\bar", File.dirname("\\\\foo\\bar\\baz\\"))
-  end
-
-  test "argument to dirname must be a string" do
-    assert_raises(TypeError){ File.dirname(nil) }
-    assert_raises(TypeError){ File.dirname(['foo', 'bar']) }
-  end
-
-  test "split method basic functionality" do
-    assert_respond_to(File, :split)
-    assert_nothing_raised{ File.split("C:\\foo\\bar") }
-    assert_kind_of(Array, File.split("C:\\foo\\bar"))
-  end
-      
-  test "split method handles standard windows path names" do
-    assert_equal(["C:\\foo", "bar"], File.split("C:\\foo\\bar"))     
-    assert_equal([".", "foo"], File.split("foo"))
-  end
-
-  test "split method handles windows paths with forward slashes" do
-    assert_equal(["C:\\foo", "bar"], File.split("C:/foo/bar"))
-    assert_equal([".", "foo"], File.split("foo"))
-  end
-      
-  test "split method handles standard unix paths as expected" do
-    assert_equal(["\\foo","bar"], File.split("/foo/bar"))
-    assert_equal(["\\", "foo"], File.split("/foo"))
-    assert_equal([".", "foo"], File.split("foo"))
-  end
-      
-  test "split method handles unc paths as expected" do
-    assert_equal(["\\\\foo\\bar", "baz"], File.split("\\\\foo\\bar\\baz"))
-    assert_equal(["\\\\foo\\bar", ""], File.split("\\\\foo\\bar"))
-    assert_equal(["\\\\foo", ""], File.split("\\\\foo"))
-    assert_equal(["\\\\", ""], File.split("\\\\"))
-  end
-
-  test "split method handles various edge cases as expected" do
-    assert_equal(["C:\\", ""], File.split("C:\\"))
-    assert_equal(["", ""], File.split(""))
-  end
-      
-  test "split method does not modify its arguments" do
-    path = "C:\\foo\\bar"
-    assert_nothing_raised{ File.split(path) }
-    assert_equal("C:\\foo\\bar", path)
-  end
-   
-  test "long_path method works as expected" do
-    assert_respond_to(File, :long_path)
-    assert_equal(@long_file, File.long_path(@short_file))
-    assert_equal('PATH_T~1.TXT', File.basename(@short_file))
-  end
-   
-  test "short_path method works as expected" do
-    assert_respond_to(File, :short_path)
-    assert_equal('path_test.txt', File.basename(@long_file))
-  end
-
-  test "join method works as expected" do
-    assert_respond_to(File, :join)
-  end
-
-  test "join handles multiple arguments as expected" do
-    assert_equal("C:\\foo\\bar", File.join("C:", "foo", "bar"))
-    assert_equal("foo\\bar", File.join("foo", "bar"))
-  end
-
-  test "join handles multiple arguments as expected with unc paths" do
-    assert_equal("\\\\foo", File.join("\\\\foo"))
-    assert_equal("\\\\foo\\bar", File.join("\\\\foo", "bar"))
-  end
-
-  test "join does not normalize paths" do
-    assert_equal("C:\\.\\foo\\..", File.join("C:", ".", "foo", ".."))
-  end
-
-  test "join with no arguments returns an empty string" do
-    assert_equal('', File.join)
-  end
-
-  test "join with one argument returns the argument" do
-    assert_equal('foo', File.join('foo'))
-    assert_equal('c:', File.join('c:'))
-  end
-   
-  def teardown
-    @short_file = nil
-    @long_file  = nil
-  end
-
-  def self.shutdown
-    File.delete(@@file) if File.exists?(@@file)
-    @@file = nil
-  end
-end
+#############################################################################
+# test_win32_file_path.rb
+#
+# Test case for the path related methods of win32-file. You should run this
+# test via the 'rake test' or 'rake test_path' task.
+#############################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'win32/file'
+
+class TC_Win32_File_Path < Test::Unit::TestCase
+  def self.startup
+    Dir.chdir(File.dirname(File.expand_path(File.basename(__FILE__))))
+    @@file = File.join(Dir.pwd, 'path_test.txt')
+    File.open(@@file, 'w'){ |fh| fh.puts "This is a path test." }
+  end
+
+  def setup
+    @long_file  = File.join(Dir.pwd, 'path_test.txt')      
+    @short_file = File.join(Dir.pwd, 'PATH_T~1.TXT')
+  end
+   
+  test "basename method basic functionality" do
+    assert_respond_to(File, :basename)
+    assert_nothing_raised{ File.basename("C:\\foo") }
+    assert_kind_of(String, File.basename("C:\\foo"))
+  end
+      
+  test "basename method handles standard paths" do
+    assert_equal("baz.txt", File.basename("C:\\foo\\bar\\baz.txt"))
+    assert_equal("baz", File.basename("C:\\foo\\bar\\baz.txt", ".txt"))
+    assert_equal("baz.txt", File.basename("C:\\foo\\bar\\baz.txt", ".zip"))
+    assert_equal("bar", File.basename("C:\\foo\\bar"))
+    assert_equal("bar", File.basename("C:\\foo\\bar\\"))
+    assert_equal("foo", File.basename("C:\\foo"))
+    assert_equal("C:\\", File.basename("C:\\"))
+  end
+      
+  test "basename method handles unc paths" do
+    assert_equal("baz.txt", File.basename("\\\\foo\\bar\\baz.txt"))
+    assert_equal("baz", File.basename("\\\\foo\\bar\\baz"))
+    assert_equal("\\\\foo", File.basename("\\\\foo"))
+    assert_equal("\\\\foo\\bar", File.basename("\\\\foo\\bar"))
+  end
+ 
+  test "basename method handles forward slashes in standard unix paths" do
+    assert_equal("bar", File.basename("/foo/bar"))
+    assert_equal("bar.txt", File.basename("/foo/bar.txt"))
+    assert_equal("bar.txt", File.basename("bar.txt"))
+    assert_equal("bar", File.basename("/bar"))
+    assert_equal("bar", File.basename("/bar/"))
+    assert_equal("baz", File.basename("//foo/bar/baz"))
+  end
+
+  test "basename method handles forward slashes in unc unix paths" do
+    assert_equal("\\\\foo", File.basename("//foo"))
+    assert_equal("\\\\foo\\bar", File.basename("//foo/bar"))
+  end
+      
+  test "basename method handles forward slashes in windows paths" do
+    assert_equal("bar", File.basename("C:/foo/bar"))
+    assert_equal("bar", File.basename("C:/foo/bar/"))
+    assert_equal("foo", File.basename("C:/foo"))
+    assert_equal("C:\\", File.basename("C:/"))
+    assert_equal("bar", File.basename("C:/foo/bar//"))
+  end
+         
+  test "basename handles edge cases as expected" do
+    assert_equal("", File.basename(""))
+    assert_equal(".", File.basename("."))
+    assert_equal("..", File.basename(".."))
+    assert_equal("foo", File.basename("//foo/"))
+  end
+ 
+  test "basename handles path names with suffixes" do
+    assert_equal("bar", File.basename("bar.txt", ".txt"))
+    assert_equal("bar", File.basename("/foo/bar.txt", ".txt"))
+    assert_equal("bar.txt", File.basename("bar.txt", ".exe"))
+    assert_equal("bar.txt", File.basename("bar.txt.exe", ".exe"))
+    assert_equal("bar.txt.exe", File.basename("bar.txt.exe", ".txt"))
+    assert_equal("bar", File.basename("bar.txt", ".*"))
+    assert_equal("bar.txt", File.basename("bar.txt.exe", ".*"))
+  end
+      
+  test "basename method does not modify its argument" do
+    path = "C:\\foo\\bar"
+    assert_nothing_raised{ File.basename(path) }
+    assert_equal("C:\\foo\\bar", path)    
+  end
+
+  test "basename removes all trailing slashes" do
+    assert_equal("foo.txt", File.basename("C:/foo.txt/"))
+    assert_equal("foo.txt", File.basename("C:/foo.txt//"))
+    assert_equal("foo.txt", File.basename("C:/foo.txt///"))
+    assert_equal("foo.txt", File.basename("C:\\foo.txt\\"))
+    assert_equal("foo.txt", File.basename("C:\\foo.txt\\\\"))
+    assert_equal("foo.txt", File.basename("C:\\foo.txt\\\\\\"))
+    assert_equal("foo.txt", File.basename("foo.txt\\\\\\"))
+  end
+   
+  test "dirname basic functionality" do
+    assert_respond_to(File, :dirname)
+    assert_nothing_raised{ File.dirname("C:\\foo") }
+    assert_kind_of(String, File.dirname("C:\\foo"))
+  end
+     
+  test "dirname handles standard windows paths as expected" do
+    assert_equal("C:\\foo", File.dirname("C:\\foo\\bar.txt"))
+    assert_equal("C:\\foo", File.dirname("C:\\foo\\bar"))
+    assert_equal("C:\\", File.dirname("C:\\foo"))
+    assert_equal("C:\\", File.dirname("C:\\"))
+    assert_equal(".", File.dirname("foo"))
+  end
+      
+  test "dirname handles unc windows paths as expected" do
+    assert_equal("\\\\foo\\bar", File.dirname("\\\\foo\\bar\\baz"))
+    assert_equal("\\\\foo\\bar", File.dirname("\\\\foo\\bar"))
+    assert_equal("\\\\foo", File.dirname("\\\\foo"))
+    assert_equal("\\\\", File.dirname("\\\\"))
+  end
+    
+  test "dirname handles forward slashes in standard windows path names" do
+    assert_equal("C:\\foo", File.dirname("C:/foo/bar.txt"))
+    assert_equal("C:\\foo", File.dirname("C:/foo/bar"))
+    assert_equal("C:\\", File.dirname("C:/foo"))
+    assert_equal("C:\\", File.dirname("C:/"))
+  end
+
+  test "dirname handles forward slashes in unc windows path names" do
+    assert_equal("\\\\foo\\bar", File.dirname("//foo/bar/baz"))
+    assert_equal("\\\\foo\\bar", File.dirname("//foo/bar"))
+    assert_equal("\\\\foo", File.dirname("//foo"))
+    assert_equal("\\\\", File.dirname("//"))
+  end
+
+  test "dirname handles forward slashes in relative path names" do
+    assert_equal(".", File.dirname("./foo"))
+    assert_equal(".\\foo", File.dirname("./foo/bar"))
+  end
+    
+  test "dirname handles various edge cases as expected" do
+    assert_equal(".", File.dirname(""))
+    assert_equal(".", File.dirname("."))
+    assert_equal(".", File.dirname(".."))
+    assert_equal(".", File.dirname("./"))
+  end
+      
+  test "dirname method does not modify its argument" do
+    path = "C:\\foo\\bar"
+    assert_nothing_raised{ File.dirname(path) }
+    assert_equal("C:\\foo\\bar", path)
+  end
+
+  test "dirname method ignores trailing slashes" do
+    assert_equal("C:\\foo\\bar", File.dirname("C:/foo/bar/baz/"))
+    assert_equal("C:\\foo\\bar", File.dirname("C:/foo/bar/baz//"))
+    assert_equal("C:\\foo\\bar", File.dirname("C:/foo/bar/baz///"))
+    assert_equal("C:\\foo\\bar", File.dirname("C:\\foo\\bar\\baz\\"))
+    assert_equal("\\\\foo\\bar", File.dirname("\\\\foo\\bar\\baz\\"))
+  end
+
+  test "argument to dirname must be a string" do
+    assert_raises(TypeError){ File.dirname(nil) }
+    assert_raises(TypeError){ File.dirname(['foo', 'bar']) }
+  end
+
+  test "split method basic functionality" do
+    assert_respond_to(File, :split)
+    assert_nothing_raised{ File.split("C:\\foo\\bar") }
+    assert_kind_of(Array, File.split("C:\\foo\\bar"))
+  end
+      
+  test "split method handles standard windows path names" do
+    assert_equal(["C:\\foo", "bar"], File.split("C:\\foo\\bar"))     
+    assert_equal([".", "foo"], File.split("foo"))
+  end
+
+  test "split method handles windows paths with forward slashes" do
+    assert_equal(["C:\\foo", "bar"], File.split("C:/foo/bar"))
+    assert_equal([".", "foo"], File.split("foo"))
+  end
+      
+  test "split method handles standard unix paths as expected" do
+    assert_equal(["\\foo","bar"], File.split("/foo/bar"))
+    assert_equal(["\\", "foo"], File.split("/foo"))
+    assert_equal([".", "foo"], File.split("foo"))
+  end
+      
+  test "split method handles unc paths as expected" do
+    assert_equal(["\\\\foo\\bar", "baz"], File.split("\\\\foo\\bar\\baz"))
+    assert_equal(["\\\\foo\\bar", ""], File.split("\\\\foo\\bar"))
+    assert_equal(["\\\\foo", ""], File.split("\\\\foo"))
+    assert_equal(["\\\\", ""], File.split("\\\\"))
+  end
+
+  test "split method handles various edge cases as expected" do
+    assert_equal(["C:\\", ""], File.split("C:\\"))
+    assert_equal(["", ""], File.split(""))
+  end
+      
+  test "split method does not modify its arguments" do
+    path = "C:\\foo\\bar"
+    assert_nothing_raised{ File.split(path) }
+    assert_equal("C:\\foo\\bar", path)
+  end
+   
+  test "long_path method works as expected" do
+    assert_respond_to(File, :long_path)
+    assert_equal(@long_file, File.long_path(@short_file))
+    assert_equal('PATH_T~1.TXT', File.basename(@short_file))
+  end
+   
+  test "short_path method works as expected" do
+    assert_respond_to(File, :short_path)
+    assert_equal('path_test.txt', File.basename(@long_file))
+  end
+
+  test "join method works as expected" do
+    assert_respond_to(File, :join)
+  end
+
+  test "join handles multiple arguments as expected" do
+    assert_equal("C:\\foo\\bar", File.join("C:", "foo", "bar"))
+    assert_equal("foo\\bar", File.join("foo", "bar"))
+  end
+
+  test "join handles multiple arguments as expected with unc paths" do
+    assert_equal("\\\\foo", File.join("\\\\foo"))
+    assert_equal("\\\\foo\\bar", File.join("\\\\foo", "bar"))
+  end
+
+  test "join does not normalize paths" do
+    assert_equal("C:\\.\\foo\\..", File.join("C:", ".", "foo", ".."))
+  end
+
+  test "join with no arguments returns an empty string" do
+    assert_equal('', File.join)
+  end
+
+  test "join with one argument returns the argument" do
+    assert_equal('foo', File.join('foo'))
+    assert_equal('c:', File.join('c:'))
+  end
+   
+  def teardown
+    @short_file = nil
+    @long_file  = nil
+  end
+
+  def self.shutdown
+    File.delete(@@file) if File.exists?(@@file)
+    @@file = nil
+  end
+end