#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "wine/test.h"

Include dependency graph for menu.c:

Classes
struct	TEST_INPUT

struct	menu_item_pair_s

struct	menu_mouse_tests_s

struct	menu_data

Macros
#define	_WIN32_WINNT 0x0501

#define	OEMRESOURCE /* For OBM_MNARROW */

#define	GET_PROC(func)

#define	MOD_SIZE 10

#define	MOD_NRMENUS 8

#define	TMII_INSMI(c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1, eret1)

#define	TMII_GMII(c2, l2, d3, e3, f3, g3, h3, i3, j3, k3, l3, m3, expname, eret2, eret3)

#define	TMII_DONE

#define	TMII_MODM(flags, id, data) modify_menu( __LINE__, hmenu, ansi, flags, id, data )

#define	TMII_SMII(c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1) set_menu_item_info( __LINE__, hmenu, ansi, c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1 )

#define	OK 1

#define	ER 0

#define	create_menu(a) create_menu_from_data((a), sizeof(a)/sizeof((a)[0]))

#define	create_menuitem(a) create_menuitem_from_data((a), sizeof(a)/sizeof((a)[0]))

#define	compare_menu(h, a) compare_menu_data((h), (a), sizeof(a)/sizeof((a)[0]))

#define	NR_MENUS 100

Functions
static	BOOL (WINAPI *pGetMenuInfo)(HMENU

static	UINT (WINAPI *pSendInput)(UINT

static void	init_function_pointers (void)

static BOOL	correct_behavior (void)

static LRESULT WINAPI	menu_check_wnd_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	menu_ownerdraw_wnd_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	register_menu_check_class (void)

static void	test_getmenubarinfo (void)

static void	test_system_menu (void)

static void	test_menu_locked_by_window (void)

static LRESULT WINAPI	subpopuplocked_wnd_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_subpopup_locked_by_menu (void)

static void	test_menu_ownerdraw (void)

static void	test_mbs_help (int ispop, int hassub, int mnuopt, HWND hwnd, int arrowwidth, int count, HBITMAP hbmp, SIZE bmpsize, LPCSTR text, SIZE size, SIZE sc_size)

static void	test_menu_bmp_and_string (void)

static void	test_menu_add_string (void)

static int	strncmpW (const WCHAR str1, const WCHAR str2, int n)

static WCHAR *	strcpyW (WCHAR dst, const WCHAR src)

static void	insert_menu_item (int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state, UINT id, HMENU submenu, HBITMAP checked, HBITMAP unchecked, ULONG_PTR data, void *type_data, UINT len, HBITMAP item, BOOL expect)

static void	check_menu_item_info (int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state, UINT id, HMENU submenu, HBITMAP checked, HBITMAP unchecked, ULONG_PTR data, void *type_data, UINT in_len, UINT out_len, HBITMAP item, LPCSTR expname, BOOL expect, BOOL expstring)

static void	modify_menu (int line, HMENU hmenu, BOOL ansi, UINT flags, UINT_PTR id, void *data)

static void	set_menu_item_info (int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state, UINT id, HMENU submenu, HBITMAP checked, HBITMAP unchecked, ULONG_PTR data, void *type_data, UINT len, HBITMAP item)

static void	test_menu_iteminfo (void)

static void	test_menu_search_bycommand (void)

static void	send_key (WORD wVk)

static BOOL	click_menu (HANDLE hWnd, struct menu_item_pair_s *mi)

static DWORD WINAPI	test_menu_input_thread (LPVOID lpParameter)

static LRESULT CALLBACK	WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)

static void	test_menu_input (void)

static void	test_menu_flags (void)

static void	test_menu_hilitemenuitem (void)

static void	check_menu_items (HMENU hmenu, UINT checked_cmd, UINT checked_type, UINT checked_state)

static void	clear_ftype_and_state (HMENU hmenu, UINT id, UINT flags)

static void	test_CheckMenuRadioItem (void)

static void	test_menu_resource_layout (void)

static HMENU	create_menu_from_data (const struct menu_data *item, INT item_count)

static HMENU	create_menuitem_from_data (const struct menu_data *item, INT item_count)

static void	compare_menu_data (HMENU hmenu, const struct menu_data *item, INT item_count)

static void	test_InsertMenu (void)

static void	test_menu_getmenuinfo (void)

static void	test_menu_setmenuinfo (void)

static DWORD	MyTrackPopupMenu (int ex, HMENU hmenu, UINT flags, INT x, INT y, HWND hwnd, LPTPMPARAMS ptpm)

static void	test_menu_trackpopupmenu (void)

static LRESULT WINAPI	menu_track_again_wnd_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_menu_trackagain (void)

static LRESULT WINAPI	menu_cancelmode_wnd_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_menu_cancelmode (void)

static void	test_menu_maxdepth (void)

static void	test_menu_circref (void)

static void	test_menualign (void)

static LRESULT WINAPI	menu_fill_in_init (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_emptypopup (void)

static HMENU	get_bad_hmenu (UINT_PTR id)

static void	test_AppendMenu (void)

	START_TEST (menu)

Variables
static ATOM	atomMenuCheckClass

static	LPCMENUINFO

static	LONG

static	PMENUBARINFO

static INPUT	size_t

static BOOL	bMenuVisible

static INT	popmenu

static BOOL	got_input

static HMENU	hMenus [4]

struct {
LPCSTR text

SIZE size

SIZE sc_size

}	MOD_txtsizes []

static unsigned int	MOD_maxid

static RECT	MOD_rc [MOD_NRMENUS]

static int	MOD_avec

static int	MOD_hic

static int	MOD_odheight

static SIZE	MODsizes [MOD_NRMENUS]

static BOOL	MOD_GotDrawItemMsg = FALSE

static int	gflag_initmenupopup

static int	gflag_entermenuloop

static int	gflag_initmenu

static int	gflag_enteridle

static WPARAM	selectitem_wp

static LPARAM	selectitem_lp

static struct menu_mouse_tests_s	menu_tests []

static HMENU	g_hmenu

static int	g_got_enteridle

static HWND	g_hwndtosend

Macro Definition Documentation

◆ _WIN32_WINNT

#define _WIN32_WINNT 0x0501

Definition at line 23 of file menu.c.

◆ compare_menu

#define compare_menu	(	h,
		a
	)	compare_menu_data((h), (a), sizeof(a)/sizeof((a)[0]))

◆ create_menu

#define create_menu ( a ) create_menu_from_data((a), sizeof(a)/sizeof((a)[0]))

◆ create_menuitem

#define create_menuitem ( a ) create_menuitem_from_data((a), sizeof(a)/sizeof((a)[0]))

◆ ER

#define ER 0

Definition at line 1425 of file menu.c.

◆ GET_PROC

#define GET_PROC ( func )

Value:

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

◆ MOD_NRMENUS

#define MOD_NRMENUS 8

Definition at line 126 of file menu.c.

◆ MOD_SIZE

#define MOD_SIZE 10

Definition at line 125 of file menu.c.

◆ NR_MENUS

#define NR_MENUS 100

◆ OEMRESOURCE

#define OEMRESOURCE /* For OBM_MNARROW */

Definition at line 31 of file menu.c.

◆ OK

#define OK 1

Definition at line 1424 of file menu.c.

◆ TMII_DONE

#define TMII_DONE

Value:

RemoveMenu(hmenu, 0, TRUE );\
    DestroyMenu( hmenu );\
    DestroyMenu( submenu );

Definition at line 1410 of file menu.c.

◆ TMII_GMII

#define TMII_GMII	(	c2,
		l2,
		d3,
		e3,
		f3,
		g3,
		h3,
		i3,
		j3,
		k3,
		l3,
		m3,
		expname,
		eret2,
		eret3
	)

Value:

check_menu_item_info( __LINE__, hmenu, ansi, c2, d3, e3, f3, g3, h3, i3, j3, k3, l2, l3, m3, \

expname, eret2, eret3 )

f3

#define f3(x, y, z)

Definition: sha1.c:32

hmenu

static HMENU hmenu

Definition: win.c:66

check_menu_item_info

static void check_menu_item_info(int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state, UINT id, HMENU submenu, HBITMAP checked, HBITMAP unchecked, ULONG_PTR data, void *type_data, UINT in_len, UINT out_len, HBITMAP item, LPCSTR expname, BOOL expect, BOOL expstring)

Definition: menu.c:1283

Definition at line 1404 of file menu.c.

◆ TMII_INSMI

#define TMII_INSMI	(	c1,
		d1,
		e1,
		f1,
		g1,
		h1,
		i1,
		j1,
		k1,
		l1,
		m1,
		eret1
	)

Value:

hmenu = CreateMenu();\
    submenu = CreateMenu();\
    if(ansi)strcpy( string, init );\
    else strcpyW( string, init );\
    insert_menu_item( __LINE__, hmenu, ansi, c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1, eret1 )

Definition at line 1396 of file menu.c.

◆ TMII_MODM

#define TMII_MODM	(	flags,
		id,
		data
	)	modify_menu( __LINE__, hmenu, ansi, flags, id, data )

Definition at line 1416 of file menu.c.

◆ TMII_SMII

#define TMII_SMII	(	c1,
		d1,
		e1,
		f1,
		g1,
		h1,
		i1,
		j1,
		k1,
		l1,
		m1
	)	set_menu_item_info( __LINE__, hmenu, ansi, c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1 )

Definition at line 1420 of file menu.c.

Function Documentation

◆ BOOL()

static BOOL ( WINAPI * pGetMenuInfo )

static

◆ check_menu_item_info()

static void check_menu_item_info	(	int	line,
		HMENU	hmenu,
		BOOL	ansi,
		UINT	mask,
		UINT	type,
		UINT	state,
		UINT	id,
		HMENU	submenu,
		HBITMAP	checked,
		HBITMAP	unchecked,
		ULONG_PTR	data,
		void *	type_data,
		UINT	in_len,
		UINT	out_len,
		HBITMAP	item,
		LPCSTR	expname,
		BOOL	expect,
		BOOL	expstring
	)

static

