windows-pr 0.7.0 → 0.7.1

data/test/tc_library.rb

@@ -3,42 +3,35 @@
 #
 # Test case for the Windows::Library 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/library'
 require 'test/unit'
 
-class Foo
+class LibraryFoo
    include Windows::Library
 end
 
 class TC_Windows_Library < Test::Unit::TestCase
    def setup
-      @foo  = Foo.new
+      @LibraryFoo  = LibraryFoo.new
    end
 
    def test_numeric_constants
-      assert_equal(0, Foo::DLL_PROCESS_DETACH)
-      assert_equal(1, Foo::DLL_PROCESS_ATTACH)
-      assert_equal(2, Foo::DLL_THREAD_ATTACH)
-      assert_equal(3, Foo::DLL_THREAD_DETACH)
+      assert_equal(0, LibraryFoo::DLL_PROCESS_DETACH)
+      assert_equal(1, LibraryFoo::DLL_PROCESS_ATTACH)
+      assert_equal(2, LibraryFoo::DLL_THREAD_ATTACH)
+      assert_equal(3, LibraryFoo::DLL_THREAD_DETACH)
    end
 
    def test_method_constants
-      assert_not_nil(Foo::FreeLibrary)
-      assert_not_nil(Foo::GetModuleFileName)
-      assert_not_nil(Foo::GetModuleHandle)
-      assert_not_nil(Foo::LoadLibrary)
-      assert_not_nil(Foo::LoadLibraryEx)
-      assert_not_nil(Foo::LoadModule)
+      assert_not_nil(LibraryFoo::FreeLibrary)
+      assert_not_nil(LibraryFoo::GetModuleFileName)
+      assert_not_nil(LibraryFoo::GetModuleHandle)
+      assert_not_nil(LibraryFoo::LoadLibrary)
+      assert_not_nil(LibraryFoo::LoadLibraryEx)
+      assert_not_nil(LibraryFoo::LoadModule)
    end
 
    def teardown
-      @foo  = nil
+      @LibraryFoo  = nil
    end
 end

data/test/tc_memory.rb

@@ -3,45 +3,38 @@
 #
 # Test case for the Windows::Memory 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/memory'
 require 'test/unit'
 
-class Foo
+class MemoryFoo
    include Windows::Memory
 end
 
-class TC_Windows_Path < Test::Unit::TestCase
+class TC_Windows_Memory < Test::Unit::TestCase
    def setup
-      @foo  = Foo.new
+      @foo  = MemoryFoo.new
       @path = "C:\\"
    end
 
    def test_numeric_constants
-      assert_not_nil(Foo::GHND)
-      assert_not_nil(Foo::GMEM_FIXED)
-      assert_not_nil(Foo::GMEM_MOVABLE)
-      assert_not_nil(Foo::GMEM_ZEROINIT)
-      assert_not_nil(Foo::GPTR)
+      assert_not_nil(MemoryFoo::GHND)
+      assert_not_nil(MemoryFoo::GMEM_FIXED)
+      assert_not_nil(MemoryFoo::GMEM_MOVABLE)
+      assert_not_nil(MemoryFoo::GMEM_ZEROINIT)
+      assert_not_nil(MemoryFoo::GPTR)
    end
 
    def test_method_constants
-      assert_not_nil(Foo::GlobalAlloc)
-      assert_not_nil(Foo::GlobalFlags)
-      assert_not_nil(Foo::GlobalFree)
-      assert_not_nil(Foo::GlobalHandle)
-      assert_not_nil(Foo::GlobalLock)
-      assert_not_nil(Foo::GlobalMemoryStatus)
-      assert_not_nil(Foo::GlobalMemoryStatusEx)
-      assert_not_nil(Foo::GlobalReAlloc)
-      assert_not_nil(Foo::GlobalSize)
-      assert_not_nil(Foo::GlobalUnlock)
+      assert_not_nil(MemoryFoo::GlobalAlloc)
+      assert_not_nil(MemoryFoo::GlobalFlags)
+      assert_not_nil(MemoryFoo::GlobalFree)
+      assert_not_nil(MemoryFoo::GlobalHandle)
+      assert_not_nil(MemoryFoo::GlobalLock)
+      assert_not_nil(MemoryFoo::GlobalMemoryStatus)
+      assert_not_nil(MemoryFoo::GlobalMemoryStatusEx)
+      assert_not_nil(MemoryFoo::GlobalReAlloc)
+      assert_not_nil(MemoryFoo::GlobalSize)
+      assert_not_nil(MemoryFoo::GlobalUnlock)
    end
 
    def teardown

