win32-file 0.5.5 → 0.5.6

data/CHANGES

@@ -1,3 +1,12 @@
+== 0.5.6 - 30-Sep-2008
+* The File.long_path and File.short_path methods now return the full path
+  instead of just the basename of the path. I really have no idea why I was
+  doing that before, but it's fixed now.
+* Fixed error handling in the File#compressed= and File#sparse= methods.
+* All tests were renamed and refactored to use test-unix 2.x, which is now
+  a pre-requisite for this library.
+* Some gemspec updates, including a rubyforge project.
+
 == 0.5.5 - 22-Nov-2007
 * Fixed a bug in the File.dirname method with regards to relative paths.
   Thanks go to an Laust Rud for the spot.
@@ -136,4 +145,4 @@
 * Documentation additions
 
 == 0.1.0 - 29-Oct-2003
-* Initial release
+* Initial release

data/MANIFEST

@@ -5,9 +5,9 @@
 * win32-file.gemspec
 * lib/win32/file.rb
 * test/sometestfile.txt
-* test/tc_file_attributes.rb
-* test/tc_file_constants.rb
-* test/tc_file_encryption.rb
-* test/tc_file_path.rb
-* test/tc_file_security.rb
-* test/tc_file_stat.rb
+* test/test_win32_file_attributes.rb
+* test/test_win32_file_constants.rb
+* test/test_win32_file_encryption.rb
+* test/test_win32_file_path.rb
+* test/test_win32_file_security.rb
+* test/test_win32_file_stat.rb

data/Rakefile

@@ -3,11 +3,14 @@ require 'rake/testtask'
 require 'rbconfig'
 include Config
 
+desc 'Clean any text files that may have been left over from tests'
 task :clean do 
-   rm 'sometestfile.txt' if File.exists? 'sometestfile.txt'
+   Dir['test/*'].each{ |file|
+      rm file if File.extname(file) == '.txt'
+   }
 end
 
-desc 'Install the win32-file package (non-gem)'
+desc 'Install the win32-file library (non-gem)'
 task :install do
    sitelibdir = CONFIG['sitelibdir']
    installdir = File.join(sitelibdir, 'win32')
@@ -17,7 +20,7 @@ task :install do
    FileUtils.cp(file, installdir, :verbose => true)
 end
 
-desc 'Install the win32-file package as a gem'
+desc 'Install the win32-file library as a gem'
 task :install_gem => [:clean] do
    ruby 'win32-file.gemspec'
    file = Dir['win32-file*.gem'].first
@@ -25,44 +28,42 @@ task :install_gem => [:clean] do
 end
 
 Rake::TestTask.new("test") do |t|
-   t.libs << 'test'
    t.verbose = true
    t.warning = true
-   t.test_files = FileList['test/tc*']
 end
 
 Rake::TestTask.new("test_attributes") do |t|
    t.verbose = true
    t.warning = true
-   t.test_files = FileList['test/tc_file_attributes.rb']
+   t.test_files = FileList['test/test_win32_file_attributes.rb']
 end
 
 Rake::TestTask.new("test_constants") do |t|
    t.verbose = true
    t.warning = true
-   t.test_files = FileList['test/tc_file_constants.rb']
+   t.test_files = FileList['test/test_win32_file_constants.rb']
 end
 
 Rake::TestTask.new("test_encryption") do |t|
    t.verbose = true
    t.warning = true
-   t.test_files = FileList['test/tc_file_encryption.rb']
+   t.test_files = FileList['test/test_win32_file_encryption.rb']
 end
 
 Rake::TestTask.new("test_path") do |t|
    t.verbose = true
    t.warning = true
-   t.test_files = FileList['test/tc_file_path.rb']
+   t.test_files = FileList['test/test_win32_file_path.rb']
 end
 
 Rake::TestTask.new("test_security") do |t|
    t.verbose = true
    t.warning = true
-   t.test_files = FileList['test/tc_file_security.rb']
+   t.test_files = FileList['test/test_win32_file_security.rb']
 end
 
 Rake::TestTask.new("test_stat") do |t|
    t.verbose = true
    t.warning = true
-   t.test_files = FileList['test/tc_file_stat.rb']
-end
+   t.test_files = FileList['test/test_win32_file_stat.rb']
+end

data/lib/win32/file.rb

@@ -3,12 +3,13 @@ require 'windows/limits'
 require 'win32/file/stat'
 
 class File
-   # Some of these are courtesy of win32-file-stat
    include Windows::Error
    include Windows::File
    include Windows::Security
    include Windows::Limits
    include Windows::DeviceIO
+   include Windows::Handle
+
    extend Windows::Error
    extend Windows::File
    extend Windows::Path
@@ -16,10 +17,11 @@ class File
    extend Windows::MSVCRT::Buffer
    extend Windows::Limits
    
-   VERSION  = '0.5.5'
-   MAX_PATH = 260
+   # The version of the win32-file library
+   VERSION  = '0.5.6'
 
    # Abbreviated attribute constants for convenience
