win32-file-stat 1.3.6 → 1.4.0

data/lib/win32/file/windows/constants.rb

@@ -0,0 +1,92 @@
+require 'ffi'
+
+module Windows
+  module Stat
+    module Constants
+      private
+
+      MAX_PATH = 260
+      MAXDWORD = 0xFFFFFFFF
+
+      # Normally just FFI::Pointer.new(-1).address, but we need JRuby to work, too.
+      INVALID_HANDLE_VALUE = (1<<FFI::Platform::ADDRESS_SIZE)-1
+
+      ERROR_FILE_NOT_FOUND = 2
+      ERROR_NO_MORE_FILES  = 18
+      ERROR_INSUFFICIENT_BUFFER = 122
+
+      FILE_TYPE_UNKNOWN = 0x0000
+      FILE_TYPE_DISK    = 0x0001
+      FILE_TYPE_CHAR    = 0x0002
+      FILE_TYPE_PIPE    = 0x0003
+      FILE_TYPE_REMOTE  = 0x8000
+
+      FILE_ATTRIBUTE_READONLY      = 0x00000001
+      FILE_ATTRIBUTE_HIDDEN        = 0x00000002
+      FILE_ATTRIBUTE_SYSTEM        = 0x00000004
+      FILE_ATTRIBUTE_DIRECTORY     = 0x00000010
+      FILE_ATTRIBUTE_ARCHIVE       = 0x00000020
+      FILE_ATTRIBUTE_ENCRYPTED     = 0x00000040
+      FILE_ATTRIBUTE_NORMAL        = 0x00000080
+      FILE_ATTRIBUTE_TEMPORARY     = 0x00000100
+      FILE_ATTRIBUTE_SPARSE_FILE   = 0x00000200
+      FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400
+      FILE_ATTRIBUTE_COMPRESSED    = 0x00000800
+      FILE_ATTRIBUTE_OFFLINE       = 0x00001000
+
+      FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x00002000
+
+      DRIVE_REMOVABLE   = 2
+      DRIVE_CDROM       = 5
+      DRIVE_RAMDISK     = 6
+
+      NO_ERROR = 0
+
+      OPEN_EXISTING   = 3
+      GENERIC_READ    = 0x80000000
+      GENERIC_WRITE   = 0x40000000
+      GENERIC_EXECUTE = 0x20000000
+
+      FILE_SHARE_READ = 1
+
+      FILE_FLAG_BACKUP_SEMANTICS   = 0x02000000
+      FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000
+      IO_REPARSE_TAG_SYMLINK       = 0xA000000C
+
+      OWNER_SECURITY_INFORMATION = 1
+      GROUP_SECURITY_INFORMATION = 2
+      DACL_SECURITY_INFORMATION  = 4
+
+      SYNCHRONIZE = 0x00100000
+      STANDARD_RIGHTS_REQUIRED = 0x000F0000
+
+      FILE_READ_DATA = 0x0001
+      FILE_WRITE_DATA = 0x0002
+      FILE_APPEND_DATA = 0x0004
+      FILE_READ_EA = 0x0008
+      FILE_WRITE_EA = 0x0008
+      FILE_EXECUTE = 0x0020
+      FILE_READ_ATTRIBUTES = 0x0080
+      FILE_WRITE_ATTRIBUTES = 0x0100
+
+      READ_CONTROL = 0x00020000
+      STANDARD_RIGHTS_READ = READ_CONTROL
+      STANDARD_RIGHTS_WRITE = READ_CONTROL
+      STANDARD_RIGHTS_EXECUTE = READ_CONTROL
+
+      FILE_GENERIC_READ = (STANDARD_RIGHTS_READ|FILE_READ_DATA|FILE_READ_ATTRIBUTES|FILE_READ_EA|SYNCHRONIZE)
+      FILE_GENERIC_WRITE = (STANDARD_RIGHTS_WRITE|FILE_WRITE_DATA|FILE_WRITE_ATTRIBUTES|FILE_WRITE_EA|FILE_APPEND_DATA|SYNCHRONIZE)
+      FILE_GENERIC_EXECUTE = (STANDARD_RIGHTS_EXECUTE|FILE_READ_ATTRIBUTES|FILE_EXECUTE|SYNCHRONIZE)
+      FILE_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x1FF)
+
+      TOKEN_DUPLICATE = 0x0002
+      TOKEN_IMPERSONATE = 0x0004
+      TOKEN_QUERY = 0x0008
+
+      SecurityImpersonation = 2
+
+      TokenUser   = 1
+      TokenGroups = 2
+    end
+  end
+end

data/lib/win32/file/windows/functions.rb

