windows-pr 0.7.0 → 0.7.1

data/test/tc_clipboard.rb

@@ -3,53 +3,46 @@
 #
 # Test case for the Windows::Clipboard 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/clipboard"
 require "test/unit"
 
-class Foo
+class ClipboardFoo
    include Windows::Clipboard
 end
 
 class TC_Windows_Clipboard < Test::Unit::TestCase
    def setup
-      @foo = Foo.new
+      @foo = ClipboardFoo.new
    end
    
    def test_numeric_constants
-      assert_equal(1, Foo::CF_TEXT)
-      assert_equal(2, Foo::CF_BITMAP)
-      assert_equal(3, Foo::CF_METAFILEPICT)
-      assert_equal(4, Foo::CF_SYLK)
-      assert_equal(5, Foo::CF_DIF)
-      assert_equal(6, Foo::CF_TIFF)
-      assert_equal(7, Foo::CF_OEMTEXT)
-      assert_equal(8, Foo::CF_DIB)
-      assert_equal(9, Foo::CF_PALETTE)
-      assert_equal(10, Foo::CF_PENDATA)
-      assert_equal(11, Foo::CF_RIFF)
-      assert_equal(12, Foo::CF_WAVE)
-      assert_equal(13, Foo::CF_UNICODETEXT)
-      assert_equal(14, Foo::CF_ENHMETAFILE)
+      assert_equal(1, ClipboardFoo::CF_TEXT)
+      assert_equal(2, ClipboardFoo::CF_BITMAP)
+      assert_equal(3, ClipboardFoo::CF_METAFILEPICT)
+      assert_equal(4, ClipboardFoo::CF_SYLK)
+      assert_equal(5, ClipboardFoo::CF_DIF)
+      assert_equal(6, ClipboardFoo::CF_TIFF)
+      assert_equal(7, ClipboardFoo::CF_OEMTEXT)
+      assert_equal(8, ClipboardFoo::CF_DIB)
+      assert_equal(9, ClipboardFoo::CF_PALETTE)
+      assert_equal(10, ClipboardFoo::CF_PENDATA)
+      assert_equal(11, ClipboardFoo::CF_RIFF)
+      assert_equal(12, ClipboardFoo::CF_WAVE)
+      assert_equal(13, ClipboardFoo::CF_UNICODETEXT)
+      assert_equal(14, ClipboardFoo::CF_ENHMETAFILE)
    end
    
    def test_method_constants
-      assert_not_nil(Foo::OpenClipboard)
-      assert_not_nil(Foo::CloseClipboard)
-      assert_not_nil(Foo::GetClipboardData)
-      assert_not_nil(Foo::EmptyClipboard)
-      assert_not_nil(Foo::SetClipboardData)
-      assert_not_nil(Foo::CountClipboardFormats)
-      assert_not_nil(Foo::IsClipboardFormatAvailable)
-      assert_not_nil(Foo::GetClipboardFormatName)
-      assert_not_nil(Foo::EnumClipboardFormats)
-      assert_not_nil(Foo::RegisterClipboardFormat)
+      assert_not_nil(ClipboardFoo::OpenClipboard)
+      assert_not_nil(ClipboardFoo::CloseClipboard)
+      assert_not_nil(ClipboardFoo::GetClipboardData)
+      assert_not_nil(ClipboardFoo::EmptyClipboard)
+      assert_not_nil(ClipboardFoo::SetClipboardData)
+      assert_not_nil(ClipboardFoo::CountClipboardFormats)
+      assert_not_nil(ClipboardFoo::IsClipboardFormatAvailable)
+      assert_not_nil(ClipboardFoo::GetClipboardFormatName)
+      assert_not_nil(ClipboardFoo::EnumClipboardFormats)
+      assert_not_nil(ClipboardFoo::RegisterClipboardFormat)
    end
    
    def teardown

data/test/tc_com.rb