+
    ARCHIVE    = FILE_ATTRIBUTE_ARCHIVE
    COMPRESSED = FILE_ATTRIBUTE_COMPRESSED
    HIDDEN     = FILE_ATTRIBUTE_HIDDEN
@@ -32,6 +34,7 @@ class File
    CONTENT_INDEXED = 0x0002000
 
    # Custom Security rights  
+
    FULL = STANDARD_RIGHTS_ALL | FILE_READ_DATA | FILE_WRITE_DATA |
       FILE_APPEND_DATA | FILE_READ_EA | FILE_WRITE_EA | FILE_EXECUTE |
       FILE_DELETE_CHILD | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES
@@ -313,9 +316,9 @@ class File
             memcpy(ace_buf, ace_ptr.unpack('L').first, ace_buf.size)
 
             if ace_buf.unpack('CCS').first == ACCESS_ALLOWED_ACE_TYPE
-               name        = 0.chr * MAX_PATH
+               name        = 0.chr * MAXPATH
                name_size   = [name.size].pack('L')
-               domain      = 0.chr * MAX_PATH
+               domain      = 0.chr * MAXPATH
                domain_size = [domain.size].pack('L')
                snu_ptr     = 0.chr * 4
                
@@ -488,7 +491,7 @@ class File
          file
       end
 
-      # Returns +file+ in long format. For example, if 'SOMEFI~1.TXT'
+      # Returns +path+ in long format. For example, if 'SOMEFI~1.TXT'
       # was the argument provided, and the short representation for
       # 'somefile.txt', then this method would return 'somefile.txt'.
       #
@@ -496,23 +499,23 @@ class File
       # from working as expected.  In that case, you will get back the file
       # name in 8.3 format.
       #
-      def long_path(file)
-         buf = 0.chr * MAX_PATH
-         if GetLongPathName(file, buf, buf.size) == 0
+      def long_path(path)
+         buf = 0.chr * MAXPATH
+         if GetLongPathName(path, buf, buf.size) == 0
             raise ArgumentError, get_last_error
          end
-         File.basename(buf.split(0.chr).first.strip)
+         buf.split(0.chr).first
       end
 
-      # Returns 'file_name' in 8.3 format. For example, 'c:\documentation.doc'
+      # Returns +path+ in 8.3 format. For example, 'c:\documentation.doc'
       # would be returned as 'c:\docume~1.doc'.
       #
-      def short_path(file)
-         buf = 0.chr * MAX_PATH
-         if GetShortPathName(file, buf, buf.size) == 0
+      def short_path(path)
+         buf = 0.chr * MAXPATH
+         if GetShortPathName(path, buf, buf.size) == 0
             raise ArgumentError, get_last_error
          end
-         File.basename(buf.split(0.chr).first.strip)
+         buf.split(0.chr).first
       end
 
       # Splits the given string into a directory and a file component and
@@ -796,6 +799,7 @@ class File
       in_buf = [in_buf].pack('L')
       bytes  = [0].pack('L')
       
