git.oblomov.eu Git - wine/blob - dlls/imm32/tests/imm32.c

   1 /*
   2  * Unit tests for imm32
   3  *
   4  * Copyright (c) 2008 Michael Jung
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22
  23 #include "wine/test.h"
  24 #include "winuser.h"
  25 #include "imm.h"
  26
  27 #define NUMELEMS(array) (sizeof((array))/sizeof((array)[0]))
  28
  29 /*
  30  * msgspy - record and analyse message traces sent to a certain window
  31  */
  32 static struct _msg_spy {
  33     HWND         hwnd;
  34     HHOOK        get_msg_hook;
  35     HHOOK        call_wnd_proc_hook;
  36     CWPSTRUCT    msgs[32];
  37     unsigned int i_msg;
  38 } msg_spy;
  39
  40 static LRESULT CALLBACK get_msg_filter(int nCode, WPARAM wParam, LPARAM lParam)
  41 {
  42     if (HC_ACTION == nCode) {
  43         MSG *msg = (MSG*)lParam;
  44
  45         if ((msg->hwnd == msg_spy.hwnd) &&
  46             (msg_spy.i_msg < NUMELEMS(msg_spy.msgs)))
  47         {
  48             msg_spy.msgs[msg_spy.i_msg].hwnd    = msg->hwnd;
  49             msg_spy.msgs[msg_spy.i_msg].message = msg->message;
  50             msg_spy.msgs[msg_spy.i_msg].wParam  = msg->wParam;
  51             msg_spy.msgs[msg_spy.i_msg].lParam  = msg->lParam;
  52             msg_spy.i_msg++;
  53         }
  54     }
  55
  56     return CallNextHookEx(msg_spy.get_msg_hook, nCode, wParam, lParam);
  57 }
  58
  59 static LRESULT CALLBACK call_wnd_proc_filter(int nCode, WPARAM wParam,
  60                                              LPARAM lParam)
  61 {
  62     if (HC_ACTION == nCode) {
  63         CWPSTRUCT *cwp = (CWPSTRUCT*)lParam;
  64
  65         if ((cwp->hwnd == msg_spy.hwnd) &&
  66             (msg_spy.i_msg < NUMELEMS(msg_spy.msgs)))
  67         {
  68             memcpy(&msg_spy.msgs[msg_spy.i_msg], cwp, sizeof(msg_spy.msgs[0]));
  69             msg_spy.i_msg++;
  70         }
  71     }
  72
  73     return CallNextHookEx(msg_spy.call_wnd_proc_hook, nCode, wParam, lParam);
  74 }
  75
  76 static void msg_spy_pump_msg_queue(void) {
  77     MSG msg;
  78
  79     while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
  80         TranslateMessage(&msg);
  81         DispatchMessage(&msg);
  82     }
  83
  84     return;
  85 }
  86
  87 static void msg_spy_flush_msgs(void) {
  88     msg_spy_pump_msg_queue();
  89     msg_spy.i_msg = 0;
  90 }
  91
  92 static CWPSTRUCT* msg_spy_find_msg(UINT message) {
  93     UINT i;
  94
  95     msg_spy_pump_msg_queue();
  96
  97     if (msg_spy.i_msg >= NUMELEMS(msg_spy.msgs))
  98         fprintf(stdout, "%s:%d: msg_spy: message buffer overflow!\n",
  99                 __FILE__, __LINE__);
 100
 101     for (i = 0; i < msg_spy.i_msg; i++)
 102         if (msg_spy.msgs[i].message == message)
 103             return &msg_spy.msgs[i];
 104
 105     return NULL;
 106 }
 107
 108 static void msg_spy_init(HWND hwnd) {
 109     msg_spy.hwnd = hwnd;
 110     msg_spy.get_msg_hook =
 111             SetWindowsHookEx(WH_GETMESSAGE, get_msg_filter, GetModuleHandle(0),
 112                              GetCurrentThreadId());
 113     msg_spy.call_wnd_proc_hook =
 114             SetWindowsHookEx(WH_CALLWNDPROC, call_wnd_proc_filter,
 115                              GetModuleHandle(0), GetCurrentThreadId());
 116     msg_spy.i_msg = 0;
 117
 118     msg_spy_flush_msgs();
 119 }
 120
 121 static void msg_spy_cleanup() {
 122     if (msg_spy.get_msg_hook)
 123         UnhookWindowsHookEx(msg_spy.get_msg_hook);
 124     if (msg_spy.call_wnd_proc_hook)
 125         UnhookWindowsHookEx(msg_spy.call_wnd_proc_hook);
 126     memset(&msg_spy, 0, sizeof(msg_spy));
 127 }
 128
 129 /*
 130  * imm32 test cases - Issue some IMM commands on a dummy window and analyse the
 131  * messages being sent to this window in response.
 132  */
 133 static const char wndcls[] = "winetest_imm32_wndcls";
 134 static HWND hwnd;
 135
 136 static int init(void) {
 137     WNDCLASSEX wc;
 138     HIMC imc;
 139
 140     wc.cbSize        = sizeof(WNDCLASSEX);
 141     wc.style         = 0;
 142     wc.lpfnWndProc   = DefWindowProc;
 143     wc.cbClsExtra    = 0;
 144     wc.cbWndExtra    = 0;
 145     wc.hInstance     = GetModuleHandle(0);
 146     wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
 147     wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
 148     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
 149     wc.lpszMenuName  = NULL;
 150     wc.lpszClassName = wndcls;
 151     wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
 152
 153     if (!RegisterClassExA(&wc))
 154         return 0;
 155
 156     hwnd = CreateWindowEx(WS_EX_CLIENTEDGE, wndcls, "Wine imm32.dll test",
 157                           WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
 158                           240, 120, NULL, NULL, GetModuleHandle(0), NULL);
 159     if (!hwnd)
 160         return 0;
 161
 162     imc = ImmGetContext(hwnd);
 163     if (!imc)
 164     {
 165         win_skip("IME support not implemented\n");
 166         return 0;
 167     }
 168     ImmReleaseContext(hwnd, imc);
 169
 170     ShowWindow(hwnd, SW_SHOWNORMAL);
 171     UpdateWindow(hwnd);
 172
 173     msg_spy_init(hwnd);
 174
 175     return 1;
 176 }
 177
 178 static void cleanup(void) {
 179     msg_spy_cleanup();
 180     if (hwnd)
 181         DestroyWindow(hwnd);
 182     UnregisterClass(wndcls, GetModuleHandle(0));
 183 }
 184
 185 static void test_ImmNotifyIME(void) {
 186     static const char string[] = "wine";
 187     char resstr[16] = "";
 188     HIMC imc;
 189     BOOL ret;
 190
 191     imc = ImmGetContext(hwnd);
 192     msg_spy_flush_msgs();
 193
 194     ret = ImmNotifyIME(imc, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
 195     todo_wine
 196     {
 197         ok(!ret ||
 198            broken(ret), /* Vista and W2K8 */
 199            "Canceling an empty composition string should fail.\n");
 200     }
 201     ok(!msg_spy_find_msg(WM_IME_COMPOSITION), "Windows does not post "
 202        "WM_IME_COMPOSITION in response to NI_COMPOSITIONSTR / CPS_CANCEL, if "
 203        "the composition string being canceled is empty.\n");
 204
 205     ImmSetCompositionString(imc, SCS_SETSTR, string, sizeof(string), NULL, 0);
 206     msg_spy_flush_msgs();
 207
 208     ImmNotifyIME(imc, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
 209     ok(!msg_spy_find_msg(WM_IME_COMPOSITION), "Windows does not post "
 210        "WM_IME_COMPOSITION in response to NI_COMPOSITIONSTR / CPS_CANCEL, if "
 211        "the composition string being canceled is non empty.\n");
 212
 213     /* behavior differs between win9x and NT */
 214     ret = ImmGetCompositionString(imc, GCS_COMPSTR, resstr, sizeof(resstr));
 215     ok(!ret, "After being cancelled the composition string is empty.\n");
 216
 217     msg_spy_flush_msgs();
 218
 219     ret = ImmNotifyIME(imc, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
 220     todo_wine
 221     {
 222         ok(!ret ||
 223            broken(ret), /* Vista and W2K8 */
 224            "Canceling an empty composition string should fail.\n");
 225     }
 226     ok(!msg_spy_find_msg(WM_IME_COMPOSITION), "Windows does not post "
 227        "WM_IME_COMPOSITION in response to NI_COMPOSITIONSTR / CPS_CANCEL, if "
 228        "the composition string being canceled is empty.\n");
 229
 230     msg_spy_flush_msgs();
 231     ImmReleaseContext(hwnd, imc);
 232 }
 233
 234 static void test_ImmGetCompositionString(void)
 235 {
 236     HIMC imc;
 237     static const WCHAR string[] = {'w','i','n','e',0x65e5,0x672c,0x8a9e};
 238     char cstring[20];
 239     WCHAR wstring[20];
 240     DWORD len;
 241     DWORD alen,wlen;
 242
 243     imc = ImmGetContext(hwnd);
 244     ImmSetCompositionStringW(imc, SCS_SETSTR, string, sizeof(string), NULL,0);
 245     alen = ImmGetCompositionStringA(imc, GCS_COMPSTR, cstring, 20);
 246     wlen = ImmGetCompositionStringW(imc, GCS_COMPSTR, wstring, 20);
 247     /* windows machines without any IME installed just return 0 above */
 248     if( alen && wlen)
 249     {
 250         len = ImmGetCompositionStringW(imc, GCS_COMPATTR, NULL, 0);
 251         ok(len*sizeof(WCHAR)==wlen,"GCS_COMPATTR(W) not returning correct count\n");
 252         len = ImmGetCompositionStringA(imc, GCS_COMPATTR, NULL, 0);
 253         ok(len==alen,"GCS_COMPATTR(A) not returning correct count\n");
 254     }
 255     ImmReleaseContext(hwnd, imc);
 256 }
 257
 258 static void test_ImmSetCompositionString(void)
 259 {
 260     HIMC imc;
 261     BOOL ret;
 262
 263     SetLastError(0xdeadbeef);
 264     imc = ImmGetContext(hwnd);
 265     ok(imc != 0, "ImmGetContext() failed. Last error: %u\n", GetLastError());
 266     if (!imc)
 267         return;
 268
 269     ret = ImmSetCompositionStringW(imc, SCS_SETSTR, NULL, 0, NULL, 0);
 270     todo_wine
 271     ok(!ret ||
 272        broken(ret), /* Vista and W2K8 */
 273        "ImmSetCompositionStringW() succeeded.\n");
 274
 275     ret = ImmSetCompositionStringW(imc, SCS_SETSTR | SCS_CHANGEATTR,
 276         NULL, 0, NULL, 0);
 277     todo_wine
 278     ok(!ret, "ImmSetCompositionStringW() succeeded.\n");
 279
 280     ret = ImmSetCompositionStringW(imc, SCS_SETSTR | SCS_CHANGECLAUSE,
 281         NULL, 0, NULL, 0);
 282     todo_wine
 283     ok(!ret, "ImmSetCompositionStringW() succeeded.\n");
 284
 285     ret = ImmSetCompositionStringW(imc, SCS_CHANGEATTR | SCS_CHANGECLAUSE,
 286         NULL, 0, NULL, 0);
 287     todo_wine
 288     ok(!ret, "ImmSetCompositionStringW() succeeded.\n");
 289
 290     ret = ImmSetCompositionStringW(imc, SCS_SETSTR | SCS_CHANGEATTR | SCS_CHANGECLAUSE,
 291         NULL, 0, NULL, 0);
 292     todo_wine
 293     ok(!ret, "ImmSetCompositionStringW() succeeded.\n");
 294
 295     ImmReleaseContext(hwnd, imc);
 296 }
 297
 298 static void test_ImmIME(void)
 299 {
 300     HIMC imc;
 301
 302     imc = ImmGetContext(hwnd);
 303     if (imc)
 304     {
 305         BOOL rc;
 306         rc = ImmConfigureIMEA(imc, NULL, IME_CONFIG_REGISTERWORD, NULL);
 307         ok (rc == 0, "ImmConfigureIMEA did not fail\n");
 308         rc = ImmConfigureIMEW(imc, NULL, IME_CONFIG_REGISTERWORD, NULL);
 309         ok (rc == 0, "ImmConfigureIMEW did not fail\n");
 310     }
 311     ImmReleaseContext(hwnd,imc);
 312 }
 313
 314 START_TEST(imm32) {
 315     if (init())
 316     {
 317         test_ImmNotifyIME();
 318         test_ImmGetCompositionString();
 319         test_ImmSetCompositionString();
 320         test_ImmIME();
 321     }
 322     cleanup();
 323 }