data/test/tc_msvcrt_buffer.rb

@@ -3,34 +3,27 @@
 #
 # Test case for the Windows::MSVCRT::Buffer 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/msvcrt/buffer"
 require "test/unit"
 
-class Foo
+class BufferFoo
    include Windows::MSVCRT::Buffer
 end
 
 class TC_Windows_MSVCRT_Buffer < Test::Unit::TestCase
    def setup
-      @foo = Foo.new
+      @foo = BufferFoo.new
    end
    
    def test_method_constants
-      assert_not_nil(Foo::Memcpy)
-      assert_not_nil(Foo::Memccpy)
-      assert_not_nil(Foo::Memchr)
-      assert_not_nil(Foo::Memcmp)
-      assert_not_nil(Foo::Memicmp)
-      assert_not_nil(Foo::Memmove)
-      assert_not_nil(Foo::Memset)
-      assert_not_nil(Foo::Swab)
+      assert_not_nil(BufferFoo::Memcpy)
+      assert_not_nil(BufferFoo::Memccpy)
+      assert_not_nil(BufferFoo::Memchr)
+      assert_not_nil(BufferFoo::Memcmp)
+      assert_not_nil(BufferFoo::Memicmp)
+      assert_not_nil(BufferFoo::Memmove)
+      assert_not_nil(BufferFoo::Memset)
+      assert_not_nil(BufferFoo::Swab)
    end
    
    def test_memcpy

data/test/tc_path.rb

@@ -3,91 +3,84 @@
 #
 # Test case for the Windows::Path 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/path"
 require "test/unit"
 
-class Foo
+class PathFoo
    include Windows::Path
 end
 
 class TC_Windows_Path < Test::Unit::TestCase
    def setup
-      @foo  = Foo.new
+      @foo  = PathFoo.new
       @path = "C:\\"
    end
 
    def test_numeric_constants
-      assert_equal(0x0000, Foo::GCT_INVALID)
-      assert_equal(0x0001, Foo::GCT_LFNCHAR)
-      assert_equal(0x0002, Foo::GCT_SHORTCHAR)
-      assert_equal(0x0004, Foo::GCT_WILD)
-      assert_equal(0x0008, Foo::GCT_SEPARATOR)
+      assert_equal(0x0000, PathFoo::GCT_INVALID)
+      assert_equal(0x0001, PathFoo::GCT_LFNCHAR)
+      assert_equal(0x0002, PathFoo::GCT_SHORTCHAR)
+      assert_equal(0x0004, PathFoo::GCT_WILD)
+      assert_equal(0x0008, PathFoo::GCT_SEPARATOR)
    end
 
    def test_method_constants