@@ -0,0 +1,34 @@
+#####################################################################
+# tc_com.rb
+#
+# Test case for the Windows::COM module.
+#####################################################################
+require "windows/com"
+require "test/unit"
+
+class COMFoo
+   include Windows::COM
+end
+
+class TC_Windows_COM < Test::Unit::TestCase
+   def setup
+      @foo = COMFoo.new
+   end
+   
+   def test_method_constants
+      assert_not_nil(COMFoo::BindMoniker)
+      assert_not_nil(COMFoo::CLSIDFromProgID)
+      assert_not_nil(COMFoo::CLSIDFromProgIDEx)
+      assert_not_nil(COMFoo::CoAddRefServerProcess)
+      assert_not_nil(COMFoo::CoAllowSetForegroundWindow)
+      assert_not_nil(COMFoo::CoCancelCall)
+      assert_not_nil(COMFoo::CoCopyProxy)
+      assert_not_nil(COMFoo::CoCreateFreeThreadedMarshaler)
+      assert_not_nil(COMFoo::CoCreateGuid)
+      assert_not_nil(COMFoo::CoCreateInstance)
+   end
+
+   def teardown
+      @foo = nil
+   end
+end

data/test/tc_console.rb

@@ -3,105 +3,112 @@
 #
 # Test case for the Windows::Console 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/console'
 require 'test/unit'
 
-class Foo
+class ConsoleFoo
    include Windows::Console
 end
 
 class TC_Windows_Console < Test::Unit::TestCase
    def setup
-      @foo = Foo.new
+      @foo = ConsoleFoo.new
+      @ver = `ver`.chomp
    end
 
    def test_numeric_constants
-      assert_equal(0, Foo::CTRL_C_EVENT)
-      assert_equal(1, Foo::CTRL_BREAK_EVENT)
-      assert_equal(5, Foo::CTRL_LOGOFF_EVENT)
-      assert_equal(6, Foo::CTRL_SHUTDOWN_EVENT)
+      assert_equal(0, ConsoleFoo::CTRL_C_EVENT)
+      assert_equal(1, ConsoleFoo::CTRL_BREAK_EVENT)
+      assert_equal(5, ConsoleFoo::CTRL_LOGOFF_EVENT)
+      assert_equal(6, ConsoleFoo::CTRL_SHUTDOWN_EVENT)
 
-      assert_equal(0x0001, Foo::ENABLE_PROCESSED_INPUT)
-      assert_equal(0x0002, Foo::ENABLE_LINE_INPUT)
-      assert_equal(0x0002, Foo::ENABLE_WRAP_AT_EOL_OUTPUT)
-      assert_equal(0x0004, Foo::ENABLE_ECHO_INPUT)
-      assert_equal(0x0008, Foo::ENABLE_WINDOW_INPUT)
-      assert_equal(0x0010, Foo::ENABLE_MOUSE_INPUT)
-      assert_equal(0x0020, Foo::ENABLE_INSERT_MODE)
-      assert_equal(0x0040, Foo::ENABLE_QUICK_EDIT_MODE)
+      assert_equal(0x0001, ConsoleFoo::ENABLE_PROCESSED_INPUT)
+      assert_equal(0x0002, ConsoleFoo::ENABLE_LINE_INPUT)
+      assert_equal(0x0002, ConsoleFoo::ENABLE_WRAP_AT_EOL_OUTPUT)
+      assert_equal(0x0004, ConsoleFoo::ENABLE_ECHO_INPUT)
+      assert_equal(0x0008, ConsoleFoo::ENABLE_WINDOW_INPUT)
+      assert_equal(0x0010, ConsoleFoo::ENABLE_MOUSE_INPUT)
+      assert_equal(0x0020, ConsoleFoo::ENABLE_INSERT_MODE)
+      assert_equal(0x0040, ConsoleFoo::ENABLE_QUICK_EDIT_MODE)
 
