24 Aug
2023
24 Aug
'23
2:33 p.m.
https://git.reactos.org/?p=reactos.git;a=commitdiff;h=26ffe2f826c9c3e98023d…
commit 26ffe2f826c9c3e98023d3274fa681d2f66c988b
Author: Egor Ananyin <ananinegor(a)gmail.com>
AuthorDate: Sat Aug 19 10:13:43 2023 +0300
Commit: Hermès BÉLUSCA - MAÏTO <hermes.belusca-maito(a)reactos.org>
CommitDate: Thu Aug 24 16:33:03 2023 +0200
[USER32_APITEST] Add a test for system menu messages (#5573)
Based on msg.c Wine test. CORE-19061
---
modules/rostests/apitests/user32/CMakeLists.txt | 1 +
modules/rostests/apitests/user32/SystemMenu.c | 777 ++++++++++++++++++++++++
modules/rostests/apitests/user32/testlist.c | 2 +
3 files changed, 780 insertions(+)
diff --git a/modules/rostests/apitests/user32/CMakeLists.txt
b/modules/rostests/apitests/user32/CMakeLists.txt
index 4ab323f327c..4ecc693f1ed 100644
--- a/modules/rostests/apitests/user32/CMakeLists.txt
+++ b/modules/rostests/apitests/user32/CMakeLists.txt
@@ -50,6 +50,7 @@ list(APPEND SOURCE
SetScrollRange.c
ShowWindow.c
SwitchToThisWindow.c
+ SystemMenu.c
SystemParametersInfo.c
TrackMouseEvent.c
VirtualKey.c
diff --git a/modules/rostests/apitests/user32/SystemMenu.c
b/modules/rostests/apitests/user32/SystemMenu.c
new file mode 100644
index 00000000000..8d07ccf3bf5
--- /dev/null
+++ b/modules/rostests/apitests/user32/SystemMenu.c
@@ -0,0 +1,777 @@
+/*
+ * PROJECT: ReactOS API tests
+ * LICENSE: LGPL-2.1+ (https://spdx.org/licenses/LGPL-2.1+)
+ * PURPOSE: Tests for system menu messages, based on msg.c Wine test
+ * COPYRIGHT: Copyright 1999 Ove Kaaven <ovek(a)transgaming.com>
+ * Copyright 2003 Dimitrie O. Paun <dimi(a)lattica.com>
+ * Copyright 2004-2005, 2016 Dmitry Timoshkov <dmitry(a)baikal.ru>
+ * Copyright 2023 Egor Ananyin <ananinegor(a)gmail.com>
+ */
+
+#include "precomp.h"
+
+#define WND_PARENT_ID 1
+#define WND_POPUP_ID 2
+
+static BOOL (WINAPI *pGetCurrentActCtx)(HANDLE *);
+static BOOL (WINAPI *pQueryActCtxW)(DWORD, HANDLE, void *, ULONG, void *, SIZE_T, SIZE_T
*);
+
+static BOOL test_DestroyWindow_flag;
+static HWINEVENTHOOK hEvent_hook;
+static HHOOK hKBD_hook;
+static HHOOK hCBT_hook;
+static DWORD cbt_hook_thread_id;
+
+typedef enum
+{
+ sent = 0x1,
+ posted = 0x2,
+ parent = 0x4,
+ wparam = 0x8,
+ lparam = 0x10,
+ defwinproc = 0x20,
+ beginpaint = 0x40,
+ optional = 0x80,
+ hook = 0x100,
+ winevent_hook = 0x200,
+ kbd_hook = 0x400
+} 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 */
+ WPARAM wp_mask; /* mask for wParam checks */
+ LPARAM lp_mask; /* mask for lParam checks */
+};
+
+struct recvd_message
+{
+ UINT message; /* the WM_* code */
+ msg_flags_t flags; /* message props */
+ HWND hwnd; /* window that received the message */
+ WPARAM wParam; /* expected value of wParam */
+ LPARAM lParam; /* expected value of lParam */
+ int line; /* source line where logged */
+ const char *descr; /* description for trace output */
+ char output[512]; /* trace output */
+};
+
+static int sequence_cnt, sequence_size;
+static struct recvd_message* sequence;
+static CRITICAL_SECTION sequence_cs;
+
+/* user32 functions */
+static HWND (WINAPI *pGetAncestor)(HWND, UINT);
+static BOOL (WINAPI *pUnhookWinEvent)(HWINEVENTHOOK);
+
+static void init_procs(void)
+{
+ HMODULE user32 = GetModuleHandleA("user32.dll");
+
+#define GET_PROC(dll, func) \
+ p ## func = (void*)GetProcAddress(dll, #func); \
+ if (!p ## func) { \
+ trace("GetProcAddress(%s) failed\n", #func); \
+ }
+
+ GET_PROC(user32, GetAncestor)
+ GET_PROC(user32, UnhookWinEvent)
+
+#undef GET_PROC
+}
+
+static BOOL ignore_message(UINT message)
+{
+ /* these are always ignored */
+ return (message >= 0xc000 ||
+ message == WM_GETICON ||
+ message == WM_GETOBJECT ||
+ message == WM_TIMECHANGE ||
+ message == WM_DISPLAYCHANGE ||
+ message == WM_DEVICECHANGE ||
+ message == WM_DWMNCRENDERINGCHANGED);
+}
+
+#define add_message(msg) add_message_(__LINE__, msg);
+static void add_message_(int line, const struct recvd_message *msg)
+{
+ struct recvd_message *seq;
+
+ EnterCriticalSection(&sequence_cs);
+ if (!sequence)
+ {
+ sequence_size = 10;
+ sequence = HeapAlloc(GetProcessHeap(), 0, sequence_size * sizeof(*sequence));
+ }
+ if (sequence_cnt == sequence_size)
+ {
+ sequence_size *= 2;
+ sequence = HeapReAlloc(GetProcessHeap(), 0, sequence, sequence_size *
sizeof(*sequence));
+ }
+ assert(sequence);
+
+ seq = &sequence[sequence_cnt++];
+ seq->hwnd = msg->hwnd;
+ seq->message = msg->message;
+ seq->flags = msg->flags;
+ seq->wParam = msg->wParam;
+ seq->lParam = msg->lParam;
+ seq->line = line;
+ seq->descr = msg->descr;
+ seq->output[0] = 0;
+ LeaveCriticalSection(&sequence_cs);
+
+ if (msg->descr)
+ {
+ if (msg->flags & hook)
+ {
+ static const char * const CBT_code_name[10] =
+ {
+ "HCBT_MOVESIZE",
+ "HCBT_MINMAX",
+ "HCBT_QS",
+ "HCBT_CREATEWND",
+ "HCBT_DESTROYWND",
+ "HCBT_ACTIVATE",
+ "HCBT_CLICKSKIPPED",
+ "HCBT_KEYSKIPPED",
+ "HCBT_SYSCOMMAND",
+ "HCBT_SETFOCUS"
+ };
+ const char *code_name = (msg->message <= HCBT_SETFOCUS ?
CBT_code_name[msg->message] : "Unknown");
+
+ sprintf(seq->output, "%s: hook %d (%s) wp %08Ix lp %08Ix",
+ msg->descr, msg->message, code_name, msg->wParam,
msg->lParam);
+ }
+ else if (msg->flags & winevent_hook)
+ {
+ sprintf(seq->output, "%s: winevent %p %08x %08Ix %08Ix",
+ msg->descr, msg->hwnd, msg->message, msg->wParam,
msg->lParam);
+ }
+ else
+ {
+ if (msg->message >= 0xc000)
+ return; /* ignore registered messages */
+ sprintf(seq->output, "%s: %p %04x wp %08Ix lp %08Ix",
+ msg->descr, msg->hwnd, msg->message, msg->wParam,
msg->lParam);
+ if (msg->flags & (sent | posted | parent | defwinproc | beginpaint))
+ sprintf(seq->output + strlen(seq->output), " (flags %x)",
msg->flags);
+ }
+ }
+}
+
+/* try to make sure pending X events have been processed before continuing */
+static void flush_events(void)
+{
+ MSG msg;
+ int diff = 200;
+ int min_timeout = 100;
+ DWORD time = GetTickCount() + diff;
+
+ while (diff > 0)
+ {
+ if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) ==
WAIT_TIMEOUT)
+ break;
+ while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
+ DispatchMessageA(&msg);
+ diff = time - GetTickCount();
+ }
+}
+
+static void flush_sequence(void)
+{
+ EnterCriticalSection(&sequence_cs);
+ HeapFree(GetProcessHeap(), 0, sequence);
+ sequence = 0;
+ sequence_cnt = sequence_size = 0;
+ LeaveCriticalSection(&sequence_cs);
+}
+
+static void dump_sequence(const struct message *expected, const char *context, const char
*file, int line)
+{
+ const struct recvd_message *actual = sequence;
+ unsigned int count = 0;
+
+ trace_(file, line)("Failed sequence %s:\n", context);
+
+ while (expected->message && actual->message)
+ {
+ if (actual->output[0])
+ {
+ if (expected->flags & hook)
+ {
+ trace_(file, line)(" %u: expected: hook %04x - actual:
%s\n",
+ count, expected->message, actual->output);
+ }
+ else if (expected->flags & winevent_hook)
+ {
+ trace_(file, line)(" %u: expected: winevent %04x - actual:
%s\n",
+ count, expected->message, actual->output);
+ }
+ else if (expected->flags & kbd_hook)
+ {
+ trace_(file, line)(" %u: expected: kbd %04x - actual: %s\n",
+ count, expected->message, actual->output);
+ }
+ else
+ {
+ trace_(file, line)(" %u: expected: msg %04x - actual: %s\n",
+ count, expected->message, actual->output);
+ }
+ }
+
+ if (expected->message == actual->message)
+ {
+ if ((expected->flags & defwinproc) != (actual->flags &
defwinproc) &&
+ (expected->flags & optional))
+ {
+ /* don't match messages if their defwinproc status differs */
+ expected++;
+ }
+ else
+ {
+ expected++;
+ actual++;
+ }
+ }
+ /* silently drop winevent messages if there is no support for them */
+ else if ((expected->flags & optional) || ((expected->flags &
winevent_hook) && !hEvent_hook))
+ expected++;
+ else
+ {
+ expected++;
+ actual++;
+ }
+
+ count++;
+ }
+
+ /* optional trailing messages */
+ while (expected->message && ((expected->flags & optional) ||
+ ((expected->flags & winevent_hook) && !hEvent_hook)))
+ {
+ trace_(file, line)(" %u: expected: msg %04x - actual: nothing\n",
count, expected->message);
+ expected++;
+ count++;
+ }
+
+ if (expected->message)
+ {
+ trace_(file, line)(" %u: expected: msg %04x - actual: nothing\n",
count, expected->message);
+ return;
+ }
+
+ while (actual->message && actual->output[0])
+ {
+ trace_(file, line)(" %u: expected: nothing - actual: %s\n", count,
actual->output);
+ actual++;
+ count++;
+ }
+}
+
+#define ok_sequence(exp, contx, todo) \
+ ok_sequence_((exp), (contx), (todo), __FILE__, __LINE__)
+
+
+static void ok_sequence_(const struct message *expected_list, const char *context, BOOL
todo,
+ const char *file, int line)
+{
+ static const struct recvd_message end_of_sequence;
+ const struct message *expected = expected_list;
+ const struct recvd_message *actual;
+ int failcount = 0, dump = 0;
+ unsigned int count = 0;
+
+ add_message(&end_of_sequence);
+
+ actual = sequence;
+
+ while (expected->message && actual->message)
+ {
+ if (expected->message == actual->message &&
+ !((expected->flags ^ actual->flags) & (hook | winevent_hook |
kbd_hook)))
+ {
+ if (expected->flags & wparam)
+ {
+ if (((expected->wParam ^ actual->wParam) &
~expected->wp_mask) && todo)
+ {
+ todo_wine
+ {
+ failcount++;
+ if (strcmp(winetest_platform, "wine"))
+ dump++;
+ ok_( file, line) (FALSE,
+ "%s: %u: in msg 0x%04x expecting wParam 0x%x got
0x%x\n",
+ context, count, expected->message, expected->wParam,
actual->wParam);
+ }
+ }
+ else
+ {
+ ok_( file, line)(((expected->wParam ^ actual->wParam) &
~expected->wp_mask) == 0,
+ "%s: %u: in msg 0x%04x expecting wParam 0x%x
got 0x%x\n",
+ context, count, expected->message,
expected->wParam, actual->wParam);
+ if ((expected->wParam ^ actual->wParam) &
~expected->wp_mask)
+ dump++;
+ }
+ }
+
+ if (expected->flags & lparam)
+ {
+ if (((expected->lParam ^ actual->lParam) &
~expected->lp_mask) && todo)
+ {
+ todo_wine
+ {
+ failcount++;
+ if (strcmp(winetest_platform, "wine"))
+ dump++;
+ ok_( file, line) (FALSE,
+ "%s: %u: in msg 0x%04x expecting lParam 0x%lx got
0x%lx\n",
+ context, count, expected->message, expected->lParam,
actual->lParam);
+ }
+ }
+ else
+ {
+ ok_( file, line)(((expected->lParam ^ actual->lParam) &
~expected->lp_mask) == 0,
+ "%s: %u: in msg 0x%04x expecting lParam 0x%lx
got 0x%lx\n",
+ context, count, expected->message,
expected->lParam, actual->lParam);
+ if ((expected->lParam ^ actual->lParam) &
~expected->lp_mask)
+ dump++;
+ }
+ }
+ if ((expected->flags & optional) &&
+ ((expected->flags ^ actual->flags) & (defwinproc | parent)))
+ {
+ /* don't match optional messages if their defwinproc or parent status
differs */
+ expected++;
+ count++;
+ continue;
+ }
+ if ((expected->flags & defwinproc) != (actual->flags &
defwinproc) && todo)
+ {
+ todo_wine
+ {
+ failcount++;
+ if (strcmp(winetest_platform, "wine"))
+ dump++;
+ ok_(file, line) (FALSE,
+ "%s: %u: the msg 0x%04x should %shave been sent by
DefWindowProc\n",
+ context, count, expected->message, (expected->flags &
defwinproc) ? "" : "NOT ");
+ }
+ }
+ else
+ {
+ ok_(file, line) ((expected->flags & defwinproc) ==
(actual->flags & defwinproc),
+ "%s: %u: the msg 0x%04x should %shave been sent by
DefWindowProc\n",
+ context, count, expected->message, (expected->flags &
defwinproc) ? "" : "NOT ");
+ if ((expected->flags & defwinproc) != (actual->flags &
defwinproc))
+ dump++;
+ }
+
+ ok_(file, line) ((expected->flags & beginpaint) == (actual->flags
& beginpaint),
+ "%s: %u: the msg 0x%04x should %shave been sent by
BeginPaint\n",
+ context, count, expected->message, (expected->flags &
beginpaint) ? "" : "NOT ");
+ if ((expected->flags & beginpaint) != (actual->flags &
beginpaint))
+ dump++;
+
+ ok_(file, line) ((expected->flags & (sent | posted)) ==
(actual->flags & (sent | posted)),
+ "%s: %u: the msg 0x%04x should have been %s\n",
+ context, count, expected->message, (expected->flags & posted) ?
"posted" : "sent");
+ if ((expected->flags & (sent | posted)) != (actual->flags &
(sent | posted)))
+ dump++;
+
+ ok_(file, line) ((expected->flags & parent) == (actual->flags &
parent),
+ "%s: %u: the msg 0x%04x was expected in %s\n",
+ context, count, expected->message, (expected->flags & parent) ?
"parent" : "child");
+ if ((expected->flags & parent) != (actual->flags & parent))
+ dump++;
+
+ ok_(file, line) ((expected->flags & hook) == (actual->flags &
hook),
+ "%s: %u: the msg 0x%04x should have been sent by a hook\n",
+ context, count, expected->message);
+ if ((expected->flags & hook) != (actual->flags & hook))
+ dump++;
+
+ ok_(file, line) ((expected->flags & winevent_hook) ==
(actual->flags & winevent_hook),
+ "%s: %u: the msg 0x%04x should have been sent by a winevent
hook\n",
+ context, count, expected->message);
+ if ((expected->flags & winevent_hook) != (actual->flags &
winevent_hook))
+ dump++;
+
+ ok_(file, line) ((expected->flags & kbd_hook) == (actual->flags
& kbd_hook),
+ "%s: %u: the msg 0x%04x should have been sent by a keyboard
hook\n",
+ context, count, expected->message);
+ if ((expected->flags & kbd_hook) != (actual->flags &
kbd_hook))
+ dump++;
+
+ expected++;
+ actual++;
+ }
+ /* silently drop hook messages if there is no support for them */
+ else if ((expected->flags & optional) ||
+ ((expected->flags & hook) && !hCBT_hook) ||
+ ((expected->flags & winevent_hook) && !hEvent_hook) ||
+ ((expected->flags & kbd_hook) && !hKBD_hook))
+ expected++;
+ else if (todo)
+ {
+ failcount++;
+ todo_wine
+ {
+ if (strcmp(winetest_platform, "wine"))
+ dump++;
+ ok_(file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but
got msg 0x%04x instead\n",
+ context, count, expected->message,
actual->message);
+ }
+ goto done;
+ }
+ else
+ {
+ ok_(file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but got
msg 0x%04x instead\n",
+ context, count, expected->message, actual->message);
+ dump++;
+ expected++;
+ actual++;
+ }
+ count++;
+ }
+
+ /* skip all optional trailing messages */
+ while (expected->message && ((expected->flags & optional) ||
+ ((expected->flags & hook) && !hCBT_hook)
||
+ ((expected->flags & winevent_hook) &&
!hEvent_hook)))
+ expected++;
+
+ if (todo)
+ {
+ todo_wine
+ {
+ if (expected->message || actual->message)
+ {
+ failcount++;
+ if (strcmp(winetest_platform, "wine"))
+ dump++;
+ ok_(file, line) (FALSE, "%s: %u: the msg sequence is not complete:
expected %04x - actual %04x\n",
+ context, count, expected->message,
actual->message);
+ }
+ }
+ }
+ else
+ {
+ if (expected->message || actual->message)
+ {
+ dump++;
+ ok_(file, line) (FALSE, "%s: %u: the msg sequence is not complete:
expected %04x - actual %04x\n",
+ context, count, expected->message, actual->message);
+ }
+ }
+ if (todo && !failcount) /* succeeded yet marked todo */
+ todo_wine
+ {
+ if (!strcmp(winetest_platform, "wine"))
+ dump++;
+ ok_(file, line) (TRUE, "%s: marked \"todo_wine\" but
succeeds\n", context);
+ }
+
+done:
+ if (dump) dump_sequence(expected_list, context, file, line);
+ flush_sequence();
+}
+
+#define expect(EXPECTED,GOT) ok((GOT)==(EXPECTED), "Expected %d, got %d\n",
(EXPECTED), (GOT))
+
+/************* window procedures ********************/
+
+static LRESULT MsgCheckProc(BOOL unicode, HWND hwnd, UINT message, WPARAM wParam, LPARAM
lParam)
+{
+ static LONG defwndproc_counter = 0;
+ static LONG beginpaint_counter = 0;
+ LRESULT ret;
+ struct recvd_message msg;
+
+ if (ignore_message(message)) return 0;
+
+ msg.hwnd = hwnd;
+ msg.message = message;
+ msg.flags = sent | wparam | lparam;
+ if (defwndproc_counter) msg.flags |= defwinproc;
+ if (beginpaint_counter) msg.flags |= beginpaint;
+ msg.wParam = wParam;
+ msg.lParam = lParam;
+ msg.descr = "MsgCheckProc";
+ add_message(&msg);
+
+ defwndproc_counter++;
+ ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam)
+ : DefWindowProcA(hwnd, message, wParam, lParam);
+ defwndproc_counter--;
+
+ return ret;
+}
+
+static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM
lParam)
+{
+ return MsgCheckProc(FALSE, hwnd, message, wParam, lParam);
+}
+
+static BOOL RegisterWindowClasses(void)
+{
+ WNDCLASSA cls;
+
+ cls.style = 0;
+ cls.lpfnWndProc = MsgCheckProcA;
+ cls.cbClsExtra = 0;
+ cls.cbWndExtra = 0;
+ cls.hInstance = GetModuleHandleA(0);
+ cls.hIcon = 0;
+ cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
+ cls.hbrBackground = GetStockObject(WHITE_BRUSH);
+ cls.lpszMenuName = NULL;
+ cls.lpszClassName = "TestWindowClass";
+ if (!RegisterClassA(&cls)) return FALSE;
+
+ return TRUE;
+}
+
+static BOOL is_our_logged_class(HWND hwnd)
+{
+ char buf[256];
+
+ if (GetClassNameA(hwnd, buf, sizeof(buf)))
+ {
+ if (!lstrcmpiA(buf, "TestWindowClass") ||
+ !lstrcmpiA(buf, "ShowWindowClass") ||
+ !lstrcmpiA(buf, "RecursiveActivationClass") ||
+ !lstrcmpiA(buf, "TestParentClass") ||
+ !lstrcmpiA(buf, "TestPopupClass") ||
+ !lstrcmpiA(buf, "SimpleWindowClass") ||
+ !lstrcmpiA(buf, "TestDialogClass") ||
+ !lstrcmpiA(buf, "MDI_frame_class") ||
+ !lstrcmpiA(buf, "MDI_client_class") ||
+ !lstrcmpiA(buf, "MDI_child_class") ||
+ !lstrcmpiA(buf, "my_button_class") ||
+ !lstrcmpiA(buf, "my_edit_class") ||
+ !lstrcmpiA(buf, "static") ||
+ !lstrcmpiA(buf, "ListBox") ||
+ !lstrcmpiA(buf, "ComboBox") ||
+ !lstrcmpiA(buf, "MyDialogClass") ||
+ !lstrcmpiA(buf, "#32770") ||
+ !lstrcmpiA(buf, "#32768"))
+ return TRUE;
+ }
+ return FALSE;
+}
+
+static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+ HWND hwnd;
+
+ ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events
from other threads\n");
+
+ if (nCode == HCBT_CLICKSKIPPED)
+ {
+ /* ignore this event, XP sends it a lot when switching focus between windows */
+ return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
+ }
+
+ if (nCode == HCBT_SYSCOMMAND || nCode == HCBT_KEYSKIPPED)
+ {
+ struct recvd_message msg;
+
+ msg.hwnd = 0;
+ msg.message = nCode;
+ msg.flags = hook | wparam | lparam;
+ msg.wParam = wParam;
+ msg.lParam = lParam;
+ msg.descr = "CBT";
+ add_message(&msg);
+
+ return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
+ }
+
+ if (nCode == HCBT_DESTROYWND)
+ {
+ if (test_DestroyWindow_flag)
+ {
+ DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
+ if (style & WS_CHILD)
+ lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
+ else if (style & WS_POPUP)
+ lParam = WND_POPUP_ID;
+ else
+ lParam = WND_PARENT_ID;
+ }
+ }
+
+ /* Log also SetFocus(0) calls */
+ hwnd = wParam ? (HWND)wParam : (HWND)lParam;
+
+ if (is_our_logged_class(hwnd))
+ {
+ struct recvd_message msg;
+
+ msg.hwnd = hwnd;
+ msg.message = nCode;
+ msg.flags = hook | wparam | lparam;
+ msg.wParam = wParam;
+ msg.lParam = lParam;
+ msg.descr = "CBT";
+ add_message(&msg);
+ }
+ return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
+}
+
+/*************************** Menu test ******************************/
+
+static const struct message wm_popup_menu_4[] =
+{
+ { HCBT_CREATEWND, hook },
+ { WM_ENTERMENULOOP, sent | wparam | lparam, 0, 0 },
+ { WM_INITMENU, sent | lparam, 0, 0 },
+ { WM_INITMENUPOPUP, sent | lparam, 0, 0x10000 },
+ { HCBT_KEYSKIPPED, hook | wparam | lparam | optional, VK_DOWN, 0x10000001 },
+ { WM_MENUSELECT, sent, MAKEWPARAM(0,0xffff), 0 },
+ { HCBT_KEYSKIPPED, hook | wparam | lparam | optional, VK_DOWN, 0xd0000001 },
+ { HCBT_KEYSKIPPED, hook | wparam | lparam | optional, VK_ESCAPE, 0x10000001 },
+ { HCBT_DESTROYWND, hook },
+ { WM_UNINITMENUPOPUP, sent | lparam, 0, 0x20000000 },
+ { WM_MENUSELECT, sent, MAKEWPARAM(0,0xffff), 0 },
+ { WM_EXITMENULOOP, sent | wparam | lparam, 0, 0 },
+ { HCBT_KEYSKIPPED, hook | wparam | lparam | optional, VK_ESCAPE, 0xc0000001 },
+ { WM_KEYUP, sent | wparam | lparam, VK_ESCAPE, 0xc0000001 },
+ { 0 }
+};
+
+static LRESULT WINAPI parent_menu_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
+{
+ if (message == WM_ENTERIDLE ||
+ message == WM_INITMENU ||
+ message == WM_INITMENUPOPUP ||
+ message == WM_MENUSELECT ||
+ message == WM_PARENTNOTIFY ||
+ message == WM_ENTERMENULOOP ||
+ message == WM_EXITMENULOOP ||
+ message == WM_UNINITMENUPOPUP ||
+ message == WM_KEYDOWN ||
+ message == WM_KEYUP ||
+ message == WM_CHAR ||
+ message == WM_SYSKEYDOWN ||
+ message == WM_SYSKEYUP ||
+ message == WM_SYSCHAR ||
+ message == WM_COMMAND ||
+ message == WM_MENUCOMMAND)
+ {
+ struct recvd_message msg;
+
+ msg.hwnd = hwnd;
+ msg.message = message;
+ msg.flags = sent | wparam | lparam;
+ msg.wParam = wp;
+ msg.lParam = lp;
+ msg.descr = "parent_menu_proc";
+ add_message(&msg);
+ }
+
+ return DefWindowProcA(hwnd, message, wp, lp);
+}
+
+static void test_menu_messages(void)
+{
+ MSG msg;
+ WNDCLASSA cls;
+ HWND hwnd;
+ RECT rect;
+
+ cls.style = 0;
+ cls.lpfnWndProc = parent_menu_proc;
+ cls.cbClsExtra = 0;
+ cls.cbWndExtra = 0;
+ cls.hInstance = GetModuleHandleA(0);
+ cls.hIcon = 0;
+ cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
+ cls.hbrBackground = GetStockObject(WHITE_BRUSH);
+ cls.lpszMenuName = NULL;
+ cls.lpszClassName = "TestMenuClass";
+ UnregisterClassA(cls.lpszClassName, cls.hInstance);
+ if (!RegisterClassA(&cls))
+ assert(0);
+
+ SetLastError(0xdeadbeef);
+ hwnd = CreateWindowExA(0, "TestMenuClass", NULL, WS_OVERLAPPEDWINDOW |
WS_VISIBLE,
+ 100, 100, 200, 200, 0, 0, 0, NULL);
+ ok(hwnd != 0, "LoadMenuA error %lu\n", GetLastError());
+
+ SetForegroundWindow(hwnd);
+ flush_events();
+
+ trace("testing system menu\n");
+ GetWindowRect(hwnd, &rect);
+ SetCursorPos(rect.left + 30, rect.top + 10);
+ flush_sequence();
+ mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
+ mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
+ keybd_event(VK_DOWN, 0, 0, 0);
+ keybd_event(VK_DOWN, 0, KEYEVENTF_KEYUP, 0);
+ keybd_event(VK_ESCAPE, 0, 0, 0);
+ keybd_event(VK_ESCAPE, 0, KEYEVENTF_KEYUP, 0);
+ while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
+ {
+ TranslateMessage(&msg);
+ DispatchMessageA(&msg);
+ }
+ ok_sequence(wm_popup_menu_4, "system menu command", FALSE);
+
+ DestroyWindow(hwnd);
+}
+
+static void init_funcs(void)
+{
+ HMODULE hKernel32 = GetModuleHandleA("kernel32.dll");
+
+#define X(f) p##f = (void*)GetProcAddress(hKernel32, #f)
+ X(GetCurrentActCtx);
+ X(QueryActCtxW);
+#undef X
+}
+
+static void init_tests()
+{
+ init_funcs();
+
+ InitializeCriticalSection(&sequence_cs);
+ init_procs();
+
+ if (!RegisterWindowClasses())
+ assert(0);
+
+ cbt_hook_thread_id = GetCurrentThreadId();
+ hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
+ if (!hCBT_hook)
+ win_skip("cannot set global hook, will skip hook tests\n");
+}
+
+static void cleanup_tests()
+{
+ BOOL ret;
+ UnhookWindowsHookEx(hCBT_hook);
+ if (pUnhookWinEvent && hEvent_hook)
+ {
+ ret = pUnhookWinEvent(hEvent_hook);
+ ok(ret, "UnhookWinEvent error %ld\n", GetLastError());
+ SetLastError(0xdeadbeef);
+ ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
+ ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
+ GetLastError() == 0xdeadbeef, /* Win9x */
+ "unexpected error %ld\n", GetLastError());
+ }
+ DeleteCriticalSection(&sequence_cs);
+}
+
+START_TEST(SystemMenu)
+{
+ init_tests();
+ test_menu_messages();
+ cleanup_tests();
+}
diff --git a/modules/rostests/apitests/user32/testlist.c
b/modules/rostests/apitests/user32/testlist.c
index ee6f6970d76..0ff533691b8 100644
--- a/modules/rostests/apitests/user32/testlist.c
+++ b/modules/rostests/apitests/user32/testlist.c
@@ -53,6 +53,7 @@ extern void func_SetScrollRange(void);
extern void func_ShowWindow(void);
extern void func_SwitchToThisWindow(void);
extern void func_SystemParametersInfo(void);
+extern void func_SystemMenu(void);
extern void func_TrackMouseEvent(void);
extern void func_VirtualKey(void);
extern void func_WndProc(void);
@@ -109,6 +110,7 @@ const struct test winetest_testlist[] =
{ "SetScrollRange", func_SetScrollRange },
{ "ShowWindow", func_ShowWindow },
{ "SwitchToThisWindow", func_SwitchToThisWindow },
+ { "SystemMenu", func_SystemMenu },
{ "SystemParametersInfo", func_SystemParametersInfo },
{ "TrackMouseEvent", func_TrackMouseEvent },
{ "VirtualKey", func_VirtualKey },