-      assert_not_nil(Foo::PathAddBackslash)
-      assert_not_nil(Foo::PathAddExtension)
-      assert_not_nil(Foo::PathAppend)
-      assert_not_nil(Foo::PathBuildRoot)
-      assert_not_nil(Foo::PathCanonicalize)
-      assert_not_nil(Foo::PathCombine)
-      assert_not_nil(Foo::PathCommonPrefix)
-      assert_not_nil(Foo::PathCompactPath)
-      assert_not_nil(Foo::PathCompactPathEx)
-      assert_not_nil(Foo::PathCreateFromUrl)
-      assert_not_nil(Foo::PathFileExists)
-      assert_not_nil(Foo::PathFindExtension)
-      assert_not_nil(Foo::PathFindFileName)
-      assert_not_nil(Foo::PathFindNextComponent)
-      assert_not_nil(Foo::PathFindOnPath)
-      assert_not_nil(Foo::PathFindSuffixArray)
-      assert_not_nil(Foo::PathGetArgs)
-      assert_not_nil(Foo::PathGetCharType)
-      assert_not_nil(Foo::PathGetDriveNumber)
-      assert_not_nil(Foo::PathIsContentType)
-      assert_not_nil(Foo::PathIsDirectory)
-      assert_not_nil(Foo::PathIsDirectoryEmpty)
-      assert_not_nil(Foo::PathIsFileSpec)
-      #assert_not_nil(Foo::PathIsHTMLFile)
-      assert_not_nil(Foo::PathIsLFNFileSpec)
-      assert_not_nil(Foo::PathIsNetworkPath)
-      assert_not_nil(Foo::PathIsPrefix)
-      assert_not_nil(Foo::PathIsRelative)
-      assert_not_nil(Foo::PathIsRoot)
-      assert_not_nil(Foo::PathIsSameRoot)
-      assert_not_nil(Foo::PathIsSystemFolder)
-      assert_not_nil(Foo::PathIsUNC)
-      assert_not_nil(Foo::PathIsUNCServer)
-      assert_not_nil(Foo::PathIsUNCServerShare)
-      assert_not_nil(Foo::PathIsURL)
-      assert_not_nil(Foo::PathMakePretty)
-      assert_not_nil(Foo::PathMakeSystemFolder)
-      assert_not_nil(Foo::PathMatchSpec)
-      assert_not_nil(Foo::PathParseIconLocation)
-      assert_not_nil(Foo::PathQuoteSpaces)
-      assert_not_nil(Foo::PathRelativePathTo)
-      assert_not_nil(Foo::PathRemoveArgs)
-      assert_not_nil(Foo::PathRemoveBackslash)
-      assert_not_nil(Foo::PathRemoveBlanks)
-      assert_not_nil(Foo::PathRemoveExtension)
-      assert_not_nil(Foo::PathRemoveFileSpec)
-      assert_not_nil(Foo::PathRenameExtension)
-      assert_not_nil(Foo::PathSearchAndQualify)
-      assert_not_nil(Foo::PathSetDlgItemPath)
-      assert_not_nil(Foo::PathSkipRoot)
-      assert_not_nil(Foo::PathStripPath)
-      assert_not_nil(Foo::PathStripToRoot)
-      assert_not_nil(Foo::PathUndecorate)
-      assert_not_nil(Foo::PathUnExpandEnvStrings)
-      assert_not_nil(Foo::PathUnmakeSystemFolder)
-      assert_not_nil(Foo::PathUnquoteSpaces)
+      assert_not_nil(PathFoo::PathAddBackslash)
+      assert_not_nil(PathFoo::PathAddExtension)
+      assert_not_nil(PathFoo::PathAppend)
+      assert_not_nil(PathFoo::PathBuildRoot)
+      assert_not_nil(PathFoo::PathCanonicalize)
+      assert_not_nil(PathFoo::PathCombine)
+      assert_not_nil(PathFoo::PathCommonPrefix)
+      assert_not_nil(PathFoo::PathCompactPath)
+      assert_not_nil(PathFoo::PathCompactPathEx)
+      assert_not_nil(PathFoo::PathCreateFromUrl)
+      assert_not_nil(PathFoo::PathFileExists)
+      assert_not_nil(PathFoo::PathFindExtension)
+      assert_not_nil(PathFoo::PathFindFileName)
+      assert_not_nil(PathFoo::PathFindNextComponent)
+      assert_not_nil(PathFoo::PathFindOnPath)
+      assert_not_nil(PathFoo::PathFindSuffixArray)
+      assert_not_nil(PathFoo::PathGetArgs)
+      assert_not_nil(PathFoo::PathGetCharType)
+      assert_not_nil(PathFoo::PathGetDriveNumber)
+      assert_not_nil(PathFoo::PathIsContentType)
+      assert_not_nil(PathFoo::PathIsDirectory)
+      assert_not_nil(PathFoo::PathIsDirectoryEmpty)
+      assert_not_nil(PathFoo::PathIsFileSpec)
+      #assert_not_nil(PathFoo::PathIsHTMLFile)
+      assert_not_nil(PathFoo::PathIsLFNFileSpec)
+      assert_not_nil(PathFoo::PathIsNetworkPath)
+      assert_not_nil(PathFoo::PathIsPrefix)
+      assert_not_nil(PathFoo::PathIsRelative)
+      assert_not_nil(PathFoo::PathIsRoot)
+      assert_not_nil(PathFoo::PathIsSameRoot)
+      assert_not_nil(PathFoo::PathIsSystemFolder)
+      assert_not_nil(PathFoo::PathIsUNC)
+      assert_not_nil(PathFoo::PathIsUNCServer)
+      assert_not_nil(PathFoo::PathIsUNCServerShare)
+      assert_not_nil(PathFoo::PathIsURL)
+      assert_not_nil(PathFoo::PathMakePretty)
+      assert_not_nil(PathFoo::PathMakeSystemFolder)
+      assert_not_nil(PathFoo::PathMatchSpec)
+      assert_not_nil(PathFoo::PathParseIconLocation)
+      assert_not_nil(PathFoo::PathQuoteSpaces)
+      assert_not_nil(PathFoo::PathRelativePathTo)
+      assert_not_nil(PathFoo::PathRemoveArgs)
+      assert_not_nil(PathFoo::PathRemoveBackslash)
+      assert_not_nil(PathFoo::PathRemoveBlanks)
+      assert_not_nil(PathFoo::PathRemoveExtension)
+      assert_not_nil(PathFoo::PathRemoveFileSpec)
+      assert_not_nil(PathFoo::PathRenameExtension)
+      assert_not_nil(PathFoo::PathSearchAndQualify)
+      assert_not_nil(PathFoo::PathSetDlgItemPath)
+      assert_not_nil(PathFoo::PathSkipRoot)
+      assert_not_nil(PathFoo::PathStripPath)
+      assert_not_nil(PathFoo::PathStripToRoot)
+      assert_not_nil(PathFoo::PathUndecorate)
+      assert_not_nil(PathFoo::PathUnExpandEnvStrings)
+      assert_not_nil(PathFoo::PathUnmakeSystemFolder)
+      assert_not_nil(PathFoo::PathUnquoteSpaces)
    end
 
    def teardown