-      assert_equal(-10, Foo::STD_INPUT_HANDLE)
-      assert_equal(-11, Foo::STD_OUTPUT_HANDLE)
-      assert_equal(-12, Foo::STD_ERROR_HANDLE)
+      assert_equal(-10, ConsoleFoo::STD_INPUT_HANDLE)
+      assert_equal(-11, ConsoleFoo::STD_OUTPUT_HANDLE)
+      assert_equal(-12, ConsoleFoo::STD_ERROR_HANDLE)
    end
 
    def test_method_constants
-      assert_not_nil(Foo::AddConsoleAlias)
-      assert_not_nil(Foo::AllocConsole)
-      assert_not_nil(Foo::AttachConsole)
-      assert_not_nil(Foo::CreateConsoleScreenBuffer)
-      assert_not_nil(Foo::FillConsoleOutputAttribute)
-      assert_not_nil(Foo::FillConsoleOutputCharacter)
-      assert_not_nil(Foo::FlushConsoleInputBuffer)
-      assert_not_nil(Foo::FreeConsole)
-      assert_not_nil(Foo::GenerateConsoleCtrlEvent)
-      assert_not_nil(Foo::GetConsoleAlias)
-      assert_not_nil(Foo::GetConsoleAliases)
-      assert_not_nil(Foo::GetConsoleAliasesLength)
-      assert_not_nil(Foo::GetConsoleAliasExes)
-      assert_not_nil(Foo::GetConsoleAliasExesLength)
-      assert_not_nil(Foo::GetConsoleCP)
-      assert_not_nil(Foo::GetConsoleCursorInfo)
-      assert_not_nil(Foo::GetConsoleDisplayMode)
-      assert_not_nil(Foo::GetConsoleFontSize)
-      assert_not_nil(Foo::GetConsoleMode)
-      assert_not_nil(Foo::GetConsoleOutputCP)
-      assert_not_nil(Foo::GetConsoleProcessList)
-      assert_not_nil(Foo::GetConsoleScreenBufferInfo)
-      assert_not_nil(Foo::GetConsoleSelectionInfo)
-      assert_not_nil(Foo::GetConsoleTitle)
-      assert_not_nil(Foo::GetConsoleWindow)
-      assert_not_nil(Foo::GetCurrentConsoleFont)
-      assert_not_nil(Foo::GetLargestConsoleWindowSize)
-      assert_not_nil(Foo::GetNumberOfConsoleInputEvents)
-      assert_not_nil(Foo::GetNumberOfConsoleMouseButtons)
-      assert_not_nil(Foo::GetStdHandle)
-      assert_not_nil(Foo::PeekConsoleInput)
-      assert_not_nil(Foo::ReadConsole)
-      assert_not_nil(Foo::ReadConsoleInput)
-      assert_not_nil(Foo::ReadConsoleOutput)
-      assert_not_nil(Foo::ReadConsoleOutputAttribute)
-      assert_not_nil(Foo::ReadConsoleOutputCharacter)
-      assert_not_nil(Foo::ScrollConsoleScreenBuffer)
-      assert_not_nil(Foo::SetConsoleActiveScreenBuffer)
-      assert_not_nil(Foo::SetConsoleCommandHistoryMode)
-      assert_not_nil(Foo::SetConsoleCP)
-      assert_not_nil(Foo::SetConsoleCtrlHandler)
-      assert_not_nil(Foo::SetConsoleCursorInfo)
-      assert_not_nil(Foo::SetConsoleCursorPosition)
-      assert_not_nil(Foo::SetConsoleDisplayMode)
-      assert_not_nil(Foo::SetConsoleMode)
-      assert_not_nil(Foo::SetConsoleOutputCP)
-      assert_not_nil(Foo::SetConsoleScreenBufferSize)
-      assert_not_nil(Foo::SetConsoleTextAttribute)
-      assert_not_nil(Foo::SetConsoleTitle)
-      assert_not_nil(Foo::SetConsoleWindowInfo)
-      assert_not_nil(Foo::SetStdHandle)
-      assert_not_nil(Foo::WriteConsole)
-      assert_not_nil(Foo::WriteConsoleInput)
-      assert_not_nil(Foo::WriteConsoleOutput)
-      assert_not_nil(Foo::WriteConsoleOutputAttribute)
-      assert_not_nil(Foo::WriteConsoleOutputCharacter)
+      assert_not_nil(ConsoleFoo::AddConsoleAlias)
+      assert_not_nil(ConsoleFoo::AllocConsole)
+      assert_not_nil(ConsoleFoo::CreateConsoleScreenBuffer)
+      assert_not_nil(ConsoleFoo::FillConsoleOutputAttribute)
+      assert_not_nil(ConsoleFoo::FillConsoleOutputCharacter)
+      assert_not_nil(ConsoleFoo::FlushConsoleInputBuffer)
+      assert_not_nil(ConsoleFoo::FreeConsole)
+      assert_not_nil(ConsoleFoo::GenerateConsoleCtrlEvent)
+      assert_not_nil(ConsoleFoo::GetConsoleAlias)
+      assert_not_nil(ConsoleFoo::GetConsoleAliases)
+      assert_not_nil(ConsoleFoo::GetConsoleAliasesLength)
+      assert_not_nil(ConsoleFoo::GetConsoleAliasExes)
+      assert_not_nil(ConsoleFoo::GetConsoleAliasExesLength)
+      assert_not_nil(ConsoleFoo::GetConsoleCP)
+      assert_not_nil(ConsoleFoo::GetConsoleCursorInfo)
+      assert_not_nil(ConsoleFoo::GetConsoleMode)
+      assert_not_nil(ConsoleFoo::GetConsoleOutputCP)
+      assert_not_nil(ConsoleFoo::GetConsoleScreenBufferInfo)
+      assert_not_nil(ConsoleFoo::GetConsoleTitle)
+      assert_not_nil(ConsoleFoo::GetConsoleWindow)
+      assert_not_nil(ConsoleFoo::GetLargestConsoleWindowSize)
+      assert_not_nil(ConsoleFoo::GetNumberOfConsoleInputEvents)
+      assert_not_nil(ConsoleFoo::GetNumberOfConsoleMouseButtons)
+      assert_not_nil(ConsoleFoo::GetStdHandle)
+      assert_not_nil(ConsoleFoo::PeekConsoleInput)
+      assert_not_nil(ConsoleFoo::ReadConsole)
+      assert_not_nil(ConsoleFoo::ReadConsoleInput)
+      assert_not_nil(ConsoleFoo::ReadConsoleOutput)
+      assert_not_nil(ConsoleFoo::ReadConsoleOutputAttribute)
+      assert_not_nil(ConsoleFoo::ReadConsoleOutputCharacter)
+      assert_not_nil(ConsoleFoo::ScrollConsoleScreenBuffer)
+      assert_not_nil(ConsoleFoo::SetConsoleActiveScreenBuffer)
+      assert_not_nil(ConsoleFoo::SetConsoleCP)
+      assert_not_nil(ConsoleFoo::SetConsoleCtrlHandler)
+      assert_not_nil(ConsoleFoo::SetConsoleCursorInfo)
+      assert_not_nil(ConsoleFoo::SetConsoleCursorPosition)
+      assert_not_nil(ConsoleFoo::SetConsoleMode)
+      assert_not_nil(ConsoleFoo::SetConsoleOutputCP)
+      assert_not_nil(ConsoleFoo::SetConsoleScreenBufferSize)
+      assert_not_nil(ConsoleFoo::SetConsoleTextAttribute)
+      assert_not_nil(ConsoleFoo::SetConsoleTitle)
+      assert_not_nil(ConsoleFoo::SetConsoleWindowInfo)
+      assert_not_nil(ConsoleFoo::SetStdHandle)
+      assert_not_nil(ConsoleFoo::WriteConsole)
+      assert_not_nil(ConsoleFoo::WriteConsoleInput)
+      assert_not_nil(ConsoleFoo::WriteConsoleOutput)
+      assert_not_nil(ConsoleFoo::WriteConsoleOutputAttribute)
+      assert_not_nil(ConsoleFoo::WriteConsoleOutputCharacter)
+   end
+
+   def test_method_constants_xp_or_later
+      if @ver =~ /XP/
+         assert_not_nil(ConsoleFoo::AttachConsole)
+         assert_not_nil(ConsoleFoo::GetConsoleDisplayMode)
+         assert_not_nil(ConsoleFoo::GetConsoleFontSize)
+         assert_not_nil(ConsoleFoo::GetConsoleProcessList)
+         assert_not_nil(ConsoleFoo::GetConsoleSelectionInfo)
+         assert_not_nil(ConsoleFoo::GetCurrentConsoleFont)
+         assert_not_nil(ConsoleFoo::SetConsoleDisplayMode)
+      end
+   end
+
+   def test_explicit_ansi
+      assert_not_nil(ConsoleFoo::GetConsoleAliasA)
+   end
+
+   def test_explicit_unicode
+      assert_not_nil(ConsoleFoo::GetConsoleAliasW)
    end
 
    def teardown
       @foo = nil
