1 /* Test Key event to Key message translation
3 * Copyright 2003 Rein Klazes
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 /* test whether the right type of messages:
21 * WM_KEYUP/DOWN vs WM_SYSKEYUP/DOWN are sent in case of combined
24 * For instance <ALT>-X can be accomplished by
25 * the sequence ALT-KEY-DOWN, X-KEY-DOWN, ALT-KEY-UP, X-KEY-UP
26 * but also X-KEY-DOWN, ALT-KEY-DOWN, X-KEY-UP, ALT-KEY-UP
27 * Whether a KEY or a SYSKEY message is sent is not always clear, it is
28 * also not the same in WINNT as in WIN9X */
30 /* NOTE that there will be test failures under WIN9X
31 * No applications are known to me that rely on this
32 * so I don't fix it */
35 * 1. extend it to the wm_command and wm_syscommand notifications
36 * 2. add some more tests with special cases like dead keys or right (alt) key
37 * 3. there is some adapted code from input.c in here. Should really
38 * make that code exactly the same.
39 * 4. resolve the win9x case when there is a need or the testing frame work
41 * 5. The test app creates a window, the user should not take the focus
42 * away during its short existence. I could do something to prevent that
47 #define _WIN32_WINNT 0x401
48 #define _WIN32_IE 0x0500
57 #include "wine/test.h"
61 static LONG timetag
= 0x10000000;
63 static UINT (WINAPI
*pSendInput
) (UINT
, INPUT
*, size_t);
64 static int (WINAPI
*pGetMouseMovePointsEx
) (UINT
, LPMOUSEMOVEPOINT
, LPMOUSEMOVEPOINT
, int, DWORD
);
66 #define MAXKEYEVENTS 10
67 #define MAXKEYMESSAGES MAXKEYEVENTS /* assuming a key event generates one
68 and only one message */
70 /* keyboard message names, sorted as their value */
71 static const char *MSGNAME
[]={"WM_KEYDOWN", "WM_KEYUP", "WM_CHAR","WM_DEADCHAR",
72 "WM_SYSKEYDOWN", "WM_SYSKEYUP", "WM_SYSCHAR", "WM_SYSDEADCHAR" ,"WM_KEYLAST"};
74 /* keyevents, add more as needed */
76 { ALTDOWN
= 1, ALTUP
, XDOWN
, XUP
, SHIFTDOWN
, SHIFTUP
, CTRLDOWN
, CTRLUP
} KEV
;
78 static const int GETVKEY
[]={0, VK_MENU
, VK_MENU
, 'X', 'X', VK_SHIFT
, VK_SHIFT
, VK_CONTROL
, VK_CONTROL
};
79 /* matching scan codes */
80 static const int GETSCAN
[]={0, 0x38, 0x38, 0x2D, 0x2D, 0x2A, 0x2A, 0x1D, 0x1D };
81 /* matching updown events */
82 static const int GETFLAGS
[]={0, 0, KEYEVENTF_KEYUP
, 0, KEYEVENTF_KEYUP
, 0, KEYEVENTF_KEYUP
, 0, KEYEVENTF_KEYUP
};
83 /* matching descriptions */
84 static const char *getdesc
[]={"", "+alt","-alt","+X","-X","+shift","-shift","+ctrl","-ctrl"};
86 /* The MSVC headers ignore our NONAMELESSUNION requests so we have to define our own type */
98 #define ADDTOINPUTS(kev) \
99 inputs[evtctr].type = INPUT_KEYBOARD; \
100 ((TEST_INPUT*)inputs)[evtctr].u.ki.wVk = GETVKEY[ kev]; \
101 ((TEST_INPUT*)inputs)[evtctr].u.ki.wScan = GETSCAN[ kev]; \
102 ((TEST_INPUT*)inputs)[evtctr].u.ki.dwFlags = GETFLAGS[ kev]; \
103 ((TEST_INPUT*)inputs)[evtctr].u.ki.dwExtraInfo = 0; \
104 ((TEST_INPUT*)inputs)[evtctr].u.ki.time = ++timetag; \
113 /*******************************************
114 * add new test sets here
115 * the software will make all combinations of the
116 * keyevent defined here
118 static const struct {
120 KEV keydwn
[MAXKEYEVENTS
];
121 KEV keyup
[MAXKEYEVENTS
];
123 { 2, { ALTDOWN
, XDOWN
}, { ALTUP
, XUP
}},
124 { 3, { ALTDOWN
, XDOWN
, SHIFTDOWN
}, { ALTUP
, XUP
, SHIFTUP
}},
125 { 3, { ALTDOWN
, XDOWN
, CTRLDOWN
}, { ALTUP
, XUP
, CTRLUP
}},
126 { 3, { SHIFTDOWN
, XDOWN
, CTRLDOWN
}, { SHIFTUP
, XUP
, CTRLUP
}},
127 { 0 } /* mark the end */
130 /**********************adapted from input.c **********************************/
132 static BYTE InputKeyStateTable
[256];
133 static BYTE AsyncKeyStateTable
[256];
134 static BYTE TrackSysKey
= 0; /* determine whether ALT key up will cause a WM_SYSKEYUP
135 or a WM_KEYUP message */
137 static void init_function_pointers(void)
139 HMODULE hdll
= GetModuleHandleA("user32");
141 #define GET_PROC(func) \
142 p ## func = (void*)GetProcAddress(hdll, #func); \
144 trace("GetProcAddress(%s) failed\n", #func);
147 GET_PROC(GetMouseMovePointsEx
)
152 static int KbdMessage( KEV kev
, WPARAM
*pwParam
, LPARAM
*plParam
)
155 int VKey
= GETVKEY
[kev
];
158 flags
= LOBYTE(GETSCAN
[kev
]);
159 if (GETFLAGS
[kev
] & KEYEVENTF_EXTENDEDKEY
) flags
|= KF_EXTENDED
;
161 if (GETFLAGS
[kev
] & KEYEVENTF_KEYUP
)
164 if( (InputKeyStateTable
[VK_MENU
] & 0x80) && (
165 (VKey
== VK_MENU
) || (VKey
== VK_CONTROL
) ||
166 !(InputKeyStateTable
[VK_CONTROL
] & 0x80))) {
167 if( TrackSysKey
== VK_MENU
|| /* <ALT>-down/<ALT>-up sequence */
168 (VKey
!= VK_MENU
)) /* <ALT>-down...<something else>-up */
169 message
= WM_SYSKEYUP
;
172 InputKeyStateTable
[VKey
] &= ~0x80;
173 flags
|= KF_REPEAT
| KF_UP
;
177 if (InputKeyStateTable
[VKey
] & 0x80) flags
|= KF_REPEAT
;
178 if (!(InputKeyStateTable
[VKey
] & 0x80)) InputKeyStateTable
[VKey
] ^= 0x01;
179 InputKeyStateTable
[VKey
] |= 0x80;
180 AsyncKeyStateTable
[VKey
] |= 0x80;
182 message
= WM_KEYDOWN
;
183 if( (InputKeyStateTable
[VK_MENU
] & 0x80) &&
184 !(InputKeyStateTable
[VK_CONTROL
] & 0x80)) {
185 message
= WM_SYSKEYDOWN
;
190 if (InputKeyStateTable
[VK_MENU
] & 0x80) flags
|= KF_ALTDOWN
;
192 if( plParam
) *plParam
= MAKELPARAM( 1, flags
);
193 if( pwParam
) *pwParam
= VKey
;
197 /****************************** end copy input.c ****************************/
200 * . prepare the keyevents for SendInputs
201 * . calculate the "expected" messages
202 * . Send the events to our window
203 * . retrieve the messages from the input queue
206 static BOOL
do_test( HWND hwnd
, int seqnr
, const KEV td
[] )
208 INPUT inputs
[MAXKEYEVENTS
];
209 KMSG expmsg
[MAXKEYEVENTS
];
216 TrackSysKey
=0; /* see input.c */
217 for( i
= 0; i
< MAXKEYEVENTS
; i
++) {
219 strcat(buf
, getdesc
[td
[i
]]);
221 expmsg
[i
].message
= KbdMessage(td
[i
], &(expmsg
[i
].wParam
), &(expmsg
[i
].lParam
)); /* see queue_kbd_event() */
223 expmsg
[i
].message
= 0;
225 for( kmctr
= 0; kmctr
< MAXKEYEVENTS
&& expmsg
[kmctr
].message
; kmctr
++)
227 assert( evtctr
<= MAXKEYEVENTS
);
228 assert( evtctr
== pSendInput(evtctr
, &inputs
[0], sizeof(INPUT
)));
230 if (winetest_debug
> 1)
231 trace("======== key stroke sequence #%d: %s =============\n",
233 while( PeekMessage(&msg
,hwnd
,WM_KEYFIRST
,WM_KEYLAST
,PM_REMOVE
) ) {
234 if (winetest_debug
> 1)
235 trace("message[%d] %-15s wParam %04lx lParam %08lx time %x\n", i
,
236 MSGNAME
[msg
.message
- WM_KEYFIRST
], msg
.wParam
, msg
.lParam
, msg
.time
);
238 ok( msg
.message
== expmsg
[i
].message
&&
239 msg
.wParam
== expmsg
[i
].wParam
&&
240 msg
.lParam
== expmsg
[i
].lParam
,
241 "%u/%u: wrong message %x/%08lx/%08lx expected %s/%08lx/%08lx\n",
242 seqnr
, i
, msg
.message
, msg
.wParam
, msg
.lParam
,
243 MSGNAME
[(expmsg
[i
]).message
- WM_KEYFIRST
], expmsg
[i
].wParam
, expmsg
[i
].lParam
);
247 if (winetest_debug
> 1)
248 trace("%d messages retrieved\n", i
);
251 skip( "simulated keyboard input doesn't work\n" );
254 ok( i
== kmctr
, "message count is wrong: got %d expected: %d\n", i
, kmctr
);
258 /* test all combinations of the specified key events */
259 static BOOL
TestASet( HWND hWnd
, int nrkev
, const KEV kevdwn
[], const KEV kevup
[] )
263 KEV kbuf
[MAXKEYEVENTS
];
264 assert( nrkev
==2 || nrkev
==3);
265 for(i
=0;i
<MAXKEYEVENTS
;i
++) kbuf
[i
]=0;
266 /* two keys involved gives 4 test cases */
268 for(i
=0;i
<nrkev
;i
++) {
269 for(j
=0;j
<nrkev
;j
++) {
271 kbuf
[1] = kevdwn
[1-i
];
273 kbuf
[3] = kevup
[1-j
];
274 if (!do_test( hWnd
, count
++, kbuf
)) return FALSE
;
278 /* three keys involved gives 36 test cases */
280 for(i
=0;i
<nrkev
;i
++){
281 for(j
=0;j
<nrkev
;j
++){
283 for(k
=0;k
<nrkev
;k
++){
284 if(k
==i
|| k
==j
) continue;
285 for(l
=0;l
<nrkev
;l
++){
286 for(m
=0;m
<nrkev
;m
++){
288 for(n
=0;n
<nrkev
;n
++){
289 if(n
==l
||n
==m
) continue;
296 if (!do_test( hWnd
, count
++, kbuf
)) return FALSE
;
307 /* test each set specified in the global testkeyset array */
308 static void TestSysKeys( HWND hWnd
)
311 for(i
=0; testkeyset
[i
].nrkev
;i
++)
312 if (!TestASet( hWnd
, testkeyset
[i
].nrkev
, testkeyset
[i
].keydwn
, testkeyset
[i
].keyup
)) break;
315 static LRESULT CALLBACK
WndProc( HWND hWnd
, UINT msg
, WPARAM wParam
,
318 return DefWindowProcA( hWnd
, msg
, wParam
, lParam
);
321 static void test_Input_whitebox(void)
325 HANDLE hInstance
= GetModuleHandleA( NULL
);
327 wclass
.lpszClassName
= "InputSysKeyTestClass";
328 wclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
329 wclass
.lpfnWndProc
= WndProc
;
330 wclass
.hInstance
= hInstance
;
331 wclass
.hIcon
= LoadIconA( 0, IDI_APPLICATION
);
332 wclass
.hCursor
= LoadCursorA( NULL
, IDC_ARROW
);
333 wclass
.hbrBackground
= (HBRUSH
)( COLOR_WINDOW
+ 1 );
334 wclass
.lpszMenuName
= 0;
335 wclass
.cbClsExtra
= 0;
336 wclass
.cbWndExtra
= 0;
337 RegisterClassA( &wclass
);
338 /* create the test window that will receive the keystrokes */
339 hWndTest
= CreateWindowA( wclass
.lpszClassName
, "InputSysKeyTest",
340 WS_OVERLAPPEDWINDOW
, CW_USEDEFAULT
, 0, 100, 100,
341 NULL
, NULL
, hInstance
, NULL
);
343 ShowWindow( hWndTest
, SW_SHOW
);
344 SetWindowPos( hWndTest
, HWND_TOPMOST
, 0, 0, 0, 0, SWP_NOSIZE
|SWP_NOMOVE
);
345 SetForegroundWindow( hWndTest
);
346 UpdateWindow( hWndTest
);
348 /* flush pending messages */
349 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessageA( &msg
);
351 SetFocus( hWndTest
);
352 TestSysKeys( hWndTest
);
353 DestroyWindow(hWndTest
);
356 /* try to make sure pending X events have been processed before continuing */
357 static void empty_message_queue(void)
361 int min_timeout
= 50;
362 DWORD time
= GetTickCount() + diff
;
366 if (MsgWaitForMultipleObjects(0, NULL
, FALSE
, min_timeout
, QS_ALLINPUT
) == WAIT_TIMEOUT
) break;
367 while (PeekMessage(&msg
, 0, 0, 0, PM_REMOVE
))
369 TranslateMessage(&msg
);
370 DispatchMessage(&msg
);
372 diff
= time
- GetTickCount();
376 struct transition_s
{
396 UINT message
; /* the WM_* code */
397 msg_flags_t flags
; /* message props */
398 WPARAM wParam
; /* expected value of wParam */
399 LPARAM lParam
; /* expected value of lParam */
402 struct sendinput_test_s
{
406 struct transition_s expected_transitions
[MAXKEYEVENTS
+1];
407 struct message expected_messages
[MAXKEYMESSAGES
+1];
408 } sendinput_test
[] = {
411 {VK_LMENU
, 0, 0, {{VK_MENU
, 0x00}, {VK_LMENU
, 0x00}, {0}},
412 {{WM_SYSKEYDOWN
, hook
|wparam
, VK_LMENU
}, {WM_SYSKEYDOWN
}, {0}}},
413 {'F', 0, 0, {{'F', 0x00}, {0}},
414 {{WM_SYSKEYDOWN
, hook
}, {WM_SYSKEYDOWN
},
416 {WM_SYSCOMMAND
}, {0}}},
417 {'F', KEYEVENTF_KEYUP
, 0, {{'F', 0x80}, {0}},
418 {{WM_SYSKEYUP
, hook
}, {WM_SYSKEYUP
}, {0}}},
419 {VK_LMENU
, KEYEVENTF_KEYUP
, 0, {{VK_MENU
, 0x80}, {VK_LMENU
, 0x80}, {0}},
420 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
424 {VK_LCONTROL
, 0, 0, {{VK_CONTROL
, 0x00}, {VK_LCONTROL
, 0x00}, {0}},
425 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {0}}},
426 {'O', 0, 0, {{'O', 0x00}, {0}},
427 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {WM_CHAR
}, {0}}},
428 {'O', KEYEVENTF_KEYUP
, 0, {{'O', 0x80}, {0}},
429 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
430 {VK_LCONTROL
, KEYEVENTF_KEYUP
, 0, {{VK_CONTROL
, 0x80}, {VK_LCONTROL
, 0x80}, {0}},
431 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
433 /* test ALT+CTRL+X */
435 {VK_LMENU
, 0, 0, {{VK_MENU
, 0x00}, {VK_LMENU
, 0x00}, {0}},
436 {{WM_SYSKEYDOWN
, hook
}, {WM_SYSKEYDOWN
}, {0}}},
437 {VK_LCONTROL
, 0, 0, {{VK_CONTROL
, 0x00}, {VK_LCONTROL
, 0x00}, {0}},
438 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {0}}},
439 {'X', 0, 0, {{'X', 0x00}, {0}},
440 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {0}}},
441 {'X', KEYEVENTF_KEYUP
, 0, {{'X', 0x80}, {0}},
442 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
443 {VK_LCONTROL
, KEYEVENTF_KEYUP
, 0, {{VK_CONTROL
, 0x80}, {VK_LCONTROL
, 0x80}, {0}},
444 {{WM_SYSKEYUP
, hook
}, {WM_SYSKEYUP
}, {0}}},
445 {VK_LMENU
, KEYEVENTF_KEYUP
, 0, {{VK_MENU
, 0x80}, {VK_LMENU
, 0x80}, {0}},
446 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
450 {VK_LSHIFT
, 0, 0, {{VK_SHIFT
, 0x00}, {VK_LSHIFT
, 0x00}, {0}},
451 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {0}}},
452 {'A', 0, 0, {{'A', 0x00}, {0}},
453 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {WM_CHAR
}, {0}}},
454 {'A', KEYEVENTF_KEYUP
, 0, {{'A', 0x80}, {0}},
455 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
456 {VK_LSHIFT
, KEYEVENTF_KEYUP
, 0, {{VK_SHIFT
, 0x80}, {VK_LSHIFT
, 0x80}, {0}},
457 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
458 /* test L-SHIFT & R-SHIFT: */
459 /* RSHIFT == LSHIFT */
462 /* recent windows versions (>= w2k3) correctly report an RSHIFT transition */
463 {{VK_SHIFT
, 0x00}, {VK_LSHIFT
, 0x00, TRUE
}, {VK_RSHIFT
, 0x00, TRUE
}, {0}},
464 {{WM_KEYDOWN
, hook
|wparam
, VK_RSHIFT
},
466 {VK_RSHIFT
, KEYEVENTF_KEYUP
, 0,
467 {{VK_SHIFT
, 0x80}, {VK_LSHIFT
, 0x80, TRUE
}, {VK_RSHIFT
, 0x80, TRUE
}, {0}},
468 {{WM_KEYUP
, hook
, hook
|wparam
, VK_RSHIFT
},
471 /* LSHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */
473 {VK_LSHIFT
, KEYEVENTF_EXTENDEDKEY
, 0,
474 {{VK_SHIFT
, 0x00}, {VK_RSHIFT
, 0x00}, {0}},
475 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_LSHIFT
, LLKHF_EXTENDED
},
476 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
477 {VK_LSHIFT
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
478 {{VK_SHIFT
, 0x80}, {VK_RSHIFT
, 0x80}, {0}},
479 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_LSHIFT
, LLKHF_UP
|LLKHF_EXTENDED
},
480 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
481 /* RSHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */
483 {VK_RSHIFT
, KEYEVENTF_EXTENDEDKEY
, 0,
484 {{VK_SHIFT
, 0x00}, {VK_RSHIFT
, 0x00}, {0}},
485 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_RSHIFT
, LLKHF_EXTENDED
},
486 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
487 {VK_RSHIFT
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
488 {{VK_SHIFT
, 0x80}, {VK_RSHIFT
, 0x80}, {0}},
489 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_RSHIFT
, LLKHF_UP
|LLKHF_EXTENDED
},
490 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
492 /* Note about wparam for hook with generic key (VK_SHIFT, VK_CONTROL, VK_MENU):
493 win2k - sends to hook whatever we generated here
494 winXP+ - Attempts to convert key to L/R key but not always correct
496 /* SHIFT == LSHIFT */
499 {{VK_SHIFT
, 0x00}, {VK_LSHIFT
, 0x00}, {0}},
500 {{WM_KEYDOWN
, hook
/* |wparam */|lparam
, VK_SHIFT
, 0},
501 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
502 {VK_SHIFT
, KEYEVENTF_KEYUP
, 0,
503 {{VK_SHIFT
, 0x80}, {VK_LSHIFT
, 0x80}, {0}},
504 {{WM_KEYUP
, hook
/*|wparam*/|lparam
, VK_SHIFT
, LLKHF_UP
},
505 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
506 /* SHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */
508 {VK_SHIFT
, KEYEVENTF_EXTENDEDKEY
, 0,
509 {{VK_SHIFT
, 0x00}, {VK_RSHIFT
, 0x00}, {0}},
510 {{WM_KEYDOWN
, hook
/*|wparam*/|lparam
, VK_SHIFT
, LLKHF_EXTENDED
},
511 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
512 {VK_SHIFT
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
513 {{VK_SHIFT
, 0x80}, {VK_RSHIFT
, 0x80}, {0}},
514 {{WM_KEYUP
, hook
/*|wparam*/|lparam
, VK_SHIFT
, LLKHF_UP
|LLKHF_EXTENDED
},
515 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
517 /* test L-CONTROL & R-CONTROL: */
518 /* RCONTROL == LCONTROL */
521 {{VK_CONTROL
, 0x00}, {VK_LCONTROL
, 0x00}, {0}},
522 {{WM_KEYDOWN
, hook
|wparam
, VK_RCONTROL
},
523 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, 0}, {0}}},
524 {VK_RCONTROL
, KEYEVENTF_KEYUP
, 0,
525 {{VK_CONTROL
, 0x80}, {VK_LCONTROL
, 0x80}, {0}},
526 {{WM_KEYUP
, hook
|wparam
, VK_RCONTROL
},
527 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
}, {0}}},
528 /* LCONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */
530 {VK_LCONTROL
, KEYEVENTF_EXTENDEDKEY
, 0,
531 {{VK_CONTROL
, 0x00}, {VK_RCONTROL
, 0x00}, {0}},
532 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_LCONTROL
, LLKHF_EXTENDED
},
533 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, KF_EXTENDED
}, {0}}},
534 {VK_LCONTROL
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
535 {{VK_CONTROL
, 0x80}, {VK_RCONTROL
, 0x80}, {0}},
536 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_LCONTROL
, LLKHF_UP
|LLKHF_EXTENDED
},
537 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
|KF_EXTENDED
}, {0}}},
538 /* RCONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */
540 {VK_RCONTROL
, KEYEVENTF_EXTENDEDKEY
, 0,
541 {{VK_CONTROL
, 0x00}, {VK_RCONTROL
, 0x00}, {0}},
542 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_RCONTROL
, LLKHF_EXTENDED
},
543 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, KF_EXTENDED
}, {0}}},
544 {VK_RCONTROL
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
545 {{VK_CONTROL
, 0x80}, {VK_RCONTROL
, 0x80}, {0}},
546 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_RCONTROL
, LLKHF_UP
|LLKHF_EXTENDED
},
547 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
|KF_EXTENDED
}, {0}}},
548 /* CONTROL == LCONTROL */
551 {{VK_CONTROL
, 0x00}, {VK_LCONTROL
, 0x00}, {0}},
552 {{WM_KEYDOWN
, hook
/*|wparam, VK_CONTROL*/},
553 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, 0}, {0}}},
554 {VK_CONTROL
, KEYEVENTF_KEYUP
, 0,
555 {{VK_CONTROL
, 0x80}, {VK_LCONTROL
, 0x80}, {0}},
556 {{WM_KEYUP
, hook
/*|wparam, VK_CONTROL*/},
557 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
}, {0}}},
558 /* CONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */
560 {VK_CONTROL
, KEYEVENTF_EXTENDEDKEY
, 0,
561 {{VK_CONTROL
, 0x00}, {VK_RCONTROL
, 0x00}, {0}},
562 {{WM_KEYDOWN
, hook
/*|wparam*/|lparam
, VK_CONTROL
, LLKHF_EXTENDED
},
563 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, KF_EXTENDED
}, {0}}},
564 {VK_CONTROL
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
565 {{VK_CONTROL
, 0x80}, {VK_RCONTROL
, 0x80}, {0}},
566 {{WM_KEYUP
, hook
/*|wparam*/|lparam
, VK_CONTROL
, LLKHF_UP
|LLKHF_EXTENDED
},
567 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
|KF_EXTENDED
}, {0}}},
569 /* test L-MENU & R-MENU: */
573 {{VK_MENU
, 0x00}, {VK_LMENU
, 0x00}, {VK_CONTROL
, 0x00, 1}, {VK_LCONTROL
, 0x01, 1}, {0}},
574 {{WM_SYSKEYDOWN
, hook
|wparam
|optional
, VK_LCONTROL
},
575 {WM_SYSKEYDOWN
, hook
|wparam
, VK_RMENU
},
576 {WM_KEYDOWN
, wparam
|lparam
|optional
, VK_CONTROL
, 0},
577 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, 0}, {0}}},
578 {VK_RMENU
, KEYEVENTF_KEYUP
, 1,
579 {{VK_MENU
, 0x80}, {VK_LMENU
, 0x80}, {VK_CONTROL
, 0x81, 1}, {VK_LCONTROL
, 0x80, 1}, {0}},
580 {{WM_KEYUP
, hook
|wparam
|optional
, VK_LCONTROL
},
581 {WM_KEYUP
, hook
|wparam
, VK_RMENU
},
582 {WM_SYSKEYUP
, wparam
|lparam
|optional
, VK_CONTROL
, KF_UP
},
583 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
},
584 {WM_SYSCOMMAND
, optional
}, {0}}},
585 /* LMENU | KEYEVENTF_EXTENDEDKEY == RMENU */
587 {VK_LMENU
, KEYEVENTF_EXTENDEDKEY
, 0,
588 {{VK_MENU
, 0x00}, {VK_RMENU
, 0x00}, {0}},
589 {{WM_SYSKEYDOWN
, hook
|wparam
|lparam
, VK_LMENU
, LLKHF_EXTENDED
},
590 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, KF_EXTENDED
}, {0}}},
591 {VK_LMENU
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 1,
592 {{VK_MENU
, 0x80}, {VK_RMENU
, 0x80}, {0}},
593 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_LMENU
, LLKHF_UP
|LLKHF_EXTENDED
},
594 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
|KF_EXTENDED
},
595 {WM_SYSCOMMAND
}, {0}}},
596 /* RMENU | KEYEVENTF_EXTENDEDKEY == RMENU */
598 {VK_RMENU
, KEYEVENTF_EXTENDEDKEY
, 0,
599 {{VK_MENU
, 0x00}, {VK_RMENU
, 0x00}, {VK_CONTROL
, 0x00, 1}, {VK_LCONTROL
, 0x01, 1}, {0}},
600 {{WM_SYSKEYDOWN
, hook
|wparam
|lparam
|optional
, VK_LCONTROL
, 0},
601 {WM_SYSKEYDOWN
, hook
|wparam
|lparam
, VK_RMENU
, LLKHF_EXTENDED
},
602 {WM_KEYDOWN
, wparam
|lparam
|optional
, VK_CONTROL
, 0},
603 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, KF_EXTENDED
}, {0}}},
604 {VK_RMENU
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 1,
605 {{VK_MENU
, 0x80}, {VK_RMENU
, 0x80}, {VK_CONTROL
, 0x81, 1}, {VK_LCONTROL
, 0x80, 1}, {0}},
606 {{WM_KEYUP
, hook
|wparam
|lparam
|optional
, VK_LCONTROL
, LLKHF_UP
},
607 {WM_KEYUP
, hook
|wparam
|lparam
, VK_RMENU
, LLKHF_UP
|LLKHF_EXTENDED
},
608 {WM_SYSKEYUP
, wparam
|lparam
|optional
, VK_CONTROL
, KF_UP
},
609 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
|KF_EXTENDED
},
610 {WM_SYSCOMMAND
, optional
}, {0}}},
614 {{VK_MENU
, 0x00}, {VK_LMENU
, 0x00}, {0}},
615 {{WM_SYSKEYDOWN
, hook
/*|wparam, VK_MENU*/},
616 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, 0}, {0}}},
617 {VK_MENU
, KEYEVENTF_KEYUP
, 1,
618 {{VK_MENU
, 0x80}, {VK_LMENU
, 0x80}, {0}},
619 {{WM_KEYUP
, hook
/*|wparam, VK_MENU*/},
620 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
},
621 {WM_SYSCOMMAND
}, {0}}},
622 /* MENU | KEYEVENTF_EXTENDEDKEY == RMENU */
624 {VK_MENU
, KEYEVENTF_EXTENDEDKEY
, 0,
625 {{VK_MENU
, 0x00}, {VK_RMENU
, 0x00}, {VK_CONTROL
, 0x00, 1}, {VK_LCONTROL
, 0x01, 1}, {0}},
626 {{WM_SYSKEYDOWN
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 0},
627 {WM_SYSKEYDOWN
, hook
/*|wparam*/|lparam
, VK_MENU
, LLKHF_EXTENDED
},
628 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, KF_EXTENDED
}, {0}}},
629 {VK_MENU
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 1,
630 {{VK_MENU
, 0x80}, {VK_RMENU
, 0x80}, {VK_CONTROL
, 0x81, 1}, {VK_LCONTROL
, 0x80, 1}, {0}},
631 {{WM_KEYUP
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, LLKHF_UP
},
632 {WM_KEYUP
, hook
/*|wparam*/|lparam
, VK_MENU
, LLKHF_UP
|LLKHF_EXTENDED
},
633 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
|KF_EXTENDED
},
634 {WM_SYSCOMMAND
}, {0}}},
636 /* test LSHIFT & RSHIFT */
639 {{VK_SHIFT
, 0x00}, {VK_LSHIFT
, 0x00}, {0}},
640 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_LSHIFT
, 0},
641 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
642 {VK_RSHIFT
, KEYEVENTF_EXTENDEDKEY
, 0,
643 {{VK_RSHIFT
, 0x00}, {0}},
644 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_RSHIFT
, LLKHF_EXTENDED
},
645 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
646 {VK_RSHIFT
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
647 {{VK_RSHIFT
, 0x80}, {0}},
648 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_RSHIFT
, LLKHF_UP
|LLKHF_EXTENDED
},
649 {WM_KEYUP
, optional
}, {0}}},
650 {VK_LSHIFT
, KEYEVENTF_KEYUP
, 0,
651 {{VK_SHIFT
, 0x80}, {VK_LSHIFT
, 0x80}, {0}},
652 {{WM_KEYUP
, hook
|wparam
, VK_LSHIFT
},
653 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
655 {0, 0, 0, {{0}}, {{0}}} /* end */
658 static struct message sent_messages
[MAXKEYMESSAGES
];
659 static UINT sent_messages_cnt
;
661 /* Verify that only specified key state transitions occur */
662 static void compare_and_check(int id
, BYTE
*ks1
, BYTE
*ks2
, struct sendinput_test_s
*test
)
664 int i
, failcount
= 0;
665 struct transition_s
*t
= test
->expected_transitions
;
667 const struct message
*expected
= test
->expected_messages
;
670 int matched
= ((ks1
[t
->wVk
]&0x80) == (t
->before_state
&0x80)
671 && (ks2
[t
->wVk
]&0x80) == (~t
->before_state
&0x80));
673 if (!matched
&& !t
->optional
&& test
->_todo_wine
)
677 ok(matched
, "%2d (%x/%x): %02x from %02x -> %02x "
678 "instead of %02x -> %02x\n", id
, test
->wVk
, test
->dwFlags
,
679 t
->wVk
, ks1
[t
->wVk
]&0x80, ks2
[t
->wVk
]&0x80, t
->before_state
,
680 ~t
->before_state
&0x80);
683 ok(matched
|| t
->optional
, "%2d (%x/%x): %02x from %02x -> %02x "
684 "instead of %02x -> %02x\n", id
, test
->wVk
, test
->dwFlags
,
685 t
->wVk
, ks1
[t
->wVk
]&0x80, ks2
[t
->wVk
]&0x80, t
->before_state
,
686 ~t
->before_state
&0x80);
688 ks2
[t
->wVk
] = ks1
[t
->wVk
]; /* clear the match */
691 for (i
= 0; i
< 256; i
++)
692 if (ks2
[i
] != ks1
[i
] && test
->_todo_wine
)
696 ok(FALSE
, "%2d (%x/%x): %02x from %02x -> %02x unexpected\n",
697 id
, test
->wVk
, test
->dwFlags
, i
, ks1
[i
], ks2
[i
]);
700 ok(ks2
[i
] == ks1
[i
], "%2d (%x/%x): %02x from %02x -> %02x unexpected\n",
701 id
, test
->wVk
, test
->dwFlags
, i
, ks1
[i
], ks2
[i
]);
703 while (expected
->message
&& actual_cnt
< sent_messages_cnt
)
705 const struct message
*actual
= &sent_messages
[actual_cnt
];
707 if (expected
->message
== actual
->message
)
709 if (expected
->flags
& wparam
)
711 if ((expected
->flags
& optional
) && (expected
->wParam
!= actual
->wParam
))
716 if (expected
->wParam
!= actual
->wParam
&& test
->_todo_wine
)
720 ok(FALSE
, "%2d (%x/%x): in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
721 id
, test
->wVk
, test
->dwFlags
, expected
->message
, expected
->wParam
, actual
->wParam
);
724 ok(expected
->wParam
== actual
->wParam
,
725 "%2d (%x/%x): in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
726 id
, test
->wVk
, test
->dwFlags
, expected
->message
, expected
->wParam
, actual
->wParam
);
728 if (expected
->flags
& lparam
)
730 if (expected
->lParam
!= actual
->lParam
&& test
->_todo_wine
)
734 ok(FALSE
, "%2d (%x/%x): in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
735 id
, test
->wVk
, test
->dwFlags
, expected
->message
, expected
->lParam
, actual
->lParam
);
738 ok(expected
->lParam
== actual
->lParam
,
739 "%2d (%x/%x): in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
740 id
, test
->wVk
, test
->dwFlags
, expected
->message
, expected
->lParam
, actual
->lParam
);
742 ok((expected
->flags
& hook
) == (actual
->flags
& hook
),
743 "%2d (%x/%x): the msg 0x%04x should have been sent by a hook\n",
744 id
, test
->wVk
, test
->dwFlags
, expected
->message
);
747 else if (expected
->flags
& optional
)
752 /* NT4 doesn't send SYSKEYDOWN/UP to hooks, only KEYDOWN/UP */
753 else if ((expected
->flags
& hook
) &&
754 (expected
->message
== WM_SYSKEYDOWN
|| expected
->message
== WM_SYSKEYUP
) &&
755 (actual
->message
== expected
->message
- 4))
757 ok((expected
->flags
& hook
) == (actual
->flags
& hook
),
758 "%2d (%x/%x): the msg 0x%04x should have been sent by a hook\n",
759 id
, test
->wVk
, test
->dwFlags
, expected
->message
);
761 /* For VK_RMENU, at least localized Win2k/XP sends KEYDOWN/UP
762 * instead of SYSKEYDOWN/UP to the WNDPROC */
763 else if (test
->wVk
== VK_RMENU
&& !(expected
->flags
& hook
) &&
764 (expected
->message
== WM_SYSKEYDOWN
|| expected
->message
== WM_SYSKEYUP
) &&
765 (actual
->message
== expected
->message
- 4))
767 ok(expected
->wParam
== actual
->wParam
&& expected
->lParam
== actual
->lParam
,
768 "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n",
769 id
, test
->wVk
, test
->dwFlags
, expected
->message
, actual
->message
);
771 else if (test
->_todo_wine
)
776 "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n",
777 id
, test
->wVk
, test
->dwFlags
, expected
->message
, actual
->message
);
781 "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n",
782 id
, test
->wVk
, test
->dwFlags
, expected
->message
, actual
->message
);
787 /* skip all optional trailing messages */
788 while (expected
->message
&& (expected
->flags
& optional
))
792 if (expected
->message
|| actual_cnt
< sent_messages_cnt
)
794 if (test
->_todo_wine
)
798 ok(FALSE
, "%2d (%x/%x): the msg sequence is not complete: expected %04x - actual %04x\n",
799 id
, test
->wVk
, test
->dwFlags
, expected
->message
, sent_messages
[actual_cnt
].message
);
802 ok(FALSE
, "%2d (%x/%x): the msg sequence is not complete: expected %04x - actual %04x\n",
803 id
, test
->wVk
, test
->dwFlags
, expected
->message
, sent_messages
[actual_cnt
].message
);
806 if( test
->_todo_wine
&& !failcount
) /* succeeded yet marked todo */
808 ok(TRUE
, "%2d (%x/%x): marked \"todo_wine\" but succeeds\n", id
, test
->wVk
, test
->dwFlags
);
810 sent_messages_cnt
= 0;
813 /* WndProc2 checks that we get at least the messages specified */
814 static LRESULT CALLBACK
WndProc2(HWND hWnd
, UINT Msg
, WPARAM wParam
,
817 if (winetest_debug
> 1) trace("MSG: %8x W:%8lx L:%8lx\n", Msg
, wParam
, lParam
);
819 if (Msg
!= WM_PAINT
&&
821 Msg
!= WM_SYNCPAINT
&&
822 Msg
!= WM_ERASEBKGND
&&
823 Msg
!= WM_NCHITTEST
&&
826 Msg
!= WM_IME_SELECT
&&
827 Msg
!= WM_DEVICECHANGE
)
829 ok(sent_messages_cnt
< MAXKEYMESSAGES
, "Too many messages\n");
830 if (sent_messages_cnt
< MAXKEYMESSAGES
)
832 sent_messages
[sent_messages_cnt
].message
= Msg
;
833 sent_messages
[sent_messages_cnt
].flags
= 0;
834 sent_messages
[sent_messages_cnt
].wParam
= wParam
;
835 sent_messages
[sent_messages_cnt
++].lParam
= HIWORD(lParam
) & (KF_UP
|KF_EXTENDED
);
838 return DefWindowProc(hWnd
, Msg
, wParam
, lParam
);
841 static LRESULT CALLBACK
hook_proc(int code
, WPARAM wparam
, LPARAM lparam
)
843 KBDLLHOOKSTRUCT
*hook_info
= (KBDLLHOOKSTRUCT
*)lparam
;
845 if (code
== HC_ACTION
)
847 ok(sent_messages_cnt
< MAXKEYMESSAGES
, "Too many messages\n");
848 if (sent_messages_cnt
< MAXKEYMESSAGES
)
850 sent_messages
[sent_messages_cnt
].message
= wparam
;
851 sent_messages
[sent_messages_cnt
].flags
= hook
;
852 sent_messages
[sent_messages_cnt
].wParam
= hook_info
->vkCode
;
853 sent_messages
[sent_messages_cnt
++].lParam
= hook_info
->flags
& (LLKHF_UP
|LLKHF_EXTENDED
);
856 if(0) /* For some reason not stable on Wine */
858 if (wparam
== WM_KEYDOWN
|| wparam
== WM_SYSKEYDOWN
)
859 ok(!(GetAsyncKeyState(hook_info
->vkCode
) & 0x8000), "key %x should be up\n", hook_info
->vkCode
);
860 else if (wparam
== WM_KEYUP
|| wparam
== WM_SYSKEYUP
)
861 ok(GetAsyncKeyState(hook_info
->vkCode
) & 0x8000, "key %x should be down\n", hook_info
->vkCode
);
864 if (winetest_debug
> 1)
865 trace("Hook: w=%lx vk:%8x sc:%8x fl:%8x %lx\n", wparam
,
866 hook_info
->vkCode
, hook_info
->scanCode
, hook_info
->flags
, hook_info
->dwExtraInfo
);
868 return CallNextHookEx( 0, code
, wparam
, lparam
);
870 static void test_Input_blackbox(void)
874 BYTE ks1
[256], ks2
[256];
875 LONG_PTR prevWndProc
;
879 window
= CreateWindow("Static", NULL
, WS_POPUP
|WS_HSCROLL
|WS_VSCROLL
880 |WS_VISIBLE
, 0, 0, 200, 60, NULL
, NULL
,
882 ok(window
!= NULL
, "error: %d\n", (int) GetLastError());
883 SetWindowPos( window
, HWND_TOPMOST
, 0, 0, 0, 0, SWP_NOSIZE
|SWP_NOMOVE
);
884 SetForegroundWindow( window
);
886 hook
= SetWindowsHookExA(WH_KEYBOARD_LL
, hook_proc
, GetModuleHandleA( NULL
), 0);
888 /* must process all initial messages, otherwise X11DRV_KeymapNotify unsets
889 * key state set by SendInput(). */
890 empty_message_queue();
892 prevWndProc
= SetWindowLongPtr(window
, GWLP_WNDPROC
, (LONG_PTR
) WndProc2
);
893 ok(prevWndProc
!= 0 || (prevWndProc
== 0 && GetLastError() == 0),
894 "error: %d\n", (int) GetLastError());
896 i
.type
= INPUT_KEYBOARD
;
898 i
.u
.ki
.dwExtraInfo
= 0;
900 for (ii
= 0; ii
< sizeof(sendinput_test
)/sizeof(struct sendinput_test_s
)-1;
902 GetKeyboardState(ks1
);
903 i
.u
.ki
.wScan
= ii
+1 /* useful for debugging */;
904 i
.u
.ki
.dwFlags
= sendinput_test
[ii
].dwFlags
;
905 i
.u
.ki
.wVk
= sendinput_test
[ii
].wVk
;
906 pSendInput(1, (INPUT
*)&i
, sizeof(TEST_INPUT
));
907 empty_message_queue();
908 GetKeyboardState(ks2
);
909 if (!ii
&& sent_messages_cnt
<= 1 && !memcmp( ks1
, ks2
, sizeof(ks1
) ))
911 win_skip( "window doesn't receive the queued input\n" );
912 /* release the key */
913 i
.u
.ki
.dwFlags
|= KEYEVENTF_KEYUP
;
914 pSendInput(1, (INPUT
*)&i
, sizeof(TEST_INPUT
));
917 compare_and_check(ii
, ks1
, ks2
, &sendinput_test
[ii
]);
920 empty_message_queue();
921 DestroyWindow(window
);
922 UnhookWindowsHookEx(hook
);
925 static void test_keynames(void)
930 for (i
= 0; i
< 512; i
++)
932 strcpy(buff
, "----");
933 len
= GetKeyNameTextA(i
<< 16, buff
, sizeof(buff
));
934 ok(len
|| !buff
[0], "%d: Buffer is not zeroed\n", i
);
938 static POINT pt_old
, pt_new
;
942 static LRESULT CALLBACK
hook_proc1( int code
, WPARAM wparam
, LPARAM lparam
)
944 MSLLHOOKSTRUCT
*hook
= (MSLLHOOKSTRUCT
*)lparam
;
947 if (code
== HC_ACTION
)
949 /* This is our new cursor position */
951 /* Should return previous position */
953 ok(pt
.x
== pt_old
.x
&& pt
.y
== pt_old
.y
, "GetCursorPos: (%d,%d)\n", pt
.x
, pt
.y
);
955 /* Should set new position until hook chain is finished. */
956 pt
.x
= pt_old
.x
+ STEP
;
957 pt
.y
= pt_old
.y
+ STEP
;
958 SetCursorPos(pt
.x
, pt
.y
);
961 ok(pt1
.x
== pt_old
.x
&& pt1
.y
== pt_old
.y
, "Wrong set pos: (%d,%d)\n", pt1
.x
, pt1
.y
);
963 ok(pt1
.x
== pt
.x
&& pt1
.y
== pt
.y
, "Wrong set pos: (%d,%d)\n", pt1
.x
, pt1
.y
);
965 return CallNextHookEx( 0, code
, wparam
, lparam
);
968 static LRESULT CALLBACK
hook_proc2( int code
, WPARAM wparam
, LPARAM lparam
)
970 MSLLHOOKSTRUCT
*hook
= (MSLLHOOKSTRUCT
*)lparam
;
973 if (code
== HC_ACTION
)
975 ok(hook
->pt
.x
== pt_new
.x
&& hook
->pt
.y
== pt_new
.y
,
976 "Wrong hook coords: (%d %d) != (%d,%d)\n", hook
->pt
.x
, hook
->pt
.y
, pt_new
.x
, pt_new
.y
);
978 /* Should match position set above */
981 ok(pt
.x
== pt_old
.x
&& pt
.y
== pt_old
.y
, "GetCursorPos: (%d,%d)\n", pt
.x
, pt
.y
);
983 ok(pt
.x
== pt_old
.x
+STEP
&& pt
.y
== pt_old
.y
+STEP
, "GetCursorPos: (%d,%d)\n", pt
.x
, pt
.y
);
985 return CallNextHookEx( 0, code
, wparam
, lparam
);
988 static void test_mouse_ll_hook(void)
995 GetCursorPos(&pt_org
);
996 hwnd
= CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW
| WS_VISIBLE
,
997 10, 10, 200, 200, NULL
, NULL
, NULL
, NULL
);
998 SetCursorPos(100, 100);
1000 if (!(hook2
= SetWindowsHookExA(WH_MOUSE_LL
, hook_proc2
, GetModuleHandleA(0), 0)))
1002 win_skip( "cannot set MOUSE_LL hook\n" );
1005 hook1
= SetWindowsHookExA(WH_MOUSE_LL
, hook_proc1
, GetModuleHandleA(0), 0);
1007 GetCursorPos(&pt_old
);
1008 mouse_event(MOUSEEVENTF_MOVE
, -STEP
, 0, 0, 0);
1009 GetCursorPos(&pt_old
);
1010 ok(pt_old
.x
== pt_new
.x
&& pt_old
.y
== pt_new
.y
, "Wrong new pos: (%d,%d)\n", pt_old
.x
, pt_old
.y
);
1011 mouse_event(MOUSEEVENTF_MOVE
, +STEP
, 0, 0, 0);
1012 GetCursorPos(&pt_old
);
1013 ok(pt_old
.x
== pt_new
.x
&& pt_old
.y
== pt_new
.y
, "Wrong new pos: (%d,%d)\n", pt_old
.x
, pt_old
.y
);
1014 mouse_event(MOUSEEVENTF_MOVE
, 0, -STEP
, 0, 0);
1015 GetCursorPos(&pt_old
);
1016 ok(pt_old
.x
== pt_new
.x
&& pt_old
.y
== pt_new
.y
, "Wrong new pos: (%d,%d)\n", pt_old
.x
, pt_old
.y
);
1017 mouse_event(MOUSEEVENTF_MOVE
, 0, +STEP
, 0, 0);
1018 GetCursorPos(&pt_old
);
1019 ok(pt_old
.x
== pt_new
.x
&& pt_old
.y
== pt_new
.y
, "Wrong new pos: (%d,%d)\n", pt_old
.x
, pt_old
.y
);
1021 SetRect(&rc
, 50, 50, 151, 151);
1025 SetCursorPos(40, 40);
1026 GetCursorPos(&pt_old
);
1027 ok(pt_old
.x
== 50 && pt_old
.y
== 50, "Wrong new pos: (%d,%d)\n", pt_new
.x
, pt_new
.y
);
1028 SetCursorPos(160, 160);
1029 GetCursorPos(&pt_old
);
1030 ok(pt_old
.x
== 150 && pt_old
.y
== 150, "Wrong new pos: (%d,%d)\n", pt_new
.x
, pt_new
.y
);
1031 mouse_event(MOUSEEVENTF_MOVE
, +STEP
, +STEP
, 0, 0);
1032 GetCursorPos(&pt_old
);
1033 ok(pt_old
.x
== 150 && pt_old
.y
== 150, "Wrong new pos: (%d,%d)\n", pt_new
.x
, pt_new
.y
);
1036 pt_new
.x
= pt_new
.y
= 150;
1038 UnhookWindowsHookEx(hook1
);
1040 /* Now check that mouse buttons do not change mouse position
1041 if we don't have MOUSEEVENTF_MOVE flag specified. */
1043 /* We reusing the same hook callback, so make it happy */
1044 pt_old
.x
= pt_new
.x
- STEP
;
1045 pt_old
.y
= pt_new
.y
- STEP
;
1046 mouse_event(MOUSEEVENTF_LEFTUP
, 123, 456, 0, 0);
1048 ok(pt
.x
== pt_new
.x
&& pt
.y
== pt_new
.y
, "Position changed: (%d,%d)\n", pt
.x
, pt
.y
);
1049 mouse_event(MOUSEEVENTF_RIGHTUP
, 456, 123, 0, 0);
1051 ok(pt
.x
== pt_new
.x
&& pt
.y
== pt_new
.y
, "Position changed: (%d,%d)\n", pt
.x
, pt
.y
);
1053 mouse_event(MOUSEEVENTF_LEFTUP
| MOUSEEVENTF_ABSOLUTE
, 123, 456, 0, 0);
1055 ok(pt
.x
== pt_new
.x
&& pt
.y
== pt_new
.y
, "Position changed: (%d,%d)\n", pt
.x
, pt
.y
);
1056 mouse_event(MOUSEEVENTF_RIGHTUP
| MOUSEEVENTF_ABSOLUTE
, 456, 123, 0, 0);
1058 ok(pt
.x
== pt_new
.x
&& pt
.y
== pt_new
.y
, "Position changed: (%d,%d)\n", pt
.x
, pt
.y
);
1060 UnhookWindowsHookEx(hook2
);
1062 DestroyWindow(hwnd
);
1063 SetCursorPos(pt_org
.x
, pt_org
.y
);
1066 static void test_GetMouseMovePointsEx(void)
1069 #define MYERROR 0xdeadbeef
1072 MOUSEMOVEPOINT out
[200];
1075 /* Get a valid content for the input struct */
1076 if(!GetCursorPos(&point
)) {
1077 skip("GetCursorPos() failed with error %u\n", GetLastError());
1080 memset(&in
, 0, sizeof(MOUSEMOVEPOINT
));
1084 /* test first parameter
1085 * everything different than sizeof(MOUSEMOVEPOINT)
1086 * is expected to fail with ERROR_INVALID_PARAMETER
1088 SetLastError(MYERROR
);
1089 retval
= pGetMouseMovePointsEx(0, &in
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1090 if (retval
== ERROR_INVALID_PARAMETER
)
1092 win_skip( "GetMouseMovePointsEx broken on WinME\n" );
1095 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1096 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1097 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1099 SetLastError(MYERROR
);
1100 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
)-1, &in
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1101 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1102 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1103 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1105 SetLastError(MYERROR
);
1106 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
)+1, &in
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1107 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1108 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1109 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1111 /* test second and third parameter
1113 SetLastError(MYERROR
);
1114 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), NULL
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1115 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1116 ok(GetLastError() == ERROR_NOACCESS
|| GetLastError() == MYERROR
,
1117 "expected error ERROR_NOACCESS, got %u\n", GetLastError());
1119 SetLastError(MYERROR
);
1120 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, NULL
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1121 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1122 ok(ERROR_NOACCESS
== GetLastError(),
1123 "expected error ERROR_NOACCESS, got %u\n", GetLastError());
1125 SetLastError(MYERROR
);
1126 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), NULL
, NULL
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1127 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1128 ok(ERROR_NOACCESS
== GetLastError(),
1129 "expected error ERROR_NOACCESS, got %u\n", GetLastError());
1131 SetLastError(MYERROR
);
1133 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, NULL
, count
, GMMP_USE_DISPLAY_POINTS
);
1135 ok(GetLastError() == ERROR_POINT_NOT_FOUND
, "unexpected error %u\n", GetLastError());
1137 ok(retval
== count
, "expected GetMouseMovePointsEx to succeed, got %d\n", retval
);
1139 /* test fourth parameter
1140 * a value higher than 64 is expected to fail with ERROR_INVALID_PARAMETER
1142 SetLastError(MYERROR
);
1144 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, out
, count
, GMMP_USE_DISPLAY_POINTS
);
1145 ok(retval
== count
, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1146 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1147 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1149 SetLastError(MYERROR
);
1151 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, out
, count
, GMMP_USE_DISPLAY_POINTS
);
1153 ok(GetLastError() == ERROR_POINT_NOT_FOUND
, "unexpected error %u\n", GetLastError());
1155 ok(retval
== count
, "expected GetMouseMovePointsEx to succeed, got %d\n", retval
);
1157 SetLastError(MYERROR
);
1159 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, out
, count
, GMMP_USE_DISPLAY_POINTS
);
1161 ok(GetLastError() == ERROR_POINT_NOT_FOUND
, "unexpected error %u\n", GetLastError());
1163 ok((0 <= retval
) && (retval
<= count
), "expected GetMouseMovePointsEx to succeed, got %d\n", retval
);
1165 SetLastError(MYERROR
);
1166 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, out
, BUFLIM
+1, GMMP_USE_DISPLAY_POINTS
);
1167 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1168 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1169 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1171 /* it was not possible to force an error with the fifth parameter on win2k */
1173 /* test combinations of wrong parameters to see which error wins */
1174 SetLastError(MYERROR
);
1175 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
)-1, NULL
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1176 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1177 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1178 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1180 SetLastError(MYERROR
);
1181 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
)-1, &in
, NULL
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1182 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1183 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1184 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1186 SetLastError(MYERROR
);
1187 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), NULL
, out
, BUFLIM
+1, GMMP_USE_DISPLAY_POINTS
);
1188 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1189 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1190 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1192 SetLastError(MYERROR
);
1193 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, NULL
, BUFLIM
+1, GMMP_USE_DISPLAY_POINTS
);
1194 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1195 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1196 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1202 static void test_key_map(void)
1204 HKL kl
= GetKeyboardLayout(0);
1207 static const UINT numpad_collisions
[][2] = {
1208 { VK_NUMPAD0
, VK_INSERT
},
1209 { VK_NUMPAD1
, VK_END
},
1210 { VK_NUMPAD2
, VK_DOWN
},
1211 { VK_NUMPAD3
, VK_NEXT
},
1212 { VK_NUMPAD4
, VK_LEFT
},
1213 { VK_NUMPAD6
, VK_RIGHT
},
1214 { VK_NUMPAD7
, VK_HOME
},
1215 { VK_NUMPAD8
, VK_UP
},
1216 { VK_NUMPAD9
, VK_PRIOR
},
1219 s
= MapVirtualKeyEx(VK_SHIFT
, MAPVK_VK_TO_VSC
, kl
);
1220 ok(s
!= 0, "MapVirtualKeyEx(VK_SHIFT) should return non-zero\n");
1221 sL
= MapVirtualKeyEx(VK_LSHIFT
, MAPVK_VK_TO_VSC
, kl
);
1222 ok(s
== sL
|| broken(sL
== 0), /* win9x */
1223 "%x != %x\n", s
, sL
);
1225 kL
= MapVirtualKeyEx(0x2a, MAPVK_VSC_TO_VK
, kl
);
1226 ok(kL
== VK_SHIFT
, "Scan code -> vKey = %x (not VK_SHIFT)\n", kL
);
1227 kR
= MapVirtualKeyEx(0x36, MAPVK_VSC_TO_VK
, kl
);
1228 ok(kR
== VK_SHIFT
, "Scan code -> vKey = %x (not VK_SHIFT)\n", kR
);
1230 kL
= MapVirtualKeyEx(0x2a, MAPVK_VSC_TO_VK_EX
, kl
);
1231 ok(kL
== VK_LSHIFT
|| broken(kL
== 0), /* win9x */
1232 "Scan code -> vKey = %x (not VK_LSHIFT)\n", kL
);
1233 kR
= MapVirtualKeyEx(0x36, MAPVK_VSC_TO_VK_EX
, kl
);
1234 ok(kR
== VK_RSHIFT
|| broken(kR
== 0), /* win9x */
1235 "Scan code -> vKey = %x (not VK_RSHIFT)\n", kR
);
1237 /* test that MAPVK_VSC_TO_VK prefers the non-numpad vkey if there's ambiguity */
1238 for (i
= 0; i
< sizeof(numpad_collisions
)/sizeof(numpad_collisions
[0]); i
++)
1240 UINT numpad_scan
= MapVirtualKeyEx(numpad_collisions
[i
][0], MAPVK_VK_TO_VSC
, kl
);
1241 UINT other_scan
= MapVirtualKeyEx(numpad_collisions
[i
][1], MAPVK_VK_TO_VSC
, kl
);
1243 /* do they really collide for this layout? */
1244 if (numpad_scan
&& other_scan
== numpad_scan
)
1246 UINT vkey
= MapVirtualKeyEx(numpad_scan
, MAPVK_VSC_TO_VK
, kl
);
1247 ok(vkey
!= numpad_collisions
[i
][0],
1248 "Got numpad vKey %x for scan code %x when there was another choice\n",
1254 static void test_ToUnicode(void)
1258 const BYTE SC_RETURN
= 0x1c, SC_TAB
= 0x0f;
1259 const BYTE HIGHEST_BIT
= 0x80;
1261 for(i
=0; i
<256; i
++)
1264 SetLastError(0xdeadbeef);
1265 ret
= ToUnicode(VK_RETURN
, SC_RETURN
, state
, wStr
, 2, 0);
1266 if (!ret
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
1268 win_skip("ToUnicode is not implemented\n");
1272 ok(ret
== 1, "ToUnicode for Return key didn't return 1 (was %i)\n", ret
);
1274 ok(wStr
[0]=='\r', "ToUnicode for CTRL + Return was %i (expected 13)\n", wStr
[0]);
1275 state
[VK_CONTROL
] |= HIGHEST_BIT
;
1276 state
[VK_LCONTROL
] |= HIGHEST_BIT
;
1278 ret
= ToUnicode(VK_TAB
, SC_TAB
, state
, wStr
, 2, 0);
1279 ok(ret
== 0, "ToUnicode for CTRL + Tab didn't return 0 (was %i)\n", ret
);
1281 ret
= ToUnicode(VK_RETURN
, SC_RETURN
, state
, wStr
, 2, 0);
1282 ok(ret
== 1, "ToUnicode for CTRL + Return didn't return 1 (was %i)\n", ret
);
1284 ok(wStr
[0]=='\n', "ToUnicode for CTRL + Return was %i (expected 10)\n", wStr
[0]);
1286 state
[VK_SHIFT
] |= HIGHEST_BIT
;
1287 state
[VK_LSHIFT
] |= HIGHEST_BIT
;
1288 ret
= ToUnicode(VK_TAB
, SC_TAB
, state
, wStr
, 2, 0);
1289 ok(ret
== 0, "ToUnicode for CTRL + SHIFT + Tab didn't return 0 (was %i)\n", ret
);
1290 ret
= ToUnicode(VK_RETURN
, SC_RETURN
, state
, wStr
, 2, 0);
1291 todo_wine
ok(ret
== 0, "ToUnicode for CTRL + SHIFT + Return didn't return 0 (was %i)\n", ret
);
1294 static void test_get_async_key_state(void)
1296 /* input value sanity checks */
1297 ok(0 == GetAsyncKeyState(1000000), "GetAsyncKeyState did not return 0\n");
1298 ok(0 == GetAsyncKeyState(-1000000), "GetAsyncKeyState did not return 0\n");
1301 static void test_keyboard_layout_name(void)
1304 char klid
[KL_NAMELENGTH
];
1306 if (GetKeyboardLayout(0) != (HKL
)(ULONG_PTR
)0x04090409) return;
1309 ret
= GetKeyboardLayoutNameA(klid
);
1310 ok(ret
, "GetKeyboardLayoutNameA failed %u\n", GetLastError());
1311 ok(!strcmp(klid
, "00000409"), "expected 00000409, got %s\n", klid
);
1316 init_function_pointers();
1320 test_Input_blackbox();
1321 test_Input_whitebox();
1323 else win_skip("SendInput is not available\n");
1326 test_mouse_ll_hook();
1329 test_get_async_key_state();
1330 test_keyboard_layout_name();
1332 if(pGetMouseMovePointsEx
)
1333 test_GetMouseMovePointsEx();
1335 win_skip("GetMouseMovePointsEx is not available\n");