data/test/tc_pipe.rb

@@ -3,55 +3,48 @@
 #
 # 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
+class PipeFoo
    include Windows::Pipe
 end
 
 class TC_Windows_Pipe < Test::Unit::TestCase
   
    def setup
-      @foo = Foo.new
+      @foo = PipeFoo.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)
+      assert_equal(0x00000001, PipeFoo::NMPWAIT_NOWAIT)
+      assert_equal(0xffffffff, PipeFoo::NMPWAIT_WAIT_FOREVER)
+      assert_equal(0x00000000, PipeFoo::NMPWAIT_USE_DEFAULT_WAIT)
+      assert_equal(0x00000000, PipeFoo::PIPE_WAIT)
+      assert_equal(0x00000001, PipeFoo::PIPE_NOWAIT)
+      assert_equal(0x00000001, PipeFoo::PIPE_ACCESS_INBOUND)
+      assert_equal(0x00000002, PipeFoo::PIPE_ACCESS_OUTBOUND)
+      assert_equal(0x00000003, PipeFoo::PIPE_ACCESS_DUPLEX)
+      assert_equal(0x00000000, PipeFoo::PIPE_TYPE_BYTE)
+      assert_equal(0x00000004, PipeFoo::PIPE_TYPE_MESSAGE)
+      assert_equal(0x00000000, PipeFoo::PIPE_READMODE_BYTE)
+      assert_equal(0x00000002, PipeFoo::PIPE_READMODE_MESSAGE)
+      assert_equal(0x00000000, PipeFoo::PIPE_CLIENT_END)
+      assert_equal(0x00000001, PipeFoo::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)
+      assert_not_nil(PipeFoo::CallNamedPipe)
+      assert_not_nil(PipeFoo::ConnectNamedPipe)
+      assert_not_nil(PipeFoo::CreateNamedPipe)
+      assert_not_nil(PipeFoo::CreatePipe)
+      assert_not_nil(PipeFoo::DisconnectNamedPipe)
+      assert_not_nil(PipeFoo::GetNamedPipeHandleState)
+      assert_not_nil(PipeFoo::GetNamedPipeInfo)
+      assert_not_nil(PipeFoo::PeekNamedPipe)
+      assert_not_nil(PipeFoo::SetNamedPipeHandleState)
+      assert_not_nil(PipeFoo::TransactNamedPipe)
+      assert_not_nil(PipeFoo::WaitNamedPipe)
    end
    
    def teardown

data/test/tc_process.rb

@@ -3,31 +3,24 @@
 #
 # 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
+class ProcessFoo
    include Windows::Process
 end
 
 class TC_Windows_Process < Test::Unit::TestCase
    def setup
-      @foo  = Foo.new
+      @foo  = ProcessFoo.new
    end
 
    def test_numeric_constants
-      assert_equal(0x1F0FFF, Foo::PROCESS_ALL_ACCESS)
+      assert_equal(0x1F0FFF, ProcessFoo::PROCESS_ALL_ACCESS)
    end
 
    def test_method_constants
-      assert_not_nil(Foo::CreateProcess)
+      assert_not_nil(ProcessFoo::CreateProcess)
    end
 
    def teardown

data/test/tc_registry.rb

@@ -3,31 +3,24 @@
 #
 # Test case for the Windows::Registry 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/registry'
 require 'test/unit'
 
-class Foo
+class RegistryFoo
    include Windows::Registry
 end
 
 class TC_Windows_Registry < Test::Unit::TestCase
    def setup
-      @foo  = Foo.new
+      @foo  = RegistryFoo.new
    end
 
    def test_numeric_constants