@@ -0,0 +1,57 @@
+require 'ffi'
+
+module Windows
+  module Stat
+    module Functions
+      extend FFI::Library
+
+      # Wrapper method for attach_pfunc + private
+      def self.attach_pfunc(*args)
+        attach_function(*args)
+        private args[0]
+      end
+
+      typedef :ulong, :dword
+      typedef :uintptr_t, :handle
+      typedef :pointer, :ptr
+      typedef :buffer_in, :buf_in
+      typedef :string, :str
+
+      ffi_convention :stdcall
+
+      ffi_lib :kernel32
+
+      attach_pfunc :CloseHandle, [:handle], :bool
+      attach_pfunc :CreateFile, :CreateFileW, [:buf_in, :dword, :dword, :ptr, :dword, :dword, :handle], :handle
+      attach_pfunc :FindFirstFile, :FindFirstFileW, [:buf_in, :ptr], :handle
+      attach_pfunc :FindClose, [:handle], :bool
+      attach_pfunc :GetCurrentProcess, [], :handle
+      attach_pfunc :GetDiskFreeSpace, :GetDiskFreeSpaceW, [:buf_in, :ptr, :ptr, :ptr, :ptr], :bool
+      attach_pfunc :GetDriveType, :GetDriveTypeW, [:buf_in], :uint
+      attach_pfunc :GetFileInformationByHandle, [:handle, :ptr], :bool
+      attach_pfunc :GetFileType, [:handle], :dword
+      attach_pfunc :OpenProcessToken, [:handle, :dword, :ptr], :bool
+
+      ffi_lib :shlwapi
+
+      attach_pfunc :PathGetDriveNumber, :PathGetDriveNumberW, [:buf_in], :int
+      attach_pfunc :PathIsUNC, :PathIsUNCW, [:buf_in], :bool
+      attach_pfunc :PathStripToRoot, :PathStripToRootW, [:ptr], :bool
+
+      ffi_lib :advapi32
+
+      attach_pfunc :ConvertSidToStringSid, :ConvertSidToStringSidA, [:ptr, :ptr], :bool
+      attach_pfunc :ConvertStringSidToSid, :ConvertStringSidToSidA, [:ptr, :ptr], :bool
+      attach_pfunc :GetFileSecurity, :GetFileSecurityW, [:buf_in, :int, :ptr, :dword, :ptr], :bool
+      attach_pfunc :GetSecurityDescriptorOwner, [:ptr, :ptr, :ptr], :bool
+      attach_pfunc :GetSecurityDescriptorGroup, [:ptr, :ptr, :ptr], :bool
+      attach_pfunc :GetTokenInformation, [:handle, :int, :ptr, :dword, :ptr], :bool
+      attach_pfunc :DuplicateToken, [:handle, :dword, :ptr], :bool
+      attach_pfunc :MapGenericMask, [:ptr, :ptr], :void
+      attach_pfunc :AccessCheck, [:ptr, :handle, :dword, :ptr, :ptr, :ptr, :ptr, :ptr], :bool
+      attach_pfunc :BuildTrusteeWithSid, :BuildTrusteeWithSidW, [:ptr, :ptr], :void
+      attach_pfunc :GetSecurityDescriptorDacl, [:ptr, :ptr, :ptr, :ptr], :bool
+      attach_pfunc :GetEffectiveRightsFromAcl, :GetEffectiveRightsFromAclW, [:ptr, :ptr, :ptr], :dword
+    end
+  end
+end

data/lib/win32/file/windows/helper.rb

@@ -0,0 +1,13 @@
+class String
+  # Convenience method for converting strings to UTF-16LE for wide character
+  # functions that require it.
+  def wincode
+    (self.tr(File::SEPARATOR, File::ALT_SEPARATOR) + 0.chr).encode('UTF-16LE')
+  end
+
+  # Read a wide character string up until the first double null, and delete
+  # any remaining null characters.
+  def read_wide
+    self[/^.*?(?=\x00{2})/].delete(0.chr)
+  end
+end

data/lib/win32/file/windows/structs.rb

@@ -0,0 +1,165 @@
+require File.join(File.dirname(__FILE__), 'constants')
+
+require 'ffi'
+
+module Windows
+  module Stat
+    module Structs
+      extend FFI::Library
+
+      private
+
+      class LowHigh < FFI::Struct
+        layout(:LowPart, :ulong, :HighPart, :ulong)
+      end
+
+      class ULARGE_INTEGER < FFI::Union
+        layout(:u, LowHigh, :QuadPart, :ulong_long)
+      end
+
+      class FILETIME < FFI::Struct
+        layout(:dwLowDateTime, :ulong, :dwHighDateTime, :ulong)
+      end
+
+      class BY_HANDLE_FILE_INFORMATION < FFI::Struct
+        include Windows::Stat::Constants
+
+        layout(
+          :dwFileAttributes, :ulong,
+          :ftCreationTime, FILETIME,
+          :ftLastAccessTime, FILETIME,
+          :ftLastWriteTime, FILETIME,
+          :dwVolumeSerialNumber, :ulong,
+          :nFileSizeHigh, :ulong,
+          :nFileSizeLow, :ulong,
+          :nNumberOfLinks, :ulong,
+          :nFileIndexHigh, :ulong,
+          :nFileIndexLow, :ulong
+        )
+
+        # Return the atime as a number
+        def atime
+          date = ULARGE_INTEGER.new
+          date[:u][:LowPart] = self[:ftLastAccessTime][:dwLowDateTime]
+          date[:u][:HighPart] = self[:ftLastAccessTime][:dwHighDateTime]
+          date[:QuadPart] / 10000000 - 11644473600 # ns, 100-ns since Jan 1, 1601.
+        end
+
+        # Return the ctime as a number
+        def ctime
+          date = ULARGE_INTEGER.new
+          date[:u][:LowPart] = self[:ftCreationTime][:dwLowDateTime]
+          date[:u][:HighPart] = self[:ftCreationTime][:dwHighDateTime]
+          date[:QuadPart] / 10000000 - 11644473600 # ns, 100-ns since Jan 1, 1601.
+        end
+
+        # Return the mtime as a number
+        def mtime
+          date = ULARGE_INTEGER.new
+          date[:u][:LowPart] = self[:ftLastWriteTime][:dwLowDateTime]
+          date[:u][:HighPart] = self[:ftLastWriteTime][:dwHighDateTime]
+          date[:QuadPart] / 10000000 - 11644473600 # ns, 100-ns since Jan 1, 1601.
+        end
+
+        # Return the size as a single number
+        def size
+          (self[:nFileSizeHigh] * (MAXDWORD + 1)) + self[:nFileSizeLow]
+        end
+      end
+
+      class WIN32_FIND_DATA < FFI::Struct
+        include Windows::Stat::Constants
+
+        layout(
+          :dwFileAttributes, :ulong,
+          :ftCreationTime, FILETIME,
+          :ftLastAccessTime, FILETIME,
+          :ftLastWriteTime, FILETIME,
+          :nFileSizeHigh, :ulong,
+          :nFileSizeLow, :ulong,
+          :dwReserved0, :ulong,
+          :dwReserved1, :ulong,
+          :cFileName, [:uint8, MAX_PATH*2],
+          :cAlternateFileName, [:uint8, 28]
+        )
+
+        # Return the atime as a number
+        def atime
+          date = ULARGE_INTEGER.new
+          date[:u][:LowPart] = self[:ftLastAccessTime][:dwLowDateTime]
+          date[:u][:HighPart] = self[:ftLastAccessTime][:dwHighDateTime]
+          return 0 if date[:QuadPart]==0
+          date[:QuadPart] / 10000000 - 11644473600 # ns, 100-ns since Jan 1, 1601.
+        end
+
+        # Return the ctime as a number
+        def ctime
+          date = ULARGE_INTEGER.new
+          date[:u][:LowPart] = self[:ftCreationTime][:dwLowDateTime]
+          date[:u][:HighPart] = self[:ftCreationTime][:dwHighDateTime]
+          return 0 if date[:QuadPart]==0
+          date[:QuadPart] / 10000000 - 11644473600 # ns, 100-ns since Jan 1, 1601.
+        end
+
+        # Return the mtime as a number
+        def mtime
+          date = ULARGE_INTEGER.new
+          date[:u][:LowPart] = self[:ftLastWriteTime][:dwLowDateTime]
+          date[:u][:HighPart] = self[:ftLastWriteTime][:dwHighDateTime]
+          return 0 if date[:QuadPart]==0
+          date[:QuadPart] / 10000000 - 11644473600 # ns, 100-ns since Jan 1, 1601.
+        end
+
+        # Return the size as a single number
+        def size
+          (self[:nFileSizeHigh] * (MAXDWORD + 1)) + self[:nFileSizeLow]
+        end
+      end
+
+      class SID_AND_ATTRIBUTES < FFI::Struct
+        layout(:Sid, :pointer, :Attributes, :ulong)
+      end
+
+      class TOKEN_GROUP < FFI::Struct
+        layout(
+          :GroupCount, :ulong,
+          :Groups, [SID_AND_ATTRIBUTES, 128]
+        )
+      end
+
+      class GENERIC_MAPPING < FFI::Struct
+        layout(
+          :GenericRead, :ulong,
+          :GenericWrite, :ulong,
+          :GenericExecute, :ulong,
+          :GenericAll, :ulong
+        )
+      end
+
+      class LUID_AND_ATTRIBUTES < FFI::Struct
+        layout(
+          :Luid, LowHigh,
+          :Attributes, :ulong
+        )
+      end
+
+      class PRIVILEGE_SET < FFI::Struct
+        layout(
+          :PrivilegeCount, :ulong,
+          :Control, :ulong,
+          :Privilege, [LUID_AND_ATTRIBUTES, 1]
+        )
+      end
+
+      class TRUSTEE < FFI::Struct
+        layout(
+          :pMultipleTrustee, :pointer,
+          :MultipleTrusteeOperation, :ulong,
+          :TrusteeForm, :ulong,
+          :TrusteeType, :ulong,
+          :ptstrName, :pointer
+        )
+      end
+    end
+  end
+end