Definition at line 1283 of file menu.c.

 {
     MENUITEMINFOA info;
     BOOL ret;
     WCHAR buffer[80];
 
     SetLastError( 0xdeadbeef );
     memset( &info, 0xcc, sizeof(info) );
     info.cbSize = sizeof(info);
     info.fMask = mask;
     info.dwTypeData = type_data;
     info.cch = in_len;
 
     ret = ansi ? GetMenuItemInfoA( hmenu, 0, TRUE, &info ) :
                  GetMenuItemInfoW( hmenu, 0, TRUE, (MENUITEMINFOW *)&info );
     if (!expect)
     {
         ok_(__FILE__, line)( !ret, "GetMenuItemInfo should have failed.\n" );
         return;
     }
     ok_(__FILE__, line)( ret, "GetMenuItemInfo failed, err %u\n", GetLastError());
     if (mask & MIIM_TYPE)
         ok_(__FILE__, line)( info.fType == type || info.fType == LOWORD(type),
                              "wrong type %x/%x\n", info.fType, type );
     if (mask & MIIM_STATE)
         ok_(__FILE__, line)( info.fState == state || info.fState == LOWORD(state),
                              "wrong state %x/%x\n", info.fState, state );
     if (mask & MIIM_ID)
         ok_(__FILE__, line)( info.wID == id || info.wID == LOWORD(id),
                              "wrong id %x/%x\n", info.wID, id );
     if (mask & MIIM_SUBMENU)
         ok_(__FILE__, line)( info.hSubMenu == submenu || (ULONG_PTR)info.hSubMenu == LOWORD(submenu),
                              "wrong submenu %p/%p\n", info.hSubMenu, submenu );
     if (mask & MIIM_CHECKMARKS)
     {
         ok_(__FILE__, line)( info.hbmpChecked == checked || (ULONG_PTR)info.hbmpChecked == LOWORD(checked),
                              "wrong bmpchecked %p/%p\n", info.hbmpChecked, checked );
         ok_(__FILE__, line)( info.hbmpUnchecked == unchecked || (ULONG_PTR)info.hbmpUnchecked == LOWORD(unchecked),
                              "wrong bmpunchecked %p/%p\n", info.hbmpUnchecked, unchecked );
     }
     if (mask & MIIM_DATA)
         ok_(__FILE__, line)( info.dwItemData == data || info.dwItemData == LOWORD(data),
                              "wrong item data %lx/%lx\n", info.dwItemData, data );
     if (mask & MIIM_BITMAP)
         ok_(__FILE__, line)( info.hbmpItem == item || (ULONG_PTR)info.hbmpItem == LOWORD(item),
                              "wrong bmpitem %p/%p\n", info.hbmpItem, item );
     ok_(__FILE__, line)( info.dwTypeData == type_data || (ULONG_PTR)info.dwTypeData == LOWORD(type_data),
                          "wrong type data %p/%p\n", info.dwTypeData, type_data );
     ok_(__FILE__, line)( info.cch == out_len ||
                          broken(! ansi && info.cch == 2 * out_len) /* East-Asian */,
                          "wrong len %x/%x\n", info.cch, out_len );
     if (expname)
     {
         if(ansi)
             ok_(__FILE__, line)( !strncmp( expname, info.dwTypeData, out_len ),
                                  "menu item name differed from '%s' '%s'\n", expname, info.dwTypeData );
         else
             ok_(__FILE__, line)( !strncmpW( (WCHAR *)expname, (WCHAR *)info.dwTypeData, out_len ),
                                  "menu item name wrong\n" );
 
         SetLastError( 0xdeadbeef );
         ret = ansi ? GetMenuStringA( hmenu, 0, (char *)buffer, 80, MF_BYPOSITION ) :
             GetMenuStringW( hmenu, 0, buffer, 80, MF_BYPOSITION );
         if (expstring)
             ok_(__FILE__, line)( ret, "GetMenuString failed, err %u\n", GetLastError());
         else
             ok_(__FILE__, line)( !ret, "GetMenuString should have failed\n" );
     }
 }

◆ check_menu_items()

static void check_menu_items	(	HMENU	hmenu,
		UINT	checked_cmd,
		UINT	checked_type,
		UINT	checked_state
	)

static

Definition at line 2693 of file menu.c.

 {
     INT i, count;
 
     count = GetMenuItemCount(hmenu);
     ok (count != -1, "GetMenuItemCount returned -1\n");
 
     for (i = 0; i < count; i++)
     {
         BOOL ret;
         MENUITEMINFOA mii;
 
         memset(&mii, 0, sizeof(mii));
         mii.cbSize = sizeof(mii);
         mii.fMask  = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU;
         ret = GetMenuItemInfoA(hmenu, i, TRUE, &mii);
         ok(ret, "GetMenuItemInfo(%u) failed\n", i);
 
         if (winetest_debug > 1)
             trace("item #%u: fType %04x, fState %04x, wID %u, hSubMenu %p\n",
                   i, mii.fType, mii.fState, mii.wID, mii.hSubMenu);
 
         if (mii.hSubMenu)
         {
             ok(mii.wID == (UINT_PTR)mii.hSubMenu, "id %u: wID %x should be equal to hSubMenu %p\n",
                checked_cmd, mii.wID, mii.hSubMenu);
             if (!GetMenuItemCount(mii.hSubMenu))
             {
                 ok(mii.fType == checked_type, "id %u: expected fType %04x, got %04x\n", checked_cmd, checked_type, mii.fType);
                 ok(mii.fState == checked_state, "id %u: expected fState %04x, got %04x\n", checked_cmd, checked_state, mii.fState);
             }
             check_menu_items(mii.hSubMenu, checked_cmd, checked_type, checked_state);
         }
         else
         {
             if (mii.wID == checked_cmd)
             {
                 ok(mii.fType == checked_type, "id %u: expected fType %04x, got %04x\n", checked_cmd, checked_type, mii.fType);
                 ok(mii.fState == checked_state, "id %u: expected fState %04x, got %04x\n", checked_cmd, checked_state, mii.fState);
                 ok(mii.wID != 0, "id %u: not expected wID 0\n", checked_cmd);
             }
             else
             {
                 ok(mii.fType != MFT_RADIOCHECK, "id %u: not expected fType MFT_RADIOCHECK on cmd %u\n", checked_cmd, mii.wID);
 
                 if (mii.fType == MFT_SEPARATOR)
                 {
                     ok(mii.fState == MFS_GRAYED, "id %u: expected fState MFS_GRAYED, got %04x\n", checked_cmd, mii.fState);
                     ok(mii.wID == 0, "id %u: expected wID 0, got %u\n", checked_cmd, mii.wID);
                 }
                 else
                 {
                     ok(mii.fState == 0, "id %u: expected fState 0, got %04x\n", checked_cmd, mii.fState);
                     ok(mii.wID != 0, "id %u: not expected wID 0\n", checked_cmd);
                 }
             }
         }
     }
 }

Referenced by test_AppendMenu(), and test_CheckMenuRadioItem().

◆ clear_ftype_and_state()

static void clear_ftype_and_state	(	HMENU	hmenu,
		UINT	id,
		UINT	flags
	)

static

Definition at line 2754 of file menu.c.

 {
     BOOL ret;
     MENUITEMINFOA mii;
 
     memset(&mii, 0, sizeof(mii));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_FTYPE | MIIM_STATE;
     ret = SetMenuItemInfoA(hmenu, id, (flags & MF_BYPOSITION) != 0, &mii);
     ok(ret, "SetMenuItemInfo(%u) failed\n", id);
 }

Referenced by test_CheckMenuRadioItem().

◆ click_menu()

static BOOL click_menu	(	HANDLE	hWnd,
		struct menu_item_pair_s *	mi
	)

static

Definition at line 2304 of file menu.c.

 {
     HMENU hMenu = hMenus[mi->uMenu];
     TEST_INPUT i[3];
     MSG msg;
     RECT r;
     int screen_w = GetSystemMetrics(SM_CXSCREEN);
     int screen_h = GetSystemMetrics(SM_CYSCREEN);
     BOOL ret = GetMenuItemRect(mi->uMenu > 2 ? NULL : hWnd, hMenu, mi->uItem, &r);
     if(!ret) return FALSE;
 
     memset(i, 0, sizeof(i));
     i[0].type = i[1].type = i[2].type = INPUT_MOUSE;
     i[0].u.mi.dx = i[1].u.mi.dx = i[2].u.mi.dx
             = ((r.left + 5) * 65535) / screen_w;
     i[0].u.mi.dy = i[1].u.mi.dy = i[2].u.mi.dy
             = ((r.top + 5) * 65535) / screen_h;
     i[0].u.mi.dwFlags = i[1].u.mi.dwFlags = i[2].u.mi.dwFlags
             = MOUSEEVENTF_ABSOLUTE;
     i[0].u.mi.dwFlags |= MOUSEEVENTF_MOVE;
     i[1].u.mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
     i[2].u.mi.dwFlags |= MOUSEEVENTF_LEFTUP;
     ret = pSendInput(3, (INPUT *) i, sizeof(INPUT));
 
     /* hack to prevent mouse message buildup in Wine */
     while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
     return ret;
 }

Referenced by test_menu_input_thread().

◆ compare_menu_data()

static void compare_menu_data	(	HMENU	hmenu,
		const struct menu_data *	item,
		INT	item_count
	)

static

Definition at line 2963 of file menu.c.

 {
     INT count, i;
     BOOL ret;
 
     count = GetMenuItemCount(hmenu);
     ok(count == item_count, "expected %d, got %d menu items\n", count, item_count);
 
     for (i = 0; i < count; i++)
     {
         char buf[20];
         MENUITEMINFOA mii;
 
         memset(&mii, 0, sizeof(mii));
         mii.cbSize = sizeof(mii);
         mii.dwTypeData = buf;
         mii.cch = sizeof(buf);
         mii.fMask  = MIIM_FTYPE | MIIM_ID | MIIM_STRING | MIIM_BITMAP;
         ret = GetMenuItemInfoA(hmenu, i, TRUE, &mii);
         ok(ret, "GetMenuItemInfo(%u) failed\n", i);
 
         if (winetest_debug > 1)
             trace("item #%u: fType %04x, fState %04x, wID %04x, hbmp %p\n",
                   i, mii.fType, mii.fState, mii.wID, mii.hbmpItem);
 
         ok(mii.fType == item[i].type,
            "%u: expected fType %04x, got %04x\n", i, item[i].type, mii.fType);
         ok(mii.wID == item[i].id,
            "%u: expected wID %04x, got %04x\n", i, item[i].id, mii.wID);
         if (mii.hbmpItem || !item[i].str)
             /* For some reason Windows sets high word to not 0 for
              * not "magic" ids.
              */
             ok(LOWORD(mii.hbmpItem) == LOWORD(item[i].str),
                "%u: expected hbmpItem %p, got %p\n", i, item[i].str, mii.hbmpItem);
         else
         {
             ok(mii.cch == strlen(item[i].str),
                "%u: expected cch %u, got %u\n", i, (UINT)strlen(item[i].str), mii.cch);
             ok(!strcmp(mii.dwTypeData, item[i].str),
                "%u: expected dwTypeData %s, got %s\n", i, item[i].str, (LPCSTR)mii.dwTypeData);
         }
     }
 }

