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;
66 LONG last_syskey_down
;
72 LONG last_hook_syskey_down
;
73 LONG last_hook_syskey_up
;
75 BOOL sendinput_broken
;
78 static UINT (WINAPI
*pSendInput
) (UINT
, INPUT
*, size_t);
79 static int (WINAPI
*pGetMouseMovePointsEx
) (UINT
, LPMOUSEMOVEPOINT
, LPMOUSEMOVEPOINT
, int, DWORD
);
81 #define MAXKEYEVENTS 12
82 #define MAXKEYMESSAGES MAXKEYEVENTS /* assuming a key event generates one
83 and only one message */
85 /* keyboard message names, sorted as their value */
86 static const char *MSGNAME
[]={"WM_KEYDOWN", "WM_KEYUP", "WM_CHAR","WM_DEADCHAR",
87 "WM_SYSKEYDOWN", "WM_SYSKEYUP", "WM_SYSCHAR", "WM_SYSDEADCHAR" ,"WM_KEYLAST"};
89 /* keyevents, add more as needed */
91 { ALTDOWN
= 1, ALTUP
, XDOWN
, XUP
, SHIFTDOWN
, SHIFTUP
, CTRLDOWN
, CTRLUP
} KEV
;
93 static const int GETVKEY
[]={0, VK_MENU
, VK_MENU
, 'X', 'X', VK_SHIFT
, VK_SHIFT
, VK_CONTROL
, VK_CONTROL
};
94 /* matching scan codes */
95 static const int GETSCAN
[]={0, 0x38, 0x38, 0x2D, 0x2D, 0x2A, 0x2A, 0x1D, 0x1D };
96 /* matching updown events */
97 static const int GETFLAGS
[]={0, 0, KEYEVENTF_KEYUP
, 0, KEYEVENTF_KEYUP
, 0, KEYEVENTF_KEYUP
, 0, KEYEVENTF_KEYUP
};
98 /* matching descriptions */
99 static const char *getdesc
[]={"", "+alt","-alt","+X","-X","+shift","-shift","+ctrl","-ctrl"};
101 /* The MSVC headers ignore our NONAMELESSUNION requests so we have to define our own type */
113 #define ADDTOINPUTS(kev) \
114 inputs[evtctr].type = INPUT_KEYBOARD; \
115 ((TEST_INPUT*)inputs)[evtctr].u.ki.wVk = GETVKEY[ kev]; \
116 ((TEST_INPUT*)inputs)[evtctr].u.ki.wScan = GETSCAN[ kev]; \
117 ((TEST_INPUT*)inputs)[evtctr].u.ki.dwFlags = GETFLAGS[ kev]; \
118 ((TEST_INPUT*)inputs)[evtctr].u.ki.dwExtraInfo = 0; \
119 ((TEST_INPUT*)inputs)[evtctr].u.ki.time = ++timetag; \
128 /*******************************************
129 * add new test sets here
130 * the software will make all combinations of the
131 * keyevent defined here
133 static const struct {
135 KEV keydwn
[MAXKEYEVENTS
];
136 KEV keyup
[MAXKEYEVENTS
];
138 { 2, { ALTDOWN
, XDOWN
}, { ALTUP
, XUP
}},
139 { 3, { ALTDOWN
, XDOWN
, SHIFTDOWN
}, { ALTUP
, XUP
, SHIFTUP
}},
140 { 3, { ALTDOWN
, XDOWN
, CTRLDOWN
}, { ALTUP
, XUP
, CTRLUP
}},
141 { 3, { SHIFTDOWN
, XDOWN
, CTRLDOWN
}, { SHIFTUP
, XUP
, CTRLUP
}},
142 { 0 } /* mark the end */
145 /**********************adapted from input.c **********************************/
147 static BYTE InputKeyStateTable
[256];
148 static BYTE AsyncKeyStateTable
[256];
149 static BYTE TrackSysKey
= 0; /* determine whether ALT key up will cause a WM_SYSKEYUP
150 or a WM_KEYUP message */
152 static void init_function_pointers(void)
154 HMODULE hdll
= GetModuleHandleA("user32");
156 #define GET_PROC(func) \
157 p ## func = (void*)GetProcAddress(hdll, #func); \
159 trace("GetProcAddress(%s) failed\n", #func);
162 GET_PROC(GetMouseMovePointsEx
)
167 static int KbdMessage( KEV kev
, WPARAM
*pwParam
, LPARAM
*plParam
)
170 int VKey
= GETVKEY
[kev
];
173 flags
= LOBYTE(GETSCAN
[kev
]);
174 if (GETFLAGS
[kev
] & KEYEVENTF_EXTENDEDKEY
) flags
|= KF_EXTENDED
;
176 if (GETFLAGS
[kev
] & KEYEVENTF_KEYUP
)
179 if( (InputKeyStateTable
[VK_MENU
] & 0x80) && (
180 (VKey
== VK_MENU
) || (VKey
== VK_CONTROL
) ||
181 !(InputKeyStateTable
[VK_CONTROL
] & 0x80))) {
182 if( TrackSysKey
== VK_MENU
|| /* <ALT>-down/<ALT>-up sequence */
183 (VKey
!= VK_MENU
)) /* <ALT>-down...<something else>-up */
184 message
= WM_SYSKEYUP
;
187 InputKeyStateTable
[VKey
] &= ~0x80;
188 flags
|= KF_REPEAT
| KF_UP
;
192 if (InputKeyStateTable
[VKey
] & 0x80) flags
|= KF_REPEAT
;
193 if (!(InputKeyStateTable
[VKey
] & 0x80)) InputKeyStateTable
[VKey
] ^= 0x01;
194 InputKeyStateTable
[VKey
] |= 0x80;
195 AsyncKeyStateTable
[VKey
] |= 0x80;
197 message
= WM_KEYDOWN
;
198 if( (InputKeyStateTable
[VK_MENU
] & 0x80) &&
199 !(InputKeyStateTable
[VK_CONTROL
] & 0x80)) {
200 message
= WM_SYSKEYDOWN
;
205 if (InputKeyStateTable
[VK_MENU
] & 0x80) flags
|= KF_ALTDOWN
;
207 if( plParam
) *plParam
= MAKELPARAM( 1, flags
);
208 if( pwParam
) *pwParam
= VKey
;
212 /****************************** end copy input.c ****************************/
215 * . prepare the keyevents for SendInputs
216 * . calculate the "expected" messages
217 * . Send the events to our window
218 * . retrieve the messages from the input queue
221 static BOOL
do_test( HWND hwnd
, int seqnr
, const KEV td
[] )
223 INPUT inputs
[MAXKEYEVENTS
];
224 KMSG expmsg
[MAXKEYEVENTS
];
231 TrackSysKey
=0; /* see input.c */
232 for( i
= 0; i
< MAXKEYEVENTS
; i
++) {
234 strcat(buf
, getdesc
[td
[i
]]);
236 expmsg
[i
].message
= KbdMessage(td
[i
], &(expmsg
[i
].wParam
), &(expmsg
[i
].lParam
));
238 expmsg
[i
].message
= 0;
240 for( kmctr
= 0; kmctr
< MAXKEYEVENTS
&& expmsg
[kmctr
].message
; kmctr
++)
242 ok( evtctr
<= MAXKEYEVENTS
, "evtctr is above MAXKEYEVENTS\n" );
243 if( evtctr
!= pSendInput(evtctr
, &inputs
[0], sizeof(INPUT
)))
244 ok (FALSE
, "SendInput failed to send some events\n");
246 if (winetest_debug
> 1)
247 trace("======== key stroke sequence #%d: %s =============\n",
249 while( PeekMessage(&msg
,hwnd
,WM_KEYFIRST
,WM_KEYLAST
,PM_REMOVE
) ) {
250 if (winetest_debug
> 1)
251 trace("message[%d] %-15s wParam %04lx lParam %08lx time %x\n", i
,
252 MSGNAME
[msg
.message
- WM_KEYFIRST
], msg
.wParam
, msg
.lParam
, msg
.time
);
254 ok( msg
.message
== expmsg
[i
].message
&&
255 msg
.wParam
== expmsg
[i
].wParam
&&
256 msg
.lParam
== expmsg
[i
].lParam
,
257 "%u/%u: wrong message %x/%08lx/%08lx expected %s/%08lx/%08lx\n",
258 seqnr
, i
, msg
.message
, msg
.wParam
, msg
.lParam
,
259 MSGNAME
[(expmsg
[i
]).message
- WM_KEYFIRST
], expmsg
[i
].wParam
, expmsg
[i
].lParam
);
263 if (winetest_debug
> 1)
264 trace("%d messages retrieved\n", i
);
267 skip( "simulated keyboard input doesn't work\n" );
270 ok( i
== kmctr
, "message count is wrong: got %d expected: %d\n", i
, kmctr
);
274 /* test all combinations of the specified key events */
275 static BOOL
TestASet( HWND hWnd
, int nrkev
, const KEV kevdwn
[], const KEV kevup
[] )
279 KEV kbuf
[MAXKEYEVENTS
];
280 assert( nrkev
==2 || nrkev
==3);
281 for(i
=0;i
<MAXKEYEVENTS
;i
++) kbuf
[i
]=0;
282 /* two keys involved gives 4 test cases */
284 for(i
=0;i
<nrkev
;i
++) {
285 for(j
=0;j
<nrkev
;j
++) {
287 kbuf
[1] = kevdwn
[1-i
];
289 kbuf
[3] = kevup
[1-j
];
290 if (!do_test( hWnd
, count
++, kbuf
)) return FALSE
;
294 /* three keys involved gives 36 test cases */
296 for(i
=0;i
<nrkev
;i
++){
297 for(j
=0;j
<nrkev
;j
++){
299 for(k
=0;k
<nrkev
;k
++){
300 if(k
==i
|| k
==j
) continue;
301 for(l
=0;l
<nrkev
;l
++){
302 for(m
=0;m
<nrkev
;m
++){
304 for(n
=0;n
<nrkev
;n
++){
305 if(n
==l
||n
==m
) continue;
312 if (!do_test( hWnd
, count
++, kbuf
)) return FALSE
;
323 /* test each set specified in the global testkeyset array */
324 static void TestSysKeys( HWND hWnd
)
327 for(i
=0; testkeyset
[i
].nrkev
;i
++)
328 if (!TestASet( hWnd
, testkeyset
[i
].nrkev
, testkeyset
[i
].keydwn
, testkeyset
[i
].keyup
)) break;
331 static LRESULT CALLBACK
WndProc( HWND hWnd
, UINT msg
, WPARAM wParam
,
334 return DefWindowProcA( hWnd
, msg
, wParam
, lParam
);
337 static void test_Input_whitebox(void)
341 HANDLE hInstance
= GetModuleHandleA( NULL
);
343 wclass
.lpszClassName
= "InputSysKeyTestClass";
344 wclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
345 wclass
.lpfnWndProc
= WndProc
;
346 wclass
.hInstance
= hInstance
;
347 wclass
.hIcon
= LoadIconA( 0, IDI_APPLICATION
);
348 wclass
.hCursor
= LoadCursorA( NULL
, IDC_ARROW
);
349 wclass
.hbrBackground
= (HBRUSH
)( COLOR_WINDOW
+ 1 );
350 wclass
.lpszMenuName
= 0;
351 wclass
.cbClsExtra
= 0;
352 wclass
.cbWndExtra
= 0;
353 RegisterClassA( &wclass
);
354 /* create the test window that will receive the keystrokes */
355 hWndTest
= CreateWindowA( wclass
.lpszClassName
, "InputSysKeyTest",
356 WS_OVERLAPPEDWINDOW
, CW_USEDEFAULT
, 0, 100, 100,
357 NULL
, NULL
, hInstance
, NULL
);
359 ShowWindow( hWndTest
, SW_SHOW
);
360 SetWindowPos( hWndTest
, HWND_TOPMOST
, 0, 0, 0, 0, SWP_NOSIZE
|SWP_NOMOVE
);
361 SetForegroundWindow( hWndTest
);
362 UpdateWindow( hWndTest
);
364 /* flush pending messages */
365 while (PeekMessage( &msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessageA( &msg
);
367 SetFocus( hWndTest
);
368 TestSysKeys( hWndTest
);
369 DestroyWindow(hWndTest
);
372 static inline BOOL
is_keyboard_message( UINT message
)
374 return (message
>= WM_KEYFIRST
&& message
<= WM_KEYLAST
);
377 static inline BOOL
is_mouse_message( UINT message
)
379 return (message
>= WM_MOUSEFIRST
&& message
<= WM_MOUSELAST
);
382 /* try to make sure pending X events have been processed before continuing */
383 static void empty_message_queue(void)
387 int min_timeout
= 50;
388 DWORD time
= GetTickCount() + diff
;
392 if (MsgWaitForMultipleObjects(0, NULL
, FALSE
, min_timeout
, QS_ALLINPUT
) == WAIT_TIMEOUT
) break;
393 while (PeekMessage(&msg
, 0, 0, 0, PM_REMOVE
))
395 if (is_keyboard_message(msg
.message
) || is_mouse_message(msg
.message
))
396 ok(msg
.time
!= 0, "message %#x has time set to 0\n", msg
.message
);
398 TranslateMessage(&msg
);
399 DispatchMessage(&msg
);
401 diff
= time
- GetTickCount();
405 struct transition_s
{
425 UINT message
; /* the WM_* code */
426 msg_flags_t flags
; /* message props */
427 WPARAM wParam
; /* expected value of wParam */
428 LPARAM lParam
; /* expected value of lParam */
431 static const struct sendinput_test_s
{
435 struct transition_s expected_transitions
[MAXKEYEVENTS
+1];
436 struct message expected_messages
[MAXKEYMESSAGES
+1];
437 } sendinput_test
[] = {
440 {VK_LMENU
, 0, 0, {{VK_MENU
, 0x00}, {VK_LMENU
, 0x00}, {0}},
441 {{WM_SYSKEYDOWN
, hook
|wparam
, VK_LMENU
}, {WM_SYSKEYDOWN
}, {0}}},
442 {'F', 0, 0, {{'F', 0x00}, {0}},
443 {{WM_SYSKEYDOWN
, hook
}, {WM_SYSKEYDOWN
},
445 {WM_SYSCOMMAND
}, {0}}},
446 {'F', KEYEVENTF_KEYUP
, 0, {{'F', 0x80}, {0}},
447 {{WM_SYSKEYUP
, hook
}, {WM_SYSKEYUP
}, {0}}},
448 {VK_LMENU
, KEYEVENTF_KEYUP
, 0, {{VK_MENU
, 0x80}, {VK_LMENU
, 0x80}, {0}},
449 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
453 {VK_LCONTROL
, 0, 0, {{VK_CONTROL
, 0x00}, {VK_LCONTROL
, 0x00}, {0}},
454 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {0}}},
455 {'O', 0, 0, {{'O', 0x00}, {0}},
456 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {WM_CHAR
}, {0}}},
457 {'O', KEYEVENTF_KEYUP
, 0, {{'O', 0x80}, {0}},
458 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
459 {VK_LCONTROL
, KEYEVENTF_KEYUP
, 0, {{VK_CONTROL
, 0x80}, {VK_LCONTROL
, 0x80}, {0}},
460 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
462 /* test ALT+CTRL+X */
464 {VK_LMENU
, 0, 0, {{VK_MENU
, 0x00}, {VK_LMENU
, 0x00}, {0}},
465 {{WM_SYSKEYDOWN
, hook
}, {WM_SYSKEYDOWN
}, {0}}},
466 {VK_LCONTROL
, 0, 0, {{VK_CONTROL
, 0x00}, {VK_LCONTROL
, 0x00}, {0}},
467 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {0}}},
468 {'X', 0, 0, {{'X', 0x00}, {0}},
469 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {0}}},
470 {'X', KEYEVENTF_KEYUP
, 0, {{'X', 0x80}, {0}},
471 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
472 {VK_LCONTROL
, KEYEVENTF_KEYUP
, 0, {{VK_CONTROL
, 0x80}, {VK_LCONTROL
, 0x80}, {0}},
473 {{WM_SYSKEYUP
, hook
}, {WM_SYSKEYUP
}, {0}}},
474 {VK_LMENU
, KEYEVENTF_KEYUP
, 0, {{VK_MENU
, 0x80}, {VK_LMENU
, 0x80}, {0}},
475 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
479 {VK_LSHIFT
, 0, 0, {{VK_SHIFT
, 0x00}, {VK_LSHIFT
, 0x00}, {0}},
480 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {0}}},
481 {'A', 0, 0, {{'A', 0x00}, {0}},
482 {{WM_KEYDOWN
, hook
}, {WM_KEYDOWN
}, {WM_CHAR
}, {0}}},
483 {'A', KEYEVENTF_KEYUP
, 0, {{'A', 0x80}, {0}},
484 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
485 {VK_LSHIFT
, KEYEVENTF_KEYUP
, 0, {{VK_SHIFT
, 0x80}, {VK_LSHIFT
, 0x80}, {0}},
486 {{WM_KEYUP
, hook
}, {WM_KEYUP
}, {0}}},
487 /* test L-SHIFT & R-SHIFT: */
488 /* RSHIFT == LSHIFT */
491 /* recent windows versions (>= w2k3) correctly report an RSHIFT transition */
492 {{VK_SHIFT
, 0x00}, {VK_LSHIFT
, 0x00, TRUE
}, {VK_RSHIFT
, 0x00, TRUE
}, {0}},
493 {{WM_KEYDOWN
, hook
|wparam
, VK_RSHIFT
},
495 {VK_RSHIFT
, KEYEVENTF_KEYUP
, 0,
496 {{VK_SHIFT
, 0x80}, {VK_LSHIFT
, 0x80, TRUE
}, {VK_RSHIFT
, 0x80, TRUE
}, {0}},
497 {{WM_KEYUP
, hook
, hook
|wparam
, VK_RSHIFT
},
500 /* LSHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */
502 {VK_LSHIFT
, KEYEVENTF_EXTENDEDKEY
, 0,
503 {{VK_SHIFT
, 0x00}, {VK_RSHIFT
, 0x00}, {0}},
504 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_LSHIFT
, LLKHF_EXTENDED
},
505 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
506 {VK_LSHIFT
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
507 {{VK_SHIFT
, 0x80}, {VK_RSHIFT
, 0x80}, {0}},
508 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_LSHIFT
, LLKHF_UP
|LLKHF_EXTENDED
},
509 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
510 /* RSHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */
512 {VK_RSHIFT
, KEYEVENTF_EXTENDEDKEY
, 0,
513 {{VK_SHIFT
, 0x00}, {VK_RSHIFT
, 0x00}, {0}},
514 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_RSHIFT
, LLKHF_EXTENDED
},
515 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
516 {VK_RSHIFT
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
517 {{VK_SHIFT
, 0x80}, {VK_RSHIFT
, 0x80}, {0}},
518 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_RSHIFT
, LLKHF_UP
|LLKHF_EXTENDED
},
519 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
521 /* Note about wparam for hook with generic key (VK_SHIFT, VK_CONTROL, VK_MENU):
522 win2k - sends to hook whatever we generated here
523 winXP+ - Attempts to convert key to L/R key but not always correct
525 /* SHIFT == LSHIFT */
528 {{VK_SHIFT
, 0x00}, {VK_LSHIFT
, 0x00}, {0}},
529 {{WM_KEYDOWN
, hook
/* |wparam */|lparam
, VK_SHIFT
, 0},
530 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
531 {VK_SHIFT
, KEYEVENTF_KEYUP
, 0,
532 {{VK_SHIFT
, 0x80}, {VK_LSHIFT
, 0x80}, {0}},
533 {{WM_KEYUP
, hook
/*|wparam*/|lparam
, VK_SHIFT
, LLKHF_UP
},
534 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
535 /* SHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */
537 {VK_SHIFT
, KEYEVENTF_EXTENDEDKEY
, 0,
538 {{VK_SHIFT
, 0x00}, {VK_RSHIFT
, 0x00}, {0}},
539 {{WM_KEYDOWN
, hook
/*|wparam*/|lparam
, VK_SHIFT
, LLKHF_EXTENDED
},
540 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
541 {VK_SHIFT
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
542 {{VK_SHIFT
, 0x80}, {VK_RSHIFT
, 0x80}, {0}},
543 {{WM_KEYUP
, hook
/*|wparam*/|lparam
, VK_SHIFT
, LLKHF_UP
|LLKHF_EXTENDED
},
544 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
546 /* test L-CONTROL & R-CONTROL: */
547 /* RCONTROL == LCONTROL */
550 {{VK_CONTROL
, 0x00}, {VK_LCONTROL
, 0x00}, {0}},
551 {{WM_KEYDOWN
, hook
|wparam
, VK_RCONTROL
},
552 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, 0}, {0}}},
553 {VK_RCONTROL
, KEYEVENTF_KEYUP
, 0,
554 {{VK_CONTROL
, 0x80}, {VK_LCONTROL
, 0x80}, {0}},
555 {{WM_KEYUP
, hook
|wparam
, VK_RCONTROL
},
556 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
}, {0}}},
557 /* LCONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */
559 {VK_LCONTROL
, KEYEVENTF_EXTENDEDKEY
, 0,
560 {{VK_CONTROL
, 0x00}, {VK_RCONTROL
, 0x00}, {0}},
561 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_LCONTROL
, LLKHF_EXTENDED
},
562 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, KF_EXTENDED
}, {0}}},
563 {VK_LCONTROL
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
564 {{VK_CONTROL
, 0x80}, {VK_RCONTROL
, 0x80}, {0}},
565 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_LCONTROL
, LLKHF_UP
|LLKHF_EXTENDED
},
566 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
|KF_EXTENDED
}, {0}}},
567 /* RCONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */
569 {VK_RCONTROL
, KEYEVENTF_EXTENDEDKEY
, 0,
570 {{VK_CONTROL
, 0x00}, {VK_RCONTROL
, 0x00}, {0}},
571 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_RCONTROL
, LLKHF_EXTENDED
},
572 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, KF_EXTENDED
}, {0}}},
573 {VK_RCONTROL
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
574 {{VK_CONTROL
, 0x80}, {VK_RCONTROL
, 0x80}, {0}},
575 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_RCONTROL
, LLKHF_UP
|LLKHF_EXTENDED
},
576 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
|KF_EXTENDED
}, {0}}},
577 /* CONTROL == LCONTROL */
580 {{VK_CONTROL
, 0x00}, {VK_LCONTROL
, 0x00}, {0}},
581 {{WM_KEYDOWN
, hook
/*|wparam, VK_CONTROL*/},
582 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, 0}, {0}}},
583 {VK_CONTROL
, KEYEVENTF_KEYUP
, 0,
584 {{VK_CONTROL
, 0x80}, {VK_LCONTROL
, 0x80}, {0}},
585 {{WM_KEYUP
, hook
/*|wparam, VK_CONTROL*/},
586 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
}, {0}}},
587 /* CONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */
589 {VK_CONTROL
, KEYEVENTF_EXTENDEDKEY
, 0,
590 {{VK_CONTROL
, 0x00}, {VK_RCONTROL
, 0x00}, {0}},
591 {{WM_KEYDOWN
, hook
/*|wparam*/|lparam
, VK_CONTROL
, LLKHF_EXTENDED
},
592 {WM_KEYDOWN
, wparam
|lparam
, VK_CONTROL
, KF_EXTENDED
}, {0}}},
593 {VK_CONTROL
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
594 {{VK_CONTROL
, 0x80}, {VK_RCONTROL
, 0x80}, {0}},
595 {{WM_KEYUP
, hook
/*|wparam*/|lparam
, VK_CONTROL
, LLKHF_UP
|LLKHF_EXTENDED
},
596 {WM_KEYUP
, wparam
|lparam
, VK_CONTROL
, KF_UP
|KF_EXTENDED
}, {0}}},
598 /* test L-MENU & R-MENU: */
602 {{VK_MENU
, 0x00}, {VK_LMENU
, 0x00}, {VK_CONTROL
, 0x00, 1}, {VK_LCONTROL
, 0x01, 1}, {0}},
603 {{WM_SYSKEYDOWN
, hook
|wparam
|optional
, VK_LCONTROL
},
604 {WM_SYSKEYDOWN
, hook
|wparam
, VK_RMENU
},
605 {WM_KEYDOWN
, wparam
|lparam
|optional
, VK_CONTROL
, 0},
606 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, 0}, {0}}},
607 {VK_RMENU
, KEYEVENTF_KEYUP
, 1,
608 {{VK_MENU
, 0x80}, {VK_LMENU
, 0x80}, {VK_CONTROL
, 0x81, 1}, {VK_LCONTROL
, 0x80, 1}, {0}},
609 {{WM_KEYUP
, hook
|wparam
|optional
, VK_LCONTROL
},
610 {WM_KEYUP
, hook
|wparam
, VK_RMENU
},
611 {WM_SYSKEYUP
, wparam
|lparam
|optional
, VK_CONTROL
, KF_UP
},
612 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
},
613 {WM_SYSCOMMAND
, optional
}, {0}}},
614 /* LMENU | KEYEVENTF_EXTENDEDKEY == RMENU */
616 {VK_LMENU
, KEYEVENTF_EXTENDEDKEY
, 0,
617 {{VK_MENU
, 0x00}, {VK_RMENU
, 0x00}, {0}},
618 {{WM_SYSKEYDOWN
, hook
|wparam
|lparam
, VK_LMENU
, LLKHF_EXTENDED
},
619 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, KF_EXTENDED
}, {0}}},
620 {VK_LMENU
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 1,
621 {{VK_MENU
, 0x80}, {VK_RMENU
, 0x80}, {0}},
622 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_LMENU
, LLKHF_UP
|LLKHF_EXTENDED
},
623 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
|KF_EXTENDED
},
624 {WM_SYSCOMMAND
}, {0}}},
625 /* RMENU | KEYEVENTF_EXTENDEDKEY == RMENU */
627 {VK_RMENU
, KEYEVENTF_EXTENDEDKEY
, 0,
628 {{VK_MENU
, 0x00}, {VK_RMENU
, 0x00}, {VK_CONTROL
, 0x00, 1}, {VK_LCONTROL
, 0x01, 1}, {0}},
629 {{WM_SYSKEYDOWN
, hook
|wparam
|lparam
|optional
, VK_LCONTROL
, 0},
630 {WM_SYSKEYDOWN
, hook
|wparam
|lparam
, VK_RMENU
, LLKHF_EXTENDED
},
631 {WM_KEYDOWN
, wparam
|lparam
|optional
, VK_CONTROL
, 0},
632 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, KF_EXTENDED
}, {0}}},
633 {VK_RMENU
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 1,
634 {{VK_MENU
, 0x80}, {VK_RMENU
, 0x80}, {VK_CONTROL
, 0x81, 1}, {VK_LCONTROL
, 0x80, 1}, {0}},
635 {{WM_KEYUP
, hook
|wparam
|lparam
|optional
, VK_LCONTROL
, LLKHF_UP
},
636 {WM_KEYUP
, hook
|wparam
|lparam
, VK_RMENU
, LLKHF_UP
|LLKHF_EXTENDED
},
637 {WM_SYSKEYUP
, wparam
|lparam
|optional
, VK_CONTROL
, KF_UP
},
638 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
|KF_EXTENDED
},
639 {WM_SYSCOMMAND
, optional
}, {0}}},
643 {{VK_MENU
, 0x00}, {VK_LMENU
, 0x00}, {0}},
644 {{WM_SYSKEYDOWN
, hook
/*|wparam, VK_MENU*/},
645 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, 0}, {0}}},
646 {VK_MENU
, KEYEVENTF_KEYUP
, 1,
647 {{VK_MENU
, 0x80}, {VK_LMENU
, 0x80}, {0}},
648 {{WM_KEYUP
, hook
/*|wparam, VK_MENU*/},
649 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
},
650 {WM_SYSCOMMAND
}, {0}}},
651 /* MENU | KEYEVENTF_EXTENDEDKEY == RMENU */
653 {VK_MENU
, KEYEVENTF_EXTENDEDKEY
, 0,
654 {{VK_MENU
, 0x00}, {VK_RMENU
, 0x00}, {VK_CONTROL
, 0x00, 1}, {VK_LCONTROL
, 0x01, 1}, {0}},
655 {{WM_SYSKEYDOWN
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, 0},
656 {WM_SYSKEYDOWN
, hook
/*|wparam*/|lparam
, VK_MENU
, LLKHF_EXTENDED
},
657 {WM_SYSKEYDOWN
, wparam
|lparam
, VK_MENU
, KF_EXTENDED
}, {0}}},
658 {VK_MENU
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 1,
659 {{VK_MENU
, 0x80}, {VK_RMENU
, 0x80}, {VK_CONTROL
, 0x81, 1}, {VK_LCONTROL
, 0x80, 1}, {0}},
660 {{WM_KEYUP
, hook
|wparam
|lparam
|optional
, VK_CONTROL
, LLKHF_UP
},
661 {WM_KEYUP
, hook
/*|wparam*/|lparam
, VK_MENU
, LLKHF_UP
|LLKHF_EXTENDED
},
662 {WM_SYSKEYUP
, wparam
|lparam
, VK_MENU
, KF_UP
|KF_EXTENDED
},
663 {WM_SYSCOMMAND
}, {0}}},
665 /* test LSHIFT & RSHIFT */
668 {{VK_SHIFT
, 0x00}, {VK_LSHIFT
, 0x00}, {0}},
669 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_LSHIFT
, 0},
670 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
671 {VK_RSHIFT
, KEYEVENTF_EXTENDEDKEY
, 0,
672 {{VK_RSHIFT
, 0x00}, {0}},
673 {{WM_KEYDOWN
, hook
|wparam
|lparam
, VK_RSHIFT
, LLKHF_EXTENDED
},
674 {WM_KEYDOWN
, wparam
|lparam
, VK_SHIFT
, 0}, {0}}},
675 {VK_RSHIFT
, KEYEVENTF_KEYUP
| KEYEVENTF_EXTENDEDKEY
, 0,
676 {{VK_RSHIFT
, 0x80}, {0}},
677 {{WM_KEYUP
, hook
|wparam
|lparam
, VK_RSHIFT
, LLKHF_UP
|LLKHF_EXTENDED
},
678 {WM_KEYUP
, optional
}, {0}}},
679 {VK_LSHIFT
, KEYEVENTF_KEYUP
, 0,
680 {{VK_SHIFT
, 0x80}, {VK_LSHIFT
, 0x80}, {0}},
681 {{WM_KEYUP
, hook
|wparam
, VK_LSHIFT
},
682 {WM_KEYUP
, wparam
|lparam
, VK_SHIFT
, KF_UP
}, {0}}},
684 {0, 0, 0, {{0}}, {{0}}} /* end */
687 static struct message sent_messages
[MAXKEYMESSAGES
];
688 static UINT sent_messages_cnt
;
690 /* Verify that only specified key state transitions occur */
691 static void compare_and_check(int id
, BYTE
*ks1
, BYTE
*ks2
, const struct sendinput_test_s
*test
)
693 int i
, failcount
= 0;
694 const struct transition_s
*t
= test
->expected_transitions
;
696 const struct message
*expected
= test
->expected_messages
;
699 int matched
= ((ks1
[t
->wVk
]&0x80) == (t
->before_state
&0x80)
700 && (ks2
[t
->wVk
]&0x80) == (~t
->before_state
&0x80));
702 if (!matched
&& !t
->optional
&& test
->_todo_wine
)
706 ok(matched
, "%2d (%x/%x): %02x from %02x -> %02x "
707 "instead of %02x -> %02x\n", id
, test
->wVk
, test
->dwFlags
,
708 t
->wVk
, ks1
[t
->wVk
]&0x80, ks2
[t
->wVk
]&0x80, t
->before_state
,
709 ~t
->before_state
&0x80);
712 ok(matched
|| t
->optional
, "%2d (%x/%x): %02x from %02x -> %02x "
713 "instead of %02x -> %02x\n", id
, test
->wVk
, test
->dwFlags
,
714 t
->wVk
, ks1
[t
->wVk
]&0x80, ks2
[t
->wVk
]&0x80, t
->before_state
,
715 ~t
->before_state
&0x80);
717 ks2
[t
->wVk
] = ks1
[t
->wVk
]; /* clear the match */
720 for (i
= 0; i
< 256; i
++)
721 if (ks2
[i
] != ks1
[i
] && test
->_todo_wine
)
725 ok(FALSE
, "%2d (%x/%x): %02x from %02x -> %02x unexpected\n",
726 id
, test
->wVk
, test
->dwFlags
, i
, ks1
[i
], ks2
[i
]);
729 ok(ks2
[i
] == ks1
[i
], "%2d (%x/%x): %02x from %02x -> %02x unexpected\n",
730 id
, test
->wVk
, test
->dwFlags
, i
, ks1
[i
], ks2
[i
]);
732 while (expected
->message
&& actual_cnt
< sent_messages_cnt
)
734 const struct message
*actual
= &sent_messages
[actual_cnt
];
736 if (expected
->message
== actual
->message
)
738 if (expected
->flags
& wparam
)
740 if ((expected
->flags
& optional
) && (expected
->wParam
!= actual
->wParam
))
745 if (expected
->wParam
!= actual
->wParam
&& test
->_todo_wine
)
749 ok(FALSE
, "%2d (%x/%x): in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
750 id
, test
->wVk
, test
->dwFlags
, expected
->message
, expected
->wParam
, actual
->wParam
);
753 ok(expected
->wParam
== actual
->wParam
,
754 "%2d (%x/%x): in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
755 id
, test
->wVk
, test
->dwFlags
, expected
->message
, expected
->wParam
, actual
->wParam
);
757 if (expected
->flags
& lparam
)
759 if (expected
->lParam
!= actual
->lParam
&& test
->_todo_wine
)
763 ok(FALSE
, "%2d (%x/%x): in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
764 id
, test
->wVk
, test
->dwFlags
, expected
->message
, expected
->lParam
, actual
->lParam
);
767 ok(expected
->lParam
== actual
->lParam
,
768 "%2d (%x/%x): in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
769 id
, test
->wVk
, test
->dwFlags
, expected
->message
, expected
->lParam
, actual
->lParam
);
771 ok((expected
->flags
& hook
) == (actual
->flags
& hook
),
772 "%2d (%x/%x): the msg 0x%04x should have been sent by a hook\n",
773 id
, test
->wVk
, test
->dwFlags
, expected
->message
);
776 else if (expected
->flags
& optional
)
781 /* NT4 doesn't send SYSKEYDOWN/UP to hooks, only KEYDOWN/UP */
782 else if ((expected
->flags
& hook
) &&
783 (expected
->message
== WM_SYSKEYDOWN
|| expected
->message
== WM_SYSKEYUP
) &&
784 (actual
->message
== expected
->message
- 4))
786 ok((expected
->flags
& hook
) == (actual
->flags
& hook
),
787 "%2d (%x/%x): the msg 0x%04x should have been sent by a hook\n",
788 id
, test
->wVk
, test
->dwFlags
, expected
->message
);
790 /* For VK_RMENU, at least localized Win2k/XP sends KEYDOWN/UP
791 * instead of SYSKEYDOWN/UP to the WNDPROC */
792 else if (test
->wVk
== VK_RMENU
&& !(expected
->flags
& hook
) &&
793 (expected
->message
== WM_SYSKEYDOWN
|| expected
->message
== WM_SYSKEYUP
) &&
794 (actual
->message
== expected
->message
- 4))
796 ok(expected
->wParam
== actual
->wParam
&& expected
->lParam
== actual
->lParam
,
797 "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n",
798 id
, test
->wVk
, test
->dwFlags
, expected
->message
, actual
->message
);
800 else if (test
->_todo_wine
)
805 "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n",
806 id
, test
->wVk
, test
->dwFlags
, expected
->message
, actual
->message
);
810 "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n",
811 id
, test
->wVk
, test
->dwFlags
, expected
->message
, actual
->message
);
816 /* skip all optional trailing messages */
817 while (expected
->message
&& (expected
->flags
& optional
))
821 if (expected
->message
|| actual_cnt
< sent_messages_cnt
)
823 if (test
->_todo_wine
)
827 ok(FALSE
, "%2d (%x/%x): the msg sequence is not complete: expected %04x - actual %04x\n",
828 id
, test
->wVk
, test
->dwFlags
, expected
->message
, sent_messages
[actual_cnt
].message
);
831 ok(FALSE
, "%2d (%x/%x): the msg sequence is not complete: expected %04x - actual %04x\n",
832 id
, test
->wVk
, test
->dwFlags
, expected
->message
, sent_messages
[actual_cnt
].message
);
835 if( test
->_todo_wine
&& !failcount
) /* succeeded yet marked todo */
837 ok(TRUE
, "%2d (%x/%x): marked \"todo_wine\" but succeeds\n", id
, test
->wVk
, test
->dwFlags
);
839 sent_messages_cnt
= 0;
842 /* WndProc2 checks that we get at least the messages specified */
843 static LRESULT CALLBACK
WndProc2(HWND hWnd
, UINT Msg
, WPARAM wParam
,
846 if (winetest_debug
> 1) trace("MSG: %8x W:%8lx L:%8lx\n", Msg
, wParam
, lParam
);
848 if (Msg
!= WM_PAINT
&&
850 Msg
!= WM_SYNCPAINT
&&
851 Msg
!= WM_ERASEBKGND
&&
852 Msg
!= WM_NCHITTEST
&&
855 Msg
!= WM_IME_SELECT
&&
856 Msg
!= WM_DEVICECHANGE
&&
857 Msg
!= WM_TIMECHANGE
)
859 ok(sent_messages_cnt
< MAXKEYMESSAGES
, "Too many messages\n");
860 if (sent_messages_cnt
< MAXKEYMESSAGES
)
862 sent_messages
[sent_messages_cnt
].message
= Msg
;
863 sent_messages
[sent_messages_cnt
].flags
= 0;
864 sent_messages
[sent_messages_cnt
].wParam
= wParam
;
865 sent_messages
[sent_messages_cnt
++].lParam
= HIWORD(lParam
) & (KF_UP
|KF_EXTENDED
);
868 return DefWindowProc(hWnd
, Msg
, wParam
, lParam
);
871 static LRESULT CALLBACK
hook_proc(int code
, WPARAM wparam
, LPARAM lparam
)
873 KBDLLHOOKSTRUCT
*hook_info
= (KBDLLHOOKSTRUCT
*)lparam
;
875 if (code
== HC_ACTION
)
877 ok(sent_messages_cnt
< MAXKEYMESSAGES
, "Too many messages\n");
878 if (sent_messages_cnt
< MAXKEYMESSAGES
)
880 sent_messages
[sent_messages_cnt
].message
= wparam
;
881 sent_messages
[sent_messages_cnt
].flags
= hook
;
882 sent_messages
[sent_messages_cnt
].wParam
= hook_info
->vkCode
;
883 sent_messages
[sent_messages_cnt
++].lParam
= hook_info
->flags
& (LLKHF_UP
|LLKHF_EXTENDED
);
886 if(0) /* For some reason not stable on Wine */
888 if (wparam
== WM_KEYDOWN
|| wparam
== WM_SYSKEYDOWN
)
889 ok(!(GetAsyncKeyState(hook_info
->vkCode
) & 0x8000), "key %x should be up\n", hook_info
->vkCode
);
890 else if (wparam
== WM_KEYUP
|| wparam
== WM_SYSKEYUP
)
891 ok(GetAsyncKeyState(hook_info
->vkCode
) & 0x8000, "key %x should be down\n", hook_info
->vkCode
);
894 if (winetest_debug
> 1)
895 trace("Hook: w=%lx vk:%8x sc:%8x fl:%8x %lx\n", wparam
,
896 hook_info
->vkCode
, hook_info
->scanCode
, hook_info
->flags
, hook_info
->dwExtraInfo
);
898 return CallNextHookEx( 0, code
, wparam
, lparam
);
900 static void test_Input_blackbox(void)
904 BYTE ks1
[256], ks2
[256];
905 LONG_PTR prevWndProc
;
909 if (GetKeyboardLayout(0) != (HKL
)(ULONG_PTR
)0x04090409)
911 skip("Skipping Input_blackbox test on non-US keyboard\n");
914 window
= CreateWindow("Static", NULL
, WS_POPUP
|WS_HSCROLL
|WS_VSCROLL
915 |WS_VISIBLE
, 0, 0, 200, 60, NULL
, NULL
,
917 ok(window
!= NULL
, "error: %d\n", (int) GetLastError());
918 SetWindowPos( window
, HWND_TOPMOST
, 0, 0, 0, 0, SWP_NOSIZE
|SWP_NOMOVE
);
919 SetForegroundWindow( window
);
921 if (!(hook
= SetWindowsHookExA(WH_KEYBOARD_LL
, hook_proc
, GetModuleHandleA( NULL
), 0)))
923 DestroyWindow(window
);
924 win_skip("WH_KEYBOARD_LL is not supported\n");
928 /* must process all initial messages, otherwise X11DRV_KeymapNotify unsets
929 * key state set by SendInput(). */
930 empty_message_queue();
932 prevWndProc
= SetWindowLongPtr(window
, GWLP_WNDPROC
, (LONG_PTR
) WndProc2
);
933 ok(prevWndProc
!= 0 || (prevWndProc
== 0 && GetLastError() == 0),
934 "error: %d\n", (int) GetLastError());
936 i
.type
= INPUT_KEYBOARD
;
938 i
.u
.ki
.dwExtraInfo
= 0;
940 for (ii
= 0; ii
< sizeof(sendinput_test
)/sizeof(struct sendinput_test_s
)-1;
942 GetKeyboardState(ks1
);
943 i
.u
.ki
.wScan
= ii
+1 /* useful for debugging */;
944 i
.u
.ki
.dwFlags
= sendinput_test
[ii
].dwFlags
;
945 i
.u
.ki
.wVk
= sendinput_test
[ii
].wVk
;
946 pSendInput(1, (INPUT
*)&i
, sizeof(TEST_INPUT
));
947 empty_message_queue();
948 GetKeyboardState(ks2
);
949 if (!ii
&& sent_messages_cnt
<= 1 && !memcmp( ks1
, ks2
, sizeof(ks1
) ))
951 win_skip( "window doesn't receive the queued input\n" );
952 /* release the key */
953 i
.u
.ki
.dwFlags
|= KEYEVENTF_KEYUP
;
954 pSendInput(1, (INPUT
*)&i
, sizeof(TEST_INPUT
));
957 compare_and_check(ii
, ks1
, ks2
, &sendinput_test
[ii
]);
960 empty_message_queue();
961 DestroyWindow(window
);
962 UnhookWindowsHookEx(hook
);
965 static void reset_key_status(void)
967 key_status
.last_key_down
= -1;
968 key_status
.last_key_up
= -1;
969 key_status
.last_syskey_down
= -1;
970 key_status
.last_syskey_up
= -1;
971 key_status
.last_char
= -1;
972 key_status
.last_syschar
= -1;
973 key_status
.last_hook_down
= -1;
974 key_status
.last_hook_up
= -1;
975 key_status
.last_hook_syskey_down
= -1;
976 key_status
.last_hook_syskey_up
= -1;
977 key_status
.expect_alt
= FALSE
;
978 key_status
.sendinput_broken
= FALSE
;
981 static void test_unicode_keys(HWND hwnd
, HHOOK hook
)
983 TEST_INPUT inputs
[2];
986 /* init input data that never changes */
987 inputs
[1].type
= inputs
[0].type
= INPUT_KEYBOARD
;
988 inputs
[1].u
.ki
.dwExtraInfo
= inputs
[0].u
.ki
.dwExtraInfo
= 0;
989 inputs
[1].u
.ki
.time
= inputs
[0].u
.ki
.time
= 0;
991 /* pressing & releasing a single unicode character */
992 inputs
[0].u
.ki
.wVk
= 0;
993 inputs
[0].u
.ki
.wScan
= 0x3c0;
994 inputs
[0].u
.ki
.dwFlags
= KEYEVENTF_UNICODE
;
997 pSendInput(1, (INPUT
*)inputs
, sizeof(INPUT
));
998 while(PeekMessageW(&msg
, hwnd
, 0, 0, PM_REMOVE
)){
999 if(msg
.message
== WM_KEYDOWN
&& msg
.wParam
== VK_PACKET
){
1000 TranslateMessage(&msg
);
1002 DispatchMessageW(&msg
);
1004 if(!key_status
.sendinput_broken
){
1005 ok(key_status
.last_key_down
== VK_PACKET
,
1006 "Last keydown msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET
, key_status
.last_key_down
);
1007 ok(key_status
.last_char
== 0x3c0,
1008 "Last char msg wparam should have been 0x3c0 (was: 0x%x)\n", key_status
.last_char
);
1010 ok(key_status
.last_hook_down
== 0x3c0,
1011 "Last hookdown msg should have been 0x3c0, was: 0x%x\n", key_status
.last_hook_down
);
1014 inputs
[1].u
.ki
.wVk
= 0;
1015 inputs
[1].u
.ki
.wScan
= 0x3c0;
1016 inputs
[1].u
.ki
.dwFlags
= KEYEVENTF_UNICODE
| KEYEVENTF_KEYUP
;
1019 pSendInput(1, (INPUT
*)(inputs
+1), sizeof(INPUT
));
1020 while(PeekMessageW(&msg
, hwnd
, 0, 0, PM_REMOVE
)){
1021 if(msg
.message
== WM_KEYDOWN
&& msg
.wParam
== VK_PACKET
){
1022 TranslateMessage(&msg
);
1024 DispatchMessageW(&msg
);
1026 if(!key_status
.sendinput_broken
){
1027 ok(key_status
.last_key_up
== VK_PACKET
,
1028 "Last keyup msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET
, key_status
.last_key_up
);
1030 ok(key_status
.last_hook_up
== 0x3c0,
1031 "Last hookup msg should have been 0x3c0, was: 0x%x\n", key_status
.last_hook_up
);
1034 /* holding alt, pressing & releasing a unicode character, releasing alt */
1035 inputs
[0].u
.ki
.wVk
= VK_LMENU
;
1036 inputs
[0].u
.ki
.wScan
= 0;
1037 inputs
[0].u
.ki
.dwFlags
= 0;
1039 inputs
[1].u
.ki
.wVk
= 0;
1040 inputs
[1].u
.ki
.wScan
= 0x3041;
1041 inputs
[1].u
.ki
.dwFlags
= KEYEVENTF_UNICODE
;
1044 key_status
.expect_alt
= TRUE
;
1045 pSendInput(2, (INPUT
*)inputs
, sizeof(INPUT
));
1046 while(PeekMessageW(&msg
, hwnd
, 0, 0, PM_REMOVE
)){
1047 if(msg
.message
== WM_SYSKEYDOWN
&& msg
.wParam
== VK_PACKET
){
1048 TranslateMessage(&msg
);
1050 DispatchMessageW(&msg
);
1052 if(!key_status
.sendinput_broken
){
1053 ok(key_status
.last_syskey_down
== VK_PACKET
,
1054 "Last syskeydown msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET
, key_status
.last_syskey_down
);
1055 ok(key_status
.last_syschar
== 0x3041,
1056 "Last syschar msg should have been 0x3041 (was: 0x%x)\n", key_status
.last_syschar
);
1058 ok(key_status
.last_hook_syskey_down
== 0x3041,
1059 "Last hooksysdown msg should have been 0x3041, was: 0x%x\n", key_status
.last_hook_syskey_down
);
1062 inputs
[1].u
.ki
.wVk
= 0;
1063 inputs
[1].u
.ki
.wScan
= 0x3041;
1064 inputs
[1].u
.ki
.dwFlags
= KEYEVENTF_UNICODE
| KEYEVENTF_KEYUP
;
1066 inputs
[0].u
.ki
.wVk
= VK_LMENU
;
1067 inputs
[0].u
.ki
.wScan
= 0;
1068 inputs
[0].u
.ki
.dwFlags
= KEYEVENTF_KEYUP
;
1071 key_status
.expect_alt
= TRUE
;
1072 pSendInput(2, (INPUT
*)inputs
, sizeof(INPUT
));
1073 while(PeekMessageW(&msg
, hwnd
, 0, 0, PM_REMOVE
)){
1074 if(msg
.message
== WM_SYSKEYDOWN
&& msg
.wParam
== VK_PACKET
){
1075 TranslateMessage(&msg
);
1077 DispatchMessageW(&msg
);
1079 if(!key_status
.sendinput_broken
){
1080 ok(key_status
.last_key_up
== VK_PACKET
,
1081 "Last keyup msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET
, key_status
.last_key_up
);
1083 ok(key_status
.last_hook_up
== 0x3041,
1084 "Last hook up msg should have been 0x3041, was: 0x%x\n", key_status
.last_hook_up
);
1088 static LRESULT CALLBACK
unicode_wnd_proc( HWND hWnd
, UINT msg
, WPARAM wParam
,
1093 key_status
.last_key_down
= wParam
;
1096 key_status
.last_syskey_down
= wParam
;
1099 key_status
.last_key_up
= wParam
;
1102 key_status
.last_syskey_up
= wParam
;
1105 key_status
.last_char
= wParam
;
1108 key_status
.last_syschar
= wParam
;
1111 return DefWindowProcW(hWnd
, msg
, wParam
, lParam
);
1114 static LRESULT CALLBACK
llkbd_unicode_hook(int nCode
, WPARAM wParam
, LPARAM lParam
)
1116 if(nCode
== HC_ACTION
){
1117 LPKBDLLHOOKSTRUCT info
= (LPKBDLLHOOKSTRUCT
)lParam
;
1119 key_status
.sendinput_broken
= TRUE
;
1120 win_skip("SendInput doesn't support unicode on this platform\n");
1122 if(key_status
.expect_alt
){
1123 ok(info
->vkCode
== VK_LMENU
, "vkCode should have been VK_LMENU[0x%04x], was: 0x%x\n", VK_LMENU
, info
->vkCode
);
1124 key_status
.expect_alt
= FALSE
;
1126 ok(info
->vkCode
== VK_PACKET
, "vkCode should have been VK_PACKET[0x%04x], was: 0x%x\n", VK_PACKET
, info
->vkCode
);
1130 key_status
.last_hook_down
= info
->scanCode
;
1133 key_status
.last_hook_up
= info
->scanCode
;
1136 key_status
.last_hook_syskey_down
= info
->scanCode
;
1139 key_status
.last_hook_syskey_up
= info
->scanCode
;
1143 return CallNextHookEx(NULL
, nCode
, wParam
, lParam
);
1146 static void test_Input_unicode(void)
1148 WCHAR classNameW
[] = {'I','n','p','u','t','U','n','i','c','o','d','e',
1149 'K','e','y','T','e','s','t','C','l','a','s','s',0};
1150 WCHAR windowNameW
[] = {'I','n','p','u','t','U','n','i','c','o','d','e',
1151 'K','e','y','T','e','s','t',0};
1154 HANDLE hInstance
= GetModuleHandleW(NULL
);
1156 HMODULE hModuleImm32
;
1157 BOOL (WINAPI
*pImmDisableIME
)(DWORD
);
1159 wclass
.lpszClassName
= classNameW
;
1160 wclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
1161 wclass
.lpfnWndProc
= unicode_wnd_proc
;
1162 wclass
.hInstance
= hInstance
;
1163 wclass
.hIcon
= LoadIcon(0, IDI_APPLICATION
);
1164 wclass
.hCursor
= LoadCursor( NULL
, IDC_ARROW
);
1165 wclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
1166 wclass
.lpszMenuName
= 0;
1167 wclass
.cbClsExtra
= 0;
1168 wclass
.cbWndExtra
= 0;
1169 if(!RegisterClassW(&wclass
)){
1170 win_skip("Unicode functions not supported\n");
1174 hModuleImm32
= LoadLibrary("imm32.dll");
1176 pImmDisableIME
= (void *)GetProcAddress(hModuleImm32
, "ImmDisableIME");
1180 pImmDisableIME
= NULL
;
1181 FreeLibrary(hModuleImm32
);
1183 /* create the test window that will receive the keystrokes */
1184 hWndTest
= CreateWindowW(wclass
.lpszClassName
, windowNameW
,
1185 WS_OVERLAPPEDWINDOW
, CW_USEDEFAULT
, 0, 100, 100,
1186 NULL
, NULL
, hInstance
, NULL
);
1189 assert(IsWindowUnicode(hWndTest
));
1191 hook
= SetWindowsHookExW(WH_KEYBOARD_LL
, llkbd_unicode_hook
, GetModuleHandleW(NULL
), 0);
1193 win_skip("unable to set WH_KEYBOARD_LL hook\n");
1195 ShowWindow(hWndTest
, SW_SHOW
);
1196 SetWindowPos(hWndTest
, HWND_TOPMOST
, 0, 0, 0, 0, SWP_NOSIZE
|SWP_NOMOVE
);
1197 SetForegroundWindow(hWndTest
);
1198 UpdateWindow(hWndTest
);
1200 /* flush pending messages */
1201 while (PeekMessageW(&msg
, 0, 0, 0, PM_REMOVE
)) DispatchMessageW(&msg
);
1205 test_unicode_keys(hWndTest
, hook
);
1208 UnhookWindowsHookEx(hook
);
1209 DestroyWindow(hWndTest
);
1212 static void test_keynames(void)
1217 for (i
= 0; i
< 512; i
++)
1219 strcpy(buff
, "----");
1220 len
= GetKeyNameTextA(i
<< 16, buff
, sizeof(buff
));
1221 ok(len
|| !buff
[0], "%d: Buffer is not zeroed\n", i
);
1225 static POINT pt_old
, pt_new
;
1226 static BOOL clipped
;
1229 static LRESULT CALLBACK
hook_proc1( int code
, WPARAM wparam
, LPARAM lparam
)
1231 MSLLHOOKSTRUCT
*hook
= (MSLLHOOKSTRUCT
*)lparam
;
1234 if (code
== HC_ACTION
)
1236 /* This is our new cursor position */
1238 /* Should return previous position */
1240 ok(pt
.x
== pt_old
.x
&& pt
.y
== pt_old
.y
, "GetCursorPos: (%d,%d)\n", pt
.x
, pt
.y
);
1242 /* Should set new position until hook chain is finished. */
1243 pt
.x
= pt_old
.x
+ STEP
;
1244 pt
.y
= pt_old
.y
+ STEP
;
1245 SetCursorPos(pt
.x
, pt
.y
);
1248 ok(pt1
.x
== pt_old
.x
&& pt1
.y
== pt_old
.y
, "Wrong set pos: (%d,%d)\n", pt1
.x
, pt1
.y
);
1250 ok(pt1
.x
== pt
.x
&& pt1
.y
== pt
.y
, "Wrong set pos: (%d,%d)\n", pt1
.x
, pt1
.y
);
1252 return CallNextHookEx( 0, code
, wparam
, lparam
);
1255 static LRESULT CALLBACK
hook_proc2( int code
, WPARAM wparam
, LPARAM lparam
)
1257 MSLLHOOKSTRUCT
*hook
= (MSLLHOOKSTRUCT
*)lparam
;
1260 if (code
== HC_ACTION
)
1262 ok(hook
->pt
.x
== pt_new
.x
&& hook
->pt
.y
== pt_new
.y
,
1263 "Wrong hook coords: (%d %d) != (%d,%d)\n", hook
->pt
.x
, hook
->pt
.y
, pt_new
.x
, pt_new
.y
);
1265 /* Should match position set above */
1268 ok(pt
.x
== pt_old
.x
&& pt
.y
== pt_old
.y
, "GetCursorPos: (%d,%d)\n", pt
.x
, pt
.y
);
1270 ok(pt
.x
== pt_old
.x
+STEP
&& pt
.y
== pt_old
.y
+STEP
, "GetCursorPos: (%d,%d)\n", pt
.x
, pt
.y
);
1272 return CallNextHookEx( 0, code
, wparam
, lparam
);
1275 static void test_mouse_ll_hook(void)
1282 GetCursorPos(&pt_org
);
1283 hwnd
= CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW
| WS_VISIBLE
,
1284 10, 10, 200, 200, NULL
, NULL
, NULL
, NULL
);
1285 SetCursorPos(100, 100);
1287 if (!(hook2
= SetWindowsHookExA(WH_MOUSE_LL
, hook_proc2
, GetModuleHandleA(0), 0)))
1289 win_skip( "cannot set MOUSE_LL hook\n" );
1292 hook1
= SetWindowsHookExA(WH_MOUSE_LL
, hook_proc1
, GetModuleHandleA(0), 0);
1294 GetCursorPos(&pt_old
);
1295 mouse_event(MOUSEEVENTF_MOVE
, -STEP
, 0, 0, 0);
1296 GetCursorPos(&pt_old
);
1297 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
);
1298 mouse_event(MOUSEEVENTF_MOVE
, +STEP
, 0, 0, 0);
1299 GetCursorPos(&pt_old
);
1300 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
);
1301 mouse_event(MOUSEEVENTF_MOVE
, 0, -STEP
, 0, 0);
1302 GetCursorPos(&pt_old
);
1303 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
);
1304 mouse_event(MOUSEEVENTF_MOVE
, 0, +STEP
, 0, 0);
1305 GetCursorPos(&pt_old
);
1306 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
);
1308 SetRect(&rc
, 50, 50, 151, 151);
1312 SetCursorPos(40, 40);
1313 GetCursorPos(&pt_old
);
1314 ok(pt_old
.x
== 50 && pt_old
.y
== 50, "Wrong new pos: (%d,%d)\n", pt_new
.x
, pt_new
.y
);
1315 SetCursorPos(160, 160);
1316 GetCursorPos(&pt_old
);
1317 ok(pt_old
.x
== 150 && pt_old
.y
== 150, "Wrong new pos: (%d,%d)\n", pt_new
.x
, pt_new
.y
);
1318 mouse_event(MOUSEEVENTF_MOVE
, +STEP
, +STEP
, 0, 0);
1319 GetCursorPos(&pt_old
);
1320 ok(pt_old
.x
== 150 && pt_old
.y
== 150, "Wrong new pos: (%d,%d)\n", pt_new
.x
, pt_new
.y
);
1323 pt_new
.x
= pt_new
.y
= 150;
1325 UnhookWindowsHookEx(hook1
);
1327 /* Now check that mouse buttons do not change mouse position
1328 if we don't have MOUSEEVENTF_MOVE flag specified. */
1330 /* We reusing the same hook callback, so make it happy */
1331 pt_old
.x
= pt_new
.x
- STEP
;
1332 pt_old
.y
= pt_new
.y
- STEP
;
1333 mouse_event(MOUSEEVENTF_LEFTUP
, 123, 456, 0, 0);
1335 ok(pt
.x
== pt_new
.x
&& pt
.y
== pt_new
.y
, "Position changed: (%d,%d)\n", pt
.x
, pt
.y
);
1336 mouse_event(MOUSEEVENTF_RIGHTUP
, 456, 123, 0, 0);
1338 ok(pt
.x
== pt_new
.x
&& pt
.y
== pt_new
.y
, "Position changed: (%d,%d)\n", pt
.x
, pt
.y
);
1340 mouse_event(MOUSEEVENTF_LEFTUP
| MOUSEEVENTF_ABSOLUTE
, 123, 456, 0, 0);
1342 ok(pt
.x
== pt_new
.x
&& pt
.y
== pt_new
.y
, "Position changed: (%d,%d)\n", pt
.x
, pt
.y
);
1343 mouse_event(MOUSEEVENTF_RIGHTUP
| MOUSEEVENTF_ABSOLUTE
, 456, 123, 0, 0);
1345 ok(pt
.x
== pt_new
.x
&& pt
.y
== pt_new
.y
, "Position changed: (%d,%d)\n", pt
.x
, pt
.y
);
1347 UnhookWindowsHookEx(hook2
);
1349 DestroyWindow(hwnd
);
1350 SetCursorPos(pt_org
.x
, pt_org
.y
);
1353 static void test_GetMouseMovePointsEx(void)
1356 #define MYERROR 0xdeadbeef
1359 MOUSEMOVEPOINT out
[200];
1362 /* Get a valid content for the input struct */
1363 if(!GetCursorPos(&point
)) {
1364 skip("GetCursorPos() failed with error %u\n", GetLastError());
1367 memset(&in
, 0, sizeof(MOUSEMOVEPOINT
));
1371 /* test first parameter
1372 * everything different than sizeof(MOUSEMOVEPOINT)
1373 * is expected to fail with ERROR_INVALID_PARAMETER
1375 SetLastError(MYERROR
);
1376 retval
= pGetMouseMovePointsEx(0, &in
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1377 if (retval
== ERROR_INVALID_PARAMETER
)
1379 win_skip( "GetMouseMovePointsEx broken on WinME\n" );
1382 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1383 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1384 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1386 SetLastError(MYERROR
);
1387 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
)-1, &in
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1388 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1389 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1390 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1392 SetLastError(MYERROR
);
1393 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
)+1, &in
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1394 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1395 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1396 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1398 /* test second and third parameter
1400 SetLastError(MYERROR
);
1401 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), NULL
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1402 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1403 ok(GetLastError() == ERROR_NOACCESS
|| GetLastError() == MYERROR
,
1404 "expected error ERROR_NOACCESS, got %u\n", GetLastError());
1406 SetLastError(MYERROR
);
1407 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, NULL
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1408 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1409 ok(ERROR_NOACCESS
== GetLastError(),
1410 "expected error ERROR_NOACCESS, got %u\n", GetLastError());
1412 SetLastError(MYERROR
);
1413 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), NULL
, NULL
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1414 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1415 ok(ERROR_NOACCESS
== GetLastError(),
1416 "expected error ERROR_NOACCESS, got %u\n", GetLastError());
1418 SetLastError(MYERROR
);
1420 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, NULL
, count
, GMMP_USE_DISPLAY_POINTS
);
1422 ok(GetLastError() == ERROR_POINT_NOT_FOUND
, "unexpected error %u\n", GetLastError());
1424 ok(retval
== count
, "expected GetMouseMovePointsEx to succeed, got %d\n", retval
);
1426 /* test fourth parameter
1427 * a value higher than 64 is expected to fail with ERROR_INVALID_PARAMETER
1429 SetLastError(MYERROR
);
1431 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, out
, count
, GMMP_USE_DISPLAY_POINTS
);
1432 ok(retval
== count
, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1433 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1434 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1436 SetLastError(MYERROR
);
1438 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, out
, count
, GMMP_USE_DISPLAY_POINTS
);
1440 ok(GetLastError() == ERROR_POINT_NOT_FOUND
, "unexpected error %u\n", GetLastError());
1442 ok(retval
== count
, "expected GetMouseMovePointsEx to succeed, got %d\n", retval
);
1444 SetLastError(MYERROR
);
1446 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, out
, count
, GMMP_USE_DISPLAY_POINTS
);
1448 ok(GetLastError() == ERROR_POINT_NOT_FOUND
, "unexpected error %u\n", GetLastError());
1450 ok((0 <= retval
) && (retval
<= count
), "expected GetMouseMovePointsEx to succeed, got %d\n", retval
);
1452 SetLastError(MYERROR
);
1453 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, out
, BUFLIM
+1, GMMP_USE_DISPLAY_POINTS
);
1454 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1455 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1456 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1458 /* it was not possible to force an error with the fifth parameter on win2k */
1460 /* test combinations of wrong parameters to see which error wins */
1461 SetLastError(MYERROR
);
1462 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
)-1, NULL
, out
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1463 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1464 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1465 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1467 SetLastError(MYERROR
);
1468 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
)-1, &in
, NULL
, BUFLIM
, GMMP_USE_DISPLAY_POINTS
);
1469 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1470 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1471 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1473 SetLastError(MYERROR
);
1474 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), NULL
, out
, BUFLIM
+1, GMMP_USE_DISPLAY_POINTS
);
1475 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1476 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1477 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1479 SetLastError(MYERROR
);
1480 retval
= pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT
), &in
, NULL
, BUFLIM
+1, GMMP_USE_DISPLAY_POINTS
);
1481 ok(retval
== -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval
);
1482 ok(GetLastError() == ERROR_INVALID_PARAMETER
|| GetLastError() == MYERROR
,
1483 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1489 static void test_key_map(void)
1491 HKL kl
= GetKeyboardLayout(0);
1494 static const UINT numpad_collisions
[][2] = {
1495 { VK_NUMPAD0
, VK_INSERT
},
1496 { VK_NUMPAD1
, VK_END
},
1497 { VK_NUMPAD2
, VK_DOWN
},
1498 { VK_NUMPAD3
, VK_NEXT
},
1499 { VK_NUMPAD4
, VK_LEFT
},
1500 { VK_NUMPAD6
, VK_RIGHT
},
1501 { VK_NUMPAD7
, VK_HOME
},
1502 { VK_NUMPAD8
, VK_UP
},
1503 { VK_NUMPAD9
, VK_PRIOR
},
1506 s
= MapVirtualKeyEx(VK_SHIFT
, MAPVK_VK_TO_VSC
, kl
);
1507 ok(s
!= 0, "MapVirtualKeyEx(VK_SHIFT) should return non-zero\n");
1508 sL
= MapVirtualKeyEx(VK_LSHIFT
, MAPVK_VK_TO_VSC
, kl
);
1509 ok(s
== sL
|| broken(sL
== 0), /* win9x */
1510 "%x != %x\n", s
, sL
);
1512 kL
= MapVirtualKeyEx(0x2a, MAPVK_VSC_TO_VK
, kl
);
1513 ok(kL
== VK_SHIFT
, "Scan code -> vKey = %x (not VK_SHIFT)\n", kL
);
1514 kR
= MapVirtualKeyEx(0x36, MAPVK_VSC_TO_VK
, kl
);
1515 ok(kR
== VK_SHIFT
, "Scan code -> vKey = %x (not VK_SHIFT)\n", kR
);
1517 kL
= MapVirtualKeyEx(0x2a, MAPVK_VSC_TO_VK_EX
, kl
);
1518 ok(kL
== VK_LSHIFT
|| broken(kL
== 0), /* win9x */
1519 "Scan code -> vKey = %x (not VK_LSHIFT)\n", kL
);
1520 kR
= MapVirtualKeyEx(0x36, MAPVK_VSC_TO_VK_EX
, kl
);
1521 ok(kR
== VK_RSHIFT
|| broken(kR
== 0), /* win9x */
1522 "Scan code -> vKey = %x (not VK_RSHIFT)\n", kR
);
1524 /* test that MAPVK_VSC_TO_VK prefers the non-numpad vkey if there's ambiguity */
1525 for (i
= 0; i
< sizeof(numpad_collisions
)/sizeof(numpad_collisions
[0]); i
++)
1527 UINT numpad_scan
= MapVirtualKeyEx(numpad_collisions
[i
][0], MAPVK_VK_TO_VSC
, kl
);
1528 UINT other_scan
= MapVirtualKeyEx(numpad_collisions
[i
][1], MAPVK_VK_TO_VSC
, kl
);
1530 /* do they really collide for this layout? */
1531 if (numpad_scan
&& other_scan
== numpad_scan
)
1533 UINT vkey
= MapVirtualKeyEx(numpad_scan
, MAPVK_VSC_TO_VK
, kl
);
1534 ok(vkey
!= numpad_collisions
[i
][0],
1535 "Got numpad vKey %x for scan code %x when there was another choice\n",
1541 static void test_ToUnicode(void)
1545 const BYTE SC_RETURN
= 0x1c, SC_TAB
= 0x0f;
1546 const BYTE HIGHEST_BIT
= 0x80;
1548 for(i
=0; i
<256; i
++)
1552 SetLastError(0xdeadbeef);
1553 ret
= ToUnicode(VK_RETURN
, SC_RETURN
, state
, wStr
, 4, 0);
1554 if (!ret
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
1556 win_skip("ToUnicode is not implemented\n");
1560 ok(ret
== 1, "ToUnicode for Return key didn't return 1 (was %i)\n", ret
);
1563 ok(wStr
[0]=='\r', "ToUnicode for CTRL + Return was %i (expected 13)\n", wStr
[0]);
1564 ok(wStr
[1]==0 || broken(wStr
[1]!=0) /* nt4 */,
1565 "ToUnicode didn't null-terminate the buffer when there was room.\n");
1567 state
[VK_CONTROL
] |= HIGHEST_BIT
;
1568 state
[VK_LCONTROL
] |= HIGHEST_BIT
;
1570 ret
= ToUnicode(VK_TAB
, SC_TAB
, state
, wStr
, 2, 0);
1571 ok(ret
== 0, "ToUnicode for CTRL + Tab didn't return 0 (was %i)\n", ret
);
1573 ret
= ToUnicode(VK_RETURN
, SC_RETURN
, state
, wStr
, 2, 0);
1574 ok(ret
== 1, "ToUnicode for CTRL + Return didn't return 1 (was %i)\n", ret
);
1576 ok(wStr
[0]=='\n', "ToUnicode for CTRL + Return was %i (expected 10)\n", wStr
[0]);
1578 state
[VK_SHIFT
] |= HIGHEST_BIT
;
1579 state
[VK_LSHIFT
] |= HIGHEST_BIT
;
1580 ret
= ToUnicode(VK_TAB
, SC_TAB
, state
, wStr
, 2, 0);
1581 ok(ret
== 0, "ToUnicode for CTRL + SHIFT + Tab didn't return 0 (was %i)\n", ret
);
1582 ret
= ToUnicode(VK_RETURN
, SC_RETURN
, state
, wStr
, 2, 0);
1583 todo_wine
ok(ret
== 0, "ToUnicode for CTRL + SHIFT + Return didn't return 0 (was %i)\n", ret
);
1586 static void test_get_async_key_state(void)
1588 /* input value sanity checks */
1589 ok(0 == GetAsyncKeyState(1000000), "GetAsyncKeyState did not return 0\n");
1590 ok(0 == GetAsyncKeyState(-1000000), "GetAsyncKeyState did not return 0\n");
1593 static void test_keyboard_layout_name(void)
1596 char klid
[KL_NAMELENGTH
];
1598 if (GetKeyboardLayout(0) != (HKL
)(ULONG_PTR
)0x04090409) return;
1601 ret
= GetKeyboardLayoutNameA(klid
);
1602 ok(ret
, "GetKeyboardLayoutNameA failed %u\n", GetLastError());
1603 ok(!strcmp(klid
, "00000409"), "expected 00000409, got %s\n", klid
);
1606 static void test_key_names(void)
1611 LONG lparam
= 0x1d << 16;
1613 memset( buffer
, 0xcc, sizeof(buffer
) );
1614 ret
= GetKeyNameTextA( lparam
, buffer
, sizeof(buffer
) );
1615 ok( ret
> 0, "wrong len %u for '%s'\n", ret
, buffer
);
1616 ok( ret
== strlen(buffer
), "wrong len %u for '%s'\n", ret
, buffer
);
1618 memset( buffer
, 0xcc, sizeof(buffer
) );
1620 ret
= GetKeyNameTextA( lparam
, buffer
, prev
);
1621 ok( ret
== prev
- 1, "wrong len %u for '%s'\n", ret
, buffer
);
1622 ok( ret
== strlen(buffer
), "wrong len %u for '%s'\n", ret
, buffer
);
1624 memset( buffer
, 0xcc, sizeof(buffer
) );
1625 ret
= GetKeyNameTextA( lparam
, buffer
, 0 );
1626 ok( ret
== 0, "wrong len %u for '%s'\n", ret
, buffer
);
1627 ok( buffer
[0] == 0, "wrong string '%s'\n", buffer
);
1629 memset( bufferW
, 0xcc, sizeof(bufferW
) );
1630 ret
= GetKeyNameTextW( lparam
, bufferW
, sizeof(bufferW
)/sizeof(WCHAR
) );
1631 ok( ret
> 0, "wrong len %u for %s\n", ret
, wine_dbgstr_w(bufferW
) );
1632 ok( ret
== lstrlenW(bufferW
), "wrong len %u for %s\n", ret
, wine_dbgstr_w(bufferW
) );
1634 memset( bufferW
, 0xcc, sizeof(bufferW
) );
1636 ret
= GetKeyNameTextW( lparam
, bufferW
, prev
);
1637 ok( ret
== prev
- 1, "wrong len %u for %s\n", ret
, wine_dbgstr_w(bufferW
) );
1638 ok( ret
== lstrlenW(bufferW
), "wrong len %u for %s\n", ret
, wine_dbgstr_w(bufferW
) );
1640 memset( bufferW
, 0xcc, sizeof(bufferW
) );
1641 ret
= GetKeyNameTextW( lparam
, bufferW
, 0 );
1642 ok( ret
== 0, "wrong len %u for %s\n", ret
, wine_dbgstr_w(bufferW
) );
1643 ok( bufferW
[0] == 0xcccc, "wrong string %s\n", wine_dbgstr_w(bufferW
) );
1648 init_function_pointers();
1652 test_Input_blackbox();
1653 test_Input_whitebox();
1654 test_Input_unicode();
1656 else win_skip("SendInput is not available\n");
1659 test_mouse_ll_hook();
1662 test_get_async_key_state();
1663 test_keyboard_layout_name();
1666 if(pGetMouseMovePointsEx
)
1667 test_GetMouseMovePointsEx();
1669 win_skip("GetMouseMovePointsEx is not available\n");