+      @ver = nil
    end
 end

data/test/tc_debug.rb

@@ -0,0 +1,48 @@
+#####################################################################
+# tc_debug.rb
+#
+# Test case for the Windows::Debug module.
+#####################################################################
+require "windows/debug"
+require "test/unit"
+
+class DebugFoo
+   include Windows::Debug
+end
+
+class TC_Windows_Debug < Test::Unit::TestCase
+   def setup
+      @foo = DebugFoo.new
+      @ver = `ver`.chomp
+   end
+   
+   def test_method_constants
+      assert_not_nil(DebugFoo::ContinueDebugEvent)
+      assert_not_nil(DebugFoo::DebugActiveProcess)
+      assert_not_nil(DebugFoo::DebugBreak)
+      assert_not_nil(DebugFoo::FatalExit)
+      assert_not_nil(DebugFoo::FlushInstructionCache)
+      assert_not_nil(DebugFoo::GetThreadContext)
+      assert_not_nil(DebugFoo::GetThreadSelectorEntry)
+      assert_not_nil(DebugFoo::IsDebuggerPresent)
+      assert_not_nil(DebugFoo::OutputDebugString)
+      assert_not_nil(DebugFoo::ReadProcessMemory)
+      assert_not_nil(DebugFoo::SetThreadContext)
+      assert_not_nil(DebugFoo::WaitForDebugEvent)
+      assert_not_nil(DebugFoo::WriteProcessMemory)
+   end
+
+   def test_method_constants_xp_or_later
+      if @ver =~ /XP/
+         assert_not_nil(DebugFoo::CheckRemoteDebuggerPresent)
+         assert_not_nil(DebugFoo::DebugActiveProcessStop)
+         assert_not_nil(DebugFoo::DebugBreakProcess)
+         assert_not_nil(DebugFoo::DebugSetProcessKillOnExit)
+      end
+   end
+
+   def teardown
+      @foo = nil
+      @ver = nil
+   end
+end

