win32-file 0.5.3

data/test/sometestfile.txt

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

data/test/tc_file_attributes.rb

@@ -0,0 +1,253 @@
+#############################################################################
+# tc_file_attributes.rb
+#
+# Test case for the attribute related methods of win32-file.
+#############################################################################
+base = File.basename(Dir.pwd)
+
+if base == 'test' || base =~ /win32-file/
+	Dir.chdir('..') if base == 'test'
+	$LOAD_PATH.unshift(Dir.pwd + '/lib')
+	Dir.chdir('test') rescue nil
+end
+
+require "test/unit"
+require "win32/file"
+
+class TC_Win32_File_Attributes < Test::Unit::TestCase
+   include Windows::File
+   def setup
+      @file = 'sometestfile.txt'
+      @fh   = File.open(@file)
+      @attr = GetFileAttributes(@file)
+   end
+
+   def test_version
+      assert_equal('0.5.3', File::VERSION)
+   end
+   
+   def test_temporary
+      assert_respond_to(File, :temporary?)
+      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))
+   end
+
+   def test_temporary_expected_errors
+      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_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))
+   end
+
+   def test_system_expected_errors
+      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_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
+      assert_respond_to(@fh, :sparse=)
+   end
+
+   def test_sparse_file_expected_errors
+      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_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') }
+   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))
+   end
+   
+   def test_readonly_instance
+      assert_respond_to(@fh, :readonly=)
+      assert_nothing_raised{ @fh.readonly = true }
+      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') }
+   end
+   
+   def test_offline
+      assert_respond_to(File, :offline?)
+      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))
+   end
+
+   def test_offline_expected_errors
+      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_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))
+   end
+
+   def test_normal_expected_errors
+      assert_raises(ArgumentError){ File.normal? }
+      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))
+   end
+   
+   def test_hidden_instance
+      assert_respond_to(@fh, :hidden=)
+      assert_nothing_raised{ @fh.hidden = true }
+      assert(File.hidden?(@file))
+   end
+
+   def test_hidden_expected_errors
+      assert_raises(ArgumentError){ File.hidden? }
+      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))
+   end
+
+   def test_encrypted_expected_errors
+      assert_raises(ArgumentError){ File.encrypted? }
+      assert_raises(ArgumentError){ File.encrypted?(@file, 'foo') }
+   end    
+
+   def test_indexed
+      assert_respond_to(File, :indexed?)
+      assert_respond_to(File, :content_indexed?)
+      assert_nothing_raised{ File.indexed?(@file) }    
+      assert_equal(true, File.indexed?(@file))
+   end
+   
+   def test_indexed_instance
+      assert_respond_to(@fh, :indexed=)
+      assert_nothing_raised{ @fh.indexed = true }
+      assert(File.indexed?(@file))
+   end
+
+   def test_indexed_expected_errors
+      assert_raises(ArgumentError){ File.indexed? }
+      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))
+   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_nothing_raised{ @fh.compressed = true }
+      assert(File.compressed?(@file))
+      assert_nothing_raised{ @fh.compressed = false }
+      assert_equal(false, File.compressed?(@file))
+   end
+
+   def test_compressed_expected_errors
+      assert_raises(ArgumentError){ File.compressed? }
+      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))
+   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_respond_to(File, :set_attr) # alias
+      assert_nothing_raised{ File.set_attributes(@file, File::HIDDEN) }
+      assert(File.hidden?(@file))
+   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))
+   end   
+
+   def teardown
+      SetFileAttributes(@file, @attr)
+      @file = nil
+      @fh.close
+   end
+end

data/test/tc_file_constants.rb

@@ -0,0 +1,53 @@
+#############################################################################
+# tc_file_constants.rb
+#
+# Test case for the path related methods of win32-file.
+#############################################################################
+base = File.basename(Dir.pwd)
+
+if base == 'test' || base =~ /win32-file/
+	Dir.chdir('..') if base == 'test'
+	$LOAD_PATH.unshift(Dir.pwd + '/lib')
+	Dir.chdir('test') rescue nil
+end
+
+require "test/unit"
+require "win32/file"
+
+class TC_Win32_File_Constants < Test::Unit::TestCase
+   def test_file_attribute_constants
+      assert_not_nil(File::ARCHIVE)
+      assert_not_nil(File::HIDDEN)
+      assert_not_nil(File::NORMAL)
+      assert_not_nil(File::INDEXED)
+      assert_not_nil(File::OFFLINE)
+      assert_not_nil(File::READONLY)
+      assert_not_nil(File::SYSTEM)
+      assert_not_nil(File::TEMPORARY)
+      assert_not_nil(File::CONTENT_INDEXED) # alias for INDEXED
+   end
+   
+   def test_security_rights_constants
+      assert_not_nil(File::FULL)
+      assert_not_nil(File::DELETE)
+      assert_not_nil(File::READ_CONTROL)
+      assert_not_nil(File::WRITE_DAC)
+      assert_not_nil(File::WRITE_OWNER)
+      assert_not_nil(File::SYNCHRONIZE)
+      assert_not_nil(File::STANDARD_RIGHTS_REQUIRED)
+      assert_not_nil(File::STANDARD_RIGHTS_READ)
+      assert_not_nil(File::STANDARD_RIGHTS_WRITE)
+      assert_not_nil(File::STANDARD_RIGHTS_EXECUTE)
+      assert_not_nil(File::STANDARD_RIGHTS_ALL)
+      assert_not_nil(File::SPECIFIC_RIGHTS_ALL)
+      assert_not_nil(File::ACCESS_SYSTEM_SECURITY)
+      assert_not_nil(File::MAXIMUM_ALLOWED)
+      assert_not_nil(File::GENERIC_READ)
+      assert_not_nil(File::GENERIC_WRITE)
+      assert_not_nil(File::GENERIC_EXECUTE)
+      assert_not_nil(File::GENERIC_ALL)
+      assert_not_nil(File::READ)
+      assert_not_nil(File::CHANGE)
+      assert_not_nil(File::ADD)
+   end
+end