+      # We can't use get_osfhandle here because we need specific attributes
       handle = CreateFile(
          self.path,
          FILE_READ_DATA | FILE_WRITE_DATA,
@@ -809,20 +813,24 @@ class File
       if handle == INVALID_HANDLE_VALUE
          raise ArgumentError, get_last_error
       end
+
+      begin
+         bool = DeviceIoControl(
+            handle,
+            FSCTL_SET_COMPRESSION(),
+            in_buf,
+            in_buf.length,
+            0,
+            0,
+            bytes,
+            0
+         )
       
-      val = DeviceIoControl(
-         handle,
-         FSCTL_SET_COMPRESSION(),
-         in_buf,
-         in_buf.length,
-         0,
-         0,
-         bytes,
-         0
-      )
-      
-      if val == 0
-         raise ArgumentError, get_last_error
+         unless bool
+            raise ArgumentError, get_last_error
+         end
+      ensure
+         CloseHandle(handle)
       end
       
       self
@@ -969,19 +977,23 @@ class File
          raise ArgumentError, get_last_error
       end
       
-      val = DeviceIoControl(
-         handle,
-         FSCTL_SET_SPARSE(),
-         0,
-         0,
-         0,
-         0,
-         bytes,
-         0
-      )
+      begin
+         bool = DeviceIoControl(
+            handle,
+            FSCTL_SET_SPARSE(),
+            0,
+            0,
+            0,
+            0,
+            bytes,
+            0
+         )
       
-      if val == 0
-         raise ArgumentError, get_last_error
+         unless bool == 0
+            raise ArgumentError, get_last_error
+         end
+      ensure
+         CloseHandle(handle)
       end
       
       self

data/test/{tc_file_attributes.rb → test_win32_file_attributes.rb}

@@ -1,63 +1,72 @@
 #############################################################################
-# tc_file_attributes.rb
+# test_win32_file_attributes.rb
 #
 # Test case for the attribute related methods of win32-file. You should run
 # this via the 'rake test' or 'rake test_attributes' task.
 #############################################################################
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'win32/file'
 
 class TC_Win32_File_Attributes < Test::Unit::TestCase
    include Windows::File
+   extend Windows::File
+
+   def self.startup
+      Dir.chdir('test') unless File.basename(Dir.pwd) == 'test'
+      @@file = File.join(Dir.pwd, 'test_file.txt')
+      File.open(@@file, 'w'){ |fh| fh.puts "This is a test." }
+   end
+
    def setup
-      @dir  = File.dirname(File.expand_path(__FILE__))
-      @file = File.join(@dir, 'sometestfile.txt')
-      @fh   = File.open(@file)
-      @attr = GetFileAttributes(@file)
+      @fh   = File.open(@@file)
+      @attr = GetFileAttributes(@@file)
    end
 
    def test_version
-      assert_equal('0.5.5', File::VERSION)
+      assert_equal('0.5.6', File::VERSION)
    end
    
    def test_temporary
       assert_respond_to(File, :temporary?)
-      assert_nothing_raised{ File.temporary?(@file) }    
-      assert_equal(false, 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 }
-      assert(File.temporary?(@file))
+      assert(File.temporary?(@@file))
    end
 
    def test_temporary_expected_errors
       assert_raises(ArgumentError){ File.temporary? }
-      assert_raises(ArgumentError){ File.temporary?(@file, 'foo') }
+      assert_raises(ArgumentError){ File.temporary?(@@file, 'foo') }
    end
    
    def test_system
       assert_respond_to(File, :system?)
-      assert_nothing_raised{ File.system?(@file) }    
-      assert_equal(false, 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 }
-      assert(File.system?(@file))
+      assert(File.system?(@@file))
    end
 
    def test_system_expected_errors
       assert_raises(ArgumentError){ File.system? }
-      assert_raises(ArgumentError){ File.system?(@file, 'foo') }
+      assert_raises(ArgumentError){ File.system?(@@file, 'foo') }
    end
    
    def test_sparse
       assert_respond_to(File, :sparse?)
-      assert_nothing_raised{ File.sparse?(@file) }    
-      assert_equal(false, 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
@@ -68,181 +77,203 @@ class TC_Win32_File_Attributes < Test::Unit::TestCase
 
    def test_sparse_file_expected_errors
       assert_raises(ArgumentError){ File.sparse? }
-      assert_raises(ArgumentError){ File.sparse?(@file, 'foo') }
+      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_equal(false, File.reparse_point?(@file))
+      assert_nothing_raised{ File.reparse_point?(@@file) }    
+      assert_equal(false, File.reparse_point?(@@file))
    end
 
    def test_reparse_point_expected_errors
       assert_raises(ArgumentError){ File.reparse_point? }
-      assert_raises(ArgumentError){ File.reparse_point?(@file, 'foo') }
+      assert_raises(ArgumentError){ File.reparse_point?(@@file, 'foo') }
    end
    
    def test_readonly
       assert_respond_to(File, :readonly?)
-      assert_respond_to(File, :read_only?) # alias
-      assert_nothing_raised{ File.read_only?(@file) }    
-      assert_equal(false, File.read_only?(@file))
+      assert_nothing_raised{ File.readonly?(@@file) }    
+      assert_equal(false, File.readonly?(@@file))
+   end
+
+   def test_read_only_alias
+      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 }
-      assert(File.readonly?(@file))
+      assert(File.readonly?(@@file))
    end
 
    def test_read_only_expected_errors
       assert_raises(ArgumentError){ File.read_only? }
-      assert_raises(ArgumentError){ File.read_only?(@file, 'foo') }
+      assert_raises(ArgumentError){ File.read_only?(@@file, 'foo') }
    end
    
    def test_offline
       assert_respond_to(File, :offline?)
-      assert_nothing_raised{ File.offline?(@file) }    
-      assert_equal(false, 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 }
-      assert(File.offline?(@file))
+      assert(File.offline?(@@file))
    end
 
    def test_offline_expected_errors
       assert_raises(ArgumentError){ File.offline? }
-      assert_raises(ArgumentError){ File.offline?(@file, 'foo') }
+      assert_raises(ArgumentError){ File.offline?(@@file, 'foo') }
    end
    
    def test_normal
       assert_respond_to(File, :normal?)
-      assert_nothing_raised{ File.normal?(@file) }    
-      assert_equal(false, 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 }
-      assert(File.normal?(@file))
+      assert(File.normal?(@@file))
    end
 
    def test_normal_expected_errors
       assert_raises(ArgumentError){ File.normal? }
-      assert_raises(ArgumentError){ File.normal?(@file, 'foo') }
+      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_equal(false, 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 }
-      assert(File.hidden?(@file))
+      assert(File.hidden?(@@file))
    end
 
    def test_hidden_expected_errors
       assert_raises(ArgumentError){ File.hidden? }
-      assert_raises(ArgumentError){ File.hidden?(@file, 'foo') }
+      assert_raises(ArgumentError){ File.hidden?(@@file, 'foo') }
    end 
 
    def test_encrypted
       assert_respond_to(File, :encrypted?)
-      assert_nothing_raised{ File.encrypted?(@file) }    
-      assert_equal(false, 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') }
+      assert_raises(ArgumentError){ File.encrypted?(@@file, 'foo') }
    end    
 
    def test_indexed
       assert_respond_to(File, :indexed?)
+      assert_nothing_raised{ File.indexed?(@@file) }    
+      assert_equal(true, File.indexed?(@@file))
+   end
+
+   def test_content_indexed_alias
       assert_respond_to(File, :content_indexed?)
-      assert_nothing_raised{ File.indexed?(@file) }    
-      assert_equal(true, File.indexed?(@file))
+      assert(File.method(:content_indexed?) == File.method(:indexed?))
    end
    
    def test_indexed_instance
       assert_respond_to(@fh, :indexed=)
       assert_nothing_raised{ @fh.indexed = true }
-      assert(File.indexed?(@file))
+      assert(File.indexed?(@@file))
    end
 
    def test_indexed_expected_errors
       assert_raises(ArgumentError){ File.indexed? }
-      assert_raises(ArgumentError){ File.indexed?(@file, 'foo') }
+      assert_raises(ArgumentError){ File.indexed?(@@file, 'foo') }
    end    
 
    def test_compressed
       assert_respond_to(File, :compressed?)
-      assert_nothing_raised{ File.compressed?(@file) }    
-      assert_equal(false, 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
       assert_respond_to(@fh, :compressed=)
+      assert_equal(false, File.compressed?(@@file))
+
       assert_nothing_raised{ @fh.compressed = true }
-      assert(File.compressed?(@file))
+      assert_equal(true, File.compressed?(@@file))
+
       assert_nothing_raised{ @fh.compressed = false }
-      assert_equal(false, File.compressed?(@file))
+      assert_equal(false, File.compressed?(@@file))
    end
 
    def test_compressed_expected_errors
       assert_raises(ArgumentError){ File.compressed? }
-      assert_raises(ArgumentError){ File.compressed?(@file, 'foo') }
+      assert_raises(ArgumentError){ File.compressed?(@@file, 'foo') }
    end    
    
    def test_archive
       assert_respond_to(File, :archive?)
-      assert_nothing_raised{ File.archive?(@file) }    
-      assert_equal(true, 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))
+      assert_equal(false, File.archive?(@@file))
    end
    
    def test_archive_expected_errors
       assert_raises(ArgumentError){ File.archive? }
-      assert_raises(ArgumentError){ File.archive?(@file, 'foo') }
+      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))
+      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_respond_to(File, :set_attr) # alias
-      assert_nothing_raised{ File.set_attributes(@file, File::HIDDEN) }
-      assert(File.hidden?(@file))
+      assert_nothing_raised{ File.set_attributes(@@file, File::HIDDEN) }
+      assert(File.hidden?(@@file))
+   end
+
+   def test_set_attr_alias
+      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_respond_to(File, :unset_attr) # alias
-      assert_nothing_raised{ File.remove_attributes(@file, File::ARCHIVE) }
-      assert_equal(false, File.archive?(@file))
+      assert_nothing_raised{ File.remove_attributes(@@file, File::ARCHIVE) }
+      assert_equal(false, File.archive?(@@file))
    end   
 
