SystemMenu.c File Reference

#include "precomp.h"

Include dependency graph for SystemMenu.c:

Go to the source code of this file.

Classes
struct	message
struct	recvd_message

Macros
#define	WND_PARENT_ID   1
#define	WND_POPUP_ID   2
#define	GET_PROC(dll, func)
#define	add_message(msg)   add_message_(__LINE__, msg);
#define	ok_sequence(exp, contx, todo)    ok_sequence_((exp), (contx), (todo), __FILE__, __LINE__)
#define	expect(EXPECTED, GOT)   ok((GOT)==(EXPECTED), "Expected %d, got %d\n", (EXPECTED), (GOT))
#define	X(f)   p##f = (void*)GetProcAddress(hKernel32, #f)

Enumerations
enum	msg_flags_t {   sent = 0x1 , posted = 0x2 , parent = 0x4 , wparam = 0x8 ,   lparam = 0x10 , defwinproc = 0x20 , beginpaint = 0x40 , optional = 0x80 ,   hook = 0x100 , winevent_hook = 0x200 , kbd_hook = 0x400 , sent = 0x1 ,   posted = 0x2 , parent = 0x4 , wparam = 0x8 , lparam = 0x10 ,   defwinproc = 0x20 , beginpaint = 0x40 , optional = 0x80 , hook = 0x100 ,   winevent_hook =0x200 , id = 0x400 , custdraw = 0x800 , sent = 0x1 ,   posted = 0x2 , parent = 0x4 , wparam = 0x8 , lparam = 0x10 ,   defwinproc = 0x20 , beginpaint = 0x40 , optional = 0x80 , hook = 0x100 ,   winevent_hook =0x200 , id = 0x400 , sent =0x1 , posted =0x2 ,   parent =0x4 , wparam =0x8 , lparam =0x10 , defwinproc =0x20 ,   beginpaint =0x40 , optional =0x80 , hook =0x100 , winevent_hook =0x200 ,   sent =0x1 , posted =0x2 , parent =0x4 , wparam =0x8 ,   lparam =0x10 , defwinproc =0x20 , beginpaint =0x40 , optional =0x80 ,   hook =0x100 , winevent_hook =0x200 , kbd_hook =0x400 }

Functions
static	BOOL (WINAPI *pGetCurrentActCtx)(HANDLE *)
static	HWND (WINAPI *pGetAncestor)(HWND
static void	init_procs (void)
static BOOL	ignore_message (UINT message)
static void	add_message_ (int line, const struct recvd_message *msg)
static void	flush_events (void)
static void	flush_sequence (void)
static void	dump_sequence (const struct message *expected, const char *context, const char *file, int line)
static void	ok_sequence_ (const struct message *expected_list, const char *context, BOOL todo, const char *file, int line)
static LRESULT	MsgCheckProc (BOOL unicode, HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
static LRESULT WINAPI	MsgCheckProcA (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
static BOOL	RegisterWindowClasses (void)
static BOOL	is_our_logged_class (HWND hwnd)
static LRESULT CALLBACK	cbt_hook_proc (int nCode, WPARAM wParam, LPARAM lParam)
static LRESULT WINAPI	parent_menu_proc (HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
static void	test_menu_messages (void)
static void	init_funcs (void)
static void	init_tests ()
static void	cleanup_tests ()
	START_TEST (SystemMenu)

Variables
static	HANDLE
static void	ULONG
static void void	SIZE_T
static void void 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
static int	sequence_cnt
static int	sequence_size
static struct recvd_message *	sequence
static CRITICAL_SECTION	sequence_cs
static	UINT
static const struct message	wm_popup_menu_4 []

Macro Definition Documentation

add_message

#define add_message

(

msg

)

add_message_(__LINE__, msg);

Definition at line 98 of file SystemMenu.c.

expect

#define expect	(		EXPECTED,
			GOT
	)		ok((GOT)==(EXPECTED), "Expected %d, got %d\n", (EXPECTED), (GOT))

Definition at line 483 of file SystemMenu.c.

GET_PROC

#define GET_PROC	(		dll,
			func
	)

Value:

    p ## func = (void*)GetProcAddress(dll, #func); \
    if (!p ## func) { \
        trace("GetProcAddress(%s) failed\n", #func); \
    }

ok_sequence

#define ok_sequence	(		exp,
			contx,
			todo
	)		ok_sequence_((exp), (contx), (todo), __FILE__, __LINE__)

Definition at line 275 of file SystemMenu.c.

WND_PARENT_ID

#define WND_PARENT_ID   1

Definition at line 13 of file SystemMenu.c.

WND_POPUP_ID

#define WND_POPUP_ID   2

Definition at line 14 of file SystemMenu.c.

X

#define X

(

f

)

p##f = (void*)GetProcAddress(hKernel32, #f)

Enumeration Type Documentation

msg_flags_t

enum msg_flags_t

Enumerator
sent
posted
parent
wparam
lparam
defwinproc
beginpaint
optional
hook
winevent_hook
kbd_hook
sent
posted
parent
wparam
lparam
defwinproc
beginpaint
optional
hook
winevent_hook
id
custdraw
sent
posted
parent
wparam
lparam
defwinproc
beginpaint
optional
hook
winevent_hook
id
sent
posted
parent
wparam
lparam
defwinproc
beginpaint
optional
hook
winevent_hook
sent
posted
parent
wparam
lparam
defwinproc
beginpaint
optional
hook
winevent_hook
kbd_hook

Definition at line 25 of file SystemMenu.c.

{
    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;

Function Documentation

add_message_()

static void add_message_ ( int  line, const struct recvd_message *  msg  )

static

Definition at line 99 of file SystemMenu.c.

{
    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);
        }
    }
}

