Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565/* * PROJECT: ReactOS API tests * LICENSE: LGPLv2.1+ - See COPYING.LIB in the top level directory * PURPOSE: Tests for delayload * PROGRAMMER: Mark Jansen */
#include <apitest.h>
#include <apitest.h>#include <strsafe.h>#include <delayimp.h>
/* Some libraries to test against */#include <mmsystem.h>#include <winver.h>#include <shlwapi.h>#include <intshcut.h>#include <sfc.h>#include <imagehlp.h>#include <mmddk.h>
#include <pseh/pseh2.h>
/* Compatibility with the MS defines */
#ifndef FACILITY_VISUALCPP#define FACILITY_VISUALCPP ((LONG)0x6d)#endif
#ifndef VcppException#define VcppException(sev,err) ((sev) | (FACILITY_VISUALCPP<<16) | err)#endif
#ifdef __REACTOS__#define WINMM_DLLNAME "winmm.dll"#else#define WINMM_DLLNAME "WINMM.dll"#endif
bool g_BreakFunctionName = false;bool g_BrokenFunctionName = false;bool g_BypassMost = false;bool g_ExceptionIsModule = false;bool g_ImportByName = true;const char* g_ExpectedDll = NULL;const char* g_ExpectedName = NULL;char g_Target[100] = { 0 };
char* target(PDelayLoadInfo pdli){ if (g_Target[0] == '\0' && pdli) { if (pdli->dlp.fImportByName) sprintf(g_Target, "%s!%s", pdli->szDll, pdli->dlp.szProcName); else sprintf(g_Target, "%s!#%lu", pdli->szDll, pdli->dlp.dwOrdinal); } return g_Target;}
struct UnProtect{ UnProtect(PVOID addr) :mAddr(NULL), mProt(0) { if (IsBadWritePtr(addr, 1)) { mAddr = addr; VirtualProtect(addr, 1, PAGE_EXECUTE_READWRITE, &mProt); } } ~UnProtect() { DWORD dwOld; if (mAddr) VirtualProtect(mAddr, 1, mProt, &dwOld); }
PVOID mAddr; DWORD mProt;};
unsigned* g_DliHookExpected = NULL;size_t g_DliHookIndex = 0;#define LAST_DLI 333
static void SetExpectedDli(unsigned* order){ g_DliHookExpected = order; g_DliHookIndex = 0; g_Target[0] = '\0';}
static void CheckDli_imp(unsigned dliNotify, PDelayLoadInfo pdli, BOOL ErrorHandler){ if (!g_DliHookExpected) return;
winetest_ok(dliNotify == g_DliHookExpected[g_DliHookIndex], "Expected dliNotify to be %u, was: %u for %s\n", g_DliHookExpected[g_DliHookIndex], dliNotify, target(pdli)); if (ErrorHandler) { winetest_ok(dliNotify == dliFailGetProc || dliNotify == dliFailLoadLib, "Expected code %u to be processed by the Hook, not the ErrorHandler for %s\n", dliNotify, target(pdli)); } else { winetest_ok(dliNotify == dliStartProcessing || dliNotify == dliNotePreLoadLibrary || dliNotify == dliNotePreGetProcAddress || dliNotify == dliNoteEndProcessing, "Expected code %u to be processed by the ErrorHandler, not the Hook for %s\n", dliNotify, target(pdli)); } if (g_DliHookExpected[g_DliHookIndex] != LAST_DLI) g_DliHookIndex++;}
static void CheckDliDone_imp(){ if (!g_DliHookExpected) return; winetest_ok(LAST_DLI == g_DliHookExpected[g_DliHookIndex], "Expected g_DliHookExpected[g_DliHookIndex] to be %u, was: %u for %s\n", LAST_DLI, g_DliHookExpected[g_DliHookIndex], target(NULL)); g_DliHookExpected = NULL; g_Target[0] = '\0';}
#define CheckDli (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : CheckDli_imp#define CheckDliDone (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : CheckDliDone_imp
/* Replacement functions */INT_PTR WINAPI MyFunction(){ return 123;}
BOOL WINAPI MySfcIsKeyProtected(HKEY KeyHandle, LPCWSTR SubKeyName, REGSAM KeySam){ return 12345;}
static HMODULE g_VersionDll;FARPROC WINAPI DliHook(unsigned dliNotify, PDelayLoadInfo pdli){ ok(pdli && pdli->cb >= 36, "Expected a valid pointer with a struct that is big enough: %p, %lu\n", pdli, pdli ? pdli->cb : 0u); if (!pdli || pdli->cb < 36) return NULL;
CheckDli(dliNotify, pdli, FALSE);
if (g_BreakFunctionName && pdli->dlp.fImportByName) { g_BreakFunctionName = false; g_BrokenFunctionName = true; char* procname = (char*)pdli->dlp.szProcName; UnProtect prot(procname); char c = procname[0]; procname[0] = isupper(c) ? tolower(c) : toupper(c); }
/* Validate dll name when required */ if (g_ExpectedDll && g_ExpectedName && !g_BrokenFunctionName) { ok(!strcmp(g_ExpectedDll, pdli->szDll), "Expected szDll to be '%s', but was: '%s'\n", g_ExpectedDll, pdli->szDll); ok(pdli->dlp.fImportByName, "Expected import by name (%s!%s)\n", g_ExpectedDll, g_ExpectedName); if (pdli->dlp.fImportByName) { ok(!strcmp(g_ExpectedName, pdli->dlp.szProcName), "Expected szProcName to be '%s', but was: '%s'\n", g_ExpectedName, pdli->dlp.szProcName); } }
if (dliNotify == dliStartProcessing) { /* Test loadlib fail */ if (!_stricmp(pdli->szDll, "sfc_os.dll")) { char* dll = (char*)pdli->szDll; UnProtect u(dll); dll[0] = 'l'; dll[1] = '_'; dll[2] = 'm'; } if (!_stricmp(pdli->szDll, "imagehlp.dll")) { char* dll = (char*)pdli->szDll; UnProtect u(dll); dll[0] = 'x'; dll[1] = 'x'; dll[2] = 'x'; dll[3] = 'x'; dll[4] = 'x'; } /* Test bypass */ if (!_stricmp(pdli->szDll, "dbghelp.dll")) return MyFunction; } else if (dliNotify == dliNotePreLoadLibrary) { /* Show that this value is actually used! */ if (!_stricmp(pdli->szDll, "version.dll")) { g_VersionDll = LoadLibraryA("version.dll"); return (FARPROC)1; }
} else if (dliNotify == dliNotePreGetProcAddress) { if (pdli->dlp.fImportByName && !strcmp(pdli->dlp.szProcName, "SfcIsKeyProtected")) { return (FARPROC)MySfcIsKeyProtected; } }
/* Parameter validation */ ok(pdli->ppfn != NULL, "Expected ppfn to be valid, was NULL for %s\n", target(pdli)); ok(pdli->szDll != NULL, "Expected szDll to be valid, was NULL for %s\n", target(pdli)); ok(pdli->dwLastError == ERROR_SUCCESS, "Expected dwLastError to be ERROR_SUCCESS, was: %lu for %s\n", pdli->dwLastError, target(pdli)); ok(g_ImportByName == !!pdli->dlp.fImportByName, "Expected pdli->dlp.fImportByName to equal g_ImportByname\n"); if (pdli->dlp.fImportByName) ok(pdli->dlp.szProcName != NULL, "Expected szProcName to be valid, was NULL for %s\n", target(pdli)); else ok(pdli->dlp.dwOrdinal != 0, "Expected dwOrdinal to be valid, was NULL for %s\n", target(pdli)); switch(dliNotify) { case dliStartProcessing: ok(pdli->hmodCur == NULL, "Expected hmodCur to be NULL, was: %p for %s\n", pdli->hmodCur, target(pdli)); ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli)); break; case dliNotePreLoadLibrary: ok(pdli->hmodCur == NULL, "Expected hmodCur to be NULL, was: %p for %s\n", pdli->hmodCur, target(pdli)); ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli)); break; case dliNotePreGetProcAddress: ok(pdli->hmodCur != NULL, "Expected hmodCur to be valid, was NULL for %s\n", target(pdli)); ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli)); break; case dliNoteEndProcessing: if (!g_BypassMost) ok(pdli->hmodCur != NULL, "Expected hmodCur to be valid, was NULL for %s\n", target(pdli)); ok(pdli->pfnCur != NULL, "Expected pfnCur to be a valid pointer, was NULL for %s\n", target(pdli)); if (g_ExpectedDll && g_ExpectedName && !g_BrokenFunctionName) { FARPROC targetProc = GetProcAddress(GetModuleHandleA(g_ExpectedDll), g_ExpectedName); ok(targetProc != NULL, "This should not happen, the function i need is unavail! (%s!%s)\n", g_ExpectedDll, g_ExpectedName); ok(targetProc == pdli->pfnCur, "Expected pfnCur to be %p, was %p for %s\n", targetProc, pdli->pfnCur, target(pdli)); ok(pdli->ppfn && targetProc == *pdli->ppfn, "Expected ppfn to be valid and to result in %p, was: %p(%p) for %s\n", target, pdli->ppfn, pdli->ppfn ? *pdli->ppfn : NULL, target(pdli)); } break; default: break; } return NULL;}
FARPROC WINAPI DliFailHook(unsigned dliNotify, PDelayLoadInfo pdli){ ok(pdli && pdli->cb >= 36, "Expected a valid pointer with a struct that is big enough: %p, %lu\n", pdli, pdli ? pdli->cb : 0u); if (!pdli || pdli->cb < 36) return NULL;
CheckDli(dliNotify, pdli, TRUE);
/* Redirections / fixes */ if (dliNotify == dliFailLoadLib) { if (!_stricmp(pdli->szDll, "l_m_os.dll")) return (FARPROC)LoadLibraryA("sfc_os.dll"); } else if (dliNotify == dliFailGetProc) { if (pdli->dlp.fImportByName && pdli->hmodCur == (HMODULE)1) { return GetProcAddress(g_VersionDll, pdli->dlp.szProcName); } }
/* Parameter validation */ ok(pdli->ppfn != NULL, "Expected ppfn to be valid, was NULL for %s\n", target(pdli)); ok(pdli->szDll != NULL, "Expected szDll to be valid, was NULL for %s\n", target(pdli)); if (pdli->dlp.fImportByName) ok(pdli->dlp.szProcName != NULL, "Expected szProcName to be valid, was NULL for %s\n", target(pdli)); else ok(pdli->dlp.dwOrdinal != 0, "Expected dwOrdinal to be valid, was NULL for %s\n", target(pdli)); switch(dliNotify) { case dliFailLoadLib: ok(pdli->hmodCur == NULL, "Expected hmodCur to be NULL, was: %p for %s\n", pdli->hmodCur, target(pdli)); ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli)); ok(pdli->dwLastError == ERROR_MOD_NOT_FOUND, "Expected dwLastError to be ERROR_MOD_NOT_FOUND, was: %lu for %s\n", pdli->dwLastError, target(pdli)); break; case dliFailGetProc: ok(pdli->hmodCur != NULL, "Expected hmodCur to be valid, was NULL for %s\n", target(pdli)); ok(pdli->pfnCur == NULL, "Expected pfnCur to be NULL, was: %p for %s\n", pdli->pfnCur, target(pdli)); ok(pdli->dwLastError == ERROR_PROC_NOT_FOUND, "Expected dwLastError to be ERROR_PROC_NOT_FOUND, was: %lu for %s\n", pdli->dwLastError, target(pdli)); break; }
return NULL;}
LONG ExceptionFilter(IN PEXCEPTION_POINTERS ExceptionInfo, ULONG ExceptionCode){ DWORD expected = VcppException(ERROR_SEVERITY_ERROR, (g_ExceptionIsModule ? ERROR_MOD_NOT_FOUND : ERROR_PROC_NOT_FOUND)); ok(ExceptionCode == expected, "Expected code to be 0x%lx, was: 0x%lx\n", expected, ExceptionCode); ok(ExceptionInfo != NULL, "Expected to get exception info\n"); ok(ExceptionInfo->ExceptionRecord != NULL, "Expected to get a valid record info\n");
if (ExceptionCode != expected) { skip("Skipping other checks, this was not the exception we expected!\n"); return EXCEPTION_EXECUTE_HANDLER; }
if (ExceptionInfo && ExceptionInfo->ExceptionRecord) { PEXCEPTION_RECORD ExceptionRecord = ExceptionInfo->ExceptionRecord; ok(ExceptionRecord->ExceptionCode == expected, "Expected ExceptionCode to be 0x%lx, was 0x%lx\n", expected, ExceptionRecord->ExceptionCode); /* We can still continue. */ ok(ExceptionRecord->ExceptionFlags == 0, "Expected ExceptionFlags to be 0, was: 0x%lx\n", ExceptionRecord->ExceptionFlags); ok(ExceptionRecord->NumberParameters == 1, "Expected 1 parameter, got %lu\n", ExceptionRecord->NumberParameters); if (ExceptionRecord->NumberParameters == 1) { PDelayLoadInfo LoadInfo = (PDelayLoadInfo)ExceptionRecord->ExceptionInformation[0]; ok(LoadInfo && LoadInfo->cb >= 36, "Expected a valid pointer with a struct that is big enough: %p, %lu\n", LoadInfo, LoadInfo ? LoadInfo->cb : 0);
if (g_ExpectedDll) ok(!strcmp(g_ExpectedDll, LoadInfo->szDll), "Expected szDll to be '%s', but was: '%s'\n", g_ExpectedDll, LoadInfo->szDll); if (g_ExpectedName) { ok(LoadInfo->dlp.fImportByName, "Expected import by name\n"); if (LoadInfo->dlp.fImportByName) { ok(!strcmp(g_ExpectedName, LoadInfo->dlp.szProcName), "Expected szProcName to be '%s', but was: '%s'\n", g_ExpectedName, LoadInfo->dlp.szProcName);
if (g_ExceptionIsModule) { HMODULE mod = LoadLibraryA("imagehlp.dll"); LoadInfo->pfnCur = GetProcAddress(mod, g_ExpectedName); } else { char buf[100]; char first = isupper(g_ExpectedName[0]) ? tolower(g_ExpectedName[0]) : toupper(g_ExpectedName[0]); sprintf(buf, "%c%s", first, g_ExpectedName + 1); LoadInfo->pfnCur = GetProcAddress(GetModuleHandleA(g_ExpectedDll), buf); } return LoadInfo->pfnCur ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_EXECUTE_HANDLER; } } } }
return EXCEPTION_EXECUTE_HANDLER;}
/* We register one hook the 'default' way and one manually,so that we can check that both fallback and registration work*/extern "C"{ extern PfnDliHook __pfnDliNotifyHook2; //PfnDliHook __pfnDliFailureHook2 = DliFailHook;}
bool g_UsePointers = false;
template<typename PTR>PTR Rva2Addr(PIMAGE_DOS_HEADER dos, RVA rva){ /* Old delayload type */ if (g_UsePointers) return reinterpret_cast<PTR>(rva); return reinterpret_cast<PTR>((reinterpret_cast<PBYTE>(dos) + rva));}
unsigned g_winmm_get_cur_task[] = { dliStartProcessing, dliNotePreLoadLibrary, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI };unsigned g_winmm_midi_out_close[] = { dliStartProcessing, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI };unsigned g_winmm_mide_in_close[] = { dliStartProcessing, dliNotePreGetProcAddress, dliFailGetProc, dliNoteEndProcessing, LAST_DLI };unsigned g_sfc_key[] = { dliStartProcessing, dliNotePreLoadLibrary, dliFailLoadLib, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI };unsigned g_sfc_file[] = { dliStartProcessing, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI };unsigned g_version_a[] = { dliStartProcessing, dliNotePreLoadLibrary, dliNotePreGetProcAddress, dliFailGetProc, dliNoteEndProcessing, LAST_DLI };unsigned g_version_w[] = { dliStartProcessing, dliNotePreGetProcAddress, dliFailGetProc, dliNoteEndProcessing, LAST_DLI };unsigned g_scard[] = { dliStartProcessing, dliNoteEndProcessing, LAST_DLI };unsigned g_shlwapi[] = { dliStartProcessing, dliNotePreLoadLibrary, dliNotePreGetProcAddress, dliNoteEndProcessing, LAST_DLI };unsigned g_imagehlp[] = { dliStartProcessing, dliNotePreLoadLibrary, dliFailLoadLib, LAST_DLI }; /* This exception does not fire EndProcessing! */
//#define DELAYLOAD_SUPPORTS_UNLOADINGSTART_TEST(delayimp){ __pfnDliNotifyHook2 = DliHook; /* Verify that both scenario's work */ ok(__pfnDliNotifyHook2 == DliHook, "Expected __pfnDliNotifyHook2 to be DliHook(%p), but was: %p\n", DliHook, __pfnDliNotifyHook2); ok(__pfnDliFailureHook2 == NULL, "Expected __pfnDliFailureHook2 to be NULL, but was: %p\n", __pfnDliFailureHook2);
__pfnDliFailureHook2 = DliFailHook;
PIMAGE_DOS_HEADER dos = (PIMAGE_DOS_HEADER)GetModuleHandle(NULL);
ok(dos->e_magic == IMAGE_DOS_SIGNATURE, "Expected a DOS header\n"); if (dos->e_magic != IMAGE_DOS_SIGNATURE) return;
PIMAGE_NT_HEADERS nt = (PIMAGE_NT_HEADERS)((PBYTE)dos + dos->e_lfanew); PIMAGE_DATA_DIRECTORY delaydir = nt->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT;
/* Test some advanced features (loading / unloading) */ if (delaydir->Size != 0) {#if defined(_DELAY_IMP_VER) && _DELAY_IMP_VER == 2 && defined(DELAYLOAD_SUPPORTS_UNLOADING) /* First, before mangling the delayload stuff, let's try some v2 functions */ HMODULE mod = GetModuleHandleA(WINMM_DLLNAME); ok(mod == NULL, "Expected mod to be NULL, was %p\n", mod); /* Now, a mistyped module (case sensitive!) */ HRESULT hr = __HrLoadAllImportsForDll("WiNmM.DlL"); ok(hr == HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND), "Expected hr to be HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND), was %lu\n", hr); mod = GetModuleHandleA(WINMM_DLLNAME); ok(mod == NULL, "Expected mod to be NULL, was %p\n", mod);
/* Let's load it */ hr = __HrLoadAllImportsForDll(WINMM_DLLNAME); ok(hr == S_OK, "Expected hr to be S_OK, was %lu\n", hr); mod = GetModuleHandleA(WINMM_DLLNAME); ok(mod != NULL, "Expected mod to be valid, was NULL\n");
BOOL status = __FUnloadDelayLoadedDLL2(WINMM_DLLNAME); ok(status == TRUE, "Expected __FUnloadDelayLoadedDLL2 to succeed\n"); mod = GetModuleHandleA(WINMM_DLLNAME); ok(mod == NULL, "Expected mod to be NULL, was %p\n", mod);#else trace("Binary compiled without support for unloading\n");#endif } else { skip("No IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT found, some advanced features might not work!\n"); }
/* Test the normal flow without a dll loaded */ SetExpectedDli(g_winmm_get_cur_task); g_ExpectedDll = WINMM_DLLNAME; g_ExpectedName = "mmGetCurrentTask"; DWORD task = mmGetCurrentTask(); ok(task == GetCurrentThreadId(), "Expected ret to be current thread id (0x%lx), was 0x%lx\n", GetCurrentThreadId(), task); CheckDliDone();
/* Test the normal flow with a dll loaded */ SetExpectedDli(g_winmm_midi_out_close); g_ExpectedDll = WINMM_DLLNAME; g_ExpectedName = "midiOutClose"; DWORD err = midiOutClose((HMIDIOUT)(ULONG_PTR)0xdeadbeef); ok(err == MMSYSERR_INVALHANDLE, "Expected err to be MMSYSERR_INVALHANDLE, was 0x%lx\n", err); CheckDliDone();
/* Make sure GetProcAddress fails, also ignore the Failure hook, use the exception to set the address */ SetExpectedDli(g_winmm_mide_in_close); g_ExpectedDll = WINMM_DLLNAME; g_ExpectedName = "MixerClose"; g_BreakFunctionName = true; _SEH2_TRY { err = mixerClose((HMIXER)(ULONG_PTR)0xdeadbeef); } _SEH2_EXCEPT(ExceptionFilter(_SEH2_GetExceptionInformation(), _SEH2_GetExceptionCode())) { err = _SEH2_GetExceptionCode(); } _SEH2_END; ok(err == MMSYSERR_INVALHANDLE, "Expected err to be MMSYSERR_INVALHANDLE, was 0x%lx\n", err); CheckDliDone(); ok(g_BreakFunctionName == false, "Expected the functionname to be changed\n");
/* Make the LoadLib fail, manually load the library in the Failure Hook, Respond to the dliNotePreGetProcAddress with an alternate function address */ SetExpectedDli(g_sfc_key); BOOL ret = SfcIsKeyProtected(NULL, NULL, NULL); ok(ret == 12345, "Expected ret to be 12345, was %u\n", ret); /* The original function returns FALSE! */ CheckDliDone();
/* Show that it works with the manually returned dll */ SetExpectedDli(g_sfc_file); ret = SfcGetNextProtectedFile(NULL, NULL); ok(ret == FALSE, "Expected ret to be FALSE, was %u\n", ret); CheckDliDone();
/* Return a fake dll handle, so that we can see when it is being used, and manually return a function in the Failure Hook */ SetExpectedDli(g_version_a); ret = GetFileVersionInfoA(NULL, NULL, NULL, NULL); ok(ret == FALSE, "Expected ret to be FALSE, was %u\n", ret); CheckDliDone();
/* Manually return a function in the failure hook, when the module is the previously set bad one */ SetExpectedDli(g_version_w); ret = GetFileVersionInfoW(NULL, NULL, NULL, NULL); ok(ret == FALSE, "Expected ret to be FALSE, was %u\n", ret); CheckDliDone();
if (HIWORD(SymGetOptions) == NULL) { skip("SymGetOptions until CORE-6504 is fixed\n"); } else { /* Completely bypass most hooks, by directly replying with a function address */ SetExpectedDli(g_scard); g_BypassMost = true; DWORD opt = SymGetOptions(); g_BypassMost = false; ok(opt == 123, "Expected opt to be 123, was %lu\n", opt); /* The original function returns ERROR_INVALID_HANDLE */ CheckDliDone(); }
/* Import by ordinal */ g_ImportByName = false; SetExpectedDli(g_shlwapi); PARSEDURLA pua = { sizeof(pua), 0 }; HRESULT hr = ParseURLA("", &pua); ok(hr == URL_E_INVALID_SYNTAX, "Expected tmp to be URL_E_INVALID_SYNTAX, was %lx\n", hr); CheckDliDone(); g_ImportByName = true;
/* Handle LoadLib failure with an exception handler */ if (HIWORD(MapAndLoad) == NULL) { skip("MapAndLoad until CORE-6504 is fixed\n"); } else { SetExpectedDli(g_imagehlp); LOADED_IMAGE img = {0}; ret = 123; g_ExceptionIsModule = true; g_ExpectedDll = "xxxxxhlp.dll"; g_ExpectedName = "MapAndLoad"; _SEH2_TRY { ret = MapAndLoad("some_not_existing_file.aabbcc", NULL, &img, FALSE, TRUE); } _SEH2_EXCEPT(ExceptionFilter(_SEH2_GetExceptionInformation(), _SEH2_GetExceptionCode())) { ; } _SEH2_END; g_ExceptionIsModule = false; ok(ret == FALSE, "Expected ret to be FALSE, was %u\n", ret); CheckDliDone(); }}