+   def test_unset_attr_alias
+      assert_respond_to(File, :unset_attr)
+      assert(File.method(:unset_attr) == File.method(:remove_attributes))
+   end
+
    def teardown
-      SetFileAttributes(@file, @attr)
-      @file = nil
-      @dir  = nil
+      SetFileAttributes(@@file, @attr)
       @fh.close
    end
+
+   def self.shutdown
+      File.delete(@@file)
+      @@file = nil
+   end
 end

data/test/{tc_file_constants.rb → test_win32_file_constants.rb}

@@ -1,5 +1,5 @@
 #############################################################################
-# tc_file_constants.rb
+# test_win32_file_constants.rb
 #
 # Test case for the path related methods of win32-file. Run this test via
 # the 'rake test' or 'rake test_constants' task.

data/test/{tc_file_encryption.rb → test_win32_file_encryption.rb}

@@ -1,33 +1,44 @@
 #############################################################################
-# tc_file_encryption.rb
+# test_win32_file_encryption.rb
 #
 # Test case for the encryption related methods of win32-file. You should
 # run this test via the 'rake test' or 'rake test_encryption' task.
 # 
 # Note: These tests may fail based on the security setup of your system.
 #############################################################################
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'win32/file'
 
 class TC_Win32_File_Encryption < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') unless File.basename(Dir.pwd) == 'test'
+      @@file = File.join(Dir.pwd, 'encryption_test.txt')
+      File.open(@@file, 'w'){ |fh| fh.puts "This is an encryption test." }
+   end
+
    def setup