◆ correct_behavior()

static BOOL correct_behavior ( void )

static

Definition at line 64 of file menu.c.

 {
     HMENU hmenu;
     MENUITEMINFOA info;
     BOOL rc;
 
     hmenu = CreateMenu();
 
     memset(&info, 0, sizeof(MENUITEMINFOA));
     info.cbSize= sizeof(MENUITEMINFOA);
     SetLastError(0xdeadbeef);
     rc = GetMenuItemInfoA(hmenu, 0, TRUE, &info);
     /* Win9x  : 0xdeadbeef
      * NT4    : ERROR_INVALID_PARAMETER
      * >= W2K : ERROR_MENU_ITEM_NOT_FOUND
      */
     if (!rc && GetLastError() != ERROR_MENU_ITEM_NOT_FOUND)
     {
         win_skip("NT4 and below can't handle a bigger MENUITEMINFO struct\n");
         DestroyMenu(hmenu);
         return FALSE;
     }
 
     DestroyMenu(hmenu);
     return TRUE;
 }

Referenced by START_TEST().

◆ create_menu_from_data()

static HMENU create_menu_from_data	(	const struct menu_data *	item,
		INT	item_count
	)

static

Definition at line 2902 of file menu.c.

 {
     HMENU hmenu;
     INT i;
     BOOL ret;
 
     hmenu = CreateMenu();
     assert(hmenu != 0);
 
     for (i = 0; i < item_count; i++)
     {
         SetLastError(0xdeadbeef);
         ret = AppendMenuA(hmenu, item[i].type, item[i].id, item[i].str);
         ok(ret, "%d: AppendMenu(%04x, %04x, %p) error %u\n",
            i, item[i].type, item[i].id, item[i].str, GetLastError());
     }
     return hmenu;
 }

◆ create_menuitem_from_data()

static HMENU create_menuitem_from_data	(	const struct menu_data *	item,
		INT	item_count
	)

static

Definition at line 2924 of file menu.c.

 {
     HMENU hmenu;
     INT i;
     BOOL ret;
     MENUITEMINFOA mii = { sizeof( MENUITEMINFOA) };
 
     hmenu = CreateMenu();
     assert(hmenu != 0);
 
     for (i = 0; i < item_count; i++)
     {
         SetLastError(0xdeadbeef);
 
         mii.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STATE;
         mii.fType = 0;
         if(  item[i].type & MFT_BITMAP)
         {
             mii.fMask |= MIIM_BITMAP;
             mii.hbmpItem =  (HBITMAP)item[i].str;
         }
         else if(  item[i].type & MFT_SEPARATOR)
             mii.fType = MFT_SEPARATOR;
         else
         {
             mii.fMask |= MIIM_STRING;
             mii.dwTypeData =  (LPSTR)item[i].str;
             mii.cch = strlen(  item[i].str);
         }
         mii.fState = 0;
         if(  item[i].type & MF_HELP) mii.fType |= MF_HELP;
         mii.wID = item[i].id;
         ret = InsertMenuItemA( hmenu, -1, TRUE, &mii);
         ok(ret, "%d: InsertMenuItem(%04x, %04x, %p) error %u\n",
            i, item[i].type, item[i].id, item[i].str, GetLastError());
     }
     return hmenu;
 }

◆ get_bad_hmenu()

static HMENU get_bad_hmenu ( UINT_PTR id )

static

Definition at line 3857 of file menu.c.

 {
     while (IsMenu( (HMENU)id )) id++;
     return (HMENU)id;
 }

Referenced by test_AppendMenu().

◆ init_function_pointers()

static void init_function_pointers ( void )

static

Definition at line 47 of file menu.c.

 {
     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(GetMenuInfo)
     GET_PROC(GetMenuBarInfo)
     GET_PROC(SendInput)
     GET_PROC(SetMenuInfo)
 
 #undef GET_PROC
 }

Referenced by START_TEST().

◆ insert_menu_item()

static void insert_menu_item	(	int	line,
		HMENU	hmenu,
		BOOL	ansi,
		UINT	mask,
		UINT	type,
		UINT	state,
		UINT	id,
		HMENU	submenu,
		HBITMAP	checked,
		HBITMAP	unchecked,
		ULONG_PTR	data,
		void *	type_data,
		UINT	len,
		HBITMAP	item,
		BOOL	expect
	)

static

Definition at line 1253 of file menu.c.

 {
     MENUITEMINFOA info;
     BOOL ret;
 
     /* magic bitmap handle to test smaller cbSize */
     if (item == (HBITMAP)(ULONG_PTR)0xdeadbeef)
         info.cbSize = FIELD_OFFSET(MENUITEMINFOA,hbmpItem);
     else
         info.cbSize = sizeof(info);
     info.fMask = mask;
     info.fType = type;
     info.fState = state;
     info.wID = id;
     info.hSubMenu = submenu;
     info.hbmpChecked = checked;
     info.hbmpUnchecked = unchecked;
     info.dwItemData = data;
     info.dwTypeData = type_data;
     info.cch = len;
     info.hbmpItem = item;
     SetLastError( 0xdeadbeef );
     if (ansi) ret = InsertMenuItemA( hmenu, 0, TRUE, &info );
     else ret = InsertMenuItemW( hmenu, 0, TRUE, (MENUITEMINFOW*)&info );
     if (!expect) ok_(__FILE__, line)( !ret, "InsertMenuItem should have failed.\n" );
     else ok_(__FILE__, line)( ret, "InsertMenuItem failed, err %u\n", GetLastError());
 }

◆ menu_cancelmode_wnd_proc()

static LRESULT WINAPI menu_cancelmode_wnd_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 3506 of file menu.c.

 {
     switch (msg)
     {
         case WM_ENTERMENULOOP:
             g_got_enteridle = 0;
             return SendMessageA( g_hwndtosend, WM_CANCELMODE, 0, 0);
         case WM_ENTERIDLE:
             {
                 if( g_got_enteridle++ == 0) {
                     /* little hack to get another WM_ENTERIDLE message */
                     PostMessageA( hwnd, WM_MOUSEMOVE, 0, 0);
                     return SendMessageA( g_hwndtosend, WM_CANCELMODE, 0, 0);
                 }
                 EndMenu();
                 return TRUE;
             }
     }
     return DefWindowProcA( hwnd, msg, wparam, lparam);
 }

Referenced by test_menu_cancelmode().

◆ menu_check_wnd_proc()

static LRESULT WINAPI menu_check_wnd_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 91 of file menu.c.

 {
     switch (msg)
     {
     case WM_ENTERMENULOOP:
         /* mark window as having entered menu loop */
         SetWindowLongPtrA(hwnd, GWLP_USERDATA, TRUE);
         /* exit menu modal loop
          * ( A SendMessage does not work on NT3.51 here ) */
         return PostMessageA(hwnd, WM_CANCELMODE, 0, 0);
     }
     return DefWindowProcA(hwnd, msg, wparam, lparam);
 }

Referenced by register_menu_check_class().

◆ menu_fill_in_init()

static LRESULT WINAPI menu_fill_in_init	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 3757 of file menu.c.

 {
     HMENU hmenupopup;
     BOOL ret;
     switch (msg)
     {
         case WM_INITMENUPOPUP:
             gflag_initmenupopup++;
             hmenupopup = (HMENU) wparam;
             ret = AppendMenuA(hmenupopup, MF_STRING , 100, "item 1");
             ok(ret, "AppendMenu failed.\n");
             ret = AppendMenuA(hmenupopup, MF_STRING , 101, "item 2");
             ok(ret, "AppendMenu failed.\n");
             break;
         case WM_ENTERMENULOOP:
             gflag_entermenuloop++;
             break;
         case WM_INITMENU:
             gflag_initmenu++;
             break;
         case WM_ENTERIDLE:
             gflag_enteridle++;
             PostMessageA(hwnd, WM_CANCELMODE, 0, 0);
             return TRUE;
         case WM_MENUSELECT:
             selectitem_wp = wparam;
             selectitem_lp = lparam;
             break;
     }
     return DefWindowProcA(hwnd, msg, wparam, lparam);
 }

Referenced by test_emptypopup().

◆ menu_ownerdraw_wnd_proc()