data/test/tc_error.rb

@@ -3,46 +3,39 @@
 #
 # Test case for the Windows::Error 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/error"
 require "test/unit"
 
-class Foo
+class ErrorFoo
    include Windows::Error
 end
 
 class TC_Windows_Error < Test::Unit::TestCase
   
    def setup
-      @foo = Foo.new
+      @foo = ErrorFoo.new
    end
    
    def test_numeric_constants
-      assert_equal(0x00000100, Foo::FORMAT_MESSAGE_ALLOCATE_BUFFER)
-      assert_equal(0x00000200, Foo::FORMAT_MESSAGE_IGNORE_INSERTS)
-      assert_equal(0x00000400, Foo::FORMAT_MESSAGE_FROM_STRING)
-      assert_equal(0x00000800, Foo::FORMAT_MESSAGE_FROM_HMODULE)
-      assert_equal(0x00001000, Foo::FORMAT_MESSAGE_FROM_SYSTEM)
-      assert_equal(0x00002000, Foo::FORMAT_MESSAGE_ARGUMENT_ARRAY) 
-      assert_equal(0x000000FF, Foo::FORMAT_MESSAGE_MAX_WIDTH_MASK) 
-      assert_equal(0x0001, Foo::SEM_FAILCRITICALERRORS)
-      assert_equal(0x0004, Foo::SEM_NOALIGNMENTFAULTEXCEPT)
-      assert_equal(0x0002, Foo::SEM_NOGPFAULTERRORBOX)
-      assert_equal(0x8000, Foo::SEM_NOOPENFILEERRORBOX)
+      assert_equal(0x00000100, ErrorFoo::FORMAT_MESSAGE_ALLOCATE_BUFFER)
+      assert_equal(0x00000200, ErrorFoo::FORMAT_MESSAGE_IGNORE_INSERTS)
+      assert_equal(0x00000400, ErrorFoo::FORMAT_MESSAGE_FROM_STRING)
+      assert_equal(0x00000800, ErrorFoo::FORMAT_MESSAGE_FROM_HMODULE)
+      assert_equal(0x00001000, ErrorFoo::FORMAT_MESSAGE_FROM_SYSTEM)
+      assert_equal(0x00002000, ErrorFoo::FORMAT_MESSAGE_ARGUMENT_ARRAY) 
+      assert_equal(0x000000FF, ErrorFoo::FORMAT_MESSAGE_MAX_WIDTH_MASK) 
+      assert_equal(0x0001, ErrorFoo::SEM_FAILCRITICALERRORS)
+      assert_equal(0x0004, ErrorFoo::SEM_NOALIGNMENTFAULTEXCEPT)
+      assert_equal(0x0002, ErrorFoo::SEM_NOGPFAULTERRORBOX)
+      assert_equal(0x8000, ErrorFoo::SEM_NOOPENFILEERRORBOX)
    end
    
    def test_method_constants