BOOL()

static BOOL ( WINAPI *  pGetCurrentActCtx )

static

cbt_hook_proc()

static LRESULT CALLBACK cbt_hook_proc ( int  nCode, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 567 of file SystemMenu.c.

{ 
    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);
}

Referenced by init_tests().

cleanup_tests()

static void cleanup_tests ( )

static

Definition at line 755 of file SystemMenu.c.

{
    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);
}

Referenced by START_TEST().

dump_sequence()

static void dump_sequence ( const struct message *  expected, const char *  context, const char *  file, int  line  )

static

Definition at line 193 of file SystemMenu.c.

{
    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++;
    }
}

Referenced by ok_sequence_().

flush_events()

static void flush_events ( void  )

static

Definition at line 167 of file SystemMenu.c.

{
    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();
    }
}

Referenced by check_dialog_style(), check_window_style(), main_window_procA(), ok_event_sequence(), run_NCRedrawLoop(), test_csparentdc(), test_customdraw(), test_events(), test_GetMessagePos(), test_GetUpdateRect(), test_keyboard_input(), test_menu_messages(), test_mouse_input(), test_scrolldc(), test_scrollwindow(), test_SetActiveWindow(), test_SetForegroundWindow(), test_setinfo(), test_SetWindowPos(), test_track(), test_TTN_SHOW(), test_window_from_point(), test_window_without_child_style(), and window_from_point_proc().

flush_sequence()

static void flush_sequence ( void  )

static

Definition at line 184 of file SystemMenu.c.

{
    EnterCriticalSection(&sequence_cs);
    HeapFree(GetProcessHeap(), 0, sequence);
    sequence = 0;
    sequence_cnt = sequence_size = 0;
    LeaveCriticalSection(&sequence_cs);
}

Referenced by flush_sequences(), ok_sequence_(), run_test(), and test_menu_messages().

HWND()

static HWND ( WINAPI *  pGetAncestor )

static

ignore_message()

static BOOL ignore_message ( UINT  message )

static

Definition at line 86 of file SystemMenu.c.