-      assert_equal(0x80000000, Foo::HKEY_CLASSES_ROOT)
+      assert_equal(0x80000000, RegistryFoo::HKEY_CLASSES_ROOT)
    end
 
    def test_method_constants
-      assert_not_nil(Foo::RegCloseKey)
+      assert_not_nil(RegistryFoo::RegCloseKey)
    end
 
    def teardown

data/test/tc_security.rb

@@ -3,54 +3,47 @@
 #
 # Test case for the Windows::Security 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/security"
 require "test/unit"
 
-class Foo
+class SecurityFoo
    include Windows::Security
 end
 
-class TC_Windows_Path < Test::Unit::TestCase
+class TC_Windows_Security < Test::Unit::TestCase
    def setup
-      @foo = Foo.new
+      @foo = SecurityFoo.new
    end
 
    def test_numeric_constants
-      assert_equal(2,  Foo::ACL_REVISION)
-      assert_equal(2,  Foo::ACL_REVISION2)
-      assert_equal(3,  Foo::ACL_REVISION3)
-      assert_equal(4,  Foo::ACL_REVISION4)
-      assert_equal(62, Foo::ALLOW_ACE_LENGTH)
-      assert_equal(4,  Foo::DACL_SECURITY_INFORMATION)
-      assert_equal(4,  Foo::SE_DACL_PRESENT)
-      assert_equal(20, Foo::SECURITY_DESCRIPTOR_MIN_LENGTH)
-      assert_equal(1,  Foo::SECURITY_DESCRIPTOR_REVISION)
-      assert_equal(4026597376, Foo::GENERIC_RIGHTS_MASK)
-      assert_equal(4026531840, Foo::GENERIC_RIGHTS_CHK)
-      assert_equal(2097151, Foo::REST_RIGHTS_MASK)
+      assert_equal(2,  SecurityFoo::ACL_REVISION)
+      assert_equal(2,  SecurityFoo::ACL_REVISION2)
+      assert_equal(3,  SecurityFoo::ACL_REVISION3)
+      assert_equal(4,  SecurityFoo::ACL_REVISION4)
+      assert_equal(62, SecurityFoo::ALLOW_ACE_LENGTH)
+      assert_equal(4,  SecurityFoo::DACL_SECURITY_INFORMATION)
+      assert_equal(4,  SecurityFoo::SE_DACL_PRESENT)
+      assert_equal(20, SecurityFoo::SECURITY_DESCRIPTOR_MIN_LENGTH)
+      assert_equal(1,  SecurityFoo::SECURITY_DESCRIPTOR_REVISION)
+      assert_equal(4026597376, SecurityFoo::GENERIC_RIGHTS_MASK)
+      assert_equal(4026531840, SecurityFoo::GENERIC_RIGHTS_CHK)
+      assert_equal(2097151, SecurityFoo::REST_RIGHTS_MASK)
    end
 
    def test_method_constants
-      assert_not_nil(Foo::AddAce)
-      assert_not_nil(Foo::CopySid)
-      assert_not_nil(Foo::GetAce)
-      assert_not_nil(Foo::GetFileSecurity)
-      assert_not_nil(Foo::GetLengthSid)
-      assert_not_nil(Foo::GetSecurityDescriptorControl)
-      assert_not_nil(Foo::GetSecurityDescriptorDacl)
-      assert_not_nil(Foo::InitializeAcl)
-      assert_not_nil(Foo::InitializeSecurityDescriptor)
-      assert_not_nil(Foo::LookupAccountName)
-      assert_not_nil(Foo::LookupAccountSid)
-      assert_not_nil(Foo::SetFileSecurity)
-      assert_not_nil(Foo::SetSecurityDescriptorDacl)
+      assert_not_nil(SecurityFoo::AddAce)
+      assert_not_nil(SecurityFoo::CopySid)
+      assert_not_nil(SecurityFoo::GetAce)
+      assert_not_nil(SecurityFoo::GetFileSecurity)
+      assert_not_nil(SecurityFoo::GetLengthSid)
+      assert_not_nil(SecurityFoo::GetSecurityDescriptorControl)
+      assert_not_nil(SecurityFoo::GetSecurityDescriptorDacl)
+      assert_not_nil(SecurityFoo::InitializeAcl)
+      assert_not_nil(SecurityFoo::InitializeSecurityDescriptor)
+      assert_not_nil(SecurityFoo::LookupAccountName)
+      assert_not_nil(SecurityFoo::LookupAccountSid)
+      assert_not_nil(SecurityFoo::SetFileSecurity)
+      assert_not_nil(SecurityFoo::SetSecurityDescriptorDacl)
    end
 
    def test_add_ace