static LRESULT WINAPI menu_ownerdraw_wnd_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 156 of file menu.c.

 {
     static HMENU hmenupopup;
     switch (msg)
     {
         case WM_INITMENUPOPUP:
             gflag_initmenupopup++;
             hmenupopup = (HMENU) wparam;
             break;
         case WM_ENTERMENULOOP:
             gflag_entermenuloop++;
             break;
         case WM_INITMENU:
             gflag_initmenu++;
             break;
         case WM_MEASUREITEM:
             {
                 MEASUREITEMSTRUCT* pmis = (MEASUREITEMSTRUCT*)lparam;
                 if (winetest_debug > 1)
                     trace("WM_MEASUREITEM received data %lx size %dx%d\n",
                             pmis->itemData, pmis->itemWidth, pmis->itemHeight);
                 ok( !wparam, "wrong wparam %lx\n", wparam );
                 ok( pmis->CtlType == ODT_MENU, "wrong type %x\n", pmis->CtlType );
                 MOD_odheight = pmis->itemHeight;
                 pmis->itemWidth = MODsizes[pmis->itemData].cx;
                 pmis->itemHeight = MODsizes[pmis->itemData].cy;
                 return TRUE;
             }
         case WM_DRAWITEM:
             {
                 DRAWITEMSTRUCT * pdis;
                 TEXTMETRICA tm;
                 HPEN oldpen;
                 char chrs[]="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
                 SIZE sz;
                 int i;
                 pdis = (DRAWITEMSTRUCT *) lparam;
                 if (winetest_debug > 1) {
                     RECT rc;
                     GetMenuItemRect( hwnd, (HMENU)pdis->hwndItem, pdis->itemData ,&rc);
                     trace("WM_DRAWITEM received hwnd %p hmenu %p itemdata %ld item %d rc %s itemrc:  %s\n",
                             hwnd, pdis->hwndItem, pdis->itemData, pdis->itemID,
                             wine_dbgstr_rect(&pdis->rcItem), wine_dbgstr_rect(&rc));
                     oldpen=SelectObject( pdis->hDC, GetStockObject(
                                 pdis->itemState & ODS_SELECTED ? WHITE_PEN :BLACK_PEN));
                     Rectangle( pdis->hDC, pdis->rcItem.left,pdis->rcItem.top,
                             pdis->rcItem.right,pdis->rcItem.bottom );
                     SelectObject( pdis->hDC, oldpen);
                 }
                 ok( !wparam, "wrong wparam %lx\n", wparam );
                 ok( pdis->CtlType == ODT_MENU, "wrong type %x\n", pdis->CtlType );
                 /* calculate widths of some menu texts */
                 if( ! MOD_txtsizes[0].size.cx)
                     for(i = 0; MOD_txtsizes[i].text; i++) {
                         char buf[100], *p;
                         RECT rc={0,0,0,0};
                         strcpy( buf, MOD_txtsizes[i].text);
                         if( ( p = strchr( buf, '\t'))) {
                             *p = '\0';
                             DrawTextA( pdis->hDC, p + 1, -1, &rc,
                                     DT_SINGLELINE|DT_CALCRECT);
                             MOD_txtsizes[i].sc_size.cx= rc.right - rc.left;
                             MOD_txtsizes[i].sc_size.cy= rc.bottom - rc.top;
                         }
                         DrawTextA( pdis->hDC, buf, -1, &rc,
                                 DT_SINGLELINE|DT_CALCRECT);
                         MOD_txtsizes[i].size.cx= rc.right - rc.left;
                         MOD_txtsizes[i].size.cy= rc.bottom - rc.top;
                     }
 
                 if( pdis->itemData > MOD_maxid) return TRUE;
                 /* store the rectangle */
                 MOD_rc[pdis->itemData] = pdis->rcItem;
                 /* calculate average character width */
                 GetTextExtentPointA( pdis->hDC, chrs, 52, &sz );
                 MOD_avec = (sz.cx + 26)/52;
                 GetTextMetricsA( pdis->hDC, &tm);
                 MOD_hic = tm.tmHeight;
                 MOD_GotDrawItemMsg = TRUE;
                 return TRUE;
             }
         case WM_ENTERIDLE:
             {
                 gflag_enteridle++;
                 ok( lparam || broken(!lparam), /* win9x, nt4 */
                     "Menu window handle is NULL!\n");
                 if( lparam) {
                     HMENU hmenu = (HMENU)SendMessageA( (HWND)lparam, MN_GETHMENU, 0, 0);
                     ok( hmenupopup == hmenu, "MN_GETHMENU returns %p expected %p\n",
                         hmenu, hmenupopup);
                 }
                 PostMessageA(hwnd, WM_CANCELMODE, 0, 0);
                 return TRUE;
             }
         case WM_MENUSELECT:
             selectitem_wp = wparam;
             selectitem_lp = lparam;
             break;
     }
     return DefWindowProcA(hwnd, msg, wparam, lparam);
 }

Referenced by test_emptypopup(), test_menu_bmp_and_string(), test_menu_ownerdraw(), and test_menu_trackpopupmenu().

◆ menu_track_again_wnd_proc()

static LRESULT WINAPI menu_track_again_wnd_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 3453 of file menu.c.

 {
     switch (msg)
     {
     case WM_ENTERMENULOOP:
     {
         BOOL ret;
 
         /* try a recursive call */
         SetLastError(0xdeadbeef);
         ret = TrackPopupMenu(g_hmenu, 0, 100, 100, 0, hwnd, NULL);
         ok(ret == FALSE, "got %d\n", ret);
         ok(GetLastError() == ERROR_POPUP_ALREADY_ACTIVE ||
            broken(GetLastError() == 0xdeadbeef) /* W9x */, "got %d\n", GetLastError());
 
         /* exit menu modal loop
          * ( A SendMessage does not work on NT3.51 here ) */
         return PostMessageA(hwnd, WM_CANCELMODE, 0, 0);
     }
     }
     return DefWindowProcA(hwnd, msg, wparam, lparam);
 }

Referenced by test_menu_trackagain().

◆ modify_menu()

static void modify_menu	(	int	line,
		HMENU	hmenu,
		BOOL	ansi,
		UINT	flags,
		UINT_PTR	id,
		void *	data
	)

static

Definition at line 1356 of file menu.c.

 {
     BOOL ret;
 
     SetLastError( 0xdeadbeef );
     if (ansi) ret = ModifyMenuA( hmenu, 0, flags, id, data );
     else ret = ModifyMenuW( hmenu, 0, flags, id, data );
     ok_(__FILE__,line)( ret, "ModifyMenuA failed, err %u\n", GetLastError());
 }

◆ MyTrackPopupMenu()

static DWORD MyTrackPopupMenu	(	int	ex,
		HMENU	hmenu,
		UINT	flags,
		INT	x,
		INT	y,
		HWND	hwnd,
		LPTPMPARAMS	ptpm
	)

static

Definition at line 3330 of file menu.c.

 {
     return ex
         ? TrackPopupMenuEx( hmenu, flags, x, y, hwnd, ptpm)
         : TrackPopupMenu( hmenu, flags, x, y, 0, hwnd, NULL);
 }

Referenced by test_menu_trackpopupmenu().

◆ register_menu_check_class()

static void register_menu_check_class ( void )

static

Definition at line 259 of file menu.c.

 {
     WNDCLASSA wc =
     {
         0,
         menu_check_wnd_proc,
         0,
         0,
         GetModuleHandleA(NULL),
         NULL,
         LoadCursorA(NULL, (LPCSTR)IDC_ARROW),
         (HBRUSH)(COLOR_BTNFACE+1),
         NULL,
         "WineMenuCheck",
     };
 
     atomMenuCheckClass = RegisterClassA(&wc);
 }

Referenced by START_TEST().

◆ send_key()

static void send_key ( WORD wVk )

static

Definition at line 2294 of file menu.c.

 {
     TEST_INPUT i[2];
     memset(i, 0, sizeof(i));
     i[0].type = i[1].type = INPUT_KEYBOARD;
     i[0].u.ki.wVk = i[1].u.ki.wVk = wVk;
     i[1].u.ki.dwFlags = KEYEVENTF_KEYUP;
     pSendInput(2, (INPUT *) i, sizeof(INPUT));
 }

Referenced by test_menu_input_thread().

◆ set_menu_item_info()

static void set_menu_item_info	(	int	line,
		HMENU	hmenu,
		BOOL	ansi,
		UINT	mask,
		UINT	type,
		UINT	state,
		UINT	id,
		HMENU	submenu,
		HBITMAP	checked,
		HBITMAP	unchecked,
		ULONG_PTR	data,
		void *	type_data,
		UINT	len,
		HBITMAP	item
	)

static

Definition at line 1366 of file menu.c.

 {
     MENUITEMINFOA info;
     BOOL ret;
 
     /* magic bitmap handle to test smaller cbSize */
     if (item == (HBITMAP)(ULONG_PTR)0xdeadbeef)
         info.cbSize = FIELD_OFFSET(MENUITEMINFOA,hbmpItem);
     else
         info.cbSize = sizeof(info);
     info.fMask = mask;
     info.fType = type;
     info.fState = state;
     info.wID = id;
     info.hSubMenu = submenu;
     info.hbmpChecked = checked;
     info.hbmpUnchecked = unchecked;
     info.dwItemData = data;
     info.dwTypeData = type_data;
     info.cch = len;
     info.hbmpItem = item;
     SetLastError( 0xdeadbeef );
     if (ansi) ret = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
     else ret = SetMenuItemInfoW( hmenu, 0, TRUE, (MENUITEMINFOW*)&info );
     ok_(__FILE__, line)( ret, "SetMenuItemInfo failed, err %u\n", GetLastError());
 }

◆ START_TEST()

START_TEST ( menu )

Definition at line 4299 of file menu.c.

 {
     init_function_pointers();
     register_menu_check_class();
 
     /* Wine defines MENUITEMINFO for W2K and above. NT4 and below can't
      * handle that.
      */
     if (correct_behavior())
     {
         test_menu_add_string();
         test_menu_iteminfo();
         test_menu_search_bycommand();
         test_CheckMenuRadioItem();
         test_menu_resource_layout();
         test_InsertMenu();
         test_menualign();
         test_system_menu();
     }
 
     test_menu_locked_by_window();
     test_subpopup_locked_by_menu();
     test_menu_ownerdraw();
     test_getmenubarinfo();
     test_menu_bmp_and_string();
     test_menu_getmenuinfo();
     test_menu_setmenuinfo();
     test_menu_input();
     test_menu_flags();
 
     test_menu_hilitemenuitem();
     test_menu_trackpopupmenu();
     test_menu_trackagain();
     test_menu_cancelmode();
     test_menu_maxdepth();
     test_menu_circref();
     test_emptypopup();
     test_AppendMenu();
 }

◆ strcpyW()

static WCHAR* strcpyW	(	WCHAR *	dst,
		const WCHAR *	src
	)

static

Definition at line 1246 of file menu.c.

 {
     WCHAR *p = dst;
     while ((*p++ = *src++));
     return dst;
 }

◆ strncmpW()

static int strncmpW	(	const WCHAR *	str1,
		const WCHAR *	str2,
		int	n
	)

static

Definition at line 1239 of file menu.c.

 {
     if (n <= 0) return 0;
     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
     return *str1 - *str2;
 }

Referenced by check_menu_item_info().

◆ subpopuplocked_wnd_proc()

static LRESULT WINAPI subpopuplocked_wnd_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 621 of file menu.c.

 {
     HWND hwndmenu;
     switch (msg)
     {
     case WM_ENTERIDLE:
         hwndmenu = GetCapture();
         if( hwndmenu) {
             PostMessageA( hwndmenu, WM_KEYDOWN, VK_DOWN, 0);
             PostMessageA( hwndmenu, WM_KEYDOWN, VK_RIGHT, 0);
             PostMessageA( hwndmenu, WM_KEYDOWN, VK_RETURN, 0);
         }
     }
     return DefWindowProcA(hwnd, msg, wparam, lparam);
 }

Referenced by test_subpopup_locked_by_menu().

◆ test_AppendMenu()

static void test_AppendMenu ( void )

static

