ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

imm32/tests: Enable compilation with long types. 

Signed-off-by: Eric Pouech <eric.pouech@gmail.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Eric Pouech 2022-02-28 08:26:39 +01:00 committed by Alexandre Julliard
parent a24f29cd37
commit afd2e6c840
2 changed files with 103 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dlls/imm32/tests/Makefile.in
View File

@ -1,4 +1,3 @@
EXTRADEFS = -DWINE_NO_LONG_TYPES
TESTDLL = imm32.dll TESTDLL = imm32.dll
IMPORTS = imm32 ole32 user32 IMPORTS = imm32 ole32 user32

206
dlls/imm32/tests/imm32.c
View File

@ -219,7 +219,7 @@ static LRESULT WINAPI wndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
case WM_IME_SETCONTEXT: case WM_IME_SETCONTEXT:
if (wParam) CHECK_EXPECT(WM_IME_SETCONTEXT_ACTIVATE); if (wParam) CHECK_EXPECT(WM_IME_SETCONTEXT_ACTIVATE);
else CHECK_EXPECT(WM_IME_SETCONTEXT_DEACTIVATE); else CHECK_EXPECT(WM_IME_SETCONTEXT_DEACTIVATE);
ok(lParam == ISC_SHOWUIALL || !lParam, "lParam = %lx\n", lParam); ok(lParam == ISC_SHOWUIALL || !lParam, "lParam = %Ix\n", lParam);
return TRUE; return TRUE;
case WM_NCCREATE: case WM_NCCREATE:
default_ime_wnd = get_ime_window(); default_ime_wnd = get_ime_window();
@ -441,7 +441,7 @@ static LRESULT WINAPI test_ime_wnd_proc(HWND hWnd, UINT msg, WPARAM wParam, LPAR
imc = ImmGetContext(hWnd); imc = ImmGetContext(hWnd);
size = ImmGetCompositionStringW(imc, GCS_RESULTSTR, size = ImmGetCompositionStringW(imc, GCS_RESULTSTR,
wstring, sizeof(wstring)); wstring, sizeof(wstring));
ok(size > 0, "ImmGetCompositionString(GCS_RESULTSTR) is %d\n", size); ok(size > 0, "ImmGetCompositionString(GCS_RESULTSTR) is %ld\n", size);
ImmReleaseContext(hwnd, imc); ImmReleaseContext(hwnd, imc);
ime_composition_test.catch_result_str = TRUE; ime_composition_test.catch_result_str = TRUE;
@ -507,11 +507,11 @@ static void test_ImmGetCompositionString(void)
memset(cstring, 0x1a, sizeof(cstring)); memset(cstring, 0x1a, sizeof(cstring));
len = ImmGetCompositionStringA(imc, GCS_COMPSTR, cstring, alen); len = ImmGetCompositionStringA(imc, GCS_COMPSTR, cstring, alen);
ok(len == alen, "Unexpected length %d.\n", len); ok(len == alen, "Unexpected length %ld.\n", len);
ok(cstring[alen] == 0x1a, "Unexpected buffer contents.\n"); ok(cstring[alen] == 0x1a, "Unexpected buffer contents.\n");
len = ImmGetCompositionStringW(imc, GCS_COMPSTR, wstring, wlen); len = ImmGetCompositionStringW(imc, GCS_COMPSTR, wstring, wlen);
ok(len == wlen, "Unexpected length %d.\n", len); ok(len == wlen, "Unexpected length %ld.\n", len);
ok(wstring[wlen/sizeof(WCHAR)] == 0x1a1a, "Unexpected buffer contents.\n"); ok(wstring[wlen/sizeof(WCHAR)] == 0x1a1a, "Unexpected buffer contents.\n");
/* Get strings with exactly smaller buffer sizes. */ /* Get strings with exactly smaller buffer sizes. */
@ -520,11 +520,11 @@ static void test_ImmGetCompositionString(void)
/* Returns 0 but still fills buffer. */ /* Returns 0 but still fills buffer. */
len = ImmGetCompositionStringA(imc, GCS_COMPSTR, cstring, alen - 1); len = ImmGetCompositionStringA(imc, GCS_COMPSTR, cstring, alen - 1);
ok(!len, "Unexpected length %d.\n", len); ok(!len, "Unexpected length %ld.\n", len);
ok(cstring[0] == 'w', "Unexpected buffer contents %s.\n", cstring); ok(cstring[0] == 'w', "Unexpected buffer contents %s.\n", cstring);
len = ImmGetCompositionStringW(imc, GCS_COMPSTR, wstring, wlen - 1); len = ImmGetCompositionStringW(imc, GCS_COMPSTR, wstring, wlen - 1);
ok(len == wlen - 1, "Unexpected length %d.\n", len); ok(len == wlen - 1, "Unexpected length %ld.\n", len);
ok(!memcmp(wstring, string, wlen - 1), "Unexpected buffer contents.\n"); ok(!memcmp(wstring, string, wlen - 1), "Unexpected buffer contents.\n");
/* Get the size of the required output buffer. */ /* Get the size of the required output buffer. */
@ -532,11 +532,11 @@ static void test_ImmGetCompositionString(void)
memset(cstring, 0x1a, sizeof(cstring)); memset(cstring, 0x1a, sizeof(cstring));
len = ImmGetCompositionStringA(imc, GCS_COMPSTR, cstring, 0); len = ImmGetCompositionStringA(imc, GCS_COMPSTR, cstring, 0);
ok(len == alen, "Unexpected length %d.\n", len); ok(len == alen, "Unexpected length %ld.\n", len);
ok(cstring[0] == 0x1a, "Unexpected buffer contents %s.\n", cstring); ok(cstring[0] == 0x1a, "Unexpected buffer contents %s.\n", cstring);
len = ImmGetCompositionStringW(imc, GCS_COMPSTR, wstring, 0); len = ImmGetCompositionStringW(imc, GCS_COMPSTR, wstring, 0);
ok(len == wlen, "Unexpected length %d.\n", len); ok(len == wlen, "Unexpected length %ld.\n", len);
ok(wstring[0] == 0x1a1a, "Unexpected buffer contents.\n"); ok(wstring[0] == 0x1a1a, "Unexpected buffer contents.\n");
} }
else else
@ -623,7 +623,7 @@ static void test_ImmSetCompositionString(void)
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
imc = ImmGetContext(hwnd); imc = ImmGetContext(hwnd);
ok(imc != 0, "ImmGetContext() failed. Last error: %u\n", GetLastError()); ok(imc != 0, "ImmGetContext() failed. Last error: %lu\n", GetLastError());
if (!imc) if (!imc)
return; return;
@ -1077,7 +1077,7 @@ static void test_ImmGetContext(void)
himc = ImmGetContext((HWND)0xffffffff); himc = ImmGetContext((HWND)0xffffffff);
err = GetLastError(); err = GetLastError();
ok(himc == NULL, "ImmGetContext succeeded\n"); ok(himc == NULL, "ImmGetContext succeeded\n");
ok(err == ERROR_INVALID_WINDOW_HANDLE, "got %u\n", err); ok(err == ERROR_INVALID_WINDOW_HANDLE, "got %lu\n", err);
himc = ImmGetContext(hwnd); himc = ImmGetContext(hwnd);
ok(himc != NULL, "ImmGetContext failed\n"); ok(himc != NULL, "ImmGetContext failed\n");
@ -1184,9 +1184,9 @@ static void test_ImmDefaultHwnd(void)
GetWindowTextA(def1, title, sizeof(title)); GetWindowTextA(def1, title, sizeof(title));
ok(!strcmp(title, "Default IME"), "got %s\n", title); ok(!strcmp(title, "Default IME"), "got %s\n", title);
style = GetWindowLongA(def1, GWL_STYLE); style = GetWindowLongA(def1, GWL_STYLE);
ok(style == (WS_DISABLED | WS_POPUP | WS_CLIPSIBLINGS), "got %08x\n", style); ok(style == (WS_DISABLED | WS_POPUP | WS_CLIPSIBLINGS), "got %08lx\n", style);
style = GetWindowLongA(def1, GWL_EXSTYLE); style = GetWindowLongA(def1, GWL_EXSTYLE);
ok(style == 0, "got %08x\n", style); ok(style == 0, "got %08lx\n", style);
imc2 = ImmCreateContext(); imc2 = ImmCreateContext();
ImmSetOpenStatus(imc2, TRUE); ImmSetOpenStatus(imc2, TRUE);
@ -1379,7 +1379,7 @@ static void test_default_ime_window_creation(void)
for (i = 0; i < ARRAY_SIZE(testcases); i++) for (i = 0; i < ARRAY_SIZE(testcases); i++)
{ {
thread = CreateThread(NULL, 0, test_default_ime_window_cb, &testcases[i], 0, NULL); thread = CreateThread(NULL, 0, test_default_ime_window_cb, &testcases[i], 0, NULL);
ok(thread != NULL, "CreateThread failed with error %u\n", GetLastError()); ok(thread != NULL, "CreateThread failed with error %lu\n", GetLastError());
while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_ALLINPUT) == WAIT_OBJECT_0 + 1) while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_ALLINPUT) == WAIT_OBJECT_0 + 1)
{ {
MSG msg; MSG msg;
@ -1394,7 +1394,7 @@ static void test_default_ime_window_creation(void)
if (testcases[i].top_level_window) if (testcases[i].top_level_window)
{ {
thread = CreateThread(NULL, 0, test_default_ime_window_cancel_cb, &testcases[i], 0, NULL); thread = CreateThread(NULL, 0, test_default_ime_window_cancel_cb, &testcases[i], 0, NULL);
ok(thread != NULL, "CreateThread failed with error %u\n", GetLastError()); ok(thread != NULL, "CreateThread failed with error %lu\n", GetLastError());
WaitForSingleObject(thread, INFINITE); WaitForSingleObject(thread, INFINITE);
CloseHandle(thread); CloseHandle(thread);
} }
@ -1423,32 +1423,32 @@ static void test_ImmGetIMCLockCount(void)
count = ImmGetIMCLockCount((HIMC)0xdeadcafe); count = ImmGetIMCLockCount((HIMC)0xdeadcafe);
ok(count == 0, "Invalid IMC should return 0\n"); ok(count == 0, "Invalid IMC should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
count = ImmGetIMCLockCount(0x00000000); count = ImmGetIMCLockCount(0x00000000);
ok(count == 0, "NULL IMC should return 0\n"); ok(count == 0, "NULL IMC should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "Last Error should remain unchanged: %08x\n",ret); ok(ret == 0xdeadbeef, "Last Error should remain unchanged: %08lx\n",ret);
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
ok(count == 0, "Destroyed IMC should return 0\n"); ok(count == 0, "Destroyed IMC should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
imc = ImmCreateContext(); imc = ImmCreateContext();
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
ok(count == 0, "expect 0, returned %d\n", count); ok(count == 0, "expect 0, returned %ld\n", count);
ic = ImmLockIMC(imc); ic = ImmLockIMC(imc);
ok(ic != NULL, "ImmLockIMC failed!\n"); ok(ic != NULL, "ImmLockIMC failed!\n");
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
ok(count == 1, "expect 1, returned %d\n", count); ok(count == 1, "expect 1, returned %ld\n", count);
ret = ImmUnlockIMC(imc); ret = ImmUnlockIMC(imc);
ok(ret == TRUE, "expect TRUE, ret %d\n", ret); ok(ret == TRUE, "expect TRUE, ret %ld\n", ret);
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
ok(count == 0, "expect 0, returned %d\n", count); ok(count == 0, "expect 0, returned %ld\n", count);
ret = ImmUnlockIMC(imc); ret = ImmUnlockIMC(imc);
ok(ret == TRUE, "expect TRUE, ret %d\n", ret); ok(ret == TRUE, "expect TRUE, ret %ld\n", ret);
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
ok(count == 0, "expect 0, returned %d\n", count); ok(count == 0, "expect 0, returned %ld\n", count);
for (i = 0; i < GMEM_LOCKCOUNT * 2; i++) for (i = 0; i < GMEM_LOCKCOUNT * 2; i++)
{ {
@ -1456,15 +1456,15 @@ static void test_ImmGetIMCLockCount(void)
ok(ic != NULL, "ImmLockIMC failed!\n"); ok(ic != NULL, "ImmLockIMC failed!\n");
} }
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
todo_wine ok(count == GMEM_LOCKCOUNT, "expect GMEM_LOCKCOUNT, returned %d\n", count); todo_wine ok(count == GMEM_LOCKCOUNT, "expect GMEM_LOCKCOUNT, returned %ld\n", count);
for (i = 0; i < GMEM_LOCKCOUNT - 1; i++) for (i = 0; i < GMEM_LOCKCOUNT - 1; i++)
ImmUnlockIMC(imc); ImmUnlockIMC(imc);
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
todo_wine ok(count == 1, "expect 1, returned %d\n", count); todo_wine ok(count == 1, "expect 1, returned %ld\n", count);
ImmUnlockIMC(imc); ImmUnlockIMC(imc);
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
todo_wine ok(count == 0, "expect 0, returned %d\n", count); todo_wine ok(count == 0, "expect 0, returned %ld\n", count);
ImmDestroyContext(imc); ImmDestroyContext(imc);
} }
@ -1478,18 +1478,18 @@ static void test_ImmGetIMCCLockCount(void)
imcc = ImmCreateIMCC(sizeof(CANDIDATEINFO)); imcc = ImmCreateIMCC(sizeof(CANDIDATEINFO));
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
ok(count == 0, "expect 0, returned %d\n", count); ok(count == 0, "expect 0, returned %ld\n", count);
ImmLockIMCC(imcc); ImmLockIMCC(imcc);
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
ok(count == 1, "expect 1, returned %d\n", count); ok(count == 1, "expect 1, returned %ld\n", count);
ret = ImmUnlockIMCC(imcc); ret = ImmUnlockIMCC(imcc);
ok(ret == FALSE, "expect FALSE, ret %d\n", ret); ok(ret == FALSE, "expect FALSE, ret %d\n", ret);
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
ok(count == 0, "expect 0, returned %d\n", count); ok(count == 0, "expect 0, returned %ld\n", count);
ret = ImmUnlockIMCC(imcc); ret = ImmUnlockIMCC(imcc);
ok(ret == FALSE, "expect FALSE, ret %d\n", ret); ok(ret == FALSE, "expect FALSE, ret %d\n", ret);
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
ok(count == 0, "expect 0, returned %d\n", count); ok(count == 0, "expect 0, returned %ld\n", count);
p = ImmLockIMCC(imcc); p = ImmLockIMCC(imcc);
ok(GlobalHandle(p) == imcc, "expect %p, returned %p\n", imcc, GlobalHandle(p)); ok(GlobalHandle(p) == imcc, "expect %p, returned %p\n", imcc, GlobalHandle(p));
@ -1499,18 +1499,18 @@ static void test_ImmGetIMCCLockCount(void)
ImmLockIMCC(imcc); ImmLockIMCC(imcc);
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
g_count = GlobalFlags(imcc) & GMEM_LOCKCOUNT; g_count = GlobalFlags(imcc) & GMEM_LOCKCOUNT;
ok(count == g_count, "count %d, g_count %d\n", count, g_count); ok(count == g_count, "count %ld, g_count %ld\n", count, g_count);
} }
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
ok(count == GMEM_LOCKCOUNT, "expect GMEM_LOCKCOUNT, returned %d\n", count); ok(count == GMEM_LOCKCOUNT, "expect GMEM_LOCKCOUNT, returned %ld\n", count);
for (i = 0; i < GMEM_LOCKCOUNT - 1; i++) for (i = 0; i < GMEM_LOCKCOUNT - 1; i++)
GlobalUnlock(imcc); GlobalUnlock(imcc);
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
ok(count == 1, "expect 1, returned %d\n", count); ok(count == 1, "expect 1, returned %ld\n", count);
GlobalUnlock(imcc); GlobalUnlock(imcc);
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
ok(count == 0, "expect 0, returned %d\n", count); ok(count == 0, "expect 0, returned %ld\n", count);
ImmDestroyIMCC(imcc); ImmDestroyIMCC(imcc);
} }
@ -1523,11 +1523,11 @@ static void test_ImmDestroyContext(void)
imc = ImmCreateContext(); imc = ImmCreateContext();
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
ok(count == 0, "expect 0, returned %d\n", count); ok(count == 0, "expect 0, returned %ld\n", count);
ic = ImmLockIMC(imc); ic = ImmLockIMC(imc);
ok(ic != NULL, "ImmLockIMC failed!\n"); ok(ic != NULL, "ImmLockIMC failed!\n");
count = ImmGetIMCLockCount(imc); count = ImmGetIMCLockCount(imc);
ok(count == 1, "expect 1, returned %d\n", count); ok(count == 1, "expect 1, returned %ld\n", count);
ret = ImmDestroyContext(imc); ret = ImmDestroyContext(imc);
ok(ret == TRUE, "Destroy a locked IMC should success!\n"); ok(ret == TRUE, "Destroy a locked IMC should success!\n");
ic = ImmLockIMC(imc); ic = ImmLockIMC(imc);
@ -1540,7 +1540,7 @@ static void test_ImmDestroyContext(void)
ret = ImmDestroyContext(imc); ret = ImmDestroyContext(imc);
ok(ret == FALSE, "Destroy a destroyed IMC should fail!\n"); ok(ret == FALSE, "Destroy a destroyed IMC should fail!\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
} }
static void test_ImmDestroyIMCC(void) static void test_ImmDestroyIMCC(void)
@ -1551,13 +1551,13 @@ static void test_ImmDestroyIMCC(void)
imcc = ImmCreateIMCC(sizeof(CANDIDATEINFO)); imcc = ImmCreateIMCC(sizeof(CANDIDATEINFO));
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
ok(count == 0, "expect 0, returned %d\n", count); ok(count == 0, "expect 0, returned %ld\n", count);
p = ImmLockIMCC(imcc); p = ImmLockIMCC(imcc);
ok(p != NULL, "ImmLockIMCC failed!\n"); ok(p != NULL, "ImmLockIMCC failed!\n");
count = ImmGetIMCCLockCount(imcc); count = ImmGetIMCCLockCount(imcc);
ok(count == 1, "expect 1, returned %d\n", count); ok(count == 1, "expect 1, returned %ld\n", count);
size = ImmGetIMCCSize(imcc); size = ImmGetIMCCSize(imcc);
ok(size == sizeof(CANDIDATEINFO), "returned %d\n", size); ok(size == sizeof(CANDIDATEINFO), "returned %ld\n", size);
p = ImmDestroyIMCC(imcc); p = ImmDestroyIMCC(imcc);
ok(p == NULL, "Destroy a locked IMCC should success!\n"); ok(p == NULL, "Destroy a locked IMCC should success!\n");
p = ImmLockIMCC(imcc); p = ImmLockIMCC(imcc);
@ -1572,7 +1572,7 @@ static void test_ImmDestroyIMCC(void)
p = ImmDestroyIMCC(imcc); p = ImmDestroyIMCC(imcc);
ok(p != NULL, "returned NULL\n"); ok(p != NULL, "returned NULL\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
} }
static void test_ImmMessages(void) static void test_ImmMessages(void)
@ -1807,7 +1807,7 @@ static void test_InvalidIMC(void)
oldimc = ImmAssociateContext(hwnd, imc_destroy); oldimc = ImmAssociateContext(hwnd, imc_destroy);
ok(!oldimc, "Associating to a destroyed imc should fail!\n"); ok(!oldimc, "Associating to a destroyed imc should fail!\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
imc2 = ImmGetContext(hwnd); imc2 = ImmGetContext(hwnd);
ok(imc1 == imc2, "imc should not changed! imc1 %p, imc2 %p\n", imc1, imc2); ok(imc1 == imc2, "imc should not changed! imc1 %p, imc2 %p\n", imc1, imc2);
@ -1838,7 +1838,7 @@ static void test_InvalidIMC(void)
oldimc = ImmAssociateContext(hwnd, imc_bad); oldimc = ImmAssociateContext(hwnd, imc_bad);
ok(!oldimc, "Associating to a destroyed imc should fail!\n"); ok(!oldimc, "Associating to a destroyed imc should fail!\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
imc2 = ImmGetContext(hwnd); imc2 = ImmGetContext(hwnd);
ok(imc1 == imc2, "imc should not changed! imc1 %p, imc2 %p\n", imc1, imc2); ok(imc1 == imc2, "imc should not changed! imc1 %p, imc2 %p\n", imc1, imc2);
@ -1848,306 +1848,306 @@ static void test_InvalidIMC(void)
ret = ImmGetCandidateListA(imc_bad, 0, NULL, 0); ret = ImmGetCandidateListA(imc_bad, 0, NULL, 0);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCandidateListA(imc_null, 0, NULL, 0); ret = ImmGetCandidateListA(imc_null, 0, NULL, 0);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCandidateListA(imc_destroy, 0, NULL, 0); ret = ImmGetCandidateListA(imc_destroy, 0, NULL, 0);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmGetCandidateListCountA*/ /* Test ImmGetCandidateListCountA*/
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCandidateListCountA(imc_bad,&count); ret = ImmGetCandidateListCountA(imc_bad,&count);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCandidateListCountA(imc_null,&count); ret = ImmGetCandidateListCountA(imc_null,&count);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCandidateListCountA(imc_destroy,&count); ret = ImmGetCandidateListCountA(imc_destroy,&count);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmGetCandidateWindow */ /* Test ImmGetCandidateWindow */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCandidateWindow(imc_bad, 0, (LPCANDIDATEFORM)buffer); ret = ImmGetCandidateWindow(imc_bad, 0, (LPCANDIDATEFORM)buffer);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCandidateWindow(imc_null, 0, (LPCANDIDATEFORM)buffer); ret = ImmGetCandidateWindow(imc_null, 0, (LPCANDIDATEFORM)buffer);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCandidateWindow(imc_destroy, 0, (LPCANDIDATEFORM)buffer); ret = ImmGetCandidateWindow(imc_destroy, 0, (LPCANDIDATEFORM)buffer);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmGetCompositionFontA */ /* Test ImmGetCompositionFontA */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCompositionFontA(imc_bad, (LPLOGFONTA)buffer); ret = ImmGetCompositionFontA(imc_bad, (LPLOGFONTA)buffer);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCompositionFontA(imc_null, (LPLOGFONTA)buffer); ret = ImmGetCompositionFontA(imc_null, (LPLOGFONTA)buffer);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCompositionFontA(imc_destroy, (LPLOGFONTA)buffer); ret = ImmGetCompositionFontA(imc_destroy, (LPLOGFONTA)buffer);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmGetCompositionWindow */ /* Test ImmGetCompositionWindow */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCompositionWindow(imc_bad, (LPCOMPOSITIONFORM)buffer); ret = ImmGetCompositionWindow(imc_bad, (LPCOMPOSITIONFORM)buffer);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCompositionWindow(imc_null, (LPCOMPOSITIONFORM)buffer); ret = ImmGetCompositionWindow(imc_null, (LPCOMPOSITIONFORM)buffer);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCompositionWindow(imc_destroy, (LPCOMPOSITIONFORM)buffer); ret = ImmGetCompositionWindow(imc_destroy, (LPCOMPOSITIONFORM)buffer);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmGetCompositionStringA */ /* Test ImmGetCompositionStringA */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCompositionStringA(imc_bad, GCS_COMPSTR, NULL, 0); ret = ImmGetCompositionStringA(imc_bad, GCS_COMPSTR, NULL, 0);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCompositionStringA(imc_null, GCS_COMPSTR, NULL, 0); ret = ImmGetCompositionStringA(imc_null, GCS_COMPSTR, NULL, 0);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetCompositionStringA(imc_destroy, GCS_COMPSTR, NULL, 0); ret = ImmGetCompositionStringA(imc_destroy, GCS_COMPSTR, NULL, 0);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmSetOpenStatus */ /* Test ImmSetOpenStatus */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetOpenStatus(imc_bad, 1); ret = ImmSetOpenStatus(imc_bad, 1);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetOpenStatus(imc_null, 1); ret = ImmSetOpenStatus(imc_null, 1);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetOpenStatus(imc_destroy, 1); ret = ImmSetOpenStatus(imc_destroy, 1);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmGetOpenStatus */ /* Test ImmGetOpenStatus */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetOpenStatus(imc_bad); ret = ImmGetOpenStatus(imc_bad);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetOpenStatus(imc_null); ret = ImmGetOpenStatus(imc_null);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetOpenStatus(imc_destroy); ret = ImmGetOpenStatus(imc_destroy);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmGetStatusWindowPos */ /* Test ImmGetStatusWindowPos */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetStatusWindowPos(imc_bad, NULL); ret = ImmGetStatusWindowPos(imc_bad, NULL);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetStatusWindowPos(imc_null, NULL); ret = ImmGetStatusWindowPos(imc_null, NULL);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetStatusWindowPos(imc_destroy, NULL); ret = ImmGetStatusWindowPos(imc_destroy, NULL);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmRequestMessageA */ /* Test ImmRequestMessageA */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmRequestMessageA(imc_bad, WM_CHAR, 0); ret = ImmRequestMessageA(imc_bad, WM_CHAR, 0);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmRequestMessageA(imc_null, WM_CHAR, 0); ret = ImmRequestMessageA(imc_null, WM_CHAR, 0);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmRequestMessageA(imc_destroy, WM_CHAR, 0); ret = ImmRequestMessageA(imc_destroy, WM_CHAR, 0);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmSetCompositionFontA */ /* Test ImmSetCompositionFontA */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetCompositionFontA(imc_bad, &lf); ret = ImmSetCompositionFontA(imc_bad, &lf);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetCompositionFontA(imc_null, &lf); ret = ImmSetCompositionFontA(imc_null, &lf);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetCompositionFontA(imc_destroy, &lf); ret = ImmSetCompositionFontA(imc_destroy, &lf);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmSetCompositionWindow */ /* Test ImmSetCompositionWindow */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetCompositionWindow(imc_bad, NULL); ret = ImmSetCompositionWindow(imc_bad, NULL);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetCompositionWindow(imc_null, NULL); ret = ImmSetCompositionWindow(imc_null, NULL);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetCompositionWindow(imc_destroy, NULL); ret = ImmSetCompositionWindow(imc_destroy, NULL);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmSetConversionStatus */ /* Test ImmSetConversionStatus */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetConversionStatus(imc_bad, 0, 0); ret = ImmSetConversionStatus(imc_bad, 0, 0);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetConversionStatus(imc_null, 0, 0); ret = ImmSetConversionStatus(imc_null, 0, 0);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetConversionStatus(imc_destroy, 0, 0); ret = ImmSetConversionStatus(imc_destroy, 0, 0);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmSetStatusWindowPos */ /* Test ImmSetStatusWindowPos */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetStatusWindowPos(imc_bad, 0); ret = ImmSetStatusWindowPos(imc_bad, 0);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetStatusWindowPos(imc_null, 0); ret = ImmSetStatusWindowPos(imc_null, 0);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmSetStatusWindowPos(imc_destroy, 0); ret = ImmSetStatusWindowPos(imc_destroy, 0);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmGetImeMenuItemsA */ /* Test ImmGetImeMenuItemsA */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetImeMenuItemsA(imc_bad, 0, 0, NULL, NULL, 0); ret = ImmGetImeMenuItemsA(imc_bad, 0, 0, NULL, NULL, 0);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetImeMenuItemsA(imc_null, 0, 0, NULL, NULL, 0); ret = ImmGetImeMenuItemsA(imc_null, 0, 0, NULL, NULL, 0);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGetImeMenuItemsA(imc_destroy, 0, 0, NULL, NULL, 0); ret = ImmGetImeMenuItemsA(imc_destroy, 0, 0, NULL, NULL, 0);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmLockIMC */ /* Test ImmLockIMC */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ic = ImmLockIMC(imc_bad); ic = ImmLockIMC(imc_bad);
ok(ic == 0, "Bad IME should return 0\n"); ok(ic == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ic = ImmLockIMC(imc_null); ic = ImmLockIMC(imc_null);
ok(ic == 0, "NULL IME should return 0\n"); ok(ic == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ic = ImmLockIMC(imc_destroy); ic = ImmLockIMC(imc_destroy);
ok(ic == 0, "Destroyed IME should return 0\n"); ok(ic == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmUnlockIMC */ /* Test ImmUnlockIMC */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmUnlockIMC(imc_bad); ret = ImmUnlockIMC(imc_bad);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmUnlockIMC(imc_null); ret = ImmUnlockIMC(imc_null);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == 0xdeadbeef, "last error should remain unchanged %08x!\n", ret); ok(ret == 0xdeadbeef, "last error should remain unchanged %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmUnlockIMC(imc_destroy); ret = ImmUnlockIMC(imc_destroy);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
/* Test ImmGenerateMessage */ /* Test ImmGenerateMessage */
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGenerateMessage(imc_bad); ret = ImmGenerateMessage(imc_bad);
ok(ret == 0, "Bad IME should return 0\n"); ok(ret == 0, "Bad IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGenerateMessage(imc_null); ret = ImmGenerateMessage(imc_null);
ok(ret == 0, "NULL IME should return 0\n"); ok(ret == 0, "NULL IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
SetLastError(0xdeadbeef); SetLastError(0xdeadbeef);
ret = ImmGenerateMessage(imc_destroy); ret = ImmGenerateMessage(imc_destroy);
ok(ret == 0, "Destroyed IME should return 0\n"); ok(ret == 0, "Destroyed IME should return 0\n");
ret = GetLastError(); ret = GetLastError();
ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08lx!\n", ret);
} }
#define test_apttype(apttype) _test_apttype(apttype, __LINE__) #define test_apttype(apttype) _test_apttype(apttype, __LINE__)
@ -2159,7 +2159,7 @@ static void _test_apttype(APTTYPE apttype, unsigned int line)
hr = CoGetApartmentType(&type, &qualifier); hr = CoGetApartmentType(&type, &qualifier);
hr_expected = (apttype == -1 ? CO_E_NOTINITIALIZED : S_OK); hr_expected = (apttype == -1 ? CO_E_NOTINITIALIZED : S_OK);
ok_(__FILE__, line)(hr == hr_expected, "CoGetApartmentType returned %x\n", hr); ok_(__FILE__, line)(hr == hr_expected, "CoGetApartmentType returned %lx\n", hr);
if (FAILED(hr)) if (FAILED(hr))
return; return;
@ -2178,7 +2178,7 @@ static DWORD WINAPI com_initialization_thread(void *arg)
ok(r, "ImmSetActiveContext failed\n"); ok(r, "ImmSetActiveContext failed\n");
test_apttype(APTTYPE_MAINSTA); test_apttype(APTTYPE_MAINSTA);
hr = CoInitialize(NULL); hr = CoInitialize(NULL);
ok(hr == S_OK, "CoInitialize returned %x\n", hr); ok(hr == S_OK, "CoInitialize returned %lx\n", hr);
CoUninitialize(); CoUninitialize();
test_apttype(-1); test_apttype(-1);
@ -2187,7 +2187,7 @@ static DWORD WINAPI com_initialization_thread(void *arg)
ok(r, "ImmSetActiveContext failed\n"); ok(r, "ImmSetActiveContext failed\n");
test_apttype(APTTYPE_MAINSTA); test_apttype(APTTYPE_MAINSTA);
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
ok(hr == S_OK, "CoInitialize returned %x\n", hr); ok(hr == S_OK, "CoInitialize returned %lx\n", hr);
test_apttype(APTTYPE_MTA); test_apttype(APTTYPE_MTA);
CoUninitialize(); CoUninitialize();
test_apttype(-1); test_apttype(-1);
@ -2228,7 +2228,7 @@ static void test_com_initialization(void)
ok(r, "ImmSetActiveContext failed\n"); ok(r, "ImmSetActiveContext failed\n");
test_apttype(APTTYPE_MAINSTA); test_apttype(APTTYPE_MAINSTA);
hr = CoInitialize(NULL); hr = CoInitialize(NULL);
ok(hr == S_OK, "CoInitialize returned %x\n", hr); ok(hr == S_OK, "CoInitialize returned %lx\n", hr);
CoUninitialize(); CoUninitialize();
test_apttype(-1); test_apttype(-1);
@ -2240,7 +2240,7 @@ static void test_com_initialization(void)
ok(r, "ImmSetActiveContext failed\n"); ok(r, "ImmSetActiveContext failed\n");
test_apttype(APTTYPE_MAINSTA); test_apttype(APTTYPE_MAINSTA);
hr = CoInitialize(NULL); hr = CoInitialize(NULL);
ok(hr == S_OK, "CoInitialize returned %x\n", hr); ok(hr == S_OK, "CoInitialize returned %lx\n", hr);
CoUninitialize(); CoUninitialize();
test_apttype(APTTYPE_MAINSTA); test_apttype(APTTYPE_MAINSTA);
DestroyWindow(wnd); DestroyWindow(wnd);
@ -2251,7 +2251,7 @@ static void test_com_initialization(void)
r = ImmSetActiveContext(NULL, NULL, TRUE); r = ImmSetActiveContext(NULL, NULL, TRUE);
CoUninitialize(); CoUninitialize();
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
ok(hr == S_OK, "CoInitialize returned %x\n", hr); ok(hr == S_OK, "CoInitialize returned %lx\n", hr);
test_apttype(APTTYPE_MTA); test_apttype(APTTYPE_MTA);
DestroyWindow(wnd); DestroyWindow(wnd);
test_apttype(-1); test_apttype(-1);