-      @dir  = File.dirname(File.expand_path(__FILE__))
-      @file = File.join(@dir, 'sometestfile.txt')      
-      @msg   = '=> Ignore. May not work due to security setup of your system.'
+      @msg = '=> Ignore. May not work due to security setup of your system.'
    end
    
    def test_encrypt
       assert_respond_to(File, :encrypt)
-      assert_nothing_raised(@msg){ File.encrypt(@file) }
+      assert_nothing_raised(@msg){ File.encrypt(@@file) }
    end
    
    def test_decrypt
       assert_respond_to(File, :decrypt)
-      assert_nothing_raised(@msg){ File.decrypt(@file) }
+      assert_nothing_raised(@msg){ File.decrypt(@@file) }
    end
    
    def teardown
-      @file = nil
-      @dir  = nil
+      @msg = nil
+   end
+
+   def self.shutdown
+      File.delete(@@file) if File.exists?(@@file)
+      @@file = nil
    end
-end
+end

data/test/{tc_file_path.rb → test_win32_file_path.rb}

@@ -1,25 +1,34 @@
 #############################################################################
-# tc_file_path.rb
+# 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('test') unless File.basename(Dir.pwd) == 'test'
+      @@file = File.join(Dir.pwd, 'path_test.txt')
+      File.open(@@file, 'w'){ |fh| fh.puts "This is a path test." }
+   end
+
    def setup
-      @dir  = File.dirname(File.expand_path(__FILE__))
-      @long_file  = File.join(@dir, 'sometestfile.txt')      
-      @short_file = File.join(@dir, 'SOMETE~1.TXT')
+      @long_file  = File.join(Dir.pwd, 'path_test.txt')      
+      @short_file = File.join(Dir.pwd, 'PATH_T~1.TXT')
    end
    
-   def test_basename
+   def test_basename_basic
       assert_respond_to(File, :basename)
       assert_nothing_raised{ File.basename("C:\\foo") }
       assert_kind_of(String, File.basename("C:\\foo"))
+   end
       
-      # Standard paths
+   def test_basename_standard_paths
       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"))
@@ -27,14 +36,16 @@ class TC_Win32_File_Path < Test::Unit::TestCase
       assert_equal("bar", File.basename("C:\\foo\\bar\\"))
       assert_equal("foo", File.basename("C:\\foo"))
       assert_equal("C:\\", File.basename("C:\\"))
+   end
       
-      # UNC paths
+   def test_basename_unc_paths
       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
       
-      # Unix style paths
+   def test_basename_unix_style_paths
       assert_equal("bar", File.basename("/foo/bar"))
       assert_equal("bar.txt", File.basename("/foo/bar.txt"))
       assert_equal("bar.txt", File.basename("bar.txt"))
@@ -43,21 +54,24 @@ class TC_Win32_File_Path < Test::Unit::TestCase
       assert_equal("baz", File.basename("//foo/bar/baz"))
       assert_equal("//foo", File.basename("//foo"))
       assert_equal("//foo/bar", File.basename("//foo/bar"))
+   end
       
-      # Forward slashes
+   def test_basename_with_forward_slashes
       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
          
-      # Edge cases
+   def test_basename_edge_cases
       assert_equal("", File.basename(""))
       assert_equal(".", File.basename("."))
       assert_equal("..", File.basename(".."))
       assert_equal("foo", File.basename("//foo/"))
+   end
       
-      # Suffixes
+   def test_basename_with_suffixes
       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"))
@@ -65,32 +79,36 @@ class TC_Win32_File_Path < Test::Unit::TestCase
       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
       
-      # Ensure original path not modified
+   def test_basename_does_not_modify_argument
       path = "C:\\foo\\bar"
       assert_nothing_raised{ File.basename(path) }
       assert_equal("C:\\foo\\bar", path)    
    end
    
-   def test_dirname
+   def test_dirname_basic
       assert_respond_to(File, :dirname)
       assert_nothing_raised{ File.dirname("C:\\foo") }
       assert_kind_of(String, File.dirname("C:\\foo"))
+   end
       
-      # Standard Paths
+   def test_dirname_standard_paths
       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
       
-      # UNC paths
+   def test_dirname_unc_paths
       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
     
-      # Forward slashes
+   def test_dirname_forward_slashes
       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"))
@@ -101,49 +119,57 @@ class TC_Win32_File_Path < Test::Unit::TestCase
       assert_equal("//", File.dirname("//"))
       assert_equal(".", File.dirname("./foo"))
       assert_equal("./foo", File.dirname("./foo/bar"))
+   end
       
-      # Edge cases
+   def test_dirname_edge_cases
       assert_equal(".", File.dirname(""))
       assert_equal(".", File.dirname("."))
       assert_equal(".", File.dirname("."))
       assert_equal(".", File.dirname("./"))
       assert_raises(TypeError){ File.dirname(nil) }
+   end
       
-      # Ensure original path not modified
+   def test_dirname_does_not_modify_argument
       path = "C:\\foo\\bar"
       assert_nothing_raised{ File.dirname(path) }
       assert_equal("C:\\foo\\bar", path)
    end
    