Definition at line 3863 of file menu.c.

 {
     static char string[] = "string";
     MENUITEMINFOA mii;
     HMENU hmenu, hsubmenu;
     HBITMAP hbmp;
     char buf[16];
     BOOL ret;
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     ret = AppendMenuA(hmenu, MF_OWNERDRAW, 201, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, 201, MF_OWNERDRAW, 0);
     DestroyMenu(hmenu);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     hsubmenu = get_bad_hmenu( 202 );
     ret = AppendMenuA(hmenu, MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_STRING, 0);
     DestroyMenu(hmenu);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     hsubmenu = get_bad_hmenu( 203 );
     ret = AppendMenuA(hmenu, MF_OWNERDRAW | MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_OWNERDRAW, 0);
     DestroyMenu(hmenu);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     hsubmenu = CreateMenu();
     ok(hsubmenu != 0, "CreateMenu failed\n");
     ret = AppendMenuA(hmenu, MF_OWNERDRAW, (UINT_PTR)hsubmenu, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_OWNERDRAW, 0);
     DestroyMenu(hmenu);
     DestroyMenu(hsubmenu);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     hsubmenu = CreateMenu();
     ok(hsubmenu != 0, "CreateMenu failed\n");
     ret = AppendMenuA(hmenu, MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_STRING, 0);
     DestroyMenu(hmenu);
     DestroyMenu(hsubmenu);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     hsubmenu = CreateMenu();
     ok(hsubmenu != 0, "CreateMenu failed\n");
     ret = AppendMenuA(hmenu, MF_OWNERDRAW | MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_OWNERDRAW, 0);
     DestroyMenu(hmenu);
     DestroyMenu(hsubmenu);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     hsubmenu = CreatePopupMenu();
     ok(hsubmenu != 0, "CreatePopupMenu failed\n");
     ret = AppendMenuA(hmenu, MF_OWNERDRAW, (UINT_PTR)hsubmenu, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_OWNERDRAW, 0);
     DestroyMenu(hmenu);
     DestroyMenu(hsubmenu);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     hsubmenu = CreatePopupMenu();
     ok(hsubmenu != 0, "CreatePopupMenu failed\n");
     ret = AppendMenuA(hmenu, MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_STRING, 0);
     DestroyMenu(hmenu);
     DestroyMenu(hsubmenu);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     hsubmenu = CreatePopupMenu();
     ok(hsubmenu != 0, "CreatePopupMenu failed\n");
     ret = AppendMenuA(hmenu, MF_OWNERDRAW | MF_POPUP, (UINT_PTR)hsubmenu, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_OWNERDRAW, 0);
     DestroyMenu(hmenu);
     DestroyMenu(hsubmenu);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     ret = AppendMenuA(hmenu, MF_STRING, 204, "item 1");
     ok(ret, "AppendMenu failed\n");
     check_menu_items(hmenu, 204, MF_STRING, 0);
     hsubmenu = get_bad_hmenu( 205 );
     ret = ModifyMenuA(hmenu, 0, MF_POPUP | MF_BYPOSITION, (UINT_PTR)hsubmenu, "item 2");
     ok(ret, "ModifyMenu failed\n");
     check_menu_items(hmenu, (UINT_PTR)hsubmenu, MF_STRING, 0);
     memset(&mii, 0, sizeof(mii));
     mii.cbSize = sizeof(mii);
     mii.fMask = MIIM_SUBMENU;
     mii.hSubMenu = get_bad_hmenu( 204 );
     ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
     ok(!ret, "InsertMenuItem should fail\n");
     ret = SetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(!ret, "SetMenuItemInfo should fail\n");
     mii.fMask = MIIM_ID;
     mii.wID = 206;
     ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
     ok(ret, "InsertMenuItem failed\n");
 if (0) /* FIXME: uncomment once Wine is fixed */ {
     check_menu_items(hmenu, 206, MF_SEPARATOR, MFS_GRAYED);
 }
     mii.wID = 207;
     ret = SetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "SetMenuItemInfo failed\n");
 if (0) /* FIXME: uncomment once Wine is fixed */ {
     check_menu_items(hmenu, 207, MF_SEPARATOR, MFS_GRAYED);
 }
     DestroyMenu(hmenu);
 
     hbmp = CreateBitmap(1, 1, 1, 1, NULL);
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
 
     /* menu item with a string and a bitmap */
     memset(&mii, 0, sizeof(mii));
     mii.cbSize = sizeof(mii);
     mii.fMask = MIIM_STRING | MIIM_BITMAP;
     mii.dwTypeData = string;
     mii.cch = strlen(string);
     mii.hbmpItem = hbmp;
     ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
     ok(ret, "InsertMenuItem failed\n");
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
     ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
 
     memset(&mii, 0x81, sizeof(mii));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_TYPE;
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_BITMAP, "expected MF_BITMAP, got %#x\n", mii.fType);
     ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
     ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == (LPSTR)hbmp, "expected %p, got %p\n", hbmp, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
 
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_STATE | MIIM_ID | MIIM_TYPE | MIIM_DATA;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_BITMAP, "expected MF_BITMAP, got %#x\n", mii.fType);
     ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
     ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0, "expected 0, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == (LPSTR)hbmp, "expected %p, got %p\n", hbmp, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
 
     DestroyMenu(hmenu);
     DeleteObject(hbmp);
 
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
 
     /* menu item with a string and a "magic" bitmap */
     memset(&mii, 0, sizeof(mii));
     mii.cbSize = sizeof(mii);
     mii.fMask = MIIM_STRING | MIIM_BITMAP;
     mii.dwTypeData = string;
     mii.cch = strlen(string);
     mii.hbmpItem = HBMMENU_POPUP_RESTORE;
     ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
     ok(ret, "InsertMenuItem failed\n");
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
     ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
 
     memset(&mii, 0x81, sizeof(mii));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_TYPE;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
     ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
 
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_STATE | MIIM_ID | MIIM_TYPE | MIIM_DATA;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
     ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0, "expected 0, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
 
     DestroyMenu(hmenu);
 
     hbmp = CreateBitmap(1, 1, 1, 1, NULL);
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
 
     /* menu item with a string */
     memset(&mii, 0, sizeof(mii));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_STATE | MIIM_ID | MIIM_TYPE | MIIM_DATA;
     mii.dwItemData = (ULONG_PTR)hbmp;
     mii.dwTypeData = string;
     mii.cch = strlen(string);
     mii.hbmpItem = hbmp;
     ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
     ok(ret, "InsertMenuItem failed\n");
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_STATE | MIIM_ID | MIIM_TYPE | MIIM_DATA;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
     ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == (ULONG_PTR)hbmp, "expected %p, got %#lx\n", hbmp, mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == 0, "expected 0, got %p\n", mii.hbmpItem);
 
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_TYPE;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
     ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == 0, "expected 0, got %p\n", mii.hbmpItem);
 
     DestroyMenu(hmenu);
     DeleteObject(hbmp);
 
     /* menu item with a string */
     hbmp = CreateBitmap(1, 1, 1, 1, NULL);
     hmenu = CreateMenu();
     ok(hmenu != 0, "CreateMenu failed\n");
     memset(&mii, 0, sizeof(mii));
     mii.cbSize = sizeof(mii);
     mii.fMask = MIIM_STRING;
     mii.dwTypeData = string;
     mii.cch = strlen(string);
     ret = InsertMenuItemA(hmenu, 0, TRUE, &mii);
     ok(ret, "InsertMenuItem failed\n");
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
     ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == 0, "expected 0, got %p\n", mii.hbmpItem);
 
     /* add "magic" bitmap to a menu item */
     mii.fMask = MIIM_BITMAP;
     mii.hbmpItem = HBMMENU_POPUP_RESTORE;
     ret = SetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "SetMenuItemInfo failed\n");
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
     ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
 
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_TYPE;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
     ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == HBMMENU_POPUP_RESTORE, "expected HBMMENU_POPUP_RESTORE, got %p\n", mii.hbmpItem);
 
     /* replace "magic" bitmap by a normal one */
     mii.fMask = MIIM_BITMAP;
     mii.hbmpItem = hbmp;
     ret = SetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "SetMenuItemInfo failed\n");
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_STRING | MIIM_BITMAP;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_STRING, "expected MF_STRING, got %#x\n", mii.fType);
     ok(mii.fState == MF_ENABLED, "expected MF_ENABLED, got %#x\n", mii.fState);
     ok(mii.wID == 0, "expected 0, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == buf, "expected %p, got %p\n", buf, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(!strcmp(buf, string), "expected %s, got %s\n", string, buf);
     ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
 
     memset(&mii, 0x81, sizeof(mii));
     memset(buf, 0x81, sizeof(buf));
     mii.cbSize = sizeof(mii);
     mii.fMask  = MIIM_TYPE;
     mii.dwTypeData = buf;
     mii.cch = sizeof(buf);
     mii.dwItemData = 0x81818181;
     ret = GetMenuItemInfoA(hmenu, 0, TRUE, &mii);
     ok(ret, "GetMenuItemInfo failed\n");
     ok(mii.fType == MF_BITMAP, "expected MF_BITMAP, got %#x\n", mii.fType);
     ok(mii.fState == 0x81818181, "expected 0x81818181, got %#x\n", mii.fState);
     ok(mii.wID == 0x81818181, "expected 0x81818181, got %#x\n", mii.wID);
     ok(mii.hSubMenu == 0, "expected 0, got %p\n", mii.hSubMenu);
     ok(mii.dwItemData == 0x81818181, "expected 0x81818181, got %#lx\n", mii.dwItemData);
     ok(mii.dwTypeData == (LPSTR)hbmp, "expected %p, got %p\n", hbmp, mii.dwTypeData);
     ok(mii.cch == 6, "expected 6, got %u\n", mii.cch);
     ok(mii.hbmpItem == hbmp, "expected %p, got %p\n", hbmp, mii.hbmpItem);
 
     DestroyMenu(hmenu);
     DeleteObject(hbmp);
 }

Referenced by START_TEST().

◆ test_CheckMenuRadioItem()

static void test_CheckMenuRadioItem ( void )

static