-      assert_not_nil(Foo::GetLastError)
-      assert_not_nil(Foo::SetLastError)
-      assert_not_nil(Foo::SetLastErrorEx) # Ignore for VC++ 6 or earlier.
-      assert_not_nil(Foo::SetErrorMode)
-      assert_not_nil(Foo::FormatMessage)
+      assert_not_nil(ErrorFoo::GetLastError)
+      assert_not_nil(ErrorFoo::SetLastError)
+      assert_not_nil(ErrorFoo::SetLastErrorEx) # Ignore for VC++ 6 or earlier.
+      assert_not_nil(ErrorFoo::SetErrorMode)
+      assert_not_nil(ErrorFoo::FormatMessage)
    end
    
    def test_get_last_error

data/test/tc_eventlog.rb

@@ -3,60 +3,53 @@
 #
 # Test case for the Windows::EventLog 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/eventlog'
 require 'test/unit'
 
-class Foo
+class EventLogFoo
    include Windows::EventLog
 end
 
 class TC_Windows_EventLog < Test::Unit::TestCase
    def setup
-      @foo = Foo.new
+      @foo = EventLogFoo.new
    end
    
    def test_numeric_constants
-      assert_equal(1, Foo::EVENTLOG_SEQUENTIAL_READ)
-      assert_equal(2, Foo::EVENTLOG_SEEK_READ)
-      assert_equal(4, Foo::EVENTLOG_FORWARDS_READ)
-      assert_equal(8, Foo::EVENTLOG_BACKWARDS_READ)
-      assert_equal(0, Foo::EVENTLOG_SUCCESS)
-      assert_equal(1, Foo::EVENTLOG_ERROR_TYPE)
-      assert_equal(2, Foo::EVENTLOG_WARNING_TYPE)
-      assert_equal(4, Foo::EVENTLOG_INFORMATION_TYPE)
-      assert_equal(8, Foo::EVENTLOG_AUDIT_SUCCESS)
-      assert_equal(16, Foo::EVENTLOG_AUDIT_FAILURE)
-      assert_equal(0, Foo::EVENTLOG_FULL_INFO)
+      assert_equal(1, EventLogFoo::EVENTLOG_SEQUENTIAL_READ)
+      assert_equal(2, EventLogFoo::EVENTLOG_SEEK_READ)
+      assert_equal(4, EventLogFoo::EVENTLOG_FORWARDS_READ)
+      assert_equal(8, EventLogFoo::EVENTLOG_BACKWARDS_READ)
+      assert_equal(0, EventLogFoo::EVENTLOG_SUCCESS)
+      assert_equal(1, EventLogFoo::EVENTLOG_ERROR_TYPE)
+      assert_equal(2, EventLogFoo::EVENTLOG_WARNING_TYPE)
+      assert_equal(4, EventLogFoo::EVENTLOG_INFORMATION_TYPE)
+      assert_equal(8, EventLogFoo::EVENTLOG_AUDIT_SUCCESS)
+      assert_equal(16, EventLogFoo::EVENTLOG_AUDIT_FAILURE)
+      assert_equal(0, EventLogFoo::EVENTLOG_FULL_INFO)
    end
    
    def test_method_constants