-   def test_split
+   def test_split_basic
       assert_respond_to(File, :split)
       assert_nothing_raised{ File.split("C:\\foo\\bar") }
       assert_kind_of(Array, File.split("C:\\foo\\bar"))
+   end
       
-      # Standard Paths
+   def test_split_standard_paths
       assert_equal(["C:\\foo", "bar"], File.split("C:\\foo\\bar"))     
       assert_equal([".", "foo"], File.split("foo"))
+   end
       
-      # Forward slashes
+   def test_split_forward_slashes
       assert_equal(["C:/foo", "bar"], File.split("C:/foo/bar"))
       assert_equal([".", "foo"], File.split("foo"))
+   end
       
-      # Unix paths
+   def test_split_unix_paths
       assert_equal(["/foo","bar"], File.split("/foo/bar"))
       assert_equal(["/", "foo"], File.split("/foo"))
       assert_equal([".", "foo"], File.split("foo"))
+   end
       
-      # UNC paths
+   def test_split_unc_paths
       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
 
-      # Edge cases
+   def test_split_edge_cases
       assert_equal(["C:\\", ""], File.split("C:\\"))
       assert_equal(["", ""], File.split(""))
+   end
       
-      # Ensure original path not modified
+   def test_split_does_not_modify_arguments
       path = "C:\\foo\\bar"
       assert_nothing_raised{ File.split(path) }
       assert_equal("C:\\foo\\bar", path)
@@ -151,19 +177,22 @@ class TC_Win32_File_Path < Test::Unit::TestCase
    
    def test_long_path
       assert_respond_to(File, :long_path)
-      assert_equal('sometestfile.txt', File.long_path(@short_file))
-      assert_equal('SOMETE~1.TXT', File.basename(@short_file))
+      assert_equal(@long_file, File.long_path(@short_file))
+      assert_equal('PATH_T~1.TXT', File.basename(@short_file))
    end
    
    def test_short_path
       assert_respond_to(File, :short_path)
-      assert_equal('SOMETE~1.TXT', File.short_path(@long_file))
-      assert_equal('sometestfile.txt', File.basename(@long_file))
+      assert_equal('path_test.txt', File.basename(@long_file))
    end
    
    def teardown
       @short_file = nil
       @long_file  = nil
-      @dir        = nil
    end
-end
+
+   def self.shutdown
+      File.delete(@@file) if File.exists?(@@file)
+      @@file = nil
+   end
+end

data/test/test_win32_file_security.rb

@@ -0,0 +1,66 @@
+##############################################################################
+# test_win32_file_security.rb
+#
+# Test case for security related methods of win32-file. You should use the
+# 'rake test' or 'rake test_security' task to run this.
+#
+# Note that I've removed some tests that looked for explicit security
+# accounts, since it's impossible to determine how any given system is setup.
+##############################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'win32/file'
+require 'socket'
+
+class TC_Win32_File_Security < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') unless File.basename(Dir.pwd) == 'test'
+      @@host = Socket.gethostname
+      @@file = File.join(Dir.pwd, 'security_test.txt')
+      File.open(@@file, 'w'){ |fh| fh.puts "This is a security test." }
+   end
+
+   def setup
+      @perms = nil
+   end
+
+   # This will fail if there is no "Users" builtin.  Not to worry.
+   def test_get_permissions
+      assert_respond_to(File, :get_permissions)
+      assert_nothing_raised{ File.get_permissions(@@file) }
+      assert_kind_of(Hash, File.get_permissions(@@file))
+   end
+
+   def test_get_permissions_with_host
+      assert_nothing_raised{ File.get_permissions(@@file, @@host) }
+      assert_kind_of(Hash, File.get_permissions(@@file))
+   end
+
+   def test_set_permissions
+      assert_respond_to(File, :set_permissions)
+      assert_nothing_raised{ @perms = File.get_permissions(@@file) }
+      assert_nothing_raised{ File.set_permissions(@@file, @perms) }
+   end
+
+   def test_securities
+      assert_respond_to(File, :securities)
+      assert_nothing_raised{ @perms = File.get_permissions(@@file) }
+
+      @perms.each{ |acct, mask|
+         assert_nothing_raised{ File.securities(mask) }
+         assert_kind_of(Array, File.securities(mask))
+      }
+   end
+
+   def teardown
+      @perms = nil
+   end
+
+   def self.shutdown
+      File.delete(@@file) if File.exists?(@@file)
+      @@file  = nil
+      @@host  = nil
+   end
+end

data/test/{tc_file_stat.rb → test_win32_file_stat.rb}

@@ -1,61 +1,79 @@
 #####################################################################
-# tc_file_stat.rb
+# test_win32_file_stat.rb
 #
 # Test case for stat related methods of win32-file. You should run
 # this via the 'rake test' or 'rake test_stat' task.
 #####################################################################
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'win32/file'
 
 class TC_Win32_File_Stat < Test::Unit::TestCase
