| /* Test Key event to Key message translation |
| * |
| * Copyright 2003 Rein Klazes |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| /* test whether the right type of messages: |
| * WM_KEYUP/DOWN vs WM_SYSKEYUP/DOWN are sent in case of combined |
| * keystrokes. |
| * |
| * For instance <ALT>-X can be accomplished by |
| * the sequence ALT-KEY-DOWN, X-KEY-DOWN, ALT-KEY-UP, X-KEY-UP |
| * but also X-KEY-DOWN, ALT-KEY-DOWN, X-KEY-UP, ALT-KEY-UP |
| * Whether a KEY or a SYSKEY message is sent is not always clear, it is |
| * also not the same in WINNT as in WIN9X */ |
| |
| /* NOTE that there will be test failures under WIN9X |
| * No applications are known to me that rely on this |
| * so I don't fix it */ |
| |
| /* TODO: |
| * 1. extend it to the wm_command and wm_syscommand notifications |
| * 2. add some more tests with special cases like dead keys or right (alt) key |
| * 3. there is some adapted code from input.c in here. Should really |
| * make that code exactly the same. |
| * 4. resolve the win9x case when there is a need or the testing frame work |
| * offers a nice way. |
| * 5. The test app creates a window, the user should not take the focus |
| * away during its short existence. I could do something to prevent that |
| * if it is a problem. |
| * |
| */ |
| |
| #define _WIN32_WINNT 0x401 |
| #define _WIN32_IE 0x0500 |
| |
| #include <stdarg.h> |
| #include <assert.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winuser.h" |
| |
| #include "wine/test.h" |
| |
| /* globals */ |
| static HWND hWndTest; |
| static LONG timetag = 0x10000000; |
| |
| static struct { |
| LONG last_key_down; |
| LONG last_key_up; |
| LONG last_syskey_down; |
| LONG last_syskey_up; |
| LONG last_char; |
| LONG last_syschar; |
| LONG last_hook_down; |
| LONG last_hook_up; |
| LONG last_hook_syskey_down; |
| LONG last_hook_syskey_up; |
| BOOL expect_alt; |
| BOOL sendinput_broken; |
| } key_status; |
| |
| static UINT (WINAPI *pSendInput) (UINT, INPUT*, size_t); |
| static int (WINAPI *pGetMouseMovePointsEx) (UINT, LPMOUSEMOVEPOINT, LPMOUSEMOVEPOINT, int, DWORD); |
| |
| #define MAXKEYEVENTS 12 |
| #define MAXKEYMESSAGES MAXKEYEVENTS /* assuming a key event generates one |
| and only one message */ |
| |
| /* keyboard message names, sorted as their value */ |
| static const char *MSGNAME[]={"WM_KEYDOWN", "WM_KEYUP", "WM_CHAR","WM_DEADCHAR", |
| "WM_SYSKEYDOWN", "WM_SYSKEYUP", "WM_SYSCHAR", "WM_SYSDEADCHAR" ,"WM_KEYLAST"}; |
| |
| /* keyevents, add more as needed */ |
| typedef enum KEVtag |
| { ALTDOWN = 1, ALTUP, XDOWN, XUP, SHIFTDOWN, SHIFTUP, CTRLDOWN, CTRLUP } KEV; |
| /* matching VK's */ |
| static const int GETVKEY[]={0, VK_MENU, VK_MENU, 'X', 'X', VK_SHIFT, VK_SHIFT, VK_CONTROL, VK_CONTROL}; |
| /* matching scan codes */ |
| static const int GETSCAN[]={0, 0x38, 0x38, 0x2D, 0x2D, 0x2A, 0x2A, 0x1D, 0x1D }; |
| /* matching updown events */ |
| static const int GETFLAGS[]={0, 0, KEYEVENTF_KEYUP, 0, KEYEVENTF_KEYUP, 0, KEYEVENTF_KEYUP, 0, KEYEVENTF_KEYUP}; |
| /* matching descriptions */ |
| static const char *getdesc[]={"", "+alt","-alt","+X","-X","+shift","-shift","+ctrl","-ctrl"}; |
| |
| /* The MSVC headers ignore our NONAMELESSUNION requests so we have to define our own type */ |
| typedef struct |
| { |
| DWORD type; |
| union |
| { |
| MOUSEINPUT mi; |
| KEYBDINPUT ki; |
| HARDWAREINPUT hi; |
| } u; |
| } TEST_INPUT; |
| |
| #define ADDTOINPUTS(kev) \ |
| inputs[evtctr].type = INPUT_KEYBOARD; \ |
| ((TEST_INPUT*)inputs)[evtctr].u.ki.wVk = GETVKEY[ kev]; \ |
| ((TEST_INPUT*)inputs)[evtctr].u.ki.wScan = GETSCAN[ kev]; \ |
| ((TEST_INPUT*)inputs)[evtctr].u.ki.dwFlags = GETFLAGS[ kev]; \ |
| ((TEST_INPUT*)inputs)[evtctr].u.ki.dwExtraInfo = 0; \ |
| ((TEST_INPUT*)inputs)[evtctr].u.ki.time = ++timetag; \ |
| if( kev) evtctr++; |
| |
| typedef struct { |
| UINT message; |
| WPARAM wParam; |
| LPARAM lParam; |
| } KMSG; |
| |
| /******************************************* |
| * add new test sets here |
| * the software will make all combinations of the |
| * keyevent defined here |
| */ |
| static const struct { |
| int nrkev; |
| KEV keydwn[MAXKEYEVENTS]; |
| KEV keyup[MAXKEYEVENTS]; |
| } testkeyset[]= { |
| { 2, { ALTDOWN, XDOWN }, { ALTUP, XUP}}, |
| { 3, { ALTDOWN, XDOWN , SHIFTDOWN}, { ALTUP, XUP, SHIFTUP}}, |
| { 3, { ALTDOWN, XDOWN , CTRLDOWN}, { ALTUP, XUP, CTRLUP}}, |
| { 3, { SHIFTDOWN, XDOWN , CTRLDOWN}, { SHIFTUP, XUP, CTRLUP}}, |
| { 0 } /* mark the end */ |
| }; |
| |
| /**********************adapted from input.c **********************************/ |
| |
| static BYTE InputKeyStateTable[256]; |
| static BYTE AsyncKeyStateTable[256]; |
| static BYTE TrackSysKey = 0; /* determine whether ALT key up will cause a WM_SYSKEYUP |
| or a WM_KEYUP message */ |
| |
| static void init_function_pointers(void) |
| { |
| HMODULE hdll = GetModuleHandleA("user32"); |
| |
| #define GET_PROC(func) \ |
| p ## func = (void*)GetProcAddress(hdll, #func); \ |
| if(!p ## func) \ |
| trace("GetProcAddress(%s) failed\n", #func); |
| |
| GET_PROC(SendInput) |
| GET_PROC(GetMouseMovePointsEx) |
| |
| #undef GET_PROC |
| } |
| |
| static int KbdMessage( KEV kev, WPARAM *pwParam, LPARAM *plParam ) |
| { |
| UINT message; |
| int VKey = GETVKEY[kev]; |
| WORD flags; |
| |
| flags = LOBYTE(GETSCAN[kev]); |
| if (GETFLAGS[kev] & KEYEVENTF_EXTENDEDKEY) flags |= KF_EXTENDED; |
| |
| if (GETFLAGS[kev] & KEYEVENTF_KEYUP ) |
| { |
| message = WM_KEYUP; |
| if( (InputKeyStateTable[VK_MENU] & 0x80) && ( |
| (VKey == VK_MENU) || (VKey == VK_CONTROL) || |
| !(InputKeyStateTable[VK_CONTROL] & 0x80))) { |
| if( TrackSysKey == VK_MENU || /* <ALT>-down/<ALT>-up sequence */ |
| (VKey != VK_MENU)) /* <ALT>-down...<something else>-up */ |
| message = WM_SYSKEYUP; |
| TrackSysKey = 0; |
| } |
| InputKeyStateTable[VKey] &= ~0x80; |
| flags |= KF_REPEAT | KF_UP; |
| } |
| else |
| { |
| if (InputKeyStateTable[VKey] & 0x80) flags |= KF_REPEAT; |
| if (!(InputKeyStateTable[VKey] & 0x80)) InputKeyStateTable[VKey] ^= 0x01; |
| InputKeyStateTable[VKey] |= 0x80; |
| AsyncKeyStateTable[VKey] |= 0x80; |
| |
| message = WM_KEYDOWN; |
| if( (InputKeyStateTable[VK_MENU] & 0x80) && |
| !(InputKeyStateTable[VK_CONTROL] & 0x80)) { |
| message = WM_SYSKEYDOWN; |
| TrackSysKey = VKey; |
| } |
| } |
| |
| if (InputKeyStateTable[VK_MENU] & 0x80) flags |= KF_ALTDOWN; |
| |
| if( plParam) *plParam = MAKELPARAM( 1, flags ); |
| if( pwParam) *pwParam = VKey; |
| return message; |
| } |
| |
| /****************************** end copy input.c ****************************/ |
| |
| /* |
| * . prepare the keyevents for SendInputs |
| * . calculate the "expected" messages |
| * . Send the events to our window |
| * . retrieve the messages from the input queue |
| * . verify |
| */ |
| static BOOL do_test( HWND hwnd, int seqnr, const KEV td[] ) |
| { |
| INPUT inputs[MAXKEYEVENTS]; |
| KMSG expmsg[MAXKEYEVENTS]; |
| MSG msg; |
| char buf[100]; |
| UINT evtctr=0; |
| int kmctr, i; |
| |
| buf[0]='\0'; |
| TrackSysKey=0; /* see input.c */ |
| for( i = 0; i < MAXKEYEVENTS; i++) { |
| ADDTOINPUTS(td[i]) |
| strcat(buf, getdesc[td[i]]); |
| if(td[i]) |
| expmsg[i].message = KbdMessage(td[i], &(expmsg[i].wParam), &(expmsg[i].lParam)); /* see queue_kbd_event() */ |
| else |
| expmsg[i].message = 0; |
| } |
| for( kmctr = 0; kmctr < MAXKEYEVENTS && expmsg[kmctr].message; kmctr++) |
| ; |
| assert( evtctr <= MAXKEYEVENTS ); |
| assert( evtctr == pSendInput(evtctr, &inputs[0], sizeof(INPUT))); |
| i = 0; |
| if (winetest_debug > 1) |
| trace("======== key stroke sequence #%d: %s =============\n", |
| seqnr + 1, buf); |
| while( PeekMessage(&msg,hwnd,WM_KEYFIRST,WM_KEYLAST,PM_REMOVE) ) { |
| if (winetest_debug > 1) |
| trace("message[%d] %-15s wParam %04lx lParam %08lx time %x\n", i, |
| MSGNAME[msg.message - WM_KEYFIRST], msg.wParam, msg.lParam, msg.time); |
| if( i < kmctr ) { |
| ok( msg.message == expmsg[i].message && |
| msg.wParam == expmsg[i].wParam && |
| msg.lParam == expmsg[i].lParam, |
| "%u/%u: wrong message %x/%08lx/%08lx expected %s/%08lx/%08lx\n", |
| seqnr, i, msg.message, msg.wParam, msg.lParam, |
| MSGNAME[(expmsg[i]).message - WM_KEYFIRST], expmsg[i].wParam, expmsg[i].lParam ); |
| } |
| i++; |
| } |
| if (winetest_debug > 1) |
| trace("%d messages retrieved\n", i); |
| if (!i && kmctr) |
| { |
| skip( "simulated keyboard input doesn't work\n" ); |
| return FALSE; |
| } |
| ok( i == kmctr, "message count is wrong: got %d expected: %d\n", i, kmctr); |
| return TRUE; |
| } |
| |
| /* test all combinations of the specified key events */ |
| static BOOL TestASet( HWND hWnd, int nrkev, const KEV kevdwn[], const KEV kevup[] ) |
| { |
| int i,j,k,l,m,n; |
| static int count=0; |
| KEV kbuf[MAXKEYEVENTS]; |
| assert( nrkev==2 || nrkev==3); |
| for(i=0;i<MAXKEYEVENTS;i++) kbuf[i]=0; |
| /* two keys involved gives 4 test cases */ |
| if(nrkev==2) { |
| for(i=0;i<nrkev;i++) { |
| for(j=0;j<nrkev;j++) { |
| kbuf[0] = kevdwn[i]; |
| kbuf[1] = kevdwn[1-i]; |
| kbuf[2] = kevup[j]; |
| kbuf[3] = kevup[1-j]; |
| if (!do_test( hWnd, count++, kbuf)) return FALSE; |
| } |
| } |
| } |
| /* three keys involved gives 36 test cases */ |
| if(nrkev==3){ |
| for(i=0;i<nrkev;i++){ |
| for(j=0;j<nrkev;j++){ |
| if(j==i) continue; |
| for(k=0;k<nrkev;k++){ |
| if(k==i || k==j) continue; |
| for(l=0;l<nrkev;l++){ |
| for(m=0;m<nrkev;m++){ |
| if(m==l) continue; |
| for(n=0;n<nrkev;n++){ |
| if(n==l ||n==m) continue; |
| kbuf[0] = kevdwn[i]; |
| kbuf[1] = kevdwn[j]; |
| kbuf[2] = kevdwn[k]; |
| kbuf[3] = kevup[l]; |
| kbuf[4] = kevup[m]; |
| kbuf[5] = kevup[n]; |
| if (!do_test( hWnd, count++, kbuf)) return FALSE; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return TRUE; |
| } |
| |
| /* test each set specified in the global testkeyset array */ |
| static void TestSysKeys( HWND hWnd) |
| { |
| int i; |
| for(i=0; testkeyset[i].nrkev;i++) |
| if (!TestASet( hWnd, testkeyset[i].nrkev, testkeyset[i].keydwn, testkeyset[i].keyup)) break; |
| } |
| |
| static LRESULT CALLBACK WndProc( HWND hWnd, UINT msg, WPARAM wParam, |
| LPARAM lParam ) |
| { |
| return DefWindowProcA( hWnd, msg, wParam, lParam ); |
| } |
| |
| static void test_Input_whitebox(void) |
| { |
| MSG msg; |
| WNDCLASSA wclass; |
| HANDLE hInstance = GetModuleHandleA( NULL ); |
| |
| wclass.lpszClassName = "InputSysKeyTestClass"; |
| wclass.style = CS_HREDRAW | CS_VREDRAW; |
| wclass.lpfnWndProc = WndProc; |
| wclass.hInstance = hInstance; |
| wclass.hIcon = LoadIconA( 0, IDI_APPLICATION ); |
| wclass.hCursor = LoadCursorA( NULL, IDC_ARROW ); |
| wclass.hbrBackground = (HBRUSH)( COLOR_WINDOW + 1 ); |
| wclass.lpszMenuName = 0; |
| wclass.cbClsExtra = 0; |
| wclass.cbWndExtra = 0; |
| RegisterClassA( &wclass ); |
| /* create the test window that will receive the keystrokes */ |
| hWndTest = CreateWindowA( wclass.lpszClassName, "InputSysKeyTest", |
| WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, 100, 100, |
| NULL, NULL, hInstance, NULL); |
| assert( hWndTest ); |
| ShowWindow( hWndTest, SW_SHOW); |
| SetWindowPos( hWndTest, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE ); |
| SetForegroundWindow( hWndTest ); |
| UpdateWindow( hWndTest); |
| |
| /* flush pending messages */ |
| while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg ); |
| |
| SetFocus( hWndTest ); |
| TestSysKeys( hWndTest ); |
| DestroyWindow(hWndTest); |
| } |
| |
| /* try to make sure pending X events have been processed before continuing */ |
| static void empty_message_queue(void) |
| { |
| MSG msg; |
| int diff = 200; |
| int min_timeout = 50; |
| DWORD time = GetTickCount() + diff; |
| |
| while (diff > 0) |
| { |
| if (MsgWaitForMultipleObjects(0, NULL, FALSE, min_timeout, QS_ALLINPUT) == WAIT_TIMEOUT) break; |
| while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) |
| { |
| TranslateMessage(&msg); |
| DispatchMessage(&msg); |
| } |
| diff = time - GetTickCount(); |
| } |
| } |
| |
| struct transition_s { |
| WORD wVk; |
| BYTE before_state; |
| BYTE optional; |
| }; |
| |
| typedef enum { |
| sent=0x1, |
| posted=0x2, |
| parent=0x4, |
| wparam=0x8, |
| lparam=0x10, |
| defwinproc=0x20, |
| beginpaint=0x40, |
| optional=0x80, |
| hook=0x100, |
| winevent_hook=0x200 |
| } msg_flags_t; |
| |
| struct message { |
| UINT message; /* the WM_* code */ |
| msg_flags_t flags; /* message props */ |
| WPARAM wParam; /* expected value of wParam */ |
| LPARAM lParam; /* expected value of lParam */ |
| }; |
| |
| struct sendinput_test_s { |
| WORD wVk; |
| DWORD dwFlags; |
| BOOL _todo_wine; |
| struct transition_s expected_transitions[MAXKEYEVENTS+1]; |
| struct message expected_messages[MAXKEYMESSAGES+1]; |
| } sendinput_test[] = { |
| /* test ALT+F */ |
| /* 0 */ |
| {VK_LMENU, 0, 0, {{VK_MENU, 0x00}, {VK_LMENU, 0x00}, {0}}, |
| {{WM_SYSKEYDOWN, hook|wparam, VK_LMENU}, {WM_SYSKEYDOWN}, {0}}}, |
| {'F', 0, 0, {{'F', 0x00}, {0}}, |
| {{WM_SYSKEYDOWN, hook}, {WM_SYSKEYDOWN}, |
| {WM_SYSCHAR}, |
| {WM_SYSCOMMAND}, {0}}}, |
| {'F', KEYEVENTF_KEYUP, 0, {{'F', 0x80}, {0}}, |
| {{WM_SYSKEYUP, hook}, {WM_SYSKEYUP}, {0}}}, |
| {VK_LMENU, KEYEVENTF_KEYUP, 0, {{VK_MENU, 0x80}, {VK_LMENU, 0x80}, {0}}, |
| {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}}, |
| |
| /* test CTRL+O */ |
| /* 4 */ |
| {VK_LCONTROL, 0, 0, {{VK_CONTROL, 0x00}, {VK_LCONTROL, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {0}}}, |
| {'O', 0, 0, {{'O', 0x00}, {0}}, |
| {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {WM_CHAR}, {0}}}, |
| {'O', KEYEVENTF_KEYUP, 0, {{'O', 0x80}, {0}}, |
| {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}}, |
| {VK_LCONTROL, KEYEVENTF_KEYUP, 0, {{VK_CONTROL, 0x80}, {VK_LCONTROL, 0x80}, {0}}, |
| {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}}, |
| |
| /* test ALT+CTRL+X */ |
| /* 8 */ |
| {VK_LMENU, 0, 0, {{VK_MENU, 0x00}, {VK_LMENU, 0x00}, {0}}, |
| {{WM_SYSKEYDOWN, hook}, {WM_SYSKEYDOWN}, {0}}}, |
| {VK_LCONTROL, 0, 0, {{VK_CONTROL, 0x00}, {VK_LCONTROL, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {0}}}, |
| {'X', 0, 0, {{'X', 0x00}, {0}}, |
| {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {0}}}, |
| {'X', KEYEVENTF_KEYUP, 0, {{'X', 0x80}, {0}}, |
| {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}}, |
| {VK_LCONTROL, KEYEVENTF_KEYUP, 0, {{VK_CONTROL, 0x80}, {VK_LCONTROL, 0x80}, {0}}, |
| {{WM_SYSKEYUP, hook}, {WM_SYSKEYUP}, {0}}}, |
| {VK_LMENU, KEYEVENTF_KEYUP, 0, {{VK_MENU, 0x80}, {VK_LMENU, 0x80}, {0}}, |
| {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}}, |
| |
| /* test SHIFT+A */ |
| /* 14 */ |
| {VK_LSHIFT, 0, 0, {{VK_SHIFT, 0x00}, {VK_LSHIFT, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {0}}}, |
| {'A', 0, 0, {{'A', 0x00}, {0}}, |
| {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {WM_CHAR}, {0}}}, |
| {'A', KEYEVENTF_KEYUP, 0, {{'A', 0x80}, {0}}, |
| {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}}, |
| {VK_LSHIFT, KEYEVENTF_KEYUP, 0, {{VK_SHIFT, 0x80}, {VK_LSHIFT, 0x80}, {0}}, |
| {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}}, |
| /* test L-SHIFT & R-SHIFT: */ |
| /* RSHIFT == LSHIFT */ |
| /* 18 */ |
| {VK_RSHIFT, 0, 0, |
| /* recent windows versions (>= w2k3) correctly report an RSHIFT transition */ |
| {{VK_SHIFT, 0x00}, {VK_LSHIFT, 0x00, TRUE}, {VK_RSHIFT, 0x00, TRUE}, {0}}, |
| {{WM_KEYDOWN, hook|wparam, VK_RSHIFT}, |
| {WM_KEYDOWN}, {0}}}, |
| {VK_RSHIFT, KEYEVENTF_KEYUP, 0, |
| {{VK_SHIFT, 0x80}, {VK_LSHIFT, 0x80, TRUE}, {VK_RSHIFT, 0x80, TRUE}, {0}}, |
| {{WM_KEYUP, hook, hook|wparam, VK_RSHIFT}, |
| {WM_KEYUP}, {0}}}, |
| |
| /* LSHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */ |
| /* 20 */ |
| {VK_LSHIFT, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_SHIFT, 0x00}, {VK_RSHIFT, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook|wparam|lparam, VK_LSHIFT, LLKHF_EXTENDED}, |
| {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}}, |
| {VK_LSHIFT, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_SHIFT, 0x80}, {VK_RSHIFT, 0x80}, {0}}, |
| {{WM_KEYUP, hook|wparam|lparam, VK_LSHIFT, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}}, |
| /* RSHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */ |
| /* 22 */ |
| {VK_RSHIFT, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_SHIFT, 0x00}, {VK_RSHIFT, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook|wparam|lparam, VK_RSHIFT, LLKHF_EXTENDED}, |
| {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}}, |
| {VK_RSHIFT, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_SHIFT, 0x80}, {VK_RSHIFT, 0x80}, {0}}, |
| {{WM_KEYUP, hook|wparam|lparam, VK_RSHIFT, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}}, |
| |
| /* Note about wparam for hook with generic key (VK_SHIFT, VK_CONTROL, VK_MENU): |
| win2k - sends to hook whatever we generated here |
| winXP+ - Attempts to convert key to L/R key but not always correct |
| */ |
| /* SHIFT == LSHIFT */ |
| /* 24 */ |
| {VK_SHIFT, 0, 0, |
| {{VK_SHIFT, 0x00}, {VK_LSHIFT, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook/* |wparam */|lparam, VK_SHIFT, 0}, |
| {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}}, |
| {VK_SHIFT, KEYEVENTF_KEYUP, 0, |
| {{VK_SHIFT, 0x80}, {VK_LSHIFT, 0x80}, {0}}, |
| {{WM_KEYUP, hook/*|wparam*/|lparam, VK_SHIFT, LLKHF_UP}, |
| {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}}, |
| /* SHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */ |
| /* 26 */ |
| {VK_SHIFT, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_SHIFT, 0x00}, {VK_RSHIFT, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook/*|wparam*/|lparam, VK_SHIFT, LLKHF_EXTENDED}, |
| {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}}, |
| {VK_SHIFT, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_SHIFT, 0x80}, {VK_RSHIFT, 0x80}, {0}}, |
| {{WM_KEYUP, hook/*|wparam*/|lparam, VK_SHIFT, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}}, |
| |
| /* test L-CONTROL & R-CONTROL: */ |
| /* RCONTROL == LCONTROL */ |
| /* 28 */ |
| {VK_RCONTROL, 0, 0, |
| {{VK_CONTROL, 0x00}, {VK_LCONTROL, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook|wparam, VK_RCONTROL}, |
| {WM_KEYDOWN, wparam|lparam, VK_CONTROL, 0}, {0}}}, |
| {VK_RCONTROL, KEYEVENTF_KEYUP, 0, |
| {{VK_CONTROL, 0x80}, {VK_LCONTROL, 0x80}, {0}}, |
| {{WM_KEYUP, hook|wparam, VK_RCONTROL}, |
| {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP}, {0}}}, |
| /* LCONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */ |
| /* 30 */ |
| {VK_LCONTROL, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_CONTROL, 0x00}, {VK_RCONTROL, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook|wparam|lparam, VK_LCONTROL, LLKHF_EXTENDED}, |
| {WM_KEYDOWN, wparam|lparam, VK_CONTROL, KF_EXTENDED}, {0}}}, |
| {VK_LCONTROL, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_CONTROL, 0x80}, {VK_RCONTROL, 0x80}, {0}}, |
| {{WM_KEYUP, hook|wparam|lparam, VK_LCONTROL, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP|KF_EXTENDED}, {0}}}, |
| /* RCONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */ |
| /* 32 */ |
| {VK_RCONTROL, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_CONTROL, 0x00}, {VK_RCONTROL, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook|wparam|lparam, VK_RCONTROL, LLKHF_EXTENDED}, |
| {WM_KEYDOWN, wparam|lparam, VK_CONTROL, KF_EXTENDED}, {0}}}, |
| {VK_RCONTROL, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_CONTROL, 0x80}, {VK_RCONTROL, 0x80}, {0}}, |
| {{WM_KEYUP, hook|wparam|lparam, VK_RCONTROL, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP|KF_EXTENDED}, {0}}}, |
| /* CONTROL == LCONTROL */ |
| /* 34 */ |
| {VK_CONTROL, 0, 0, |
| {{VK_CONTROL, 0x00}, {VK_LCONTROL, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook/*|wparam, VK_CONTROL*/}, |
| {WM_KEYDOWN, wparam|lparam, VK_CONTROL, 0}, {0}}}, |
| {VK_CONTROL, KEYEVENTF_KEYUP, 0, |
| {{VK_CONTROL, 0x80}, {VK_LCONTROL, 0x80}, {0}}, |
| {{WM_KEYUP, hook/*|wparam, VK_CONTROL*/}, |
| {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP}, {0}}}, |
| /* CONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */ |
| /* 36 */ |
| {VK_CONTROL, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_CONTROL, 0x00}, {VK_RCONTROL, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook/*|wparam*/|lparam, VK_CONTROL, LLKHF_EXTENDED}, |
| {WM_KEYDOWN, wparam|lparam, VK_CONTROL, KF_EXTENDED}, {0}}}, |
| {VK_CONTROL, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_CONTROL, 0x80}, {VK_RCONTROL, 0x80}, {0}}, |
| {{WM_KEYUP, hook/*|wparam*/|lparam, VK_CONTROL, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP|KF_EXTENDED}, {0}}}, |
| |
| /* test L-MENU & R-MENU: */ |
| /* RMENU == LMENU */ |
| /* 38 */ |
| {VK_RMENU, 0, 0, |
| {{VK_MENU, 0x00}, {VK_LMENU, 0x00}, {VK_CONTROL, 0x00, 1}, {VK_LCONTROL, 0x01, 1}, {0}}, |
| {{WM_SYSKEYDOWN, hook|wparam|optional, VK_LCONTROL}, |
| {WM_SYSKEYDOWN, hook|wparam, VK_RMENU}, |
| {WM_KEYDOWN, wparam|lparam|optional, VK_CONTROL, 0}, |
| {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0}, {0}}}, |
| {VK_RMENU, KEYEVENTF_KEYUP, 1, |
| {{VK_MENU, 0x80}, {VK_LMENU, 0x80}, {VK_CONTROL, 0x81, 1}, {VK_LCONTROL, 0x80, 1}, {0}}, |
| {{WM_KEYUP, hook|wparam|optional, VK_LCONTROL}, |
| {WM_KEYUP, hook|wparam, VK_RMENU}, |
| {WM_SYSKEYUP, wparam|lparam|optional, VK_CONTROL, KF_UP}, |
| {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP}, |
| {WM_SYSCOMMAND, optional}, {0}}}, |
| /* LMENU | KEYEVENTF_EXTENDEDKEY == RMENU */ |
| /* 40 */ |
| {VK_LMENU, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_MENU, 0x00}, {VK_RMENU, 0x00}, {0}}, |
| {{WM_SYSKEYDOWN, hook|wparam|lparam, VK_LMENU, LLKHF_EXTENDED}, |
| {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, KF_EXTENDED}, {0}}}, |
| {VK_LMENU, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 1, |
| {{VK_MENU, 0x80}, {VK_RMENU, 0x80}, {0}}, |
| {{WM_KEYUP, hook|wparam|lparam, VK_LMENU, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP|KF_EXTENDED}, |
| {WM_SYSCOMMAND}, {0}}}, |
| /* RMENU | KEYEVENTF_EXTENDEDKEY == RMENU */ |
| /* 42 */ |
| {VK_RMENU, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_MENU, 0x00}, {VK_RMENU, 0x00}, {VK_CONTROL, 0x00, 1}, {VK_LCONTROL, 0x01, 1}, {0}}, |
| {{WM_SYSKEYDOWN, hook|wparam|lparam|optional, VK_LCONTROL, 0}, |
| {WM_SYSKEYDOWN, hook|wparam|lparam, VK_RMENU, LLKHF_EXTENDED}, |
| {WM_KEYDOWN, wparam|lparam|optional, VK_CONTROL, 0}, |
| {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, KF_EXTENDED}, {0}}}, |
| {VK_RMENU, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 1, |
| {{VK_MENU, 0x80}, {VK_RMENU, 0x80}, {VK_CONTROL, 0x81, 1}, {VK_LCONTROL, 0x80, 1}, {0}}, |
| {{WM_KEYUP, hook|wparam|lparam|optional, VK_LCONTROL, LLKHF_UP}, |
| {WM_KEYUP, hook|wparam|lparam, VK_RMENU, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_SYSKEYUP, wparam|lparam|optional, VK_CONTROL, KF_UP}, |
| {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP|KF_EXTENDED}, |
| {WM_SYSCOMMAND, optional}, {0}}}, |
| /* MENU == LMENU */ |
| /* 44 */ |
| {VK_MENU, 0, 0, |
| {{VK_MENU, 0x00}, {VK_LMENU, 0x00}, {0}}, |
| {{WM_SYSKEYDOWN, hook/*|wparam, VK_MENU*/}, |
| {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0}, {0}}}, |
| {VK_MENU, KEYEVENTF_KEYUP, 1, |
| {{VK_MENU, 0x80}, {VK_LMENU, 0x80}, {0}}, |
| {{WM_KEYUP, hook/*|wparam, VK_MENU*/}, |
| {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP}, |
| {WM_SYSCOMMAND}, {0}}}, |
| /* MENU | KEYEVENTF_EXTENDEDKEY == RMENU */ |
| /* 46 */ |
| {VK_MENU, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_MENU, 0x00}, {VK_RMENU, 0x00}, {VK_CONTROL, 0x00, 1}, {VK_LCONTROL, 0x01, 1}, {0}}, |
| {{WM_SYSKEYDOWN, hook|wparam|lparam|optional, VK_CONTROL, 0}, |
| {WM_SYSKEYDOWN, hook/*|wparam*/|lparam, VK_MENU, LLKHF_EXTENDED}, |
| {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, KF_EXTENDED}, {0}}}, |
| {VK_MENU, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 1, |
| {{VK_MENU, 0x80}, {VK_RMENU, 0x80}, {VK_CONTROL, 0x81, 1}, {VK_LCONTROL, 0x80, 1}, {0}}, |
| {{WM_KEYUP, hook|wparam|lparam|optional, VK_CONTROL, LLKHF_UP}, |
| {WM_KEYUP, hook/*|wparam*/|lparam, VK_MENU, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP|KF_EXTENDED}, |
| {WM_SYSCOMMAND}, {0}}}, |
| |
| /* test LSHIFT & RSHIFT */ |
| /* 48 */ |
| {VK_LSHIFT, 0, 0, |
| {{VK_SHIFT, 0x00}, {VK_LSHIFT, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook|wparam|lparam, VK_LSHIFT, 0}, |
| {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}}, |
| {VK_RSHIFT, KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_RSHIFT, 0x00}, {0}}, |
| {{WM_KEYDOWN, hook|wparam|lparam, VK_RSHIFT, LLKHF_EXTENDED}, |
| {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}}, |
| {VK_RSHIFT, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, 0, |
| {{VK_RSHIFT, 0x80}, {0}}, |
| {{WM_KEYUP, hook|wparam|lparam, VK_RSHIFT, LLKHF_UP|LLKHF_EXTENDED}, |
| {WM_KEYUP, optional}, {0}}}, |
| {VK_LSHIFT, KEYEVENTF_KEYUP, 0, |
| {{VK_SHIFT, 0x80}, {VK_LSHIFT, 0x80}, {0}}, |
| {{WM_KEYUP, hook|wparam, VK_LSHIFT}, |
| {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}}, |
| |
| {0, 0, 0, {{0}}, {{0}}} /* end */ |
| }; |
| |
| static struct message sent_messages[MAXKEYMESSAGES]; |
| static UINT sent_messages_cnt; |
| |
| /* Verify that only specified key state transitions occur */ |
| static void compare_and_check(int id, BYTE *ks1, BYTE *ks2, struct sendinput_test_s *test) |
| { |
| int i, failcount = 0; |
| struct transition_s *t = test->expected_transitions; |
| UINT actual_cnt = 0; |
| const struct message *expected = test->expected_messages; |
| |
| while (t->wVk) { |
| int matched = ((ks1[t->wVk]&0x80) == (t->before_state&0x80) |
| && (ks2[t->wVk]&0x80) == (~t->before_state&0x80)); |
| |
| if (!matched && !t->optional && test->_todo_wine) |
| { |
| failcount++; |
| todo_wine { |
| ok(matched, "%2d (%x/%x): %02x from %02x -> %02x " |
| "instead of %02x -> %02x\n", id, test->wVk, test->dwFlags, |
| t->wVk, ks1[t->wVk]&0x80, ks2[t->wVk]&0x80, t->before_state, |
| ~t->before_state&0x80); |
| } |
| } else { |
| ok(matched || t->optional, "%2d (%x/%x): %02x from %02x -> %02x " |
| "instead of %02x -> %02x\n", id, test->wVk, test->dwFlags, |
| t->wVk, ks1[t->wVk]&0x80, ks2[t->wVk]&0x80, t->before_state, |
| ~t->before_state&0x80); |
| } |
| ks2[t->wVk] = ks1[t->wVk]; /* clear the match */ |
| t++; |
| } |
| for (i = 0; i < 256; i++) |
| if (ks2[i] != ks1[i] && test->_todo_wine) |
| { |
| failcount++; |
| todo_wine |
| ok(FALSE, "%2d (%x/%x): %02x from %02x -> %02x unexpected\n", |
| id, test->wVk, test->dwFlags, i, ks1[i], ks2[i]); |
| } |
| else |
| ok(ks2[i] == ks1[i], "%2d (%x/%x): %02x from %02x -> %02x unexpected\n", |
| id, test->wVk, test->dwFlags, i, ks1[i], ks2[i]); |
| |
| while (expected->message && actual_cnt < sent_messages_cnt) |
| { |
| const struct message *actual = &sent_messages[actual_cnt]; |
| |
| if (expected->message == actual->message) |
| { |
| if (expected->flags & wparam) |
| { |
| if ((expected->flags & optional) && (expected->wParam != actual->wParam)) |
| { |
| expected++; |
| continue; |
| } |
| if (expected->wParam != actual->wParam && test->_todo_wine) |
| { |
| failcount++; |
| todo_wine |
| ok(FALSE, "%2d (%x/%x): in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n", |
| id, test->wVk, test->dwFlags, expected->message, expected->wParam, actual->wParam); |
| } |
| else |
| ok(expected->wParam == actual->wParam, |
| "%2d (%x/%x): in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n", |
| id, test->wVk, test->dwFlags, expected->message, expected->wParam, actual->wParam); |
| } |
| if (expected->flags & lparam) |
| { |
| if (expected->lParam != actual->lParam && test->_todo_wine) |
| { |
| failcount++; |
| todo_wine |
| ok(FALSE, "%2d (%x/%x): in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n", |
| id, test->wVk, test->dwFlags, expected->message, expected->lParam, actual->lParam); |
| } |
| else |
| ok(expected->lParam == actual->lParam, |
| "%2d (%x/%x): in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n", |
| id, test->wVk, test->dwFlags, expected->message, expected->lParam, actual->lParam); |
| } |
| ok((expected->flags & hook) == (actual->flags & hook), |
| "%2d (%x/%x): the msg 0x%04x should have been sent by a hook\n", |
| id, test->wVk, test->dwFlags, expected->message); |
| |
| } |
| else if (expected->flags & optional) |
| { |
| expected++; |
| continue; |
| } |
| /* NT4 doesn't send SYSKEYDOWN/UP to hooks, only KEYDOWN/UP */ |
| else if ((expected->flags & hook) && |
| (expected->message == WM_SYSKEYDOWN || expected->message == WM_SYSKEYUP) && |
| (actual->message == expected->message - 4)) |
| { |
| ok((expected->flags & hook) == (actual->flags & hook), |
| "%2d (%x/%x): the msg 0x%04x should have been sent by a hook\n", |
| id, test->wVk, test->dwFlags, expected->message); |
| } |
| /* For VK_RMENU, at least localized Win2k/XP sends KEYDOWN/UP |
| * instead of SYSKEYDOWN/UP to the WNDPROC */ |
| else if (test->wVk == VK_RMENU && !(expected->flags & hook) && |
| (expected->message == WM_SYSKEYDOWN || expected->message == WM_SYSKEYUP) && |
| (actual->message == expected->message - 4)) |
| { |
| ok(expected->wParam == actual->wParam && expected->lParam == actual->lParam, |
| "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n", |
| id, test->wVk, test->dwFlags, expected->message, actual->message); |
| } |
| else if (test->_todo_wine) |
| { |
| failcount++; |
| todo_wine |
| ok(FALSE, |
| "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n", |
| id, test->wVk, test->dwFlags, expected->message, actual->message); |
| } |
| else |
| ok(FALSE, |
| "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n", |
| id, test->wVk, test->dwFlags, expected->message, actual->message); |
| |
| actual_cnt++; |
| expected++; |
| } |
| /* skip all optional trailing messages */ |
| while (expected->message && (expected->flags & optional)) |
| expected++; |
| |
| |
| if (expected->message || actual_cnt < sent_messages_cnt) |
| { |
| if (test->_todo_wine) |
| { |
| failcount++; |
| todo_wine |
| ok(FALSE, "%2d (%x/%x): the msg sequence is not complete: expected %04x - actual %04x\n", |
| id, test->wVk, test->dwFlags, expected->message, sent_messages[actual_cnt].message); |
| } |
| else |
| ok(FALSE, "%2d (%x/%x): the msg sequence is not complete: expected %04x - actual %04x\n", |
| id, test->wVk, test->dwFlags, expected->message, sent_messages[actual_cnt].message); |
| } |
| |
| if( test->_todo_wine && !failcount) /* succeeded yet marked todo */ |
| todo_wine |
| ok(TRUE, "%2d (%x/%x): marked \"todo_wine\" but succeeds\n", id, test->wVk, test->dwFlags); |
| |
| sent_messages_cnt = 0; |
| } |
| |
| /* WndProc2 checks that we get at least the messages specified */ |
| static LRESULT CALLBACK WndProc2(HWND hWnd, UINT Msg, WPARAM wParam, |
| LPARAM lParam) |
| { |
| if (winetest_debug > 1) trace("MSG: %8x W:%8lx L:%8lx\n", Msg, wParam, lParam); |
| |
| if (Msg != WM_PAINT && |
| Msg != WM_NCPAINT && |
| Msg != WM_SYNCPAINT && |
| Msg != WM_ERASEBKGND && |
| Msg != WM_NCHITTEST && |
| Msg != WM_GETTEXT && |
| Msg != WM_GETICON && |
| Msg != WM_IME_SELECT && |
| Msg != WM_DEVICECHANGE && |
| Msg != WM_TIMECHANGE) |
| { |
| ok(sent_messages_cnt < MAXKEYMESSAGES, "Too many messages\n"); |
| if (sent_messages_cnt < MAXKEYMESSAGES) |
| { |
| sent_messages[sent_messages_cnt].message = Msg; |
| sent_messages[sent_messages_cnt].flags = 0; |
| sent_messages[sent_messages_cnt].wParam = wParam; |
| sent_messages[sent_messages_cnt++].lParam = HIWORD(lParam) & (KF_UP|KF_EXTENDED); |
| } |
| } |
| return DefWindowProc(hWnd, Msg, wParam, lParam); |
| } |
| |
| static LRESULT CALLBACK hook_proc(int code, WPARAM wparam, LPARAM lparam) |
| { |
| KBDLLHOOKSTRUCT *hook_info = (KBDLLHOOKSTRUCT *)lparam; |
| |
| if (code == HC_ACTION) |
| { |
| ok(sent_messages_cnt < MAXKEYMESSAGES, "Too many messages\n"); |
| if (sent_messages_cnt < MAXKEYMESSAGES) |
| { |
| sent_messages[sent_messages_cnt].message = wparam; |
| sent_messages[sent_messages_cnt].flags = hook; |
| sent_messages[sent_messages_cnt].wParam = hook_info->vkCode; |
| sent_messages[sent_messages_cnt++].lParam = hook_info->flags & (LLKHF_UP|LLKHF_EXTENDED); |
| } |
| |
| if(0) /* For some reason not stable on Wine */ |
| { |
| if (wparam == WM_KEYDOWN || wparam == WM_SYSKEYDOWN) |
| ok(!(GetAsyncKeyState(hook_info->vkCode) & 0x8000), "key %x should be up\n", hook_info->vkCode); |
| else if (wparam == WM_KEYUP || wparam == WM_SYSKEYUP) |
| ok(GetAsyncKeyState(hook_info->vkCode) & 0x8000, "key %x should be down\n", hook_info->vkCode); |
| } |
| |
| if (winetest_debug > 1) |
| trace("Hook: w=%lx vk:%8x sc:%8x fl:%8x %lx\n", wparam, |
| hook_info->vkCode, hook_info->scanCode, hook_info->flags, hook_info->dwExtraInfo); |
| } |
| return CallNextHookEx( 0, code, wparam, lparam ); |
| } |
| static void test_Input_blackbox(void) |
| { |
| TEST_INPUT i; |
| int ii; |
| BYTE ks1[256], ks2[256]; |
| LONG_PTR prevWndProc; |
| HWND window; |
| HHOOK hook; |
| |
| if (GetKeyboardLayout(0) != (HKL)(ULONG_PTR)0x04090409) |
| { |
| skip("Skipping Input_blackbox test on non-US keyboard\n"); |
| return; |
| } |
| window = CreateWindow("Static", NULL, WS_POPUP|WS_HSCROLL|WS_VSCROLL |
| |WS_VISIBLE, 0, 0, 200, 60, NULL, NULL, |
| NULL, NULL); |
| ok(window != NULL, "error: %d\n", (int) GetLastError()); |
| SetWindowPos( window, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE ); |
| SetForegroundWindow( window ); |
| |
| if (!(hook = SetWindowsHookExA(WH_KEYBOARD_LL, hook_proc, GetModuleHandleA( NULL ), 0))) |
| { |
| DestroyWindow(window); |
| win_skip("WH_KEYBOARD_LL is not supported\n"); |
| return; |
| } |
| |
| /* must process all initial messages, otherwise X11DRV_KeymapNotify unsets |
| * key state set by SendInput(). */ |
| empty_message_queue(); |
| |
| prevWndProc = SetWindowLongPtr(window, GWLP_WNDPROC, (LONG_PTR) WndProc2); |
| ok(prevWndProc != 0 || (prevWndProc == 0 && GetLastError() == 0), |
| "error: %d\n", (int) GetLastError()); |
| |
| i.type = INPUT_KEYBOARD; |
| i.u.ki.time = 0; |
| i.u.ki.dwExtraInfo = 0; |
| |
| for (ii = 0; ii < sizeof(sendinput_test)/sizeof(struct sendinput_test_s)-1; |
| ii++) { |
| GetKeyboardState(ks1); |
| i.u.ki.wScan = ii+1 /* useful for debugging */; |
| i.u.ki.dwFlags = sendinput_test[ii].dwFlags; |
| i.u.ki.wVk = sendinput_test[ii].wVk; |
| pSendInput(1, (INPUT*)&i, sizeof(TEST_INPUT)); |
| empty_message_queue(); |
| GetKeyboardState(ks2); |
| if (!ii && sent_messages_cnt <= 1 && !memcmp( ks1, ks2, sizeof(ks1) )) |
| { |
| win_skip( "window doesn't receive the queued input\n" ); |
| /* release the key */ |
| i.u.ki.dwFlags |= KEYEVENTF_KEYUP; |
| pSendInput(1, (INPUT*)&i, sizeof(TEST_INPUT)); |
| break; |
| } |
| compare_and_check(ii, ks1, ks2, &sendinput_test[ii]); |
| } |
| |
| empty_message_queue(); |
| DestroyWindow(window); |
| UnhookWindowsHookEx(hook); |
| } |
| |
| static void reset_key_status(void) |
| { |
| key_status.last_key_down = -1; |
| key_status.last_key_up = -1; |
| key_status.last_syskey_down = -1; |
| key_status.last_syskey_up = -1; |
| key_status.last_char = -1; |
| key_status.last_syschar = -1; |
| key_status.last_hook_down = -1; |
| key_status.last_hook_up = -1; |
| key_status.last_hook_syskey_down = -1; |
| key_status.last_hook_syskey_up = -1; |
| key_status.expect_alt = FALSE; |
| key_status.sendinput_broken = FALSE; |
| } |
| |
| static void test_unicode_keys(HWND hwnd, HHOOK hook) |
| { |
| TEST_INPUT inputs[2]; |
| MSG msg; |
| |
| /* init input data that never changes */ |
| inputs[1].type = inputs[0].type = INPUT_KEYBOARD; |
| inputs[1].u.ki.dwExtraInfo = inputs[0].u.ki.dwExtraInfo = 0; |
| inputs[1].u.ki.time = inputs[0].u.ki.time = 0; |
| |
| /* pressing & releasing a single unicode character */ |
| inputs[0].u.ki.wVk = 0; |
| inputs[0].u.ki.wScan = 0x3c0; |
| inputs[0].u.ki.dwFlags = KEYEVENTF_UNICODE; |
| |
| reset_key_status(); |
| pSendInput(1, (INPUT*)inputs, sizeof(INPUT)); |
| while(PeekMessageW(&msg, hwnd, 0, 0, PM_REMOVE)){ |
| if(msg.message == WM_KEYDOWN && msg.wParam == VK_PACKET){ |
| TranslateMessage(&msg); |
| } |
| DispatchMessageW(&msg); |
| } |
| if(!key_status.sendinput_broken){ |
| ok(key_status.last_key_down == VK_PACKET, |
| "Last keydown msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET, key_status.last_key_down); |
| ok(key_status.last_char == 0x3c0, |
| "Last char msg wparam should have been 0x3c0 (was: 0x%x)\n", key_status.last_char); |
| if(hook) |
| ok(key_status.last_hook_down == 0x3c0, |
| "Last hookdown msg should have been 0x3c0, was: 0x%x\n", key_status.last_hook_down); |
| } |
| |
| inputs[1].u.ki.wVk = 0; |
| inputs[1].u.ki.wScan = 0x3c0; |
| inputs[1].u.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP; |
| |
| reset_key_status(); |
| pSendInput(1, (INPUT*)(inputs+1), sizeof(INPUT)); |
| while(PeekMessageW(&msg, hwnd, 0, 0, PM_REMOVE)){ |
| if(msg.message == WM_KEYDOWN && msg.wParam == VK_PACKET){ |
| TranslateMessage(&msg); |
| } |
| DispatchMessageW(&msg); |
| } |
| if(!key_status.sendinput_broken){ |
| ok(key_status.last_key_up == VK_PACKET, |
| "Last keyup msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET, key_status.last_key_up); |
| if(hook) |
| ok(key_status.last_hook_up == 0x3c0, |
| "Last hookup msg should have been 0x3c0, was: 0x%x\n", key_status.last_hook_up); |
| } |
| |
| /* holding alt, pressing & releasing a unicode character, releasing alt */ |
| inputs[0].u.ki.wVk = VK_LMENU; |
| inputs[0].u.ki.wScan = 0; |
| inputs[0].u.ki.dwFlags = 0; |
| |
| inputs[1].u.ki.wVk = 0; |
| inputs[1].u.ki.wScan = 0x3041; |
| inputs[1].u.ki.dwFlags = KEYEVENTF_UNICODE; |
| |
| reset_key_status(); |
| key_status.expect_alt = TRUE; |
| pSendInput(2, (INPUT*)inputs, sizeof(INPUT)); |
| while(PeekMessageW(&msg, hwnd, 0, 0, PM_REMOVE)){ |
| if(msg.message == WM_SYSKEYDOWN && msg.wParam == VK_PACKET){ |
| TranslateMessage(&msg); |
| } |
| DispatchMessageW(&msg); |
| } |
| if(!key_status.sendinput_broken){ |
| ok(key_status.last_syskey_down == VK_PACKET, |
| "Last syskeydown msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET, key_status.last_syskey_down); |
| ok(key_status.last_syschar == 0x3041, |
| "Last syschar msg should have been 0x3041 (was: 0x%x)\n", key_status.last_syschar); |
| if(hook) |
| ok(key_status.last_hook_syskey_down == 0x3041, |
| "Last hooksysdown msg should have been 0x3041, was: 0x%x\n", key_status.last_hook_syskey_down); |
| } |
| |
| inputs[1].u.ki.wVk = 0; |
| inputs[1].u.ki.wScan = 0x3041; |
| inputs[1].u.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP; |
| |
| inputs[0].u.ki.wVk = VK_LMENU; |
| inputs[0].u.ki.wScan = 0; |
| inputs[0].u.ki.dwFlags = KEYEVENTF_KEYUP; |
| |
| reset_key_status(); |
| key_status.expect_alt = TRUE; |
| pSendInput(2, (INPUT*)inputs, sizeof(INPUT)); |
| while(PeekMessageW(&msg, hwnd, 0, 0, PM_REMOVE)){ |
| if(msg.message == WM_SYSKEYDOWN && msg.wParam == VK_PACKET){ |
| TranslateMessage(&msg); |
| } |
| DispatchMessageW(&msg); |
| } |
| if(!key_status.sendinput_broken){ |
| ok(key_status.last_key_up == VK_PACKET, |
| "Last keyup msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET, key_status.last_key_up); |
| if(hook) |
| ok(key_status.last_hook_up == 0x3041, |
| "Last hook up msg should have been 0x3041, was: 0x%x\n", key_status.last_hook_up); |
| } |
| } |
| |
| static LRESULT CALLBACK unicode_wnd_proc( HWND hWnd, UINT msg, WPARAM wParam, |
| LPARAM lParam ) |
| { |
| switch(msg){ |
| case WM_KEYDOWN: |
| key_status.last_key_down = wParam; |
| break; |
| case WM_SYSKEYDOWN: |
| key_status.last_syskey_down = wParam; |
| break; |
| case WM_KEYUP: |
| key_status.last_key_up = wParam; |
| break; |
| case WM_SYSKEYUP: |
| key_status.last_syskey_up = wParam; |
| break; |
| case WM_CHAR: |
| key_status.last_char = wParam; |
| break; |
| case WM_SYSCHAR: |
| key_status.last_syschar = wParam; |
| break; |
| } |
| return DefWindowProcW(hWnd, msg, wParam, lParam); |
| } |
| |
| static LRESULT CALLBACK llkbd_unicode_hook(int nCode, WPARAM wParam, LPARAM lParam) |
| { |
| if(nCode == HC_ACTION){ |
| LPKBDLLHOOKSTRUCT info = (LPKBDLLHOOKSTRUCT)lParam; |
| if(!info->vkCode){ |
| key_status.sendinput_broken = TRUE; |
| win_skip("SendInput doesn't support unicode on this platform\n"); |
| }else{ |
| if(key_status.expect_alt){ |
| ok(info->vkCode == VK_LMENU, "vkCode should have been VK_LMENU[0x%04x], was: 0x%x\n", VK_LMENU, info->vkCode); |
| key_status.expect_alt = FALSE; |
| }else |
| ok(info->vkCode == VK_PACKET, "vkCode should have been VK_PACKET[0x%04x], was: 0x%x\n", VK_PACKET, info->vkCode); |
| } |
| switch(wParam){ |
| case WM_KEYDOWN: |
| key_status.last_hook_down = info->scanCode; |
| break; |
| case WM_KEYUP: |
| key_status.last_hook_up = info->scanCode; |
| break; |
| case WM_SYSKEYDOWN: |
| key_status.last_hook_syskey_down = info->scanCode; |
| break; |
| case WM_SYSKEYUP: |
| key_status.last_hook_syskey_up = info->scanCode; |
| break; |
| } |
| } |
| return CallNextHookEx(NULL, nCode, wParam, lParam); |
| } |
| |
| static void test_Input_unicode(void) |
| { |
| WCHAR classNameW[] = {'I','n','p','u','t','U','n','i','c','o','d','e', |
| 'K','e','y','T','e','s','t','C','l','a','s','s',0}; |
| WCHAR windowNameW[] = {'I','n','p','u','t','U','n','i','c','o','d','e', |
| 'K','e','y','T','e','s','t',0}; |
| MSG msg; |
| WNDCLASSW wclass; |
| HANDLE hInstance = GetModuleHandleW(NULL); |
| HHOOK hook; |
| |
| wclass.lpszClassName = classNameW; |
| wclass.style = CS_HREDRAW | CS_VREDRAW; |
| wclass.lpfnWndProc = unicode_wnd_proc; |
| wclass.hInstance = hInstance; |
| wclass.hIcon = LoadIcon(0, IDI_APPLICATION); |
| wclass.hCursor = LoadCursor( NULL, IDC_ARROW); |
| wclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); |
| wclass.lpszMenuName = 0; |
| wclass.cbClsExtra = 0; |
| wclass.cbWndExtra = 0; |
| if(!RegisterClassW(&wclass)){ |
| win_skip("Unicode functions not supported\n"); |
| return; |
| } |
| /* create the test window that will receive the keystrokes */ |
| hWndTest = CreateWindowW(wclass.lpszClassName, windowNameW, |
| WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, 100, 100, |
| NULL, NULL, hInstance, NULL); |
| |
| assert(hWndTest); |
| assert(IsWindowUnicode(hWndTest)); |
| |
| hook = SetWindowsHookExW(WH_KEYBOARD_LL, llkbd_unicode_hook, GetModuleHandleW(NULL), 0); |
| if(!hook) |
| win_skip("unable to set WH_KEYBOARD_LL hook\n"); |
| |
| ShowWindow(hWndTest, SW_SHOW); |
| SetWindowPos(hWndTest, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE); |
| SetForegroundWindow(hWndTest); |
| UpdateWindow(hWndTest); |
| |
| /* flush pending messages */ |
| while (PeekMessageW(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageW(&msg); |
| |
| SetFocus(hWndTest); |
| |
| test_unicode_keys(hWndTest, hook); |
| |
| if(hook) |
| UnhookWindowsHookEx(hook); |
| DestroyWindow(hWndTest); |
| } |
| |
| static void test_keynames(void) |
| { |
| int i, len; |
| char buff[256]; |
| |
| for (i = 0; i < 512; i++) |
| { |
| strcpy(buff, "----"); |
| len = GetKeyNameTextA(i << 16, buff, sizeof(buff)); |
| ok(len || !buff[0], "%d: Buffer is not zeroed\n", i); |
| } |
| } |
| |
| static POINT pt_old, pt_new; |
| static BOOL clipped; |
| #define STEP 3 |
| |
| static LRESULT CALLBACK hook_proc1( int code, WPARAM wparam, LPARAM lparam ) |
| { |
| MSLLHOOKSTRUCT *hook = (MSLLHOOKSTRUCT *)lparam; |
| POINT pt, pt1; |
| |
| if (code == HC_ACTION) |
| { |
| /* This is our new cursor position */ |
| pt_new = hook->pt; |
| /* Should return previous position */ |
| GetCursorPos(&pt); |
| ok(pt.x == pt_old.x && pt.y == pt_old.y, "GetCursorPos: (%d,%d)\n", pt.x, pt.y); |
| |
| /* Should set new position until hook chain is finished. */ |
| pt.x = pt_old.x + STEP; |
| pt.y = pt_old.y + STEP; |
| SetCursorPos(pt.x, pt.y); |
| GetCursorPos(&pt1); |
| if (clipped) |
| ok(pt1.x == pt_old.x && pt1.y == pt_old.y, "Wrong set pos: (%d,%d)\n", pt1.x, pt1.y); |
| else |
| ok(pt1.x == pt.x && pt1.y == pt.y, "Wrong set pos: (%d,%d)\n", pt1.x, pt1.y); |
| } |
| return CallNextHookEx( 0, code, wparam, lparam ); |
| } |
| |
| static LRESULT CALLBACK hook_proc2( int code, WPARAM wparam, LPARAM lparam ) |
| { |
| MSLLHOOKSTRUCT *hook = (MSLLHOOKSTRUCT *)lparam; |
| POINT pt; |
| |
| if (code == HC_ACTION) |
| { |
| ok(hook->pt.x == pt_new.x && hook->pt.y == pt_new.y, |
| "Wrong hook coords: (%d %d) != (%d,%d)\n", hook->pt.x, hook->pt.y, pt_new.x, pt_new.y); |
| |
| /* Should match position set above */ |
| GetCursorPos(&pt); |
| if (clipped) |
| ok(pt.x == pt_old.x && pt.y == pt_old.y, "GetCursorPos: (%d,%d)\n", pt.x, pt.y); |
| else |
| ok(pt.x == pt_old.x +STEP && pt.y == pt_old.y +STEP, "GetCursorPos: (%d,%d)\n", pt.x, pt.y); |
| } |
| return CallNextHookEx( 0, code, wparam, lparam ); |
| } |
| |
| static void test_mouse_ll_hook(void) |
| { |
| HWND hwnd; |
| HHOOK hook1, hook2; |
| POINT pt_org, pt; |
| RECT rc; |
| |
| GetCursorPos(&pt_org); |
| hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW | WS_VISIBLE, |
| 10, 10, 200, 200, NULL, NULL, NULL, NULL); |
| SetCursorPos(100, 100); |
| |
| if (!(hook2 = SetWindowsHookExA(WH_MOUSE_LL, hook_proc2, GetModuleHandleA(0), 0))) |
| { |
| win_skip( "cannot set MOUSE_LL hook\n" ); |
| goto done; |
| } |
| hook1 = SetWindowsHookExA(WH_MOUSE_LL, hook_proc1, GetModuleHandleA(0), 0); |
| |
| GetCursorPos(&pt_old); |
| mouse_event(MOUSEEVENTF_MOVE, -STEP, 0, 0, 0); |
| GetCursorPos(&pt_old); |
| 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); |
| mouse_event(MOUSEEVENTF_MOVE, +STEP, 0, 0, 0); |
| GetCursorPos(&pt_old); |
| 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); |
| mouse_event(MOUSEEVENTF_MOVE, 0, -STEP, 0, 0); |
| GetCursorPos(&pt_old); |
| 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); |
| mouse_event(MOUSEEVENTF_MOVE, 0, +STEP, 0, 0); |
| GetCursorPos(&pt_old); |
| 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); |
| |
| SetRect(&rc, 50, 50, 151, 151); |
| ClipCursor(&rc); |
| clipped = TRUE; |
| |
| SetCursorPos(40, 40); |
| GetCursorPos(&pt_old); |
| ok(pt_old.x == 50 && pt_old.y == 50, "Wrong new pos: (%d,%d)\n", pt_new.x, pt_new.y); |
| SetCursorPos(160, 160); |
| GetCursorPos(&pt_old); |
| ok(pt_old.x == 150 && pt_old.y == 150, "Wrong new pos: (%d,%d)\n", pt_new.x, pt_new.y); |
| mouse_event(MOUSEEVENTF_MOVE, +STEP, +STEP, 0, 0); |
| GetCursorPos(&pt_old); |
| ok(pt_old.x == 150 && pt_old.y == 150, "Wrong new pos: (%d,%d)\n", pt_new.x, pt_new.y); |
| |
| clipped = FALSE; |
| pt_new.x = pt_new.y = 150; |
| ClipCursor(NULL); |
| UnhookWindowsHookEx(hook1); |
| |
| /* Now check that mouse buttons do not change mouse position |
| if we don't have MOUSEEVENTF_MOVE flag specified. */ |
| |
| /* We reusing the same hook callback, so make it happy */ |
| pt_old.x = pt_new.x - STEP; |
| pt_old.y = pt_new.y - STEP; |
| mouse_event(MOUSEEVENTF_LEFTUP, 123, 456, 0, 0); |
| GetCursorPos(&pt); |
| ok(pt.x == pt_new.x && pt.y == pt_new.y, "Position changed: (%d,%d)\n", pt.x, pt.y); |
| mouse_event(MOUSEEVENTF_RIGHTUP, 456, 123, 0, 0); |
| GetCursorPos(&pt); |
| ok(pt.x == pt_new.x && pt.y == pt_new.y, "Position changed: (%d,%d)\n", pt.x, pt.y); |
| |
| mouse_event(MOUSEEVENTF_LEFTUP | MOUSEEVENTF_ABSOLUTE, 123, 456, 0, 0); |
| GetCursorPos(&pt); |
| ok(pt.x == pt_new.x && pt.y == pt_new.y, "Position changed: (%d,%d)\n", pt.x, pt.y); |
| mouse_event(MOUSEEVENTF_RIGHTUP | MOUSEEVENTF_ABSOLUTE, 456, 123, 0, 0); |
| GetCursorPos(&pt); |
| ok(pt.x == pt_new.x && pt.y == pt_new.y, "Position changed: (%d,%d)\n", pt.x, pt.y); |
| |
| UnhookWindowsHookEx(hook2); |
| done: |
| DestroyWindow(hwnd); |
| SetCursorPos(pt_org.x, pt_org.y); |
| } |
| |
| static void test_GetMouseMovePointsEx(void) |
| { |
| #define BUFLIM 64 |
| #define MYERROR 0xdeadbeef |
| int count, retval; |
| MOUSEMOVEPOINT in; |
| MOUSEMOVEPOINT out[200]; |
| POINT point; |
| |
| /* Get a valid content for the input struct */ |
| if(!GetCursorPos(&point)) { |
| skip("GetCursorPos() failed with error %u\n", GetLastError()); |
| return; |
| } |
| memset(&in, 0, sizeof(MOUSEMOVEPOINT)); |
| in.x = point.x; |
| in.y = point.y; |
| |
| /* test first parameter |
| * everything different than sizeof(MOUSEMOVEPOINT) |
| * is expected to fail with ERROR_INVALID_PARAMETER |
| */ |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(0, &in, out, BUFLIM, GMMP_USE_DISPLAY_POINTS); |
| if (retval == ERROR_INVALID_PARAMETER) |
| { |
| win_skip( "GetMouseMovePointsEx broken on WinME\n" ); |
| return; |
| } |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR, |
| "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError()); |
| |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT)-1, &in, out, BUFLIM, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR, |
| "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError()); |
| |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT)+1, &in, out, BUFLIM, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR, |
| "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError()); |
| |
| /* test second and third parameter |
| */ |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), NULL, out, BUFLIM, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_NOACCESS || GetLastError() == MYERROR, |
| "expected error ERROR_NOACCESS, got %u\n", GetLastError()); |
| |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, NULL, BUFLIM, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(ERROR_NOACCESS == GetLastError(), |
| "expected error ERROR_NOACCESS, got %u\n", GetLastError()); |
| |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), NULL, NULL, BUFLIM, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(ERROR_NOACCESS == GetLastError(), |
| "expected error ERROR_NOACCESS, got %u\n", GetLastError()); |
| |
| SetLastError(MYERROR); |
| count = 0; |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, NULL, count, GMMP_USE_DISPLAY_POINTS); |
| if (retval == -1) |
| ok(GetLastError() == ERROR_POINT_NOT_FOUND, "unexpected error %u\n", GetLastError()); |
| else |
| ok(retval == count, "expected GetMouseMovePointsEx to succeed, got %d\n", retval); |
| |
| /* test fourth parameter |
| * a value higher than 64 is expected to fail with ERROR_INVALID_PARAMETER |
| */ |
| SetLastError(MYERROR); |
| count = -1; |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, out, count, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == count, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR, |
| "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError()); |
| |
| SetLastError(MYERROR); |
| count = 0; |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, out, count, GMMP_USE_DISPLAY_POINTS); |
| if (retval == -1) |
| ok(GetLastError() == ERROR_POINT_NOT_FOUND, "unexpected error %u\n", GetLastError()); |
| else |
| ok(retval == count, "expected GetMouseMovePointsEx to succeed, got %d\n", retval); |
| |
| SetLastError(MYERROR); |
| count = BUFLIM; |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, out, count, GMMP_USE_DISPLAY_POINTS); |
| if (retval == -1) |
| ok(GetLastError() == ERROR_POINT_NOT_FOUND, "unexpected error %u\n", GetLastError()); |
| else |
| ok((0 <= retval) && (retval <= count), "expected GetMouseMovePointsEx to succeed, got %d\n", retval); |
| |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, out, BUFLIM+1, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR, |
| "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError()); |
| |
| /* it was not possible to force an error with the fifth parameter on win2k */ |
| |
| /* test combinations of wrong parameters to see which error wins */ |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT)-1, NULL, out, BUFLIM, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR, |
| "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError()); |
| |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT)-1, &in, NULL, BUFLIM, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR, |
| "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError()); |
| |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), NULL, out, BUFLIM+1, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR, |
| "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError()); |
| |
| SetLastError(MYERROR); |
| retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, NULL, BUFLIM+1, GMMP_USE_DISPLAY_POINTS); |
| ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval); |
| ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR, |
| "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError()); |
| |
| #undef BUFLIM |
| #undef MYERROR |
| } |
| |
| static void test_key_map(void) |
| { |
| HKL kl = GetKeyboardLayout(0); |
| UINT kL, kR, s, sL; |
| int i; |
| static const UINT numpad_collisions[][2] = { |
| { VK_NUMPAD0, VK_INSERT }, |
| { VK_NUMPAD1, VK_END }, |
| { VK_NUMPAD2, VK_DOWN }, |
| { VK_NUMPAD3, VK_NEXT }, |
| { VK_NUMPAD4, VK_LEFT }, |
| { VK_NUMPAD6, VK_RIGHT }, |
| { VK_NUMPAD7, VK_HOME }, |
| { VK_NUMPAD8, VK_UP }, |
| { VK_NUMPAD9, VK_PRIOR }, |
| }; |
| |
| s = MapVirtualKeyEx(VK_SHIFT, MAPVK_VK_TO_VSC, kl); |
| ok(s != 0, "MapVirtualKeyEx(VK_SHIFT) should return non-zero\n"); |
| sL = MapVirtualKeyEx(VK_LSHIFT, MAPVK_VK_TO_VSC, kl); |
| ok(s == sL || broken(sL == 0), /* win9x */ |
| "%x != %x\n", s, sL); |
| |
| kL = MapVirtualKeyEx(0x2a, MAPVK_VSC_TO_VK, kl); |
| ok(kL == VK_SHIFT, "Scan code -> vKey = %x (not VK_SHIFT)\n", kL); |
| kR = MapVirtualKeyEx(0x36, MAPVK_VSC_TO_VK, kl); |
| ok(kR == VK_SHIFT, "Scan code -> vKey = %x (not VK_SHIFT)\n", kR); |
| |
| kL = MapVirtualKeyEx(0x2a, MAPVK_VSC_TO_VK_EX, kl); |
| ok(kL == VK_LSHIFT || broken(kL == 0), /* win9x */ |
| "Scan code -> vKey = %x (not VK_LSHIFT)\n", kL); |
| kR = MapVirtualKeyEx(0x36, MAPVK_VSC_TO_VK_EX, kl); |
| ok(kR == VK_RSHIFT || broken(kR == 0), /* win9x */ |
| "Scan code -> vKey = %x (not VK_RSHIFT)\n", kR); |
| |
| /* test that MAPVK_VSC_TO_VK prefers the non-numpad vkey if there's ambiguity */ |
| for (i = 0; i < sizeof(numpad_collisions)/sizeof(numpad_collisions[0]); i++) |
| { |
| UINT numpad_scan = MapVirtualKeyEx(numpad_collisions[i][0], MAPVK_VK_TO_VSC, kl); |
| UINT other_scan = MapVirtualKeyEx(numpad_collisions[i][1], MAPVK_VK_TO_VSC, kl); |
| |
| /* do they really collide for this layout? */ |
| if (numpad_scan && other_scan == numpad_scan) |
| { |
| UINT vkey = MapVirtualKeyEx(numpad_scan, MAPVK_VSC_TO_VK, kl); |
| ok(vkey != numpad_collisions[i][0], |
| "Got numpad vKey %x for scan code %x when there was another choice\n", |
| vkey, numpad_scan); |
| } |
| } |
| } |
| |
| static void test_ToUnicode(void) |
| { |
| WCHAR wStr[2]; |
| BYTE state[256]; |
| const BYTE SC_RETURN = 0x1c, SC_TAB = 0x0f; |
| const BYTE HIGHEST_BIT = 0x80; |
| int i, ret; |
| for(i=0; i<256; i++) |
| state[i]=0; |
| |
| SetLastError(0xdeadbeef); |
| ret = ToUnicode(VK_RETURN, SC_RETURN, state, wStr, 2, 0); |
| if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) |
| { |
| win_skip("ToUnicode is not implemented\n"); |
| return; |
| } |
| |
| ok(ret == 1, "ToUnicode for Return key didn't return 1 (was %i)\n", ret); |
| if(ret == 1) |
| ok(wStr[0]=='\r', "ToUnicode for CTRL + Return was %i (expected 13)\n", wStr[0]); |
| state[VK_CONTROL] |= HIGHEST_BIT; |
| state[VK_LCONTROL] |= HIGHEST_BIT; |
| |
| ret = ToUnicode(VK_TAB, SC_TAB, state, wStr, 2, 0); |
| ok(ret == 0, "ToUnicode for CTRL + Tab didn't return 0 (was %i)\n", ret); |
| |
| ret = ToUnicode(VK_RETURN, SC_RETURN, state, wStr, 2, 0); |
| ok(ret == 1, "ToUnicode for CTRL + Return didn't return 1 (was %i)\n", ret); |
| if(ret == 1) |
| ok(wStr[0]=='\n', "ToUnicode for CTRL + Return was %i (expected 10)\n", wStr[0]); |
| |
| state[VK_SHIFT] |= HIGHEST_BIT; |
| state[VK_LSHIFT] |= HIGHEST_BIT; |
| ret = ToUnicode(VK_TAB, SC_TAB, state, wStr, 2, 0); |
| ok(ret == 0, "ToUnicode for CTRL + SHIFT + Tab didn't return 0 (was %i)\n", ret); |
| ret = ToUnicode(VK_RETURN, SC_RETURN, state, wStr, 2, 0); |
| todo_wine ok(ret == 0, "ToUnicode for CTRL + SHIFT + Return didn't return 0 (was %i)\n", ret); |
| } |
| |
| static void test_get_async_key_state(void) |
| { |
| /* input value sanity checks */ |
| ok(0 == GetAsyncKeyState(1000000), "GetAsyncKeyState did not return 0\n"); |
| ok(0 == GetAsyncKeyState(-1000000), "GetAsyncKeyState did not return 0\n"); |
| } |
| |
| static void test_keyboard_layout_name(void) |
| { |
| BOOL ret; |
| char klid[KL_NAMELENGTH]; |
| |
| if (GetKeyboardLayout(0) != (HKL)(ULONG_PTR)0x04090409) return; |
| |
| klid[0] = 0; |
| ret = GetKeyboardLayoutNameA(klid); |
| ok(ret, "GetKeyboardLayoutNameA failed %u\n", GetLastError()); |
| ok(!strcmp(klid, "00000409"), "expected 00000409, got %s\n", klid); |
| } |
| |
| START_TEST(input) |
| { |
| init_function_pointers(); |
| |
| if (pSendInput) |
| { |
| test_Input_blackbox(); |
| test_Input_whitebox(); |
| test_Input_unicode(); |
| } |
| else win_skip("SendInput is not available\n"); |
| |
| test_keynames(); |
| test_mouse_ll_hook(); |
| test_key_map(); |
| test_ToUnicode(); |
| test_get_async_key_state(); |
| test_keyboard_layout_name(); |
| |
| if(pGetMouseMovePointsEx) |
| test_GetMouseMovePointsEx(); |
| else |
| win_skip("GetMouseMovePointsEx is not available\n"); |
| } |