Definition at line 2766 of file menu.c.

 {
     BOOL ret;
     HMENU hmenu;
 
     hmenu = LoadMenuA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
     assert(hmenu != 0);
 
     check_menu_items(hmenu, -1, 0, 0);
 
     ret = CheckMenuRadioItem(hmenu, 100, 100, 100, MF_BYCOMMAND);
     ok(ret, "CheckMenuRadioItem failed\n");
     check_menu_items(hmenu, 100, MFT_RADIOCHECK, MFS_CHECKED);
 
     /* MSDN is wrong, Windows does not remove MFT_RADIOCHECK */
     ret = CheckMenuRadioItem(hmenu, 100, 100, -1, MF_BYCOMMAND);
     ok(!ret, "CheckMenuRadioItem should return FALSE\n");
     check_menu_items(hmenu, 100, MFT_RADIOCHECK, 0);
 
     /* clear check */
     clear_ftype_and_state(hmenu, 100, MF_BYCOMMAND);
     check_menu_items(hmenu, -1, 0, 0);
 
     /* first and checked items are on different menus */
     ret = CheckMenuRadioItem(hmenu, 0, 300, 202, MF_BYCOMMAND);
     ok(!ret, "CheckMenuRadioItem should return FALSE\n");
     check_menu_items(hmenu, -1, 0, 0);
 
     ret = CheckMenuRadioItem(hmenu, 200, 300, 202, MF_BYCOMMAND);
     ok(ret, "CheckMenuRadioItem failed\n");
     check_menu_items(hmenu, 202, MFT_RADIOCHECK, MFS_CHECKED);
 
     /* MSDN is wrong, Windows does not remove MFT_RADIOCHECK */
     ret = CheckMenuRadioItem(hmenu, 202, 202, -1, MF_BYCOMMAND);
     ok(!ret, "CheckMenuRadioItem should return FALSE\n");
     check_menu_items(hmenu, 202, MFT_RADIOCHECK, 0);
 
     /* clear check */
     clear_ftype_and_state(hmenu, 202, MF_BYCOMMAND);
     check_menu_items(hmenu, -1, 0, 0);
 
     /* just for fun, try to check separator */
     ret = CheckMenuRadioItem(hmenu, 0, 300, 0, MF_BYCOMMAND);
     ok(!ret, "CheckMenuRadioItem should return FALSE\n");
     check_menu_items(hmenu, -1, 0, 0);
 }

Referenced by START_TEST().

◆ test_emptypopup()

static void test_emptypopup ( void )

static

Definition at line 3790 of file menu.c.

 {
     BOOL ret;
     HMENU hmenu;
 
     HWND hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
                                WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
                                NULL, NULL, NULL, NULL);
     ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
     SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_ownerdraw_wnd_proc);
 
     hmenu = CreatePopupMenu();
     ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
 
     gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = gflag_enteridle = 0;
     selectitem_wp = 0xdeadbeef;
     selectitem_lp = 0xdeadbeef;
 
     ret = TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
     ok(ret == 0, "got %i\n", ret);
 
     ok(gflag_initmenupopup == 1, "got %i\n", gflag_initmenupopup);
     ok(gflag_entermenuloop == 1, "got %i\n", gflag_entermenuloop);
     ok(gflag_initmenu == 1, "got %i\n", gflag_initmenu);
     ok(gflag_enteridle == 0, "got %i\n", gflag_initmenu);
 
     ok(selectitem_wp == 0xdeadbeef, "got %lx\n", selectitem_wp);
     ok(selectitem_lp == 0xdeadbeef, "got %lx\n", selectitem_lp);
 
     gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = gflag_enteridle = 0;
     selectitem_wp = 0xdeadbeef;
     selectitem_lp = 0xdeadbeef;
 
     ret = TrackPopupMenu( hmenu, 0, 100,100, 0, hwnd, NULL);
     ok(ret == 0, "got %i\n", ret);
 
     ok(gflag_initmenupopup == 1, "got %i\n", gflag_initmenupopup);
     ok(gflag_entermenuloop == 1, "got %i\n", gflag_entermenuloop);
     ok(gflag_initmenu == 1, "got %i\n", gflag_initmenu);
     ok(gflag_enteridle == 0, "got %i\n", gflag_initmenu);
 
     ok(selectitem_wp == 0xdeadbeef, "got %lx\n", selectitem_wp);
     ok(selectitem_lp == 0xdeadbeef, "got %lx\n", selectitem_lp);
 
     SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_fill_in_init);
 
     gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = gflag_enteridle = 0;
     selectitem_wp = 0xdeadbeef;
     selectitem_lp = 0xdeadbeef;
 
     ret = TrackPopupMenu( hmenu, 0, 100,100, 0, hwnd, NULL);
     ok(ret == 1, "got %i\n", ret);
 
     ok(gflag_initmenupopup == 1, "got %i\n", gflag_initmenupopup);
     ok(gflag_entermenuloop == 1, "got %i\n", gflag_entermenuloop);
     ok(gflag_initmenu == 1, "got %i\n", gflag_initmenu);
     ok(gflag_enteridle == 1, "got %i\n", gflag_initmenu);
 
     ok(selectitem_wp == 0xffff0000, "got %lx\n", selectitem_wp);
     ok(selectitem_lp == 0, "got %lx\n", selectitem_lp);
 
     DestroyWindow(hwnd);
 
     ret = DestroyMenu(hmenu);
     ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
 }

Referenced by START_TEST().

◆ test_getmenubarinfo()

static void test_getmenubarinfo ( void )

static

Definition at line 278 of file menu.c.

 {
     BOOL ret;
     HMENU hmenu;
     MENUBARINFO mbi;
     RECT rcw, rci;
     HWND hwnd;
     INT err;
 
     if (!pGetMenuBarInfo) {
         win_skip("GetMenuBarInfo is not available\n");
         return;
     }
 
     mbi.cbSize = sizeof(MENUBARINFO);
 
     hwnd = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomMenuCheckClass), NULL,
             WS_SYSMENU | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 100, 100,
             NULL, NULL, NULL, NULL);
     ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
 
     /* no menu: getmenubarinfo should fail */
     SetLastError(0xdeadbeef);
     ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 0, &mbi);
     err = GetLastError();
     ok(ret == FALSE, "GetMenuBarInfo should not have been successful\n");
     ok(err == 0xdeadbeef, "err = %d\n", err);
 
     /* create menubar, no items yet */
     hmenu = CreateMenu();
     ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
 
     ret = SetMenu(hwnd, hmenu);
     ok(ret, "SetMenu failed with error %d\n", GetLastError());
 
     SetLastError(0xdeadbeef);
     ret = pGetMenuBarInfo(NULL, OBJID_CLIENT, 0, &mbi);
     err = GetLastError();
     ok(!ret, "GetMenuBarInfo succeeded\n");
     ok(err == ERROR_INVALID_WINDOW_HANDLE, "err = %d\n", err);
 
     SetLastError(0xdeadbeef);
     ret = pGetMenuBarInfo(hwnd, OBJID_CLIENT, 0, &mbi);
     err = GetLastError();
     ok(!ret, "GetMenuBarInfo succeeded\n");
     ok(err==ERROR_INVALID_MENU_HANDLE || broken(err==0xdeadbeef) /* NT, W2K, XP */, "err = %d\n", err);
 
     SetLastError(0xdeadbeef);
     ret = pGetMenuBarInfo(hwnd, OBJID_MENU, -1, &mbi);
     err = GetLastError();
     ok(ret == FALSE, "GetMenuBarInfo should have failed\n");
     ok(err == 0xdeadbeef, "err = %d\n", err);
 
     mbi.cbSize = 1000;
     SetLastError(0xdeadbeef);
     ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 0, &mbi);
     err = GetLastError();
     ok(ret == FALSE, "GetMenuBarInfo should have failed\n");
     ok(err == ERROR_INVALID_PARAMETER, "err = %d\n", err);
     mbi.cbSize = sizeof(MENUBARINFO);
 
     SetLastError(0xdeadbeef);
     ret = pGetMenuBarInfo(hwnd, 123, 0, &mbi);
     err = GetLastError();
     ok(ret == FALSE, "GetMenuBarInfo should have failed\n");
     ok(err == 0xdeadbeef, "err = %d\n", err);
 
     ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 0, &mbi);
     ok(ret, "GetMenuBarInfo failed with error %d\n", GetLastError());
 
     ok(mbi.rcBar.left == 0 && mbi.rcBar.top == 0 && mbi.rcBar.bottom == 0 && mbi.rcBar.right == 0,
             "rcBar: Expected (0,0)-(0,0), got: %s\n", wine_dbgstr_rect(&mbi.rcBar));
     ok(mbi.hMenu == hmenu, "hMenu: Got %p instead of %p\n",
             mbi.hMenu, hmenu);
     ok(mbi.fBarFocused == 0, "fBarFocused: Got %d instead of 0.\n", mbi.fBarFocused);
     ok(mbi.fFocused == 0, "fFocused: Got %d instead of 0.\n", mbi.fFocused);
 
     /* add some items */
     ret = AppendMenuA(hmenu, MF_STRING , 100, "item 1");
     ok(ret, "AppendMenu failed.\n");
     ret = AppendMenuA(hmenu, MF_STRING , 101, "item 2");
     ok(ret, "AppendMenu failed.\n");
     ret = SetMenu(hwnd, hmenu);
     ok(ret, "SetMenu failed with error %d\n", GetLastError());
 
     SetLastError(0xdeadbeef);
     ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 200, &mbi);
     err = GetLastError();
     ok(ret == FALSE, "GetMenuBarInfo should have failed\n");
     ok(err == 0xdeadbeef, "err = %d\n", err);
 
     /* get info for the whole menu */
     ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 0, &mbi);
     ok(ret, "GetMenuBarInfo failed with error %d\n", GetLastError());
 
     /* calculate menu rectangle, from window rectangle and the position of the first item  */
     ret = GetWindowRect(hwnd, &rcw);
     ok(ret, "GetWindowRect failed.\n");
     ret = GetMenuItemRect(hwnd, hmenu, 0, &rci);
     ok(ret, "GetMenuItemRect failed.\n");
     todo_wine ok(mbi.rcBar.left == rci.left && mbi.rcBar.top == rci.top &&
             mbi.rcBar.bottom == rci.bottom && mbi.rcBar.right == rcw.right - rci.left + rcw.left,
             "rcBar: Got %s instead of (%d,%d)-(%d,%d)\n", wine_dbgstr_rect(&mbi.rcBar),
             rci.left, rci.top, rcw.right - rci.left + rcw.left, rci.bottom);
     ok(mbi.hMenu == hmenu, "hMenu: Got %p instead of %p\n", mbi.hMenu, hmenu);
     ok(mbi.fBarFocused == 0, "fBarFocused: got %d instead of 0\n", mbi.fBarFocused);
     ok(mbi.fFocused == 0, "fFocused: got %d instead of 0\n", mbi.fFocused);
 
     /* get info for item nr.2 */
     ret = pGetMenuBarInfo(hwnd, OBJID_MENU, 2, &mbi);
     ok(ret, "GetMenuBarInfo failed with error %d\n", GetLastError());
     ret = GetMenuItemRect(hwnd, hmenu, 1, &rci);
     ok(ret, "GetMenuItemRect failed.\n");
     ok(EqualRect(&mbi.rcBar, &rci), "rcBar: Got %s instead of %s\n", wine_dbgstr_rect(&mbi.rcBar),
             wine_dbgstr_rect(&rci));
     ok(mbi.hMenu == hmenu, "hMenu: Got %p instead of %p\n", mbi.hMenu, hmenu);
     ok(mbi.fBarFocused == 0, "fBarFocused: got %d instead of 0\n", mbi.fBarFocused);
     ok(mbi.fFocused == 0, "fFocused: got %d instead of 0\n", mbi.fFocused);
 
     DestroyWindow(hwnd);
 }