-   def setup
-      @dir  = File.dirname(File.expand_path(__FILE__))
-      @file = File.join(@dir, 'sometestfile.txt')      
+   include Windows::Volume
+   extend Windows::Volume
+
+   def self.startup
+      Dir.chdir('test') unless File.basename(Dir.pwd) == 'test'
+      @@file = File.join(Dir.pwd, 'stat_test.txt')
+      File.open(@@file, 'w'){ |fh| fh.puts "This is a test." }
+
+      # Find a block device
+      'A'.upto('Z'){ |volume|
+         volume += ":\\"
+         case GetDriveType(volume)
+            when DRIVE_REMOVABLE, DRIVE_CDROM, DRIVE_RAMDISK
+               @@block_dev = volume
+               break
+         end
+      }
    end
-   
-   # Although I don't perform a test against a file > 2gb here (since I
-   # don't feel like distributing a 2gb file), it works in my own tests.
+
+   # Although I don't perform a test against a file it works in my own tests.
    def test_size
       assert_respond_to(File, :size)
-      assert_equal(17, File.size(@file))
+      assert_equal(17, File.size(@@file))
    end
    
    def test_blksize
       msg = "+The blksize may be different - ignore+"
       assert_respond_to(File, :blksize)
       assert_kind_of(Fixnum, File.blksize("C:\\Program Files\\Windows NT"))
-      assert_kind_of(Fixnum, File.blksize(@file))
-      assert_equal(4096, File.blksize(@file), msg)
+      assert_kind_of(Fixnum, File.blksize(@@file))
+      assert_equal(4096, File.blksize(@@file), msg)
    end
    
    def test_blksize_expected_errors
       assert_raises(ArgumentError){ File.blksize }
-      assert_raises(ArgumentError){ File.blksize(@file, "foo") }
+      assert_raises(ArgumentError){ File.blksize(@@file, "foo") }
    end
    
    # The test for a block device will fail unless the D: drive is a CDROM.
    def test_blockdev
       assert_respond_to(File, :blockdev?)
       assert_nothing_raised{ File.blockdev?("C:\\") }    
-      assert_equal(true, File.blockdev?("D:\\"), '+Will fail unless CDROM+')
       assert_equal(false, File.blockdev?("NUL"))
+
+      omit_unless(File.exists?("D:\\"), "No media in device - skipping")
+      assert_equal(true, File.blockdev?(@@block_dev))
    end
    
    def test_blockdev_expected_errors
       assert_raises(ArgumentError){ File.blockdev? }
-      assert_raises(ArgumentError){ File.blockdev?(@file, "foo") }
+      assert_raises(ArgumentError){ File.blockdev?(@@file, "foo") }
    end
    
    def test_chardev
       assert_respond_to(File, :chardev?)
       assert_nothing_raised{ File.chardev?("NUL") }     
       assert_equal(true, File.chardev?("NUL"))
-      assert_equal(false, File.chardev?("C:\\"))
+      assert_equal(false, File.chardev?(@@file))
    end
    
    def test_chardev_expected_errors
       assert_raises(ArgumentError){ File.chardev? }
-      assert_raises(ArgumentError){ File.chardev?(@file, "foo") }
+      assert_raises(ArgumentError){ File.chardev?(@@file, "foo") }
    end
    
    # Ensure that not only does the File class respond to the stat method,
@@ -64,8 +82,8 @@ class TC_Win32_File_Stat < Test::Unit::TestCase
    # 
    def test_stat_class
       assert_respond_to(File, :stat)
-      assert_kind_of(File::Stat, File.stat(@file))
-      assert_equal(false, File.stat(@file).hidden?)
+      assert_kind_of(File::Stat, File.stat(@@file))
+      assert_equal(false, File.stat(@@file).hidden?)
    end
    
    # This was added after it was discovered that lstat is not aliased
@@ -73,20 +91,21 @@ class TC_Win32_File_Stat < Test::Unit::TestCase
    # 
    def test_lstat_class
       assert_respond_to(File, :lstat)
-      assert_kind_of(File::Stat, File.lstat(@file))
-      assert_equal(false, File.stat(@file).hidden?)
+      assert_kind_of(File::Stat, File.lstat(@@file))
+      assert_equal(false, File.stat(@@file).hidden?)
    end
    
    def test_stat_instance