data/test/test_file_stat.rb

@@ -1,354 +1,647 @@
-#####################################################################
-# test_file_stat.rb
-#
-# Test case for stat related methods of win32-file. You should use
-# the 'rake test' task to run these tests.
-#####################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
-require 'win32/file/stat'
-
-class TC_Win32_File_Stat < Test::Unit::TestCase
-   include Windows::File
-   include Windows::Process
-   include Windows::Volume
-   extend Windows::Volume
-
-   def self.startup
-      Dir.chdir(File.expand_path(File.dirname(__FILE__)))
-
-      'A'.upto('Z'){ |volume|
-         volume += ":\\"
-         case GetDriveType(volume)
-         when DRIVE_REMOVABLE, DRIVE_CDROM, DRIVE_RAMDISK
-            @@block_dev = volume
-            break
-         end
-      }
-
-      @@txt_file = 'test_file.txt'
-      @@exe_file = 'test_file.exe'
-      @@sys_file = 'C:/pagefile.sys'
-
-      File.open(@@txt_file, "w"){ |fh| fh.print "This is a test\nHello" }
-      File.open(@@exe_file, "wb"){ |fh| fh.print "This is a test" }
-   end
-
-   def setup
-      @dir  = Dir.pwd
-      @stat = File::Stat.new(@@txt_file)
-      @attr = GetFileAttributes(@@txt_file)
-   end
-
-   def test_version
-      assert_equal('1.3.6', File::Stat::VERSION)
-   end
-
-   # One or more tests will fail if the archive attribute on @@text_file
-   # is not set.
-   def test_archive
-      assert_respond_to(@stat, :archive?)
-      assert_nothing_raised{ @stat.archive? }
-      assert(@stat.archive?, '=> May fail - ignore')
-   end
-
-   def test_atime
-      assert_respond_to(@stat, :atime)
-      assert_kind_of(Time, @stat.atime)
-   end
-
-   def test_blksize
-      assert_respond_to(@stat, :blksize)
-      assert_equal(4096, @stat.blksize)
-      assert_equal(4096, File::Stat.new("C:\\").blksize)
-   end
-
-   # The block dev test error out if there's no media in it.
-   def test_blockdev
-      assert_respond_to(@stat, :blockdev?)
-      assert_false(@stat.blockdev?)
-      assert_false(File::Stat.new('NUL').blockdev?)
-
-      begin
-         assert_true(File::Stat.new(@@block_dev).blockdev?)
-      rescue StandardError, SystemCallError
-         omit("Skipping because drive is empty or not found")
-      end
-   end
-
-   def test_blocks
-      assert_respond_to(@stat, :blocks)
-      assert_equal(1, @stat.blocks)
-   end
-
-   def test_chardev
-      assert_respond_to(@stat, :chardev?)
-      assert_nothing_raised{ File::Stat.new("NUL").chardev? }
-      assert_equal(true, File::Stat.new("NUL").chardev?)
-      assert_equal(false, File::Stat.new("C:\\").chardev?)
-   end
-
-   def test_comparison
-      assert_respond_to(@stat, :<=>)
-      assert_nothing_raised{ @stat <=> File::Stat.new(@@exe_file) }
-   end
-
-   def test_compressed
-      assert_respond_to(@stat, :compressed?)
-      assert_nothing_raised{ @stat.compressed? }
-      assert_equal(false, @stat.compressed?)
-   end
-
-   def test_ctime
-      assert_respond_to(@stat, :ctime)
-      assert_kind_of(Time, @stat.ctime)
-   end
-
-   # Assumes you've installed on C: drive.
-   def test_dev
-      assert_respond_to(@stat, :dev)
-      assert_equal('C:', @stat.dev)
-   end
-
-   def test_dev_major
-      assert_respond_to(@stat, :dev_major)
-      assert_nil(@stat.dev_major)
-   end
-
-   def test_dev_minor
-      assert_respond_to(@stat, :dev_minor)
-      assert_nil(@stat.dev_minor)
-   end
-
-   def test_directory
-      assert_respond_to(@stat, :directory?)
-      assert_equal(false, @stat.directory?)
-      assert_equal(true, File::Stat.new("C:\\").directory?)
-   end
-
-   def test_executable
-      assert_respond_to(@stat, :executable?)
-      assert_equal(false, @stat.executable?)
-      assert_equal(true, File::Stat.new(@@exe_file).executable?)
-   end
-
-   def test_executable_real
-      assert_respond_to(@stat, :executable_real?)
-      assert_equal(false, @stat.executable_real?)
-      assert_equal(true, File::Stat.new(@@exe_file).executable_real?)
-   end
-
-   def test_file
-      assert_respond_to(@stat, :file?)
-      assert_equal(true, @stat.file?)
-      assert_equal(true, File::Stat.new(@@exe_file).file?)
-      assert_equal(true, File::Stat.new(Dir.pwd).file?)
-      assert_equal(false, File::Stat.new('NUL').file?)
-   end
-
-   def test_ftype
-      assert_respond_to(@stat, :ftype)
-      assert_equal('file', @stat.ftype)
-      assert_equal('characterSpecial', File::Stat.new('NUL').ftype)
-      assert_equal('directory', File::Stat.new(Dir.pwd).ftype)
-   end
-
-   def encrypted
-      assert_respond_to(@stat, :encrypted?)
-      assert_nothing_raised{ @stat.encrypted? }
-   end
-
-   def test_gid
-      assert_respond_to(@stat, :gid)
-      assert_equal(0, @stat.gid)
-   end
-
-   def test_grpowned
-      assert_respond_to(@stat, :grpowned?)
-   end
-
-   def test_hidden
-      assert_respond_to(@stat, :hidden?)
-      assert_nothing_raised{ @stat.hidden? }
-      assert_equal(false, @stat.hidden?)
-   end
-
-   def test_indexed
-      assert_respond_to(@stat, :indexed?)
-      assert_respond_to(@stat, :content_indexed?) # alias
-      assert_nothing_raised{ @stat.indexed? }
-      assert(@stat.indexed?)
-   end
-
-   def test_ino
-      assert_respond_to(@stat, :ino)
-      assert_equal(0, @stat.ino)
-   end
-
-   def test_inspect
-      assert_respond_to(@stat, :inspect)
-   end
-
-   def test_mode
-      assert_respond_to(@stat, :mode)
-      assert_equal(33188, File::Stat.new(@@txt_file).mode)
-      assert_equal(33261, File::Stat.new(@@exe_file).mode)
-      assert_equal(16877, File::Stat.new(@dir).mode)
-
-      SetFileAttributes(@@txt_file, 1) # Set to readonly.
-      assert_equal(33060, File::Stat.new(@@txt_file).mode)
-   end
-
-   def test_mtime
-      assert_respond_to(@stat, :mtime)
-      assert_kind_of(Time, @stat.mtime)
-   end
-
-   def test_nlink
-      assert_respond_to(@stat, :nlink)
-      assert_equal(1, @stat.nlink)
-   end
-
-   def test_normal
-      assert_respond_to(@stat, :normal?)
-      assert_nothing_raised{ @stat.normal? }
-      assert_equal(false, @stat.normal?)
-   end
-
-   def test_offline
-      assert_respond_to(@stat, :offline?)
-      assert_nothing_raised{ @stat.offline? }
-      assert_equal(false, @stat.offline?)
-   end
-
-   def test_pipe
-      assert_respond_to(@stat, :pipe?)
-      assert_equal(false, @stat.pipe?)
-   end
-
-   def test_readable
-      assert_respond_to(@stat, :readable?)
-      assert_equal(true, @stat.readable?)
-   end
-
-   def test_readable_real
-      assert_respond_to(@stat, :readable_real?)
-      assert_equal(true, @stat.readable_real?)
-   end
-
-   def test_readonly
-      assert_respond_to(@stat, :readonly?)
-      assert_nothing_raised{ @stat.readonly? }
-      assert_equal(false, @stat.readonly?)
-   end
-
-   def test_reparse_point
-      assert_respond_to(@stat, :reparse_point?)
-      assert_nothing_raised{ @stat.reparse_point? }
-      assert_equal(false, @stat.reparse_point?)
-   end
-
-   # Assumes you've installed on C: drive.
-   def test_rdev
-      msg = "ignore failure if Ruby is not installed on C: drive"
-      assert_respond_to(@stat, :rdev)
-      assert_equal(2, @stat.rdev, msg)
-   end
-
-   def test_setgid
-      assert_respond_to(@stat, :setgid?)
-      assert_equal(false, @stat.setgid?)
-   end
-
-   def test_setuid
-      assert_respond_to(@stat, :setuid?)
-      assert_equal(false, @stat.setuid?)
-   end
-
-   def test_size
-      assert_respond_to(@stat, :size)
-      assert_equal(21, @stat.size)
-   end
-
-   def test_size_system_file
-      omit_if(windows_64?, 'skipping system file test on 64-bit OS')
-      assert_nothing_raised{ File::Stat.new(@@sys_file).size }
-   end
-
-   def test_size_bool
-      assert_respond_to(@stat, :size?)
-      assert_equal(21, @stat.size?)
-   end
-
-   def test_socket
-      assert_respond_to(@stat, :socket?)
-      assert_equal(false, @stat.socket?)
-   end
-
-   def test_sparse
-      assert_respond_to(@stat, :sparse?)
-      assert_nothing_raised{ @stat.sparse? }
-      assert_equal(false, @stat.sparse?)
-   end
-
-   def test_sticky
-      assert_respond_to(@stat, :sticky?)
-      assert_equal(false, @stat.sticky?)
-   end
-
-   def test_symlink
-      assert_respond_to(@stat, :symlink?)
-      assert_equal(false, @stat.symlink?)
-   end
-
-   def test_system
-      assert_respond_to(@stat, :system?)
-      assert_nothing_raised{ @stat.system? }
-      assert_equal(false, @stat.system?)
-   end
-
-   def test_temporary
-      assert_respond_to(@stat, :temporary?)
-      assert_nothing_raised{ @stat.temporary? }
-      assert_equal(false, @stat.temporary?)
-   end
-
-   def test_uid
-      assert_respond_to(@stat, :uid)
-      assert_equal(0, @stat.uid)
-   end
-
-   def test_writable
-      assert_respond_to(@stat, :writable?)
-      assert_equal(true, @stat.writable?)
-   end
-
-   def test_writable_real
-      assert_respond_to(@stat, :writable_real?)
-      assert_equal(true, @stat.writable_real?)
-   end
-
-   def test_zero
-      assert_respond_to(@stat, :zero?)
-      assert_equal(false, @stat.zero?)
-   end
-
-   def teardown
-      SetFileAttributes(@@txt_file, @attr) # Set file back to normal
-      @dir  = nil
-      @stat = nil
-      @attr = nil
-   end
-
-   def self.shutdown
-      File.delete(@@txt_file) if File.exists?(@@txt_file)
-      File.delete(@@exe_file) if File.exists?(@@exe_file)
-
-      @@block_dev = nil
-      @@txt_file  = nil
-      @@exe_file  = nil
-      @@sys_file  = nil
-   end
-end
+#####################################################################
+# test_file_stat.rb
+#
+# Test case for stat related methods of win32-file. You should use
+# the 'rake test' task to run these tests.
+#####################################################################
+require 'etc'
+require 'ffi'
+require 'test-unit'
+require 'win32/file/stat'
+require 'win32/security'
+
+class TC_Win32_File_Stat < Test::Unit::TestCase
+  extend FFI::Library
+  ffi_lib :kernel32
+
+  attach_function :GetDriveType, :GetDriveTypeA, [:string], :ulong
+  attach_function :GetFileAttributes, :GetFileAttributesA, [:string], :ulong
+  attach_function :SetFileAttributes, :SetFileAttributesA, [:string, :ulong], :bool
+
+  DRIVE_REMOVABLE = 2
+  DRIVE_CDROM     = 5
+  DRIVE_RAMDISK   = 6
+
+  def self.startup
+    @@block_dev = nil
+
+    'A'.upto('Z'){ |volume|
+      volume += ":\\"
+      case GetDriveType(volume)
+      when DRIVE_REMOVABLE, DRIVE_CDROM, DRIVE_RAMDISK
+        @@block_dev = volume
+        break
+      end
+    }
+
+    @@txt_file = File.join(File.expand_path(File.dirname(__FILE__)), 'test_file.txt')
+    @@exe_file = File.join(File.expand_path(File.dirname(__FILE__)), 'test_file.exe')
+    @@sys_file = 'C:/pagefile.sys'
+    @@elevated = Win32::Security.elevated_security?
+    @@jruby    = RUBY_PLATFORM == 'java'
+
+    File.open(@@txt_file, "w"){ |fh| fh.print "This is a test\nHello" }
+    File.open(@@exe_file, "wb"){ |fh| fh.print "This is a test" }
+  end
+
+  def setup
+    @dir  = Dir.pwd
+    @stat = File::Stat.new(@@txt_file)
+    @temp = 'win32_file_stat.tmp'
+    File.open(@temp, 'w'){}
+    @attr = GetFileAttributes(@@txt_file)
+  end
+
+  test "version is set to expected value" do
+    assert_equal('1.4.0', File::Stat::WIN32_FILE_STAT_VERSION)
+  end
+
+  test "constructor does not modify argument" do
+    expected = File.join(File.expand_path(File.dirname(__FILE__)), 'test_file.txt')
+    File::Stat.new(@@txt_file)
+    assert_equal(expected, @@txt_file)
+  end
+
+  test "archive? method basic functionality" do
+    assert_respond_to(@stat, :archive?)
+    assert_nothing_raised{ @stat.archive? }
+  end
+
+  test "archive? method returns a boolean value" do
+    assert_boolean(@stat.archive?)
+  end
+
+  test "atime method basic functionality" do
+    assert_respond_to(@stat, :atime)
+    assert_nothing_raised{ @stat.atime }
+  end
+
+  test "atime method returns expected value" do
+    assert_kind_of(Time, @stat.atime)
+    assert_true(@stat.atime.to_i > 0)
+  end
+
+  test "mtime method basic functionality" do
+    assert_respond_to(@stat, :mtime)
+    assert_nothing_raised{ @stat.mtime }
+  end
+
+  test "mtime method returns expected value" do
+    assert_kind_of(Time, @stat.mtime)
+    assert_true(@stat.mtime.to_i > 0)
+  end
+
+  test "ctime method basic functionality" do
+    assert_respond_to(@stat, :ctime)
+    assert_nothing_raised{ @stat.ctime }
+  end
+
+  test "ctime method returns expected value" do
+    assert_kind_of(Time, @stat.ctime)
+    assert_true(@stat.ctime.to_i > 0)
+  end
+
+  test "blksize basic functionality" do
+    assert_respond_to(@stat, :blksize)
+    assert_kind_of(Fixnum, @stat.blksize)
+  end
+
+  test "blksize returns expected value" do
+    assert_equal(4096, @stat.blksize)
+    assert_equal(4096, File::Stat.new("C:\\").blksize)
+  end
+
+  test "blockdev? basic functionality" do
+    assert_respond_to(@stat, :blockdev?)
+    assert_boolean(@stat.blockdev?)
+  end
+
+  test "blockdev? returns the expected value for a non-block device" do
+    assert_false(@stat.blockdev?)
+    assert_false(File::Stat.new('NUL').blockdev?)
+  end
+
+  # In unusual situations this could fail.
+  test "blockdev? returns the expected value for a block device" do
+    omit_unless(@@block_dev)
+    assert_true(File::Stat.new(@@block_dev).blockdev?)
+  end
+
+  test "blocks basic functionality" do
+    assert_respond_to(@stat, :blocks)
+    assert_kind_of(Fixnum, @stat.blocks)
+  end
+
+  test "blocks method returns expected value" do
+    assert_equal(1, @stat.blocks)
+  end
+
+  test "chardev? custom method basic functionality" do
+    assert_respond_to(@stat, :chardev?)
+    assert_boolean(@stat.chardev?)
+  end
+
+  test "chardev? custom method returns expected value" do
+    assert_true(File::Stat.new("NUL").chardev?)
+    assert_false(File::Stat.new("C:\\").chardev?)
+  end
+
+  test "custom comparison method basic functionality" do
+    assert_respond_to(@stat, :<=>)
+    assert_nothing_raised{ @stat <=> File::Stat.new(@@exe_file) }
+  end
+
+  test "custom comparison method works as expected" do
+    assert_equal(0, @stat <=> @stat)
+  end
+
+  test "compressed? basic functionality" do
+    assert_respond_to(@stat, :compressed?)
+    assert_boolean(@stat.compressed?)
+  end
+
+  test "compressed? returns expected value" do
+    assert_false(@stat.compressed?)
+  end
+
+  test "dev custom method basic functionality" do
+    assert_respond_to(@stat, :rdev)
+    assert_kind_of(Fixnum, @stat.rdev)
+  end
+
+  test "dev custom method returns expected value" do
+    notify "May fail on JRuby" if @@jruby
+    assert_equal(2, File::Stat.new("C:\\").dev)
+    assert_equal(-1, File::Stat.new("NUL").dev)
+  end
+
+  test "dev custom method accepts an optional argument" do
+    assert_nothing_raised{ File::Stat.new("C:\\").dev(true) }
+    assert_kind_of(String, File::Stat.new("C:\\").dev(true))
+  end
+
+  test "dev custom method with optional argument returns expected value" do
+    notify "May fail on JRuby" if @@jruby
+    assert_equal("C:", File::Stat.new("C:\\").dev(true))
+    assert_nil(File::Stat.new("NUL").dev(true))
+  end
+
+  test "dev_major defined and always returns nil" do
+    omit_if(@@jruby) # https://github.com/jnr/jnr-posix/issues/23
+    assert_respond_to(@stat, :dev_major)
+    assert_nil(@stat.dev_major)
+  end
+
+  test "dev_minor defined and always returns nil" do
+    omit_if(@@jruby) # https://github.com/jnr/jnr-posix/issues/23
+    assert_respond_to(@stat, :dev_minor)
+    assert_nil(@stat.dev_minor)
+  end
+
+  test "directory? custom method basic functionality" do
+    assert_respond_to(@stat, :directory?)
+    assert_boolean(@stat.directory?)
+  end
+
+  test "directory? custom method returns expected value" do
+    assert_false(@stat.directory?)
+    assert_true(File::Stat.new("C:\\").directory?)
+  end
+
+  test "executable? custom method basic functionality" do
+    assert_respond_to(@stat, :executable?)
+    assert_boolean(@stat.executable?)
+  end
+
+  test "executable? custom method returns expected value" do
+    assert_false(@stat.executable?)
+    assert_true(File::Stat.new(@@exe_file).executable?)
+  end
+
+  test "executable_real? is an alias for executable?" do
+    assert_respond_to(@stat, :executable_real?)
+    assert_alias_method(@stat, :executable?, :executable_real?)
+  end
+
+  test "file? custom method basic functionality" do
+    assert_respond_to(@stat, :file?)
+    assert_boolean(@stat.file?)
+  end
+
+  test "file? custom method returns expected value" do
+    assert_true(@stat.file?)
+    assert_true(File::Stat.new(@@exe_file).file?)
+    assert_true(File::Stat.new(Dir.pwd).file?)
+    assert_false(File::Stat.new('NUL').file?)
+  end
+
+  test "ftype custom method basic functionality" do
+    assert_respond_to(@stat, :ftype)
+    assert_kind_of(String, @stat.ftype)
+  end
+
+  test "ftype custom method returns expected value" do
+    assert_equal('file', @stat.ftype)
+    assert_equal('characterSpecial', File::Stat.new('NUL').ftype)
+    assert_equal('directory', File::Stat.new(Dir.pwd).ftype)
+  end
+
+  test "encrypted? basic functionality" do
+    assert_respond_to(@stat, :encrypted?)
+    assert_boolean(@stat.encrypted?)
+  end
+
+  test "encrypted? returns the expected value" do
+    assert_false(@stat.encrypted?)
+  end
+
+  test "gid method basic functionality" do
+    assert_respond_to(@stat, :gid)
+    assert_nothing_raised{ @stat.gid }
+    assert_kind_of(Fixnum, @stat.gid)
+  end
+
+  test "gid returns a sane result" do
+    assert_true(@stat.gid >= 0 && @stat.gid <= 10000)
+  end
+
+  test "gid returns a string argument if true argument provided" do
+    assert_nothing_raised{ @stat.gid(true) }
+    assert_match("S-1-", @stat.gid(true))
+  end
+
+  test "grpowned? defined and always returns true" do
+    assert_respond_to(@stat, :grpowned?)
+  end
+
+  test "hidden? basic functionality" do
+    assert_respond_to(@stat, :hidden?)
+    assert_boolean(@stat.hidden?)
+  end
+
+  test "hidden? returns expected value" do
+    assert_false(@stat.hidden?)
+  end
+
+  test "indexed? basic functionality" do
+    assert_respond_to(@stat, :indexed?)
+    assert_boolean(@stat.indexed?)
+  end
+
+  test "indexed? returns expected value" do
+    assert_true(@stat.indexed?)
+  end
+
+  test "content_indexed? is an alias for indexed?" do
+    assert_respond_to(@stat, :content_indexed?)
+    assert_alias_method(@stat, :indexed?, :content_indexed?)
+  end
+
+  test "ino method basic functionality" do
+    assert_respond_to(@stat, :ino)
+    assert_nothing_raised{ @stat.ino }
+    assert_kind_of(Numeric, @stat.ino)
+  end
+
+  test "ino method returns a sane value" do
+    assert_true(@stat.ino > 1000)
+  end
+
+  test "ino method returns nil on a special device" do
+    assert_nil(File::Stat.new("NUL").ino)
+  end
+
+  test "inspect custom method basic functionality" do
+    assert_respond_to(@stat, :inspect)
+  end
+
+  test "inspect string contains expected values" do
+    assert_match('File::Stat', @stat.inspect)
+    assert_match('compressed', @stat.inspect)
+    assert_match('normal', @stat.inspect)
+  end
+
+  test "mode custom method basic functionality" do
+    assert_respond_to(@stat, :mode)
+    assert_kind_of(Fixnum, @stat.mode)
+  end
+
+  test "mode custom method returns the expected value" do
+    assert_equal(33188, File::Stat.new(@@txt_file).mode)
+    assert_equal(33261, File::Stat.new(@@exe_file).mode)
+    assert_equal(16877, File::Stat.new(@dir).mode)
+  end
+
+  test "mode custom method returns expected value for readonly file" do
+    SetFileAttributes(@@txt_file, 1) # Set to readonly.
+    assert_equal(33060, File::Stat.new(@@txt_file).mode)
+  end
+
+  test "nlink basic functionality" do
+    assert_respond_to(@stat, :nlink)
+    assert_kind_of(Fixnum, @stat.nlink)
+  end
+
+  test "nlink returns the expected value" do
+    assert_equal(1, @stat.nlink)
+    assert_equal(1, File::Stat.new(Dir.pwd).nlink)
+    assert_equal(1, File::Stat.new('NUL').nlink)
+  end
+
+  test "normal? basic functionality" do
+    assert_respond_to(@stat, :normal?)
+    assert_boolean(@stat.normal?)
+  end
+
+  test "normal? returns expected value" do
+    assert_false(@stat.normal?)
+  end
+
+  test "offline? method basic functionality" do
+    assert_respond_to(@stat, :offline?)
+    assert_boolean(@stat.offline?)
+  end
+
+  test "offline? method returns expected value" do
+    assert_false(@stat.offline?)
+  end
+
+  test "owned? method basic functionality" do
+    assert_respond_to(@stat, :owned?)
+    assert_boolean(@stat.owned?)
+  end
+
+  test "owned? returns the expected results" do
+    if @@elevated
+      assert_false(@stat.owned?)
+    else
+      assert_true(@stat.owned?)
+    end
+    assert_false(File::Stat.new(@@sys_file).owned?)
+  end
+
+  test "pipe? custom method basic functionality" do
+    assert_respond_to(@stat, :pipe?)
+    assert_boolean(@stat.pipe?)
+  end
+
+  test "pipe? custom method returns expected value" do
+    assert_false(@stat.pipe?)
+  end
+
+  test "socket? is an alias for pipe?" do
+    assert_respond_to(@stat, :socket?)
+    assert_alias_method(@stat, :socket?, :pipe?)
+  end
+
+  test "readable? basic functionality" do
+    assert_respond_to(@stat, :readable?)
+    assert_boolean(@stat.readable?)
+  end
+
+  test "readable? returns expected value" do
+    assert_true(@stat.readable?)
+    assert_true(File::Stat.new(Dir.pwd).readable?)
+    assert_false(File::Stat.new(@@sys_file).readable?)
+  end
+
+  test "readable_real? basic functionality" do
+    assert_respond_to(@stat, :readable_real?)
+    assert_boolean(@stat.readable_real?)
+  end
+
+  test "readable_real? returns expected value" do
+    assert_true(@stat.readable_real?)
+  end
+
+  test "readonly? basic functionality" do
+    assert_respond_to(@stat, :readonly?)
+    assert_boolean(@stat.readonly?)
+  end
+
+  test "readonly? returns the expected value" do
+    assert_false(@stat.readonly?)
+    SetFileAttributes(@@txt_file, 1)
+    assert_true(File::Stat.new(@@txt_file).readonly?)
+  end
+
+  test "read_only? is an alias for readonly?" do
+    assert_respond_to(@stat, :read_only?)
+    assert_alias_method(@stat, :readonly?, :read_only?)
+  end
+
+  test "reparse_point? basic functionality" do
+    assert_respond_to(@stat, :reparse_point?)
+    assert_boolean(@stat.reparse_point?)
+  end
+
+  test "reparse_point returns expected value" do
+    assert_false(@stat.reparse_point?)
+  end
+
+  test "rdev basic functionality" do
+    assert_respond_to(@stat, :rdev)
+    assert_nothing_raised{ @stat.rdev }
+    assert_kind_of(Numeric, @stat.rdev)
+  end
+
+  test "rdev returns a sane value" do
+    assert_true(File::Stat.new("C:\\Program Files").rdev > 1000)
+  end
+
+  test "rdev returns nil on special files" do
+    assert_equal(nil, File::Stat.new("NUL").rdev)
+  end
+
+  # Not sure how to test properly in a generic way, but works on my local network
+  test "rdev works on unc path" do
+    omit_unless(Etc.getlogin == "djberge" && File.exists?("//scipio/users"))
+    assert_true(File::Stat.new("//scipio/users").rdev > 1000)
+  end
+
+  test "rdev_major defined and always returns nil" do
+    omit_if(@@jruby) # https://github.com/jnr/jnr-posix/issues/23
+    assert_respond_to(@stat, :rdev_major)
+    assert_nil(@stat.rdev_major)
+  end
+
+  test "rdev_minor defined and always returns nil" do
+    omit_if(@@jruby) # https://github.com/jnr/jnr-posix/issues/23
+    assert_respond_to(@stat, :rdev_minor)
+    assert_nil(@stat.rdev_minor)
+  end
+
+  test "setgid is set to false" do
+    assert_respond_to(@stat, :setgid?)
+    assert_false(@stat.setgid?)
+  end
+
+  test "setuid is set to false" do
+    assert_respond_to(@stat, :setuid?)
+    assert_false(@stat.setuid?)
+  end
+
+  test "size custom method basic functionality" do
+    assert_respond_to(@stat, :size)
+    assert_kind_of(Numeric, @stat.size)
+  end
+
+  test "size custom method returns expected value" do
+    assert_equal(21, @stat.size)
+    @stat = File::Stat.new(@temp)
+    assert_equal(0, @stat.size)
+  end
+
+  test "size custom method works on system files" do
+    assert_nothing_raised{ File::Stat.new(@@sys_file).size }
+  end
+
+  test "size? method basic functionality" do
+    assert_respond_to(@stat, :size?)
+    assert_kind_of(Numeric, @stat.size)
+  end
+
+  test "size? method returns integer if size greater than zero" do
+    assert_equal(21, @stat.size?)
+  end
+
+  test "size? method returns nil if size is zero" do
+    @stat = File::Stat.new(@temp)
+    assert_nil(@stat.size?)
+  end
+
+  test "sparse? basic fucntionality" do
+    assert_respond_to(@stat, :sparse?)
+    assert_boolean(@stat.sparse?)
+  end
+
+  test "sparse? returns expected value" do
+    assert_false(@stat.sparse?)
+  end
+
+  test "sticky is always set to false" do
+    assert_respond_to(@stat, :sticky?)
+    assert_false(@stat.sticky?)
+  end
+
+  test "symlink? basic functionality" do
+    assert_respond_to(@stat, :symlink?)
+    assert_boolean(@stat.symlink?)
+  end
+
+  test "symlink? returns expected value" do
+    assert_false(@stat.symlink?)
+  end
+
+  test "system? basic functionality" do
+    assert_respond_to(@stat, :system?)
+    assert_boolean(@stat.system?)
+  end
+
+  test "system? returns expected value" do
+    assert_false(@stat.system?)
+  end
+
+  test "temporary? basic functionality" do
+    assert_respond_to(@stat, :temporary?)
+    assert_boolean(@stat.temporary?)
+  end
+
+  test "temporary? returns expected value" do
+    assert_false(@stat.temporary?)
+  end
+
+  test "uid basic functionality" do
+    assert_respond_to(@stat, :uid)
+    assert_nothing_raised{ @stat.uid }
+    assert_kind_of(Fixnum, @stat.uid)
+  end
+
+  test "uid returns a sane result" do
+    assert_true(@stat.uid >= 0 && @stat.uid <= 10000)
+  end
+
+  test "uid returns a string argument if true argument provided" do
+    assert_nothing_raised{ @stat.uid(true) }
+    assert_match("S-1-", @stat.uid(true))
+  end
+
+  test "world_readable? basic functionality" do
+    assert_respond_to(@stat, :world_readable?)
+    assert_boolean(@stat.world_readable?)
+  end
+
+  # TODO: Find or create a file that returns true.
+  test "world_readable? returns expected result" do
+    assert_false(@stat.world_readable?)
+    assert_false(File::Stat.new("C:/").world_readable?)
+  end
+
+  test "world_writable? basic functionality" do
+    assert_respond_to(@stat, :world_writable?)
+    assert_boolean(@stat.world_writable?)
+  end
+
+  # TODO: Find or create a file that returns true.
+  test "world_writable? returns expected result" do
+    assert_false(@stat.world_writable?)
+    assert_false(File::Stat.new("C:/").world_writable?)
+  end
+
+  test "writable? basic functionality" do
+    assert_respond_to(@stat, :writable?)
+    assert_boolean(@stat.writable?)
+  end
+
+  test "writable? returns expected value" do
+    assert_true(@stat.writable?)
+    assert_true(File::Stat.new(Dir.pwd).writable?)
+    assert_false(File::Stat.new(@@sys_file).writable?)
+  end
+
+  test "writable_real? basic functionality" do
+    assert_respond_to(@stat, :writable_real?)
+    assert_boolean(@stat.writable_real?)
+  end
+
+  test "writable_real? returns expected value" do
+    assert_true(@stat.writable_real?)
+  end
+
+  test "zero? method basic functionality" do
+    assert_respond_to(@stat, :zero?)
+    assert_boolean(@stat.zero?)
+  end
+
+  test "zero? method returns expected value" do
+    assert_false(@stat.zero?)
+    @stat = File::Stat.new(@temp)
+    assert_true(@stat.zero?)
+  end
+
+  test "ffi functions are private" do
+    assert_not_respond_to(@stat, :CloseHandle)
+    assert_not_respond_to(File::Stat, :CloseHandle)
+  end
+
+  def teardown
+    SetFileAttributes(@@txt_file, @attr) # Set file back to normal
+    File.delete(@temp) if File.exists?(@temp)
+    @dir  = nil
+    @stat = nil
+    @attr = nil
+    @temp = nil
+  end
+
+  def self.shutdown
+    File.delete(@@txt_file) if File.exists?(@@txt_file)
+    File.delete(@@exe_file) if File.exists?(@@exe_file)
+
+    @@block_dev = nil
+    @@txt_file  = nil
+    @@exe_file  = nil
+    @@sys_file  = nil
+    @@elevated  = nil
+    @@jruby     = nil
+  end
+end