Referenced by START_TEST().

◆ test_InsertMenu()

static void test_InsertMenu ( void )

static

Definition at line 3008 of file menu.c.

 {
     HBITMAP hbm = CreateBitmap(1,1,1,1,NULL);
     /* Note: XP treats only bitmap handles 1 - 6 as "magic" ones
      * regardless of their id.
      */
     static const struct menu_data in1[] =
     {
         { MF_STRING, 1, "File" },
         { MF_BITMAP|MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(1) },
         { MF_STRING|MF_HELP, 2, "Help" }
     };
     static const struct menu_data out1[] =
     {
         { MF_STRING, 1, "File" },
         { MF_STRING|MF_HELP, 2, "Help" },
         { MF_BITMAP|MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(1) }
     };
     static const struct menu_data out1a[] =
     {
         { MF_STRING, 1, "File" },
         { MF_STRING|MF_HELP, 2, "Help" },
         { MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(1) }
     };
     const struct menu_data in2[] =
     {
         { MF_STRING, 1, "File" },
         { MF_BITMAP|MF_HELP, SC_CLOSE, (char*)hbm },
         { MF_STRING|MF_HELP, 2, "Help" }
     };
     const struct menu_data out2[] =
     {
         { MF_STRING, 1, "File" },
         { MF_BITMAP|MF_HELP, SC_CLOSE, (char*)hbm },
         { MF_STRING|MF_HELP, 2, "Help" }
     };
     const struct menu_data out2a[] =
     {
         { MF_STRING, 1, "File" },
         { MF_HELP, SC_CLOSE, (char*)hbm },
         { MF_STRING|MF_HELP, 2, "Help" }
     };
     static const struct menu_data in3[] =
     {
         { MF_STRING, 1, "File" },
         { MF_SEPARATOR|MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(1) },
         { MF_STRING|MF_HELP, 2, "Help" }
     };
     static const struct menu_data out3[] =
     {
         { MF_STRING, 1, "File" },
         { MF_SEPARATOR|MF_HELP, SC_CLOSE, MAKEINTRESOURCEA(0) },
         { MF_STRING|MF_HELP, 2, "Help" },
     };
     static const struct menu_data in4[] =
     {
         { MF_STRING, 1, "File" },
         { MF_BITMAP|MF_HELP, 1, MAKEINTRESOURCEA(1) },
         { MF_STRING|MF_HELP, 2, "Help" }
     };
     static const struct menu_data out4[] =
     {
         { MF_STRING, 1, "File" },
         { MF_STRING|MF_HELP, 2, "Help" },
         { MF_BITMAP|MF_HELP, 1, MAKEINTRESOURCEA(1) }
     };
     static const struct menu_data out4a[] =
     {
         { MF_STRING, 1, "File" },
         { MF_STRING|MF_HELP, 2, "Help" },
         { MF_HELP, 1, MAKEINTRESOURCEA(1) }
     };
     HMENU hmenu;
 
 #define create_menu(a) create_menu_from_data((a), sizeof(a)/sizeof((a)[0]))
 #define create_menuitem(a) create_menuitem_from_data((a), sizeof(a)/sizeof((a)[0]))
 #define compare_menu(h, a) compare_menu_data((h), (a), sizeof(a)/sizeof((a)[0]))
 
     hmenu = create_menu(in1);
     compare_menu(hmenu, out1);
     DestroyMenu(hmenu);
 
     hmenu = create_menu(in2);
     compare_menu(hmenu, out2);
     DestroyMenu(hmenu);
 
     hmenu = create_menu(in3);
     compare_menu(hmenu, out3);
     DestroyMenu(hmenu);
 
     hmenu = create_menu(in4);
     compare_menu(hmenu, out4);
     DestroyMenu(hmenu);
 
     /* now using InsertMenuItemInfo */
     hmenu = create_menuitem(in1);
     compare_menu(hmenu, out1a);
     DestroyMenu(hmenu);
 
     hmenu = create_menuitem(in2);
     compare_menu(hmenu, out2a);
     DestroyMenu(hmenu);
 
     hmenu = create_menuitem(in3);
     compare_menu(hmenu, out3);
     DestroyMenu(hmenu);
 
     hmenu = create_menuitem(in4);
     compare_menu(hmenu, out4a);
     DestroyMenu(hmenu);
 
 #undef create_menu
 #undef create_menuitem
 #undef compare_menu
 }

Referenced by START_TEST().

◆ test_mbs_help()

static void test_mbs_help	(	int	ispop,
		int	hassub,
		int	mnuopt,
		HWND	hwnd,
		int	arrowwidth,
		int	count,
		HBITMAP	hbmp,
		SIZE	bmpsize,
		LPCSTR	text,
		SIZE	size,
		SIZE	sc_size
	)

static

Definition at line 826 of file menu.c.

 {
     BOOL ret;
     HMENU hmenu, submenu;
     MENUITEMINFOA mii={ sizeof( MENUITEMINFOA )};
     MENUINFO mi;
     RECT rc;
     CHAR text_copy[16];
     int hastab,  expect;
     BOOL failed = FALSE;
 
     MOD_GotDrawItemMsg = FALSE;
     mii.fMask = MIIM_FTYPE | MIIM_DATA | MIIM_STATE;
     mii.fType = 0;
     /* check the menu item unless MNS_CHECKORBMP is set */
     mii.fState = (mnuopt != 2 ? MFS_CHECKED : MFS_UNCHECKED);
     mii.dwItemData =0;
     MODsizes[0] = bmpsize;
     hastab = 0;
     if( text ) {
         char *p;
         mii.fMask |= MIIM_STRING;
         strcpy(text_copy, text);
         mii.dwTypeData = text_copy; /* structure member declared non-const */
         if( ( p = strchr( text, '\t'))) {
             hastab = *(p + 1) ? 2 : 1;
         }
     }
     /* tabs don't make sense in menubars */
     if(hastab && !ispop) return;
     if( hbmp) {
         mii.fMask |= MIIM_BITMAP;
         mii.hbmpItem = hbmp;
     }
     submenu = CreateMenu();
     ok( submenu != 0, "CreateMenu failed with error %d\n", GetLastError());
     if( ispop)
         hmenu = CreatePopupMenu();
     else
         hmenu = CreateMenu();
     ok( hmenu != 0, "Create{Popup}Menu failed with error %d\n", GetLastError());
     if( hassub) {
         mii.fMask |= MIIM_SUBMENU;
         mii.hSubMenu = submenu;
     }
     if( mnuopt) {
         mi.cbSize = sizeof(mi);
         mi.fMask = MIM_STYLE;
         pGetMenuInfo( hmenu, &mi);
         if( mnuopt) mi.dwStyle |= mnuopt == 1 ? MNS_NOCHECK : MNS_CHECKORBMP;
         ret = pSetMenuInfo( hmenu, &mi);
         ok( ret, "SetMenuInfo failed with error %d\n", GetLastError());
     }
     ret = InsertMenuItemA( hmenu, 0, FALSE, &mii);
     ok( ret, "InsertMenuItem failed with error %d\n", GetLastError());
     failed = !ret;
     if( winetest_debug) {
         HDC hdc=GetDC(hwnd);
         RECT rc = {100, 50, 400, 70};
         char buf[100];
 
         sprintf( buf,"%d text \"%s\" mnuopt %d", count, text ? text: "(nil)", mnuopt);
         FillRect( hdc, &rc, (HBRUSH) COLOR_WINDOW);
         TextOutA( hdc, 10, 50, buf, strlen( buf));
         ReleaseDC( hwnd, hdc);
     }
     if(ispop)
         TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
     else {
         ret = SetMenu( hwnd, hmenu);
         ok(ret, "SetMenu failed with error %d\n", GetLastError());
         DrawMenuBar( hwnd);
     }
     ret = GetMenuItemRect( hwnd, hmenu, 0, &rc);
     ok(ret, "GetMenuItemRect failed with error %d\n", GetLastError());
 
     if (0)  /* comment out menu size checks, behavior is different in almost every Windows version */
             /* the tests should however succeed on win2000, XP and Wine (at least up to 1.1.15) */
             /* with a variety of dpis and desktop font sizes */
     {
         /* check menu width */
         if( ispop)
             expect = ( text || hbmp ?
                        4 + (mnuopt != 1 ? GetSystemMetrics(SM_CXMENUCHECK) : 0)
                        : 0) +
                        arrowwidth  + MOD_avec + (hbmp ?
                                     ((INT_PTR)hbmp<0||(INT_PTR)hbmp>12 ? bmpsize.cx + 2 : GetSystemMetrics( SM_CXMENUSIZE) + 2)
                                     : 0) +
                 (text && hastab ? /* TAB space */
                  MOD_avec + ( hastab==2 ? sc_size.cx : 0) : 0) +
                 (text ?  2 + (text[0] ? size.cx :0): 0) ;
         else
             expect = !(text || hbmp) ? 0 :
                 ( hbmp ? (text ? 2:0) + bmpsize.cx  : 0 ) +
                 (text ? 2 * MOD_avec + (text[0] ? size.cx :0): 0) ;
         ok( rc.right - rc.left == expect,
             "menu width wrong, got %d expected %d\n", rc.right - rc.left, expect);
         failed = failed || !(rc.right - rc.left == expect);
         /* check menu height */
         if( ispop)
             expect = max( ( !(text || hbmp) ? GetSystemMetrics( SM_CYMENUSIZE)/2 : 0),
                           max( (text ? max( 2 + size.cy, MOD_hic + 4) : 0),
                                (hbmp ?
                                    ((INT_PTR)hbmp<0||(INT_PTR)hbmp>12 ?
                                        bmpsize.cy + 2
                                      : GetSystemMetrics( SM_CYMENUSIZE) + 2)
                                  : 0)));
         else
             expect = ( !(text || hbmp) ? GetSystemMetrics( SM_CYMENUSIZE)/2 :
                        max( GetSystemMetrics( SM_CYMENU) - 1, (hbmp ? bmpsize.cy : 0)));
         ok( rc.bottom - rc.top == expect,
             "menu height wrong, got %d expected %d (%d)\n",
             rc.bottom - rc.top, expect, GetSystemMetrics( SM_CYMENU));
         failed = failed || !(rc.bottom - rc.top == expect);
         if( hbmp == HBMMENU_CALLBACK && MOD_GotDrawItemMsg) {
             /* check the position of the bitmap */
             /* horizontal */
             if (!ispop)
                 expect = 3;
             else if (mnuopt == 0)
                 expect = 4 + GetSystemMetrics(SM_CXMENUCHECK);
             else if (mnuopt == 1)
                 expect = 4;
             else /* mnuopt == 2 */
                 expect = 2;
             ok( expect == MOD_rc[0].left,
                 "bitmap left is %d expected %d\n", MOD_rc[0].left, expect);
             failed = failed || !(expect == MOD_rc[0].left);
             /* vertical */
             expect = (rc.bottom - rc.top - MOD_rc[0].bottom + MOD_rc[0].top) / 2;
             ok( expect == MOD_rc[0].top,
                 "bitmap top is %d expected %d\n", MOD_rc[0].top, expect);
             failed = failed || !(expect == MOD_rc[0].top);
         }
     }
     /* if there was a failure, report details */
     if( failed) {
         trace("*** count %d %s text \"%s\" bitmap %p bmsize %d,%d textsize %d+%d,%d mnuopt %d hastab %d\n",
                 count, (ispop? "POPUP": "MENUBAR"),text ? text: "(nil)", hbmp, bmpsize.cx, bmpsize.cy,
                 size.cx, size.cy, sc_size.cx, mnuopt, hastab);
         trace("    check %d,%d arrow %d avechar %d\n",
                 GetSystemMetrics(SM_CXMENUCHECK ),
                 GetSystemMetrics(SM_CYMENUCHECK ),arrowwidth, MOD_avec);
         if( hbmp == HBMMENU_CALLBACK)
             trace( "    rc %s bmp.rc %s\n", wine_dbgstr_rect(&rc), wine_dbgstr_rect(&MOD_rc[0]));
     }
     /* clean up */
     ret = DestroyMenu(submenu);
     ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
     ret = DestroyMenu(hmenu);
     ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
 }