-      File.open(@file){ |f|
+      File.open(@@file){ |f|
          assert_respond_to(f, :stat)
          assert_kind_of(File::Stat, f.stat)
          assert_equal(false, f.stat.hidden?)
       }
    end
    
-   def teardown
-      @file = nil
-      @dir  = nil
+   def self.shutdown
+      File.delete(@@file) if File.exists?(@@file)
+      @@file = nil
+      @@block_dev = nil
    end
 end

data/win32-file.gemspec

@@ -2,20 +2,22 @@ require "rubygems"
 
 spec = Gem::Specification.new do |gem|
    gem.name        = "win32-file"
-   gem.version     = "0.5.5"
-   gem.author      = "Daniel J. Berger"
+   gem.version     = "0.5.6"
+   gem.authors     = ["Daniel J. Berger", "Park Heesob"]
    gem.email       = "djberg96@gmail.com"
    gem.homepage    = "http://www.rubyforge.org/projects/win32utils"
    gem.platform    = Gem::Platform::RUBY
    gem.summary     = "Extra or redefined methods for the File class on Windows."
    gem.description = "Extra or redefined methods for the File class on Windows."
-   gem.test_files  = Dir["test/tc*"]
+   gem.test_files  = Dir["test/test*"]
    gem.has_rdoc    = true
    gem.files       = Dir["lib/win32/*.rb"] + Dir["test/*"] + Dir["[A-Z]*"]
    gem.files.reject! { |fn| fn.include? "CVS" }
    gem.require_path = "lib"
    gem.extra_rdoc_files = ["README", "CHANGES"]
    gem.add_dependency("win32-file-stat", ">= 1.2.0")
+   gem.add_dependency("test-unit", ">= 2.0.0")
+   gem.rubyforge_project = "win32utils"
 end
 
 if $0 == __FILE__

metadata

@@ -1,19 +1,21 @@
 --- !ruby/object:Gem::Specification 
 name: win32-file
 version: !ruby/object:Gem::Version 
-  version: 0.5.5
+  version: 0.5.6
 platform: ruby
 authors: 
 - Daniel J. Berger
+- Park Heesob
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2007-11-22 00:00:00 -07:00
+date: 2008-09-30 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: win32-file-stat
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -21,6 +23,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.2.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
 description: Extra or redefined methods for the File class on Windows.
 email: djberg96@gmail.com
 executables: []
@@ -32,16 +44,13 @@ extra_rdoc_files:
 - CHANGES
 files: 
 - lib/win32/file.rb
-- test/CVS
-- test/sometestfile.txt
-- test/tc_file_attributes.rb
-- test/tc_file_constants.rb
-- test/tc_file_encryption.rb
-- test/tc_file_path.rb
-- test/tc_file_security.rb
-- test/tc_file_stat.rb
+- test/test_win32_file_attributes.rb
+- test/test_win32_file_constants.rb
+- test/test_win32_file_encryption.rb
+- test/test_win32_file_path.rb
+- test/test_win32_file_security.rb
+- test/test_win32_file_stat.rb
 - CHANGES
-- CVS
 - lib
 - MANIFEST
 - Rakefile
@@ -69,15 +78,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 0.9.5
+rubyforge_project: win32utils
+rubygems_version: 1.3.0
 signing_key: 
 specification_version: 2
 summary: Extra or redefined methods for the File class on Windows.
 test_files: 
-- test/tc_file_attributes.rb
-- test/tc_file_constants.rb
-- test/tc_file_encryption.rb
-- test/tc_file_path.rb
-- test/tc_file_security.rb
-- test/tc_file_stat.rb
+- test/test_win32_file_attributes.rb
+- test/test_win32_file_constants.rb
+- test/test_win32_file_encryption.rb
+- test/test_win32_file_path.rb
+- test/test_win32_file_security.rb
+- test/test_win32_file_stat.rb

data/test/sometestfile.txt

@@ -1 +0,0 @@
-This is a test.

data/test/tc_file_security.rb

@@ -1,51 +0,0 @@
-#####################################################################
-# tc_file_security.rb
-#
-# Test case for security related methods of win32-file. You should
-# use the 'rake test' or 'rake test_security' task to run this.
-#####################################################################
-require 'test/unit'
-require 'win32/file'
-require 'socket'
-
-class TC_Win32_File_Security < Test::Unit::TestCase
-   def setup
-      @host  = Socket.gethostname
-      @dir   = File.dirname(File.expand_path(__FILE__))
-      @file  = File.join(@dir, 'sometestfile.txt')      
-      @perms = nil
-   end
-
-   # This will fail if there is no "Users" builtin.  Not to worry.
-   def test_get_permissions
-      assert_respond_to(File, :get_permissions)
-      assert_nothing_raised{ File.get_permissions(@file) }
-      assert_nothing_raised{ File.get_permissions(@file, @host) }
-      assert_kind_of(Hash, File.get_permissions(@file))
-      assert(File.get_permissions(@file).has_key?('BUILTIN\\Users'))
-      assert(File.get_permissions(@file).has_key?('BUILTIN\\Administrators'))
-   end
-
-   def test_set_permissions
-      assert_respond_to(File, :set_permissions)
-      assert_nothing_raised{ @perms = File.get_permissions(@file) }
-      assert_nothing_raised{ File.set_permissions(@file, @perms) }
-   end
-
-   def test_securities
-      assert_respond_to(File, :securities)
-      assert_nothing_raised{ @perms = File.get_permissions(@file) }
-
-      @perms.each{ |acct, mask|
-         assert_nothing_raised{ File.securities(mask) }
-         assert_kind_of(Array, File.securities(mask))
-      }
-   end
-
-   def teardown
-      @file  = nil
-      @host  = nil
-      @perms = nil
-      @dir   = nil
-   end
-end