windows-pr 0.5.1-mswin32 → 0.5.2-mswin32

data/CHANGES

@@ -1,3 +1,15 @@
+= 0.5.2 - 29-Jul-2006
+* Prototype fixes/changes for CreateProcess, GlobalLock, GlobalMemoryStatusEx,
+  and CreateFileMapping.
+* Finer grained method wrapping/checking for the Windows::Process module (only
+  two methods might not be defined).
+* Added method wrappers for the Handle constants.
+* Added mmap related methods and constants.
+* Added more test cases.
+* Added wide character methods to the Windows::Directory class.
+* Added wide character helper methods.
+* Added a few more methods to MSVCRT::String. 
+
 = 0.5.1 - 26-May-2006
 * Minor updates and fixes for the Unicode and DeviceIO modules.
 * Added some wide character support, based on $KCODE values (which should

data/README

@@ -45,15 +45,16 @@
    file contains clipboard related functions, such as CloseClipboard(), as
    well as constants such as CF_TEXT, CF_BITMAP, etc.
    
-== Wide character functions - DO NOT USE
-   Because there's no way to "#define UNICODE" from outside of C, I have
-   instead taken the approach of defining the wide character functions and
-   automatically using those if $KCODE is set to anything other than "NONE".
-   
-   However, support for this is very incomplete at the moment.  In addition,
-   unpredictable segfaults occur with Ruby's string processing in some cases,
-   the cause of which is unknown at this time.  The upshot of this is that you
-   should not use these modules with $KCODE set to anything other than "NONE".
+== Wide character functions
+	I decided that the $KCODE handling was a bad idea, so most of the $KCODE
+	handling has been removed.  The only methods that change their behavior
+	based on $KCODE are the multi_to_wide and wide_to_multi helper methods
+	in the Windows::Unicode module.  If $KCODE is set to UTF8, then the code
+	point used is CP_UTF8.  Otherwise, CP_ACP is used.
+	
+	In the future I'll add the wide character functions explicitly.  I haven't
+	added many yet (as of 29-Jul-2006) but I plan on adding as many as I can
+	as time permits.
    
 == Where are the tests, dude?
    While I've made some effort to test these functions, there are simply too

data/lib/windows/directory.rb

@@ -5,10 +5,12 @@ module Windows
       CreateDirectory             = Win32API.new('kernel32', 'CreateDirectory', 'PP', 'I')
       CreateDirectoryW            = Win32API.new('kernel32', 'CreateDirectoryW', 'PP', 'I')
       CreateDirectoryEx           = Win32API.new('kernel32', 'CreateDirectoryEx', 'PPP', 'I')
+      CreateDirectoryExW          = Win32API.new('kernel32', 'CreateDirectoryExW', 'PPP', 'I')
       FindCloseChangeNotification = Win32API.new('kernel32', 'FindCloseChangeNotification', 'L', 'I')
       FindFirstChangeNotification = Win32API.new('kernel32', 'FindFirstChangeNotification', 'PIL', 'L')
       FindNextChangeNotification  = Win32API.new('kernel32', 'FindFirstChangeNotification', 'PIL', 'I')
       GetCurrentDirectory         = Win32API.new('kernel32', 'GetCurrentDirectory', 'LP', 'L')
+      GetCurrentDirectoryW        = Win32API.new('kernel32', 'GetCurrentDirectoryW', 'LP', 'L')
       ReadDirectoryChangesW       = Win32API.new('kernel32', 'ReadDirectoryChangesW', 'LPLILPPP', 'I')
       RemoveDirectory             = Win32API.new('kernel32', 'RemoveDirectory', 'P', 'I')
       RemoveDirectoryW            = Win32API.new('kernel32', 'RemoveDirectoryW', 'P', 'I')
@@ -16,15 +18,21 @@ module Windows
       SetCurrentDirectoryW        = Win32API.new('kernel32', 'SetCurrentDirectoryW', 'P', 'I')
 
       def CreateDirectory(path, attributes = 0)
-         if $KCODE != 'NONE'
-            CreateDirectoryW.call(path, attributes) != 0
-         else
-            CreateDirectory.call(path, attributes) != 0
-         end
+         CreateDirectory.call(path, attributes) != 0
+      end
+      
+      def CreateDirectoryW(path, attributes)
+         path = multi_to_wide(path) unless IsTextUnicode(path)
+         CreateDirectoryW.call(path, attributes) != 0
       end
 
-      def CreateDirectoryEx(template, new, attributes)
-         CreateDirectoryEx.call(template, new, attributes) != 0
+      def CreateDirectoryEx(template, new_dir, attributes)
+         CreateDirectoryEx.call(template, new_dir, attributes) != 0
+      end
+      
+      def CreateDirectoryExW(template, new_dir, attributes)
+         new_dir = multi_to_wide(new_dir) unless IsTextUnicode(new_dir)
+         CreateDirectoryExW.call(template, new_dir, attributes) != 0
       end
 
       def FindCloseChangeNotification(handle)
@@ -42,25 +50,31 @@ module Windows
       def GetCurrentDirectory(buf_len, buf)
          GetCurrentDirectory.call(buf_len, buf)
       end
+      
+      def GetCurrentDirectoryW(buf_len, buf)
+         GetCurrentDirectoryW.call(buf_len, buf)
+      end
 
       def ReadDirectoryChangesW(handle, buf, buf_len, subtree, filter, bytes, overlapped, routine)
          ReadDirectoryChangesW.call(handle, buf, buf_len, subtree, filter, bytes, overlapped, routine) != 0
       end
 
       def RemoveDirectory(path)
-         if $KCODE != 'NONE'
-            RemoveDirectoryW.call(path) != 0
-         else
-            RemoveDirectory.call(path) != 0
-         end
+         RemoveDirectory.call(path) != 0
+      end
+      
+      def RemoveDirectoryW(path)
+         path = multi_to_wide(path) unless IsTextUnicode(path)
+         RemoveDirectoryW.call(path) != 0
       end
 
       def SetCurrentDirectory(path)
-         if $KCODE != 'NONE'
-            SetCurrentDirectoryW.call(path) != 0
-         else
-            SetCurrentDirectory.call(path) != 0
-         end
+         SetCurrentDirectory.call(path) != 0
+      end
+      
+      def SetCurrentDirectoryW(path)
+         path = multi_to_wide(path) unless IsTextUnicode(path)
+         SetCurrentDirectoryW.call(path) != 0
       end
    end
 end

data/lib/windows/error.rb

@@ -196,6 +196,7 @@ module Windows
       ERROR_BAD_DYNALINK          = 213 #@@ PTM 5760 
       ERROR_TOO_MANY_MODULES      = 214
       ERROR_NESTING_NOT_ALLOWED   = 215
+      ERROR_MORE_DATA             = 234
  
       ERROR_USER_DEFINED_BASE = 0xF000
 
@@ -295,18 +296,17 @@ module Windows
          FormatMessage.call(flags, src, msg_id, lang_id, buf, size, args)
       end
       
+      def FormatMessageW(flags, src, msg_id, lang_id, buf, size, args)
+         FormatMessageW.call(flags, src, msg_id, lang_id, buf, size, args)
+      end
+      
       # Convenience method that wraps FormatMessage with some sane defaults and
       # returns a human readable string.
       #
       def get_last_error(err_num = GetLastError.call)
          buf   = 0.chr * 260
-         flags = FORMAT_MESSAGE_FROM_SYSTEM + FORMAT_MESSAGE_ARGUMENT_ARRAY
-         
-         if $KCODE != 'NONE'
-            FormatMessageW.call(flags, 0, err_num, 0, buf, buf.length, 0)
-         else
-            FormatMessage.call(flags, 0, err_num, 0, buf, buf.length, 0)      
-         end
+         flags = FORMAT_MESSAGE_FROM_SYSTEM + FORMAT_MESSAGE_ARGUMENT_ARRAY        
+         FormatMessage.call(flags, 0, err_num, 0, buf, buf.size, 0)      
          buf.split(0.chr).first.chomp       
       end
    end

data/lib/windows/file.rb

@@ -137,6 +137,40 @@ module Windows
       OPEN_EXISTING     = 3
       OPEN_ALWAYS       = 4
       TRUNCATE_EXISTING = 5
+
+      # Page file access
+      PAGE_NOACCESS          = 0x01     
+      PAGE_READONLY          = 0x02     
+      PAGE_READWRITE         = 0x04     
+      PAGE_WRITECOPY         = 0x08     
+      PAGE_EXECUTE           = 0x10     
+      PAGE_EXECUTE_READ      = 0x20     
+      PAGE_EXECUTE_READWRITE = 0x40     
+      PAGE_EXECUTE_WRITECOPY = 0x80     
+      PAGE_GUARD             = 0x100     
+      PAGE_NOCACHE           = 0x200     
+      PAGE_WRITECOMBINE      = 0x400
+      SEC_FILE               = 0x800000     
+      SEC_IMAGE              = 0x1000000     
+      SEC_VLM                = 0x2000000     
+      SEC_RESERVE            = 0x4000000     
+      SEC_COMMIT             = 0x8000000     
+      SEC_NOCACHE            = 0x10000000
+      
+      SECTION_QUERY       = 0x0001
+      SECTION_MAP_WRITE   = 0x0002
+      SECTION_MAP_READ    = 0x0004
+      SECTION_MAP_EXECUTE = 0x0008
+      SECTION_EXTEND_SIZE = 0x0010
+
+      SECTION_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY |
+         SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE |
+         SECTION_EXTEND_SIZE
+      
+      FILE_MAP_COPY       = SECTION_QUERY
+      FILE_MAP_WRITE      = SECTION_MAP_WRITE
+      FILE_MAP_READ       = SECTION_MAP_READ
+      FILE_MAP_ALL_ACCESS = SECTION_ALL_ACCESS
       
       # Errors
       INVALID_FILE_ATTRIBUTES   = -1
@@ -147,10 +181,15 @@ module Windows
       CopyFileEx     = Win32API.new('kernel32', 'CopyFileEx', 'PPPPPL', 'I')
       CreateFile     = Win32API.new('kernel32', 'CreateFile', 'PLLPLLL', 'L')
       CreateFileW    = Win32API.new('kernel32', 'CreateFileW', 'PLLPLLL', 'L')
+
+      CreateFileMapping = Win32API.new('kernel32', 'CreateFileMapping', 'LPLLLP', 'L')
+
       CreateHardLink = Win32API.new('kernel32', 'CreateHardLink', 'PPP', 'I')
       DecryptFile    = Win32API.new('advapi32', 'DecryptFile', 'PL', 'I')
       DeleteFile     = Win32API.new('kernel32', 'DeleteFile', 'P', 'I')
       EncryptFile    = Win32API.new('advapi32', 'EncryptFile', 'P', 'I')
+      
+      FlushViewOfFile = Win32API.new('kernel32', 'FlushViewOfFile', 'PL', 'I')
 
       GetBinaryType       = Win32API.new('kernel32', 'GetBinaryType', 'PP', 'I')
       GetFileAttributes   = Win32API.new('kernel32', 'GetFileAttributes', 'P', 'L')
@@ -165,6 +204,11 @@ module Windows
 
       LockFile   = Win32API.new('kernel32', 'LockFile', 'LLLLL', 'I')
       LockFileEx = Win32API.new('kernel32', 'LockFileEx', 'LLLLLL', 'I')
+
+      MapViewOfFile   = Win32API.new('kernel32', 'MapViewOfFile', 'LLLLL', 'L')
+      MapViewOfFileEx = Win32API.new('kernel32', 'MapViewOfFileEx', 'LLLLLP', 'L')
+      OpenFileMapping = Win32API.new('kernel32', 'OpenFileMapping', 'LIP', 'L')
+
       ReadFile   = Win32API.new('kernel32', 'ReadFile', 'LPLPP', 'I')
       ReadFileEx = Win32API.new('kernel32', 'ReadFileEx', 'LPLPP', 'I')
 
@@ -172,6 +216,9 @@ module Windows
 
       UnlockFile   = Win32API.new('kernel32', 'UnlockFile', 'LLLLL', 'I')
       UnlockFileEx = Win32API.new('kernel32', 'UnlockFileEx', 'LLLLL', 'I')
+
+      UnmapViewOfFile = Win32API.new('kernel32', 'UnmapViewOfFile', 'P', 'I')
+
       WriteFile    = Win32API.new('kernel32', 'WriteFile', 'LPLPP', 'I')
       WriteFileEx  = Win32API.new('kernel32', 'WriteFileEx', 'LPLPP', 'I')
 
@@ -184,11 +231,11 @@ module Windows
       end
 
       def CreateFile(file, access, share, sec, disp, flags, template)
-         if $KCODE != 'NONE'
-            CreateFileW.call(file, access, share, sec, disp, flags, template)
-         else
-            CreateFile.call(file, access, share, sec, disp, flags, template)
-         end
+         CreateFile.call(file, access, share, sec, disp, flags, template)
+      end
+
+      def CreateFileMapping(handle, security, protect, high, low, name)
+         CreateFileMapping.call(handle, security, protect, high, low, name)
       end
 
       def CreateHardLink(new_file, old_file, attributes)
@@ -206,6 +253,10 @@ module Windows
       def EncryptFile(file)
          EncryptFile.call(file) > 0
       end
+      
+      def FlushViewOfFile(address, bytes)
+         FlushViewOfFile.call(address, bytes) != 0
+      end
 
       def GetBinaryType(file, type)
          GetBinaryType.call(file, type) > 0
@@ -232,11 +283,7 @@ module Windows
       end
       
       def GetFullPathName(file, buf, buf_size, part)
-         if $KCODE != 'NONE'
-            GetFullPathNameW.call(file, buf, buf_size, part)
-         else
-            GetFullPathName.call(file, buf, buf_size, part)
-         end
+         GetFullPathName.call(file, buf, buf_size, part)
       end
       
       def GetLongPathName(short, buf, buf_size)
@@ -255,6 +302,18 @@ module Windows
          LockFileEx.call(handle, flags, res, low, high, overlapped) > 0
       end
 
+      def MapViewOfFile(handle, access, high, low, bytes)
+         MapViewOfFile.call(handle, access, high, low, bytes)
+      end
+      
+      def MapViewOfFileEx(handle, access, high, low, bytes, address)
+         MapViewOfFile.call(handle, access, high, low, bytes, address)
+      end
+
+      def OpenFileMapping(access, inherit, name)
+         OpenFileMapping.call(access, inherit, name)
+      end
+
       def ReadFile(file, buf, bytes, bytes_read, overlapped)
          ReadFile.call(file, buf, bytes, bytes_read, overlapped) > 0
       end
@@ -275,6 +334,10 @@ module Windows
          UnlockFileEx.call(handle, res, low, high, overlapped) > 0
       end
 
+      def UnmapViewOfFile(address)
+         UnmapViewOfFile.call(address) != 0
+      end
+
       def WriteFile(handle, buf, bytes, overlapped)
          WriteFileEx.call(handle, buf, bytes, overlapped) > 0
       end

data/lib/windows/handle.rb

@@ -1,19 +1,3 @@
-#####################################################################
-# handle.rb
-#
-# Defines the following functions:
-#
-# CloseHandle()
-# DuplicateHandle()
-# GetHandleInformation()
-# SetHandleInformation()
-#
-# Defines the following constants
-#
-# INVALID_HANDLE_VALUE
-# HANDLE_FLAG_INHERIT
-# HANDLE_FLAG_PROTECT_FROM_CLOSE
-######################################################################
 require 'Win32API'
 
 module Windows

data/lib/windows/memory.rb

@@ -14,10 +14,21 @@ module Windows
       GlobalHandle         = Win32API.new('kernel32', 'GlobalHandle', 'P', 'I')
       GlobalLock           = Win32API.new('kernel32', 'GlobalLock', 'L', 'L')
       GlobalMemoryStatus   = Win32API.new('kernel32', 'GlobalMemoryStatus', 'P', 'V')
-      GlobalMemoryStatusEx = Win32API.new('kernel32', 'GlobalMemoryStatus', 'P', 'V')
+      GlobalMemoryStatusEx = Win32API.new('kernel32', 'GlobalMemoryStatusEx', 'P', 'V')
       GlobalReAlloc        = Win32API.new('kernel32', 'GlobalReAlloc', 'III', 'I')
       GlobalSize           = Win32API.new('kernel32', 'GlobalSize', 'I', 'I')
       GlobalUnlock         = Win32API.new('kernel32', 'GlobalUnlock', 'I', 'I')
+      VirtualAlloc         = Win32API.new('kernel32', 'VirtualAlloc', 'PLLL', 'P')
+      VirtualAllocEx       = Win32API.new('kernel32', 'VirtualAllocEx', 'LPLLL', 'P')
+      VirtualFree          = Win32API.new('kernel32', 'VirtualFree', 'PLL', 'I')
+      VirtualFreeEx        = Win32API.new('kernel32', 'VirtualFreeEx', 'LPLL', 'I')
+      VirtualLock          = Win32API.new('kernel32', 'VirtualLock', 'PL', 'I')
+      VirtualProtect       = Win32API.new('kernel32', 'VirtualProtect', 'PLLP', 'I')
+      VirtualProtectEx     = Win32API.new('kernel32', 'VirtualProtectEx', 'LPLLP', 'I')
+      VirtualQuery         = Win32API.new('kernel32', 'VirtualQuery', 'PPL', 'L')
+      VirtualQueryEx       = Win32API.new('kernel32', 'VirtualQueryEx', 'LPPL', 'L')
+      VirtualUnlock        = Win32API.new('kernel32', 'VirtualUnlock', 'PL', 'I')
+      ZeroMemory           = Win32API.new('kernel32', 'RtlZeroMemory', 'PL', 'I')
 
       def GlobalAlloc(flags, bytes)
          GlobalAlloc.call(flags, bytes)
@@ -36,7 +47,7 @@ module Windows
       end
 
       def GlobalLock(handle)
-         GlobalHandle.call(handle)
+         GlobalLock.call(handle)
       end
 
       def GlobalMemoryStatus(buf)
@@ -58,5 +69,49 @@ module Windows
       def GlobalUnlock(handle)
          GlobalUnlock.call(handle)
       end
+
+      def VirtualAlloc(address, size, alloc_type, protect)
+         VirtualAlloc.call(address, size, alloc_type, protect)
+      end
+
+      def VirtualAllocEx(handle, address, size, alloc_type, protect)
+         VirtualAllocEx.call(handle, address, size, alloc_type, protect)
+      end
+
+      def VirtualFree(address, size, free_type)
+         VirtualFree.call(address, size, free_type) != 0
+      end
+
+      def VirtualFreeEx(handle, address, size, free_type)
+         VirtualFreeEx.call(handle, address, size, free_type) != 0
+      end
+
+      def VirtualLock(address, size)
+         VirtualLock.call(address, size) != 0
+      end
+
+      def VirtualProtect(address, size, new_protect, old_protect)
+         VirtualProtect.call(address, size, new_protect, old_protect) != 0
+      end
+
+      def VirtualProtectEx(handle, address, size, new_protect, old_protect)
+         VirtualProtect.call(handle, address, size, new_protect, old_protect) != 0
+      end
+
+      def VirtualQuery(address, buffer, length)
+         VirtualQuery.call(address, buffer, length)
+      end
+      
+      def VirtualQueryEx(handle, address, buffer, length)
+         VirtualQueryEx.call(handle, address, buffer, length)
+      end
+
+      def VirtualUnlock(address, size)
+         VirtualUnlock.call(address, size) != 0
+      end
+
+      def ZeroMemory(dest, length)
+         ZeroMemory.call(dest, length)
+      end
    end
 end

data/lib/windows/msvcrt/string.rb

@@ -0,0 +1,46 @@
+require 'Win32API'
+
+module Windows
+   module MSVCRT
+      module String
+         Strcpy = Win32API.new('msvcrt', 'strcpy', 'PL', 'l')
+         Strrev = Win32API.new('msvcrt', '_strrev', 'P', 'P')
+         
+         Mbscpy = Win32API.new('msvcrt', '_mbscpy', 'PL', 'L')
+         Mbsrev = Win32API.new('msvcrt', '_mbsrev', 'P', 'P')
+         
+         Wcscpy = Win32API.new('msvcrt', 'wcscpy', 'PL', 'l')
+         Wcsrev = Win32API.new('msvcrt', '_wcsrev', 'P', 'P')       
+
+         def strcpy(dest, src)
+            return nil if src == 0
+            Strcpy.call(dest, src)
+         end
+         
+         def strrev(str)
+            return nil if str == 0
+            Strrev.call(str)
+         end
+         
+         def mbscpy(dest, src)
+            return nil if src == 0
+            Mbscpy.call(dest, src)
+         end
+         
+         def mbsrev(str)
+            return nil if str == 0
+            Mbsrev.call(str)
+         end
+
+         def wcscpy(dest, src)
+            return nil if src == 0
+            Wcscpy.call(dest, src)
+         end
+         
+         def wcsrev(str)
+            return nil if str == 0
+            Wcsrev.call(str)
+         end  
+      end
+   end
+end

data/lib/windows/national.rb

@@ -519,10 +519,10 @@ module Windows
       SORT_GEORGIAN_TRADITIONAL       = 0x0     # Georgian Traditional order
       SORT_GEORGIAN_MODERN            = 0x1     # Georgian Modern order
 
-      LANG_SYSTEM_DEFAULT   = 2
-      LANG_USER_DEFAULT     = 1
-      LOCALE_SYSTEM_DEFAULT = 131072
-      LOCALE_USER_DEFAULT   = 65536
+      LANG_SYSTEM_DEFAULT   = 2048
+      LANG_USER_DEFAULT     = 1024
+      LOCALE_SYSTEM_DEFAULT = 2048
+      LOCALE_USER_DEFAULT   = 1024
       
       GetACP        = Win32API.new('kernel32', 'GetACP', 'V', 'I')
       GetDateFormat = Win32API.new('kernel32', 'GetDateFormat', 'LLPPPI', 'I')

data/lib/windows/pipe.rb

@@ -0,0 +1,77 @@
+require 'Win32API'
+
+module Windows
+   module Pipe
+      NMPWAIT_NOWAIT           = 0x00000001
+      NMPWAIT_WAIT_FOREVER     = 0xffffffff
+      NMPWAIT_USE_DEFAULT_WAIT = 0x00000000
+
+      PIPE_WAIT             = 0x00000000
+      PIPE_NOWAIT           = 0x00000001
+      PIPE_ACCESS_INBOUND   = 0x00000001
+      PIPE_ACCESS_OUTBOUND  = 0x00000002
+      PIPE_ACCESS_DUPLEX    = 0x00000003
+      PIPE_TYPE_BYTE        = 0x00000000
+      PIPE_TYPE_MESSAGE     = 0x00000004
+      PIPE_READMODE_BYTE    = 0x00000000
+      PIPE_READMODE_MESSAGE = 0x00000002
+      PIPE_CLIENT_END       = 0x00000000
+      PIPE_SERVER_END       = 0x00000001
+
+      CallNamedPipe           = Win32API.new('kernel32', 'CallNamedPipe', 'PPLPLPL', 'I')
+      ConnectNamedPipe        = Win32API.new('kernel32', 'ConnectNamedPipe', 'LP', 'I')
+      CreateNamedPipe         = Win32API.new('kernel32', 'CreateNamedPipe', 'PLLLLLLL', 'L')
+      CreatePipe              = Win32API.new('kernel32', 'CreatePipe', 'PPPL', 'I')
+      DisconnectNamedPipe     = Win32API.new('kernel32', 'DisconnectNamedPipe', 'L', 'I')
+      GetNamedPipeHandleState = Win32API.new('kernel32', 'GetNamedPipeHandleState', 'LPPPPPL', 'I')
+      GetNamedPipeInfo        = Win32API.new('kernel32', 'GetNamedPipeInfo', 'LPPPP', 'I')
+      PeekNamedPipe           = Win32API.new('kernel32', 'PeekNamedPipe', 'LPLPPP', 'I')
+      SetNamedPipeHandleState = Win32API.new('kernel32', 'SetNamedPipeHandleState', 'LPPP', 'I')
+      TransactNamedPipe       = Win32API.new('kernel32', 'TransactNamedPipe', 'LPLPLPP', 'I')
+      WaitNamedPipe           = Win32API.new('kernel32', 'WaitNamedPipe', 'PL', 'I')
+
+      def CallNamedPipe(name, buf, buf_size, out, out_size, read, timeout)
+         CallNamedPipe.call(name, buf, buf_size, out, out_size, read, timeout) != 0
+      end
+
+      def ConnectNamedPipe(pipe, overlapped = 0)
+         ConnectNamedPipe.call(pipe, overlapped) != 0
+      end
+
+      def CreateNamedPipe(name, open_mode, pipe_mode, max, out_size, in_size, timeout, sec_attr)
+         CreateNamedPipe.call(name, open_mode, pipe_mode, max, out_size, in_size, timeout, sec_attr)
+      end
+
+      def CreatePipe(read_pipe, write_pipe, pipe_attr, size)
+         CreatePipe.call(read_pipe, write_pipe, pipe_attr, size) != 0
+      end
+
+      def DisconnectNamedPipe(name)
+         DisconnectNamedPipe.call(name) != 0
+      end
+
+      def GetNamedPipeHandleState(name, state, instances, count, timeout, user, size)
+         GetNamedPipeHandleState.call(name, state, instances, count, timeout, user, size) != 0
+      end
+
+      def GetNamedPipeInfo(name, flags, out_size, in_size, max)
+         GetNamedPipeInfo.call(name, flags, out_size, in_size, max) != 0
+      end
+
+      def PeekNamedPipe(name, buf, buf_size, bytes_read, bytes_avail, bytes_left)
+         PeekNamedPipe.call(name, buf, buf_size, bytes_read, bytes_avail, bytes_left) != 0
+      end
+
+      def SetNamedPipeHandleState(name, mode, max, timeout)
+         SetNamedPipeHandleState.call(name, mode, max, timeout) != 0
+      end
+
+      def TransactNamedPipe(name, in_buf, in_buf_size, out_buf, out_buf_size, read, overlapped)
+         TransactNamedPipe.call(name, in_buf, in_buf_size, out_buf, out_buf_size, read, overlapped) != 0
+      end
+
+      def WaitNamedPipe(name, timeout)
+         WaitNamedPipe.call(name, timeout) != 0
+      end
+   end
+end

data/lib/windows/process.rb

@@ -51,19 +51,17 @@ module Windows
       STARTF_USESTDHANDLES    = 0x00000100
       STARTF_USEHOTKEY        = 0x00000200
       
-      CreateProcess          = Win32API.new('kernel32', 'CreateProcess', 'LPLLLLLLPP', 'I')
+      CreateProcess          = Win32API.new('kernel32', 'CreateProcess', 'LPLLLLLPPP', 'I')
       CreateRemoteThread     = Win32API.new('kernel32', 'CreateRemoteThread', 'LPLLPLP', 'L')
       CreateThread           = Win32API.new('kernel32', 'CreateThread', 'PLPPLP', 'L')
       ExitProcess            = Win32API.new('kernel32', 'ExitProcess', 'L', 'V')
       GetCommandLine         = Win32API.new('kernel32', 'GetCommandLine', 'V', 'P')
-      GetCurrentProcess      = Win32API.new('kernel32', 'GetCurrentProcess', 'V', 'L')
+      GetCurrentProcess      = Win32API.new('kernel32', 'GetCurrentProcess', 'V', 'L')      
       GetCurrentProcessId    = Win32API.new('kernel32', 'GetCurrentProcessId', 'V', 'L')
       GetEnvironmentStrings  = Win32API.new('kernel32', 'GetEnvironmentStrings', 'V', 'L')
       GetEnvironmentVariable = Win32API.new('kernel32', 'GetEnvironmentVariable', 'PPL', 'L')
       GetExitCodeProcess     = Win32API.new('kernel32', 'GetExitCodeProcess', 'LP', 'I')
       GetPriorityClass       = Win32API.new('kernel32', 'GetPriorityClass', 'L', 'L')
-      GetProcessHandleCount  = Win32API.new('kernel32', 'GetProcessHandleCount', 'LP', 'I')
-      GetProcessId           = Win32API.new('kernel32', 'GetProcessId', 'L', 'L')
       GetProcessTimes        = Win32API.new('kernel32', 'GetProcessTimes', 'LPPPP', 'I')
       GetStartupInfo         = Win32API.new('kernel32', 'GetStartupInfo', 'P', 'V')
       OpenProcess            = Win32API.new('kernel32', 'OpenProcess', 'LIL', 'L')
@@ -72,6 +70,15 @@ module Windows
       SleepEx                = Win32API.new('kernel32', 'SleepEx', 'LI', 'L')
       TerminateProcess       = Win32API.new('kernel32', 'TerminateProcess', 'LL', 'I')
       WaitForInputIdle       = Win32API.new('user32', 'WaitForInputIdle', 'LL', 'L')
+      
+      # Windows XP or later
+      begin
+         GetProcessId           = Win32API.new('kernel32', 'GetProcessId', 'L', 'L')
+         GetProcessHandleCount  = Win32API.new('kernel32', 'GetProcessHandleCount', 'LP', 'I')
+      rescue Exception
+         # Do nothing - not supported on current platform.  It's up to you to
+         # check for the existence of the constant in your code.
+      end
            
       def CreateProcess(app, cmd, pattr, tattr, handles, flags, env, dir, sinfo, pinfo)
          CreateProcess.call(app, cmd, pattr, tattr, handles, flags, env, dir, sinfo, pinfo) != 0
@@ -117,14 +124,6 @@ module Windows
          GetPriorityClass.call(handle)
       end
       
-      def GetProcessHandleCount(handle, count)
-         GetProcessHandleCount.call(handle, count) != 0
-      end
-      
-      def GetProcessId(handle)
-         GetProcessId.call(handle)
-      end
-      
       def GetProcessTimes(handle, t_creation, t_exit, t_kernel, t_user)
          GetProcessTimes.call(handle, t_creation, t_exit, t_kernel, t_user) != 0
       end
@@ -156,5 +155,17 @@ module Windows
       def WaitForInputIdle(handle, milliseconds)
          WaitForInputIdle.call(handle, milliseconds)
       end
+
+      begin
+         def GetProcessId(handle)
+            GetProcessId.call(handle)
+         end
+
+         def GetProcessHandleCount(handle, count)
+            GetProcessHandleCount.call(handle, count) != 0
+         end
+      rescue Exception
+         # Windows XP or later      
+      end
    end
-end
+end

data/lib/windows/service.rb

@@ -0,0 +1,183 @@
+require 'Win32API'
+
+module Windows
+   module Service
+      # SCM access rights
+      SC_MANAGER_ALL_ACCESS         = 0xF003F
+      SC_MANAGER_CREATE_SERVICE     = 0x0002
+      SC_MANAGER_CONNECT            = 0x0001
+      SC_MANAGER_ENUMERATE_SERVICE  = 0x0004
+      SC_MANAGER_LOCK               = 0x0008
+      SC_MANAGER_MODIFY_BOOT_CONFIG = 0x0020
+      SC_MANAGER_QUERY_LOCK_STATUS  = 0x0010
+      SC_STATUS_PROCESS_INFO        = 0
+      SC_ENUM_PROCESS_INFO          = 0
+      
+      # Service control action types
+      SC_ACTION_NONE        = 0
+      SC_ACTION_REBOOT      = 1
+      SC_ACTION_RESTART     = 2
+      SC_ACTION_RUN_COMMAND = 3
+
+      # Service access rights
+      SERVICE_ALL_ACCESS            = 0xF01FF
+      SERVICE_CHANGE_CONFIG         = 0x0002
+      SERVICE_ENUMERATE_DEPENDENTS  = 0x0008
+      SERVICE_INTERROGATE           = 0x0080
+      SERVICE_PAUSE_CONTINUE        = 0x0040
+      SERVICE_QUERY_CONFIG          = 0x0001
+      SERVICE_QUERY_STATUS          = 0x0004
+      SERVICE_START                 = 0x0010
+      SERVICE_STOP                  = 0x0020
+      SERVICE_USER_DEFINED_CONTROL  = 0x0100
+
+      # Service types
+      SERVICE_KERNEL_DRIVER       = 0x00000001
+      SERVICE_FILE_SYSTEM_DRIVER  = 0x00000002
+      SERVICE_ADAPTER             = 0x00000004
+      SERVICE_RECOGNIZER_DRIVER   = 0x00000008
+      SERVICE_WIN32_OWN_PROCESS   = 0x00000010
+      SERVICE_WIN32_SHARE_PROCESS = 0x00000020
+      SERVICE_WIN32               = 0x00000030
+      SERVICE_INTERACTIVE_PROCESS = 0x00000100
+      SERVICE_DRIVER              = 0x0000000B
+      SERVICE_TYPE_ALL            = 0x0000013F
+
+      # Error control
+      SERVICE_ERROR_IGNORE   = 0x00000000
+      SERVICE_ERROR_NORMAL   = 0x00000001
+      SERVICE_ERROR_SEVERE   = 0x00000002
+      SERVICE_ERROR_CRITICAL = 0x00000003
+
+      # Start types
+      SERVICE_BOOT_START   = 0x00000000
+      SERVICE_SYSTEM_START = 0x00000001
+      SERVICE_AUTO_START   = 0x00000002
+      SERVICE_DEMAND_START = 0x00000003
+      SERVICE_DISABLED     = 0x00000004
+
+      # Service control
+      SERVICE_CONTROL_STOP           = 0x00000001
+      SERVICE_CONTROL_PAUSE          = 0x00000002
+      SERVICE_CONTROL_CONTINUE       = 0x00000003
+      SERVICE_CONTROL_INTERROGATE    = 0x00000004
+      SERVICE_CONTROL_PARAMCHANGE    = 0x00000006
+      SERVICE_CONTROL_NETBINDADD     = 0x00000007
+      SERVICE_CONTROL_NETBINDREMOVE  = 0x00000008
+      SERVICE_CONTROL_NETBINDENABLE  = 0x00000009
+      SERVICE_CONTROL_NETBINDDISABLE = 0x0000000A
+      
+      # Service controls accepted
+      SERVICE_ACCEPT_STOP                  =  0x00000001
+      SERVICE_ACCEPT_PAUSE_CONTINUE        =  0x00000002
+      SERVICE_ACCEPT_SHUTDOWN              =  0x00000004
+      SERVICE_ACCEPT_PARAMCHANGE           =  0x00000008
+      SERVICE_ACCEPT_NETBINDCHANGE         =  0x00000010
+      SERVICE_ACCEPT_HARDWAREPROFILECHANGE =  0x00000020
+      SERVICE_ACCEPT_POWEREVENT            =  0x00000040
+      SERVICE_ACCEPT_SESSIONCHANGE         =  0x00000080
+
+      # Service states
+      SERVICE_ACTIVE    = 0x00000001
+      SERVICE_INACTIVE  = 0x00000002
+      SERVICE_STATE_ALL = 0x00000003
+      
+      # Service current states
+      SERVICE_STOPPED          = 0x00000001
+      SERVICE_START_PENDING    = 0x00000002
+      SERVICE_STOP_PENDING     = 0x00000003
+      SERVICE_RUNNING          = 0x00000004
+      SERVICE_CONTINUE_PENDING = 0x00000005
+      SERVICE_PAUSE_PENDING    = 0x00000006
+      SERVICE_PAUSED           = 0x00000007
+      
+      # Info levels
+      SERVICE_CONFIG_DESCRIPTION              = 1
+      SERVICE_CONFIG_FAILURE_ACTIONS          = 2
+      SERVICE_CONFIG_DELAYED_AUTO_START_INFO  = 3
+      SERVICE_CONFIG_FAILURE_ACTIONS_FLAG     = 4
+      SERVICE_CONFIG_SERVICE_SID_INFO         = 5
+      SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO = 6
+      SERVICE_CONFIG_PRESHUTDOWN_INFO         = 7
+      
+      ChangeServiceConfig           = Win32API.new('advapi32', 'ChangeServiceConfig', 'LLLLPPPPPPP', 'I')
+      ChangeServiceConfig2          = Win32API.new('advapi32', 'ChangeServiceConfig2', 'LLP', 'I')
+      CloseServiceHandle            = Win32API.new('advapi32', 'CloseServiceHandle', 'L', 'I')
+      ControlService                = Win32API.new('advapi32', 'ControlService', 'LLP', 'I')
+      CreateService                 = Win32API.new('advapi32', 'CreateService', 'LPPLLLLPPPPPP', 'L')
+      DeleteService                 = Win32API.new('advapi32', 'DeleteService', 'L', 'I')
+      EnumDependentServices         = Win32API.new('advapi32', 'EnumDependentServices', 'LLPLPP', 'I')
+      EnumServicesStatus            = Win32API.new('advapi32', 'EnumServicesStatus', 'LLLPLPPP', 'I')
+      EnumServicesStatusEx          = Win32API.new('advapi32', 'EnumServicesStatusEx', 'LLLLPLPPPP', 'I')
+      GetServiceDisplayName         = Win32API.new('advapi32', 'GetServiceDisplayName', 'LPPP', 'I')
+      GetServiceKeyName             = Win32API.new('advapi32', 'GetServiceKeyName', 'LPPP', 'I')
+      LockServiceDatabase           = Win32API.new('advapi32', 'LockServiceDatabase', 'L', 'L')
+      NotifyBootConfigStatus        = Win32API.new('advapi32', 'NotifyBootConfigStatus', 'I', 'I')
+      OpenSCManager                 = Win32API.new('advapi32', 'OpenSCManager', 'PPL', 'L')
+      OpenService                   = Win32API.new('advapi32', 'OpenService', 'LPL', 'L')
+      QueryServiceConfig            = Win32API.new('advapi32', 'QueryServiceConfig', 'LPLP', 'I')
+      QueryServiceConfig2           = Win32API.new('advapi32', 'QueryServiceConfig2', 'LLPLP', 'I')
+      QueryServiceLockStatus        = Win32API.new('advapi32', 'QueryServiceLockStatus', 'LPLP', 'I')
+      QueryServiceStatus            = Win32API.new('advapi32', 'QueryServiceStatus', 'LP', 'I')
+      QueryServiceStatusEx          = Win32API.new('advapi32', 'QueryServiceStatusEx', 'LLPLP', 'I')
+      RegisterServiceCtrlHandler    = Win32API.new('advapi32', 'RegisterServiceCtrlHandler', 'PP', 'L')
+      RegisterServiceCtrlHandlerEx  = Win32API.new('advapi32', 'RegisterServiceCtrlHandlerEx', 'PPP', 'L')
+      SetServiceBits                = Win32API.new('advapi32', 'SetServiceBits', 'LLII', 'I')
+      SetServiceStatus              = Win32API.new('advapi32', 'SetServiceStatus', 'LP', 'I')
+      StartService                  = Win32API.new('advapi32', 'StartService', 'LLP', 'I')
+      StartServiceCtrlDispatcher    = Win32API.new('advapi32', 'StartServiceCtrlDispatcher', 'P', 'I')
+      UnlockServiceDatabase         = Win32API.new('advapi32', 'UnlockServiceDatabase', 'L', 'I')
+   
+      def CloseServiceHandle(handle)
+         CloseServiceHandle.call(handle) != 0
+      end
+      
+      def ControlService(service, control, status)
+         ControlService.call(service, control, status) != 0
+      end
+      
+      def DeleteService(handle)
+         DeleteService.call(handle) != 0
+      end
+      
+      def EnumServicesStatusEx(handle, info, s_type, s_state, services, size, bytes, s_returned, rhandle, grp)
+         EnumServicesStatusEx.call(handle, info, s_type, s_state, services, size, bytes, s_returned, rhandle, grp) != 0
+      end
+      
+      def GetServiceDisplayName(handle, service, display, buf)
+         GetServiceDisplayName.call(handle, service, display, buf) != 0
+      end
+      
+      def GetServiceKeyName(handle, display, service, buf)
+         GetServiceKeyName.call(handle, display, service, buf) != 0
+      end
+      
+      def OpenSCManager(host, database, access)
+         OpenSCManager.call(host, database, access)
+      end
+      
+      def OpenService(handle, service, access)
+         OpenService.call(handle, service, access)
+      end
+
+      def QueryServiceConfig(handle, buf, buf_size, bytes)
+         QueryServiceConfig.call(handle, buf, buf_size, bytes) != 0
+      end
+
+      def QueryServiceConfig2(handle, info, buf, buf_size, bytes)
+         QueryServiceConfig2.call(handle, info, buf, buf_size, bytes) != 0
+      end
+      
+      def QueryServiceStatusEx(service, info, buf, size, bytes)
+         QueryServiceStatusEx.call(service, info, buf, size, bytes) != 0
+      end
+      
+      def QueryStatusConfig2(service, info, buf, size, bytes)
+         QueryStatusConfig2.call(service, info, buf, size, bytes) != 0
+      end
+
+      def StartService(handle, num_vec, vec)
+         StartService.call(handle, num_vec, vec)
+      end
+   end
+end

data/test/tc_file.rb

@@ -0,0 +1,75 @@
+#####################################################################
+# tc_file.rb
+#
+# Test case for the Windows::File module.
+#####################################################################
+base = File.basename(Dir.pwd)
+if base == 'test' || base =~ /windows-pr/
+   Dir.chdir '..' if base == 'test'
+   $LOAD_PATH.unshift Dir.pwd + '/lib'
+   Dir.chdir 'test' rescue nil
+end
+
+require 'windows/file'
+require 'test/unit'
+
+class Foo
+   include Windows::File
+end
+
+class TC_Windows_File < Test::Unit::TestCase
+  
+   def setup
+      @foo = Foo.new
+   end
+   
+   def test_numeric_constants
+      assert_equal(0x00000001, Foo::FILE_ATTRIBUTE_READONLY)  
+      assert_equal(0x00000002, Foo::FILE_ATTRIBUTE_HIDDEN)  
+      assert_equal(0x00000004, Foo::FILE_ATTRIBUTE_SYSTEM)
+      assert_equal(0x00000010, Foo::FILE_ATTRIBUTE_DIRECTORY) 
+      assert_equal(0x00000020, Foo::FILE_ATTRIBUTE_ARCHIVE)  
+      assert_equal(0x00000040, Foo::FILE_ATTRIBUTE_ENCRYPTED)
+      assert_equal(0x00000080, Foo::FILE_ATTRIBUTE_NORMAL)  
+      assert_equal(0x00000100, Foo::FILE_ATTRIBUTE_TEMPORARY)  
+      assert_equal(0x00000200, Foo::FILE_ATTRIBUTE_SPARSE_FILE) 
+      assert_equal(0x00000400, Foo::FILE_ATTRIBUTE_REPARSE_POINT)  
+      assert_equal(0x00000800, Foo::FILE_ATTRIBUTE_COMPRESSED)  
+      assert_equal(0x00001000, Foo::FILE_ATTRIBUTE_OFFLINE) 
+      assert_equal(0x00002000, Foo::FILE_ATTRIBUTE_NOT_CONTENT_INDEXED)
+   end
+   
+   def test_method_constants
+      assert_not_nil(Foo::CopyFile)
+      assert_not_nil(Foo::CopyFileEx)
+      assert_not_nil(Foo::CreateFile)
+      assert_not_nil(Foo::CreateFileW)
+      assert_not_nil(Foo::CreateHardLink)
+      assert_not_nil(Foo::DecryptFile)
+      assert_not_nil(Foo::DeleteFile)
+      assert_not_nil(Foo::EncryptFile)
+      assert_not_nil(Foo::GetBinaryType)
+      assert_not_nil(Foo::GetFileAttributes)
+      assert_not_nil(Foo::GetFileAttributesEx)
+      assert_not_nil(Foo::GetFileSize)
+      assert_not_nil(Foo::GetFileSizeEx)
+      assert_not_nil(Foo::GetFileType)
+      assert_not_nil(Foo::GetFullPathName)
+      assert_not_nil(Foo::GetFullPathNameW)
+      assert_not_nil(Foo::GetLongPathName)
+      assert_not_nil(Foo::GetShortPathName)
+      assert_not_nil(Foo::LockFile)
+      assert_not_nil(Foo::LockFileEx)
+      assert_not_nil(Foo::ReadFile)
+      assert_not_nil(Foo::ReadFileEx)
+      assert_not_nil(Foo::SetFileAttributes)
+      assert_not_nil(Foo::UnlockFile)
+      assert_not_nil(Foo::UnlockFileEx)
+      assert_not_nil(Foo::WriteFile)
+      assert_not_nil(Foo::WriteFileEx)
+   end
+   
+   def teardown
+      @foo = nil
+   end
+end

data/test/tc_pipe.rb

@@ -0,0 +1,60 @@
+#####################################################################
+# tc_pipe.rb
+#
+# Test case for the Windows::Pipe module.
+#####################################################################
+base = File.basename(Dir.pwd)
+if base == 'test' || base =~ /windows-pr/
+   Dir.chdir '..' if base == 'test'
+   $LOAD_PATH.unshift Dir.pwd + '/lib'
+   Dir.chdir 'test' rescue nil
+end
+
+require 'windows/pipe'
+require 'test/unit'
+
+class Foo
+   include Windows::Pipe
+end
+
+class TC_Windows_Pipe < Test::Unit::TestCase
+  
+   def setup
+      @foo = Foo.new
+   end
+   
+   def test_numeric_constants
+      assert_equal(0x00000001, Foo::NMPWAIT_NOWAIT)
+      assert_equal(0xffffffff, Foo::NMPWAIT_WAIT_FOREVER)
+      assert_equal(0x00000000, Foo::NMPWAIT_USE_DEFAULT_WAIT)
+      assert_equal(0x00000000, Foo::PIPE_WAIT)
+      assert_equal(0x00000001, Foo::PIPE_NOWAIT)
+      assert_equal(0x00000001, Foo::PIPE_ACCESS_INBOUND)
+      assert_equal(0x00000002, Foo::PIPE_ACCESS_OUTBOUND)
+      assert_equal(0x00000003, Foo::PIPE_ACCESS_DUPLEX)
+      assert_equal(0x00000000, Foo::PIPE_TYPE_BYTE)
+      assert_equal(0x00000004, Foo::PIPE_TYPE_MESSAGE)
+      assert_equal(0x00000000, Foo::PIPE_READMODE_BYTE)
+      assert_equal(0x00000002, Foo::PIPE_READMODE_MESSAGE)
+      assert_equal(0x00000000, Foo::PIPE_CLIENT_END)
+      assert_equal(0x00000001, Foo::PIPE_SERVER_END)
+   end
+   
+   def test_method_constants
+      assert_not_nil(Foo::CallNamedPipe)
+      assert_not_nil(Foo::ConnectNamedPipe)
+      assert_not_nil(Foo::CreateNamedPipe)
+      assert_not_nil(Foo::CreatePipe)
+      assert_not_nil(Foo::DisconnectNamedPipe)
+      assert_not_nil(Foo::GetNamedPipeHandleState)
+      assert_not_nil(Foo::GetNamedPipeInfo)
+      assert_not_nil(Foo::PeekNamedPipe)
+      assert_not_nil(Foo::SetNamedPipeHandleState)
+      assert_not_nil(Foo::TransactNamedPipe)
+      assert_not_nil(Foo::WaitNamedPipe)
+   end
+   
+   def teardown
+      @foo = nil
+   end
+end

data/test/tc_process.rb

@@ -0,0 +1,36 @@
+#####################################################################
+# tc_process.rb
+#
+# Test case for the Windows::Process module.
+#####################################################################
+base = File.basename(Dir.pwd)
+if base == 'test' || base =~ /windows-pr/
+   Dir.chdir '..' if base == 'test'
+   $LOAD_PATH.unshift Dir.pwd + '/lib'
+   Dir.chdir 'test' rescue nil
+end
+
+require 'windows/process'
+require 'test/unit'
+
+class Foo
+   include Windows::Process
+end
+
+class TC_Windows_Process < Test::Unit::TestCase
+   def setup
+      @foo  = Foo.new
+   end
+
+   def test_numeric_constants
+      assert_equal(0x1F0FFF, Foo::PROCESS_ALL_ACCESS)
+   end
+
+   def test_method_constants
+      assert_not_nil(Foo::CreateProcess)
+   end
+
+   def teardown
+      @foo  = nil
+   end
+end

data/test/tc_unicode.rb

@@ -0,0 +1,61 @@
+#####################################################################
+# tc_unicode.rb
+#
+# Test case for the Windows::Unicode module.
+#####################################################################
+base = File.basename(Dir.pwd)
+if base == 'test' || base =~ /windows-pr/
+   Dir.chdir '..' if base == 'test'
+   $LOAD_PATH.unshift Dir.pwd + '/lib'
+   Dir.chdir 'test' rescue nil
+end
+
+require "windows/unicode"
+require "test/unit"
+
+class Foo
+   include Windows::Unicode
+end
+
+class TC_Windows_Unicode < Test::Unit::TestCase
+   def setup
+      @foo = Foo.new
+   end
+
+   def test_numeric_constants
+      assert_equal(0, Foo::CP_ACP)
+      assert_equal(1, Foo::CP_OEMCP)
+      assert_equal(2, Foo::CP_MACCP)
+      assert_equal(3, Foo::CP_THREAD_ACP)
+      assert_equal(42, Foo::CP_SYMBOL)
+      assert_equal(65000, Foo::CP_UTF7)
+      assert_equal(65001, Foo::CP_UTF8)
+
+      assert_equal(0x00000001, Foo::MB_PRECOMPOSED)
+      assert_equal(0x00000002, Foo::MB_COMPOSITE)
+      assert_equal(0x00000004, Foo::MB_USEGLYPHCHARS)
+      assert_equal(0x00000008, Foo::MB_ERR_INVALID_CHARS)
+
+      assert_equal(0x00000200, Foo::WC_COMPOSITECHECK)
+      assert_equal(0x00000010, Foo::WC_DISCARDNS)
+      assert_equal(0x00000020, Foo::WC_SEPCHARS)
+      assert_equal(0x00000040, Foo::WC_DEFAULTCHAR)
+      assert_equal(0x00000400, Foo::WC_NO_BEST_FIT_CHARS)
+   end
+
+   def test_method_constants
+      assert_not_nil(Foo::GetTextCharset)
+      assert_not_nil(Foo::GetTextCharsetInfo)
+      assert_not_nil(Foo::IsDBCSLeadByte)
+      assert_not_nil(Foo::IsDBCSLeadByteEx)
+      assert_not_nil(Foo::IsTextUnicode)
+      assert_not_nil(Foo::MultiByteToWideChar)
+      assert_not_nil(Foo::TranslateCharsetInfo)
+      assert_not_nil(Foo::WideCharToMultiByte)
+   end
+
+   def teardown
+      @foo  = nil
+      @unicode = nil
+   end
+end

data/test/ts_all.rb

@@ -8,8 +8,12 @@ Dir.chdir('test') rescue nil
 
 require 'tc_console'
 require 'tc_error'
+require 'tc_file'
+require 'tc_memory'
 require 'tc_msvcrt_buffer'
 require 'tc_path'
+require 'tc_pipe'
 require 'tc_registry'
 require 'tc_security'
-require 'tc_synchronize'
+require 'tc_synchronize'
+require 'tc_unicode'

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.0
 specification_version: 1
 name: windows-pr
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
-date: 2006-05-28 00:00:00 -06:00
+  version: 0.5.2
+date: 2006-07-29 00:00:00 -06:00
 summary: Windows functions and constants predefined via Win32API
 require_paths: 
 - lib
@@ -25,6 +25,7 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: mswin32
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Daniel J. Berger
 files: 
@@ -43,9 +44,11 @@ files:
 - lib/windows/memory.rb
 - lib/windows/national.rb
 - lib/windows/path.rb
+- lib/windows/pipe.rb
 - lib/windows/process.rb
 - lib/windows/registry.rb
 - lib/windows/security.rb
+- lib/windows/service.rb
 - lib/windows/shell.rb
 - lib/windows/sound.rb
 - lib/windows/synchronize.rb
@@ -55,14 +58,19 @@ files:
 - test/ts_all.rb
 - lib/windows/msvcrt/buffer.rb
 - lib/windows/msvcrt/file.rb
+- lib/windows/msvcrt/string.rb
 - test/tc_console.rb
 - test/tc_error.rb
+- test/tc_file.rb
 - test/tc_memory.rb
 - test/tc_msvcrt_buffer.rb
 - test/tc_path.rb
+- test/tc_pipe.rb
+- test/tc_process.rb
 - test/tc_registry.rb
 - test/tc_security.rb
 - test/tc_synchronize.rb
+- test/tc_unicode.rb
 - CHANGES
 - MANIFEST
 - README