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     int 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         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 int 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     todo_wine
 195     {
 196         ok(!ImmNotifyIME(imc, NI_COMPOSITIONSTR, CPS_CANCEL, 0), "Canceling an "
 197            "empty composition string should fail.\n");
 198     }
 199     ok(!msg_spy_find_msg(WM_IME_COMPOSITION), "Windows does not post "
 200        "WM_IME_COMPOSITION in response to NI_COMPOSITIONSTR / CPS_CANCEL, if "
 201        "the composition string being canceled is empty.\n");
 202
 203     ImmSetCompositionString(imc, SCS_SETSTR, string, sizeof(string), NULL, 0);
 204     msg_spy_flush_msgs();
 205
 206     ImmNotifyIME(imc, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
 207     ok(!msg_spy_find_msg(WM_IME_COMPOSITION), "Windows does not post "
 208        "WM_IME_COMPOSITION in response to NI_COMPOSITIONSTR / CPS_CANCEL, if "
 209        "the composition string being canceled is non empty.\n");
 210
 211     /* behavior differs between win9x and NT */
 212     ret = ImmGetCompositionString(imc, GCS_COMPSTR, resstr, sizeof(resstr));
 213     ok(ret || !ret, "You'll never read this.\n");
 214
 215     msg_spy_flush_msgs();
 216
 217     todo_wine
 218     {
 219         ok(!ImmNotifyIME(imc, NI_COMPOSITIONSTR, CPS_CANCEL, 0), "Canceling an "
 220            "empty composition string should fail.\n");
 221     }
 222     ok(!msg_spy_find_msg(WM_IME_COMPOSITION), "Windows does not post "
 223        "WM_IME_COMPOSITION in response to NI_COMPOSITIONSTR / CPS_CANCEL, if "
 224        "the composition string being canceled is empty.\n");
 225
 226     msg_spy_flush_msgs();
 227     ImmReleaseContext(hwnd, imc);
 228
 229     return 0;
 230 }
 231
 232 static int test_ImmGetCompositionString(void)
 233 {
 234     HIMC imc;
 235     static const WCHAR string[] = {'w','i','n','e',0x65e5,0x672c,0x8a9e};
 236     char cstring[20];
 237     WCHAR wstring[20];
 238     DWORD len;
 239     DWORD alen,wlen;
 240
 241     imc = ImmGetContext(hwnd);
 242     ImmSetCompositionStringW(imc, SCS_SETSTR, string, sizeof(string), NULL,0);
 243     alen = ImmGetCompositionStringA(imc, GCS_COMPSTR, cstring, 20);
 244     wlen = ImmGetCompositionStringW(imc, GCS_COMPSTR, wstring, 20);
 245     /* windows machines without any IME installed just return 0 above */
 246     if( alen && wlen)
 247     {
 248         len = ImmGetCompositionStringW(imc, GCS_COMPATTR, NULL, 0);
 249         ok(len*sizeof(WCHAR)==wlen,"GCS_COMPATTR(W) not returning correct count\n");
 250         len = ImmGetCompositionStringA(imc, GCS_COMPATTR, NULL, 0);
 251         ok(len==alen,"GCS_COMPATTR(A) not returning correct count\n");
 252     }
 253     ImmReleaseContext(hwnd, imc);
 254     return 0;
 255 }
 256
 257 static int test_ImmIME(void)
 258 {
 259     HIMC imc;
 260
 261     imc = ImmGetContext(hwnd);
 262     if (imc)
 263     {
 264         BOOL rc;
 265         rc = ImmConfigureIMEA(imc, NULL, IME_CONFIG_REGISTERWORD, NULL);
 266         ok (rc == 0, "ImmConfigureIMEA did not fail\n");
 267         rc = ImmConfigureIMEW(imc, NULL, IME_CONFIG_REGISTERWORD, NULL);
 268         ok (rc == 0, "ImmConfigureIMEW did not fail\n");
 269     }
 270     ImmReleaseContext(hwnd,imc);
 271     return 0;
 272 }
 273
 274 START_TEST(imm32) {
 275     if (init())
 276     {
 277         test_ImmNotifyIME();
 278         test_ImmGetCompositionString();
 279         test_ImmIME();
 280     }
 281     cleanup();
 282 }