{
    /* 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);
}

Referenced by MsgCheckProc().

init_funcs()

static void init_funcs ( void  )

static

Definition at line 729 of file SystemMenu.c.

{
    HMODULE hKernel32 = GetModuleHandleA("kernel32.dll");
 
#define X(f) p##f = (void*)GetProcAddress(hKernel32, #f)
    X(GetCurrentActCtx);
    X(QueryActCtxW);
#undef X
}

Referenced by init_tests().

init_procs()

static void init_procs ( void  )

static

Definition at line 70 of file SystemMenu.c.

{
    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
}

Referenced by init_tests().

init_tests()

static void init_tests ( void  )

static

Definition at line 739 of file SystemMenu.c.

{
    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");
}

Referenced by START_TEST().

is_our_logged_class()

static BOOL is_our_logged_class ( HWND  hwnd )

static

Definition at line 538 of file SystemMenu.c.

{
    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;
}

Referenced by cbt_hook_proc().

MsgCheckProc()

static LRESULT MsgCheckProc ( BOOL  unicode, HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 487 of file SystemMenu.c.

{
    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;
}

Referenced by MsgCheckProcA().

MsgCheckProcA()

static LRESULT WINAPI MsgCheckProcA ( HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 514 of file SystemMenu.c.

{
    return MsgCheckProc(FALSE, hwnd, message, wParam, lParam);
}

Referenced by RegisterWindowClasses().

ok_sequence_()

static void ok_sequence_ ( const struct message *  expected_list, const char *  context, BOOL  todo, const char *  file, int  line  )

static

Definition at line 279 of file SystemMenu.c.

{
    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();
}

Referenced by run_test_().

parent_menu_proc()

static LRESULT WINAPI parent_menu_proc ( HWND  hwnd, UINT  message, WPARAM  wp, LPARAM  lp  )

static

Definition at line 647 of file SystemMenu.c.

{
    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);
}

Referenced by test_menu_messages().

RegisterWindowClasses()

static BOOL RegisterWindowClasses ( void  )

static

Definition at line 519 of file SystemMenu.c.

{
    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;
}

Referenced by init_tests().

START_TEST()

START_TEST

(

SystemMenu

)

Definition at line 772 of file SystemMenu.c.

{
    init_tests();
    test_menu_messages();
    cleanup_tests();
}

test_menu_messages()

static void test_menu_messages ( void  )

static

Definition at line 680 of file SystemMenu.c.

{
    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);
}

Referenced by START_TEST().

Variable Documentation

cbt_hook_thread_id

DWORD cbt_hook_thread_id

static

Definition at line 23 of file SystemMenu.c.

Referenced by cbt_hook_proc(), and init_tests().

HANDLE

HANDLE

Definition at line 17 of file SystemMenu.c.

hCBT_hook

HHOOK hCBT_hook

static

Definition at line 22 of file SystemMenu.c.

Referenced by cbt_hook_proc(), cleanup_tests(), init_tests(), and ok_sequence_().

hEvent_hook

HWINEVENTHOOK hEvent_hook

static

Definition at line 20 of file SystemMenu.c.

Referenced by cleanup_tests(), dump_sequence(), and ok_sequence_().

hKBD_hook

HHOOK hKBD_hook

static

Definition at line 21 of file SystemMenu.c.

Referenced by ok_sequence_().

sequence

struct recvd_message* sequence

static

Definition at line 63 of file SystemMenu.c.

Referenced by add_message_(), do_one_pass(), dump_sequence(), flush_sequence(), journal_set_revoke(), journal_test_revoke(), maybeSplitSequence(), ok_sequence_(), s_remote_Sequence(), scan_revoke_records(), UuidCreateSequential(), ZSTD_compressSubBlock_multi(), and ZSTD_ldm_blockCompress().

sequence_cnt

int sequence_cnt

static

Definition at line 62 of file SystemMenu.c.

Referenced by add_message_(), and flush_sequence().

sequence_cs

CRITICAL_SECTION sequence_cs

static

Definition at line 64 of file SystemMenu.c.

Referenced by add_message_(), cleanup_tests(), flush_sequence(), and init_tests().

sequence_size

int sequence_size

static

Definition at line 62 of file SystemMenu.c.

Referenced by add_message_(), and flush_sequence().

SIZE_T

void void SIZE_T

Definition at line 17 of file SystemMenu.c.

test_DestroyWindow_flag

void void SIZE_T* static BOOL test_DestroyWindow_flag

static

Definition at line 19 of file SystemMenu.c.

Referenced by cbt_hook_proc().

UINT

UINT

Definition at line 67 of file SystemMenu.c.

ULONG

void ULONG

Definition at line 17 of file SystemMenu.c.

wm_popup_menu_4

const struct message wm_popup_menu_4[]

static

Initial value:

=
{
    { 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 }
}

Definition at line 628 of file SystemMenu.c.

Referenced by test_menu_messages().