data/test/tc_file_encryption.rb

@@ -0,0 +1,36 @@
+#############################################################################
+# tc_file_encryption.rb
+#
+# Test case for the encryption related methods of win32-file.
+#############################################################################
+base = File.basename(Dir.pwd)
+
+if base == 'test' || base =~ /win32-file/
+	Dir.chdir('..') if base == 'test'
+	$LOAD_PATH.unshift(Dir.pwd + '/lib')
+	Dir.chdir('test') rescue nil
+end
+
+require "test/unit"
+require "win32/file"
+
+class TC_Win32_File_Encryption < Test::Unit::TestCase
+   def setup
+      @file  = 'sometestfile.txt'
+      @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) }
+   end
+   
+   def test_decrypt
+      assert_respond_to(File, :decrypt)
+      assert_nothing_raised(@msg){ File.decrypt(@file) }
+   end
+   
+   def teardown
+      @file = nil
+   end
+end

data/test/tc_file_path.rb

@@ -0,0 +1,171 @@
+#############################################################################
+# tc_file_path.rb
+#
+# Test case for the path related methods of win32-file.
+#############################################################################
+base = File.basename(Dir.pwd)
+
+if base == 'test' || base =~ /win32-file/
+	Dir.chdir('..') if base == 'test'
+	$LOAD_PATH.unshift(Dir.pwd + '/lib')
+	Dir.chdir('test') rescue nil
+end
+
+require "test/unit"
+require "win32/file"
+
+class TC_Win32_File_Path < Test::Unit::TestCase
+   def setup
+      @short_file = 'SOMETE~1.TXT'
+      @long_file  = 'sometestfile.txt'
+   end
+   
+   def test_basename
+      assert_respond_to(File, :basename)
+      assert_nothing_raised{ File.basename("C:\\foo") }
+      assert_kind_of(String, File.basename("C:\\foo"))
+      
+      # 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"))
+      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:\\"))
+      
+      # 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"))
+      
+      # 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"))
+      assert_equal("bar", File.basename("/bar"))
+      assert_equal("bar", File.basename("/bar/"))
+      assert_equal("baz", File.basename("//foo/bar/baz"))
+      assert_equal("//foo", File.basename("//foo"))
+      assert_equal("//foo/bar", File.basename("//foo/bar"))
+      
+      # 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\\\\"))
+         
+      # Edge cases
+      assert_equal("", File.basename(""))
+      assert_equal(".", File.basename("."))
+      assert_equal("..", File.basename(".."))
+      assert_equal("foo", File.basename("//foo/"))
+      
+      # 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"))
+      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", ".*"))
+      
+      # Ensure original path not modified
+      path = "C:\\foo\\bar"
+      assert_nothing_raised{ File.basename(path) }
+      assert_equal("C:\\foo\\bar", path)    
+   end
+   
+   def test_dirname
+      assert_respond_to(File, :dirname)
+      assert_nothing_raised{ File.dirname("C:\\foo") }
+      assert_kind_of(String, File.dirname("C:\\foo"))
+      
+      # 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"))
+      
+      # 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("\\\\"))
+    
+      # 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"))
+      assert_equal("C:/", File.dirname("C:/"))
+      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("//"))
+      
+      # Edge cases
+      assert_equal(".", File.dirname(""))
+      assert_equal(".", File.dirname("."))
+      assert_equal(".", File.dirname("."))
+      assert_raises(TypeError){ File.dirname(nil) }
+      
+      # Ensure original path not modified
+      path = "C:\\foo\\bar"
+      assert_nothing_raised{ File.dirname(path) }
+      assert_equal("C:\\foo\\bar", path)
+   end
+   
+   def test_split
+      assert_respond_to(File, :split)
+      assert_nothing_raised{ File.split("C:\\foo\\bar") }
+      assert_kind_of(Array, File.split("C:\\foo\\bar"))
+      
+      # Standard Paths
+      assert_equal(["C:\\foo", "bar"], File.split("C:\\foo\\bar"))     
+      assert_equal([".", "foo"], File.split("foo"))
+      
+      # Forward slashes
+      assert_equal(["C:/foo", "bar"], File.split("C:/foo/bar"))
+      assert_equal([".", "foo"], File.split("foo"))
+      
+      # Unix paths
+      assert_equal(["/foo","bar"], File.split("/foo/bar"))
+      assert_equal(["/", "foo"], File.split("/foo"))
+      assert_equal([".", "foo"], File.split("foo"))
+      
+      # 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("\\\\"))
+
+      # Edge cases
+      assert_equal(["C:\\", ""], File.split("C:\\"))
+      assert_equal(["", ""], File.split(""))
+      
+      # Ensure original path not modified
+      path = "C:\\foo\\bar"
+      assert_nothing_raised{ File.split(path) }
+      assert_equal("C:\\foo\\bar", path)
+   end
+   
+   def test_long_path
+      assert_respond_to(File, :long_path)
+      assert_equal('sometestfile.txt', File.long_path(@short_file))
+      assert_equal('SOMETE~1.TXT', @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', @long_file)
+   end
+   
+   def teardown
+      @short_file = nil
+      @long_file  = nil
+   end
+end

data/test/tc_file_security.rb

@@ -0,0 +1,56 @@
+#####################################################################
+# tc_file_security.rb
+#
+# Test case for security related methods of win32-file.
+#####################################################################
+base = File.basename(Dir.pwd)
+
+if base == 'test' || base =~ /win32-file/
+	Dir.chdir('..') if base == 'test'
+	$LOAD_PATH.unshift(Dir.pwd + '/lib')
+	Dir.chdir('test') rescue nil
+end
+
+require 'test/unit'
+require 'win32/file'
+require 'socket'
+
+class TC_Win32_File_Security < Test::Unit::TestCase
+   def setup
+      @host  = Socket.gethostname
+      @file  = '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
+   end
+end

data/test/tc_file_stat.rb

@@ -0,0 +1,96 @@
+#####################################################################
+# tc_file_stat.rb
+#
+# Test case for stat related methods of win32-file.
+#####################################################################
+base = File.basename(Dir.pwd)
+
+if base == 'test' || base =~ /win32-file/
+	Dir.chdir('..') if base == 'test'
+	$LOAD_PATH.unshift(Dir.pwd + '/lib')
+	Dir.chdir('test') rescue nil
+end
+
+require "test/unit"
+require "win32/file"
+
+class TC_Win32_File_Stat < Test::Unit::TestCase
+   def setup
+      @file = 'sometestfile.txt'
+   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.
+   def test_size
+      assert_respond_to(File, :size)
+      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)
+   end
+   
+   def test_blksize_expected_errors
+      assert_raises(ArgumentError){ File.blksize }
+      assert_raises(ArgumentError){ File.blksize(@file, "foo") }
+   end
+   
+   def test_blockdev
+      assert_respond_to(File, :blockdev?)
+      assert_nothing_raised{ File.blockdev?("C:\\") }    
+      assert_equal(true, File.blockdev?("C:\\"))
+      assert_equal(false, File.blockdev?("NUL"))
+   end
+   
+   def test_blockdev_expected_errors
+      assert_raises(ArgumentError){ File.blockdev? }
+      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:\\"))
+   end
+   
+   def test_chardev_expected_errors
+      assert_raises(ArgumentError){ File.chardev? }
+      assert_raises(ArgumentError){ File.chardev?(@file, "foo") }
+   end
+   
+   # Ensure that not only does the File class respond to the stat method,
+   # but also that it's returning the File::Stat class from the
+   # win32-file-stat package.
+   # 
+   def test_stat_class
+      assert_respond_to(File, :stat)
+      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
+   # to stat automatically on Windows.
+   # 
+   def test_lstat_class
+      assert_respond_to(File, :lstat)
+      assert_kind_of(File::Stat, File.lstat(@file))
+      assert_equal(false, File.stat(@file).hidden?)
+   end
+   
+   def test_stat_instance
+      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
+   end
+end

data/test/ts_all.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(Dir.pwd + '/lib')
+$LOAD_PATH.unshift(Dir.pwd + '/lib/win32')
+$LOAD_PATH.unshift(Dir.pwd + '/test')
+
+require 'tc_file_encryption'
+require 'tc_file_path'
+require 'tc_file_stat'
+require 'tc_file_attributes'
+require 'tc_file_security'
+require 'tc_file_constants'