Referenced by test_menu_bmp_and_string().

◆ test_menu_add_string()

static void test_menu_add_string ( void )

static

Definition at line 1101 of file menu.c.

 {
     HMENU hmenu;
     MENUITEMINFOA info;
     BOOL rc;
     int ret;
 
     char string[0x80];
     char string2[0x80];
 
     char strback[0x80];
     WCHAR strbackW[0x80];
     static CHAR blah[] = "blah";
     static const WCHAR expectedString[] = {'D','u','m','m','y',' ','s','t','r','i','n','g', 0};
 
     hmenu = CreateMenu();
 
     memset( &info, 0, sizeof info );
     info.cbSize = sizeof info;
     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_ID;
     info.dwTypeData = blah;
     info.cch = 6;
     info.dwItemData = 0;
     info.wID = 1;
     info.fState = 0;
     InsertMenuItemA(hmenu, 0, TRUE, &info );
 
     memset( &info, 0, sizeof info );
     info.cbSize = sizeof info;
     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_DATA | MIIM_ID;
     info.dwTypeData = string;
     info.cch = sizeof string;
     string[0] = 0;
     GetMenuItemInfoA( hmenu, 0, TRUE, &info );
 
     ok( !strcmp( string, "blah" ), "menu item name differed\n");
 
     /* Test combination of ownerdraw and strings with GetMenuItemString(A/W) */
     strcpy(string, "Dummy string");
     memset(&info, 0x00, sizeof(info));
     info.cbSize= sizeof(MENUITEMINFOA);
     info.fMask= MIIM_FTYPE | MIIM_STRING; /* Set OwnerDraw + typeData */
     info.fType= MFT_OWNERDRAW;
     info.dwTypeData= string; 
     rc = InsertMenuItemA( hmenu, 0, TRUE, &info );
     ok (rc, "InsertMenuItem failed\n");
 
     strcpy(string,"Garbage");
     ok (GetMenuStringA( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
     ok (!strcmp( strback, "Dummy string" ), "Menu text from Ansi version incorrect\n");
 
     SetLastError(0xdeadbeef);
     ret = GetMenuStringW( hmenu, 0, strbackW, 99, MF_BYPOSITION );
     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
         win_skip("GetMenuStringW is not implemented\n");
     else
     {
         ok (ret, "GetMenuStringW on ownerdraw entry failed\n");
         ok (!lstrcmpW( strbackW, expectedString ), "Menu text from Unicode version incorrect\n");
     }
 
     /* Just try some invalid parameter tests */
     SetLastError(0xdeadbeef);
     rc = SetMenuItemInfoA( hmenu, 0, TRUE, NULL );
     ret = GetLastError();
     ok (!rc, "SetMenuItemInfoA succeeded unexpectedly\n");
     ok (ret == ERROR_INVALID_PARAMETER, "Expected 87, got %d\n", ret);
 
     SetLastError(0xdeadbeef);
     rc = SetMenuItemInfoA( hmenu, 0, FALSE, NULL );
     ret = GetLastError();
     ok (!rc, "SetMenuItemInfoA succeeded unexpectedly\n");
     ok (ret == ERROR_INVALID_PARAMETER, "Expected 87, got %d\n", ret);
 
     /* Just change ftype to string and see what text is stored */
     memset(&info, 0x00, sizeof(info));
     info.cbSize= sizeof(MENUITEMINFOA);
     info.fMask= MIIM_FTYPE; /* Set string type */
     info.fType= MFT_STRING;
     info.dwTypeData= (char *)0xdeadbeef;
     rc = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
     ok (rc, "SetMenuItemInfo failed\n");
 
     /* Did we keep the old dwTypeData? */
     ok (GetMenuStringA( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
     ok (!strcmp( strback, "Dummy string" ), "Menu text from Ansi version incorrect\n");
 
     /* Ensure change to bitmap type fails */
     memset(&info, 0x00, sizeof(info));
     info.cbSize= sizeof(MENUITEMINFOA);
     info.fMask= MIIM_FTYPE; /* Set as bitmap type */
     info.fType= MFT_BITMAP;
     info.dwTypeData= (char *)0xdeadbee2; 
     rc = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
     ok (!rc, "SetMenuItemInfo unexpectedly worked\n");
 
     /* Just change ftype back and ensure data hasn't been freed */
     info.fType= MFT_OWNERDRAW; /* Set as ownerdraw type */
     info.dwTypeData= (char *)0xdeadbee3; 
     rc = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
     ok (rc, "SetMenuItemInfo failed\n");
 
     /* Did we keep the old dwTypeData? */
     ok (GetMenuStringA( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
     ok (!strcmp( strback, "Dummy string" ), "Menu text from Ansi version incorrect\n");
 
     /* Just change string value (not type) */
     memset(&info, 0x00, sizeof(info));
     info.cbSize= sizeof(MENUITEMINFOA);
     info.fMask= MIIM_STRING; /* Set typeData */
     strcpy(string2, "string2");
     info.dwTypeData= string2;
     rc = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
     ok (rc, "SetMenuItemInfo failed\n");
 
     ok (GetMenuStringA( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
     ok (!strcmp( strback, "string2" ), "Menu text from Ansi version incorrect\n");
 
     /*  crashes with wine 0.9.5 */
     memset(&info, 0x00, sizeof(info));
     info.cbSize= sizeof(MENUITEMINFOA);
     info.fMask= MIIM_FTYPE | MIIM_STRING; /* Set OwnerDraw + typeData */
     info.fType= MFT_OWNERDRAW;
     rc = InsertMenuItemA( hmenu, 0, TRUE, &info );
     ok (rc, "InsertMenuItem failed\n");
     ok (!GetMenuStringA( hmenu, 0, NULL, 0, MF_BYPOSITION),
             "GetMenuString on ownerdraw entry succeeded.\n");
     SetLastError(0xdeadbeef);
     ret = GetMenuStringW( hmenu, 0, NULL, 0, MF_BYPOSITION);
     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
         win_skip("GetMenuStringW is not implemented\n");
     else
         ok (!ret, "GetMenuStringW on ownerdraw entry succeeded.\n");
 
     DestroyMenu( hmenu );
 }

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ _WIN32_WINNT

◆ compare_menu

◆ create_menu

◆ create_menuitem

◆ ER

◆ GET_PROC

◆ MOD_NRMENUS

◆ MOD_SIZE

◆ NR_MENUS

◆ OEMRESOURCE

◆ OK

◆ TMII_DONE

◆ TMII_GMII

◆ TMII_INSMI

◆ TMII_MODM

◆ TMII_SMII

Function Documentation

◆ BOOL()

◆ check_menu_item_info()

◆ check_menu_items()

◆ clear_ftype_and_state()

◆ click_menu()

◆ compare_menu_data()

◆ correct_behavior()

◆ create_menu_from_data()

◆ create_menuitem_from_data()

◆ get_bad_hmenu()

◆ init_function_pointers()

◆ insert_menu_item()

◆ menu_cancelmode_wnd_proc()

◆ menu_check_wnd_proc()

◆ menu_fill_in_init()

◆ menu_ownerdraw_wnd_proc()

◆ menu_track_again_wnd_proc()

◆ modify_menu()

◆ MyTrackPopupMenu()

◆ register_menu_check_class()

◆ send_key()

◆ set_menu_item_info()

◆ START_TEST()

◆ strcpyW()

◆ strncmpW()

◆ subpopuplocked_wnd_proc()

◆ test_AppendMenu()

◆ test_CheckMenuRadioItem()

◆ test_emptypopup()

◆ test_getmenubarinfo()

◆ test_InsertMenu()

◆ test_mbs_help()

◆ test_menu_add_string()