-      assert_not_nil(Foo::BackupEventLog)
-      assert_not_nil(Foo::BackupEventLogW)
-      assert_not_nil(Foo::ClearEventLog)
-      assert_not_nil(Foo::ClearEventLogW)
-      assert_not_nil(Foo::CloseEventLog)
-      assert_not_nil(Foo::DeregisterEventSource)
-      assert_not_nil(Foo::GetEventLogInformation)
-      assert_not_nil(Foo::GetNumberOfEventLogRecords)
-      assert_not_nil(Foo::GetOldestEventLogRecord)
-      assert_not_nil(Foo::NotifyChangeEventLog)
-      assert_not_nil(Foo::OpenBackupEventLog)
-      assert_not_nil(Foo::OpenBackupEventLogW)
-      assert_not_nil(Foo::OpenEventLog)
-      assert_not_nil(Foo::OpenEventLogW)
-      assert_not_nil(Foo::ReadEventLog)
-      assert_not_nil(Foo::ReadEventLogW)
-      assert_not_nil(Foo::RegisterEventSource)
-      assert_not_nil(Foo::RegisterEventSourceW)
-      assert_not_nil(Foo::ReportEvent)
-      assert_not_nil(Foo::ReportEventW)
+      assert_not_nil(EventLogFoo::BackupEventLog)
+      assert_not_nil(EventLogFoo::BackupEventLogW)
+      assert_not_nil(EventLogFoo::ClearEventLog)
+      assert_not_nil(EventLogFoo::ClearEventLogW)
+      assert_not_nil(EventLogFoo::CloseEventLog)
+      assert_not_nil(EventLogFoo::DeregisterEventSource)
+      assert_not_nil(EventLogFoo::GetEventLogInformation)
+      assert_not_nil(EventLogFoo::GetNumberOfEventLogRecords)
+      assert_not_nil(EventLogFoo::GetOldestEventLogRecord)
+      assert_not_nil(EventLogFoo::NotifyChangeEventLog)
+      assert_not_nil(EventLogFoo::OpenBackupEventLog)
+      assert_not_nil(EventLogFoo::OpenBackupEventLogW)
+      assert_not_nil(EventLogFoo::OpenEventLog)
+      assert_not_nil(EventLogFoo::OpenEventLogW)
+      assert_not_nil(EventLogFoo::ReadEventLog)
+      assert_not_nil(EventLogFoo::ReadEventLogW)
+      assert_not_nil(EventLogFoo::RegisterEventSource)
+      assert_not_nil(EventLogFoo::RegisterEventSourceW)
+      assert_not_nil(EventLogFoo::ReportEvent)
+      assert_not_nil(EventLogFoo::ReportEventW)
    end
    
    def teardown

data/test/tc_file.rb

@@ -3,70 +3,63 @@
 #
 # 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
+class FileFoo
    include Windows::File
 end
 
 class TC_Windows_File < Test::Unit::TestCase
   
    def setup
-      @foo = Foo.new
+      @foo = FileFoo.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)
+      assert_equal(0x00000001, FileFoo::FILE_ATTRIBUTE_READONLY)  
+      assert_equal(0x00000002, FileFoo::FILE_ATTRIBUTE_HIDDEN)  
+      assert_equal(0x00000004, FileFoo::FILE_ATTRIBUTE_SYSTEM)
+      assert_equal(0x00000010, FileFoo::FILE_ATTRIBUTE_DIRECTORY) 
+      assert_equal(0x00000020, FileFoo::FILE_ATTRIBUTE_ARCHIVE)  
+      assert_equal(0x00000040, FileFoo::FILE_ATTRIBUTE_ENCRYPTED)
+      assert_equal(0x00000080, FileFoo::FILE_ATTRIBUTE_NORMAL)  
+      assert_equal(0x00000100, FileFoo::FILE_ATTRIBUTE_TEMPORARY)  
+      assert_equal(0x00000200, FileFoo::FILE_ATTRIBUTE_SPARSE_FILE) 
+      assert_equal(0x00000400, FileFoo::FILE_ATTRIBUTE_REPARSE_POINT)  
+      assert_equal(0x00000800, FileFoo::FILE_ATTRIBUTE_COMPRESSED)  
+      assert_equal(0x00001000, FileFoo::FILE_ATTRIBUTE_OFFLINE) 
+      assert_equal(0x00002000, FileFoo::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)
+      assert_not_nil(FileFoo::CopyFile)
+      assert_not_nil(FileFoo::CopyFileEx)
+      assert_not_nil(FileFoo::CreateFile)
+      assert_not_nil(FileFoo::CreateFileW)
+      assert_not_nil(FileFoo::CreateHardLink)
+      assert_not_nil(FileFoo::DecryptFile)
+      assert_not_nil(FileFoo::DeleteFile)
+      assert_not_nil(FileFoo::EncryptFile)
+      assert_not_nil(FileFoo::GetBinaryType)
+      assert_not_nil(FileFoo::GetFileAttributes)
+      assert_not_nil(FileFoo::GetFileAttributesEx)
+      assert_not_nil(FileFoo::GetFileSize)
+      assert_not_nil(FileFoo::GetFileSizeEx)
+      assert_not_nil(FileFoo::GetFileType)
+      assert_not_nil(FileFoo::GetFullPathName)
+      assert_not_nil(FileFoo::GetFullPathNameW)
+      assert_not_nil(FileFoo::GetLongPathName)
+      assert_not_nil(FileFoo::GetShortPathName)
+      assert_not_nil(FileFoo::LockFile)
+      assert_not_nil(FileFoo::LockFileEx)
+      assert_not_nil(FileFoo::ReadFile)
+      assert_not_nil(FileFoo::ReadFileEx)
+      assert_not_nil(FileFoo::SetFileAttributes)
+      assert_not_nil(FileFoo::UnlockFile)
+      assert_not_nil(FileFoo::UnlockFileEx)
+      assert_not_nil(FileFoo::WriteFile)
+      assert_not_nil(FileFoo::WriteFileEx)
    end
    
    def teardown