git.oblomov.eu Git - wine/blob - dlls/user32/tests/menu.c

   1 /*
   2  * Unit tests for menus
   3  *
   4  * Copyright 2005 Robert Shearman
   5  * Copyright 2007 Dmitry Timoshkov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define _WIN32_WINNT 0x0501
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <assert.h>
  28
  29 #define OEMRESOURCE         /* For OBM_MNARROW */
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "wingdi.h"
  34 #include "winuser.h"
  35
  36 #include "wine/test.h"
  37
  38 static ATOM atomMenuCheckClass;
  39
  40 static BOOL (WINAPI *pGetMenuInfo)(HMENU,LPCMENUINFO);
  41 static UINT (WINAPI *pSendInput)(UINT, INPUT*, size_t);
  42 static BOOL (WINAPI *pSetMenuInfo)(HMENU,LPCMENUINFO);
  43 static BOOL (WINAPI *pEndMenu) (void);
  44
  45 static void init_function_pointers(void)
  46 {
  47     HMODULE hdll = GetModuleHandleA("user32");
  48
  49 #define GET_PROC(func) \
  50     p ## func = (void*)GetProcAddress(hdll, #func); \
  51     if(!p ## func) \
  52       trace("GetProcAddress(%s) failed\n", #func);
  53
  54     GET_PROC(GetMenuInfo)
  55     GET_PROC(SendInput)
  56     GET_PROC(SetMenuInfo)
  57     GET_PROC(EndMenu)
  58
  59 #undef GET_PROC
  60 }
  61
  62 static BOOL correct_behavior(void)
  63 {
  64     HMENU hmenu;
  65     MENUITEMINFO info;
  66     BOOL rc;
  67
  68     hmenu = CreateMenu();
  69
  70     memset(&info, 0, sizeof(MENUITEMINFO));
  71     info.cbSize= sizeof(MENUITEMINFO);
  72     SetLastError(0xdeadbeef);
  73     rc = GetMenuItemInfo(hmenu, 0, TRUE, &info);
  74     /* Win9x  : 0xdeadbeef
  75      * NT4    : ERROR_INVALID_PARAMETER
  76      * >= W2K : ERROR_MENU_ITEM_NOT_FOUND
  77      */
  78     if (!rc && GetLastError() != ERROR_MENU_ITEM_NOT_FOUND)
  79     {
  80         win_skip("NT4 and below can't handle a bigger MENUITEMINFO struct\n");
  81         DestroyMenu(hmenu);
  82         return FALSE;
  83     }
  84
  85     DestroyMenu(hmenu);
  86     return TRUE;
  87 }
  88
  89 static LRESULT WINAPI menu_check_wnd_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
  90 {
  91     switch (msg)
  92     {
  93     case WM_ENTERMENULOOP:
  94         /* mark window as having entered menu loop */
  95         SetWindowLongPtr(hwnd, GWLP_USERDATA, TRUE);
  96         /* exit menu modal loop
  97          * ( A SendMessage does not work on NT3.51 here ) */
  98         return PostMessage(hwnd, WM_CANCELMODE, 0, 0);
  99     }
 100     return DefWindowProc(hwnd, msg, wparam, lparam);
 101 }
 102
 103 /* The MSVC headers ignore our NONAMELESSUNION requests so we have to define
 104  * our own type */
 105 typedef struct
 106 {
 107     DWORD type;
 108     union
 109     {
 110         MOUSEINPUT      mi;
 111         KEYBDINPUT      ki;
 112         HARDWAREINPUT   hi;
 113     } u;
 114 } TEST_INPUT;
 115
 116 /* globals to communicate between test and wndproc */
 117
 118 static BOOL bMenuVisible;
 119 static BOOL got_input;
 120 static HMENU hMenus[4];
 121
 122 #define MOD_SIZE 10
 123 #define MOD_NRMENUS 8
 124
 125  /* menu texts with their sizes */
 126 static struct {
 127     LPCSTR text;
 128     SIZE size; /* size of text up to any \t */
 129     SIZE sc_size; /* size of the short-cut */
 130 } MOD_txtsizes[] = {
 131         { "Pinot &Noir" },
 132         { "&Merlot\bF4" },
 133         { "Shira&z\tAlt+S" },
 134         { "" },
 135         { NULL }
 136 };
 137
 138 static unsigned int MOD_maxid;
 139 static RECT MOD_rc[MOD_NRMENUS];
 140 static int MOD_avec, MOD_hic;
 141 static int MOD_odheight;
 142 static SIZE MODsizes[MOD_NRMENUS]= { {MOD_SIZE, MOD_SIZE},{MOD_SIZE, MOD_SIZE},
 143     {MOD_SIZE, MOD_SIZE},{MOD_SIZE, MOD_SIZE}};
 144 static int MOD_GotDrawItemMsg = FALSE;
 145 static int  gflag_initmenupopup,
 146             gflag_entermenuloop,
 147             gflag_initmenu;
 148
 149 /* wndproc used by test_menu_ownerdraw() */
 150 static LRESULT WINAPI menu_ownerdraw_wnd_proc(HWND hwnd, UINT msg,
 151         WPARAM wparam, LPARAM lparam)
 152 {
 153     static HMENU hmenupopup;
 154     switch (msg)
 155     {
 156         case WM_INITMENUPOPUP:
 157             gflag_initmenupopup++;
 158             hmenupopup = (HMENU) wparam;
 159             break;
 160         case WM_ENTERMENULOOP:
 161             gflag_entermenuloop++;
 162             break;
 163         case WM_INITMENU:
 164             gflag_initmenu++;
 165             break;
 166         case WM_MEASUREITEM:
 167             {
 168                 MEASUREITEMSTRUCT* pmis = (MEASUREITEMSTRUCT*)lparam;
 169                 if( winetest_debug)
 170                     trace("WM_MEASUREITEM received data %lx size %dx%d\n",
 171                             pmis->itemData, pmis->itemWidth, pmis->itemHeight);
 172                 ok( !wparam, "wrong wparam %lx\n", wparam );
 173                 ok( pmis->CtlType == ODT_MENU, "wrong type %x\n", pmis->CtlType );
 174                 MOD_odheight = pmis->itemHeight;
 175                 pmis->itemWidth = MODsizes[pmis->itemData].cx;
 176                 pmis->itemHeight = MODsizes[pmis->itemData].cy;
 177                 return TRUE;
 178             }
 179         case WM_DRAWITEM:
 180             {
 181                 DRAWITEMSTRUCT * pdis;
 182                 TEXTMETRIC tm;
 183                 HPEN oldpen;
 184                 char chrs[]="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 185                 SIZE sz;
 186                 int i;
 187                 pdis = (DRAWITEMSTRUCT *) lparam;
 188                 if( winetest_debug) {
 189                     RECT rc;
 190                     GetMenuItemRect( hwnd, (HMENU)pdis->hwndItem, pdis->itemData ,&rc);
 191                     trace("WM_DRAWITEM received hwnd %p hmenu %p itemdata %ld item %d rc %d,%d-%d,%d itemrc:  %d,%d-%d,%d\n",
 192                             hwnd, pdis->hwndItem, pdis->itemData, pdis->itemID,
 193                             pdis->rcItem.left, pdis->rcItem.top,
 194                             pdis->rcItem.right,pdis->rcItem.bottom,
 195                             rc.left,rc.top,rc.right,rc.bottom);
 196                     oldpen=SelectObject( pdis->hDC, GetStockObject(
 197                                 pdis->itemState & ODS_SELECTED ? WHITE_PEN :BLACK_PEN));
 198                     Rectangle( pdis->hDC, pdis->rcItem.left,pdis->rcItem.top,
 199                             pdis->rcItem.right,pdis->rcItem.bottom );
 200                     SelectObject( pdis->hDC, oldpen);
 201                 }
 202                 ok( !wparam, "wrong wparam %lx\n", wparam );
 203                 ok( pdis->CtlType == ODT_MENU, "wrong type %x\n", pdis->CtlType );
 204                 /* calculate widths of some menu texts */
 205                 if( ! MOD_txtsizes[0].size.cx)
 206                     for(i = 0; MOD_txtsizes[i].text; i++) {
 207                         char buf[100], *p;
 208                         RECT rc={0,0,0,0};
 209                         strcpy( buf, MOD_txtsizes[i].text);
 210                         if( ( p = strchr( buf, '\t'))) {
 211                             *p = '\0';
 212                             DrawText( pdis->hDC, p + 1, -1, &rc,
 213                                     DT_SINGLELINE|DT_CALCRECT);
 214                             MOD_txtsizes[i].sc_size.cx= rc.right - rc.left;
 215                             MOD_txtsizes[i].sc_size.cy= rc.bottom - rc.top;
 216                         }
 217                         DrawText( pdis->hDC, buf, -1, &rc,
 218                                 DT_SINGLELINE|DT_CALCRECT);
 219                         MOD_txtsizes[i].size.cx= rc.right - rc.left;
 220                         MOD_txtsizes[i].size.cy= rc.bottom - rc.top;
 221                     }
 222
 223                 if( pdis->itemData > MOD_maxid) return TRUE;
 224                 /* store the rectangle */
 225                 MOD_rc[pdis->itemData] = pdis->rcItem;
 226                 /* calculate average character width */
 227                 GetTextExtentPoint( pdis->hDC, chrs, 52, &sz );
 228                 MOD_avec = (sz.cx + 26)/52;
 229                 GetTextMetrics( pdis->hDC, &tm);
 230                 MOD_hic = tm.tmHeight;
 231                 MOD_GotDrawItemMsg = TRUE;
 232                 return TRUE;
 233             }
 234         case WM_ENTERIDLE:
 235             {
 236                 ok( lparam || broken(!lparam), /* win9x, nt4 */
 237                     "Menu window handle is NULL!\n");
 238                 if( lparam) {
 239                     HMENU hmenu = (HMENU)SendMessageA( (HWND)lparam, MN_GETHMENU, 0, 0);
 240                     ok( hmenupopup == hmenu, "MN_GETHMENU returns %p expected %p\n",
 241                         hmenu, hmenupopup);
 242                 }
 243                 PostMessage(hwnd, WM_CANCELMODE, 0, 0);
 244                 return TRUE;
 245             }
 246
 247     }
 248     return DefWindowProc(hwnd, msg, wparam, lparam);
 249 }
 250
 251 static void register_menu_check_class(void)
 252 {
 253     WNDCLASS wc =
 254     {
 255         0,
 256         menu_check_wnd_proc,
 257         0,
 258         0,
 259         GetModuleHandle(NULL),
 260         NULL,
 261         LoadCursor(NULL, IDC_ARROW),
 262         (HBRUSH)(COLOR_BTNFACE+1),
 263         NULL,
 264         TEXT("WineMenuCheck"),
 265     };
 266
 267     atomMenuCheckClass = RegisterClass(&wc);
 268 }
 269
 270 /* demonstrates that windows locks the menu object so that it is still valid
 271  * even after a client calls DestroyMenu on it */
 272 static void test_menu_locked_by_window(void)
 273 {
 274     BOOL ret;
 275     HMENU hmenu;
 276     HWND hwnd = CreateWindowEx(0, MAKEINTATOM(atomMenuCheckClass), NULL,
 277                                WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
 278                                NULL, NULL, NULL, NULL);
 279     ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
 280     hmenu = CreateMenu();
 281     ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
 282     ret = InsertMenu(hmenu, 0, MF_STRING, 0, TEXT("&Test"));
 283     ok(ret, "InsertMenu failed with error %d\n", GetLastError());
 284     ret = SetMenu(hwnd, hmenu);
 285     ok(ret, "SetMenu failed with error %d\n", GetLastError());
 286     ret = DestroyMenu(hmenu);
 287     ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
 288
 289     ret = DrawMenuBar(hwnd);
 290     todo_wine {
 291     ok(ret, "DrawMenuBar failed with error %d\n", GetLastError());
 292     }
 293     ret = IsMenu(GetMenu(hwnd));
 294     ok(!ret || broken(ret) /* nt4 */, "Menu handle should have been destroyed\n");
 295
 296     SendMessage(hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
 297     /* did we process the WM_INITMENU message? */
 298     ret = GetWindowLongPtr(hwnd, GWLP_USERDATA);
 299     todo_wine {
 300     ok(ret, "WM_INITMENU should have been sent\n");
 301     }
 302
 303     DestroyWindow(hwnd);
 304 }
 305
 306 /* demonstrates that subpopup's are locked
 307  * even after a client calls DestroyMenu on it */
 308 static LRESULT WINAPI subpopuplocked_wnd_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 309 {
 310     HWND hwndmenu;
 311     switch (msg)
 312     {
 313     case WM_ENTERIDLE:
 314         hwndmenu = GetCapture();
 315         if( hwndmenu) {
 316             PostMessage( hwndmenu, WM_KEYDOWN, VK_DOWN, 0);
 317             PostMessage( hwndmenu, WM_KEYDOWN, VK_RIGHT, 0);
 318             PostMessage( hwndmenu, WM_KEYDOWN, VK_RETURN, 0);
 319         }
 320     }
 321     return DefWindowProc(hwnd, msg, wparam, lparam);
 322 }
 323
 324 static void test_subpopup_locked_by_menu(void)
 325 {
 326     DWORD gle;
 327     BOOL ret;
 328     HMENU hmenu, hsubmenu;
 329     MENUINFO mi = { sizeof( MENUINFO)};
 330     MENUITEMINFO mii = { sizeof( MENUITEMINFO)};
 331     HWND hwnd;
 332     const int itemid = 0x1234567;
 333     if( !pGetMenuInfo)
 334     {
 335         win_skip("GetMenuInfo is not available\n");
 336         return;
 337     }
 338     /* create window, popupmenu with one subpopup */
 339     hwnd = CreateWindowEx(0, MAKEINTATOM(atomMenuCheckClass), NULL,
 340             WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
 341             NULL, NULL, NULL, NULL);
 342     ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
 343     SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR) subpopuplocked_wnd_proc);
 344     hmenu = CreatePopupMenu();
 345     ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
 346     hsubmenu = CreatePopupMenu();
 347     ok(hsubmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
 348     ret = InsertMenu(hmenu, 0, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hsubmenu,
 349             TEXT("PopUpLockTest"));
 350     ok(ret, "InsertMenu failed with error %d\n", GetLastError());
 351     ret = InsertMenu(hsubmenu, 0, MF_BYPOSITION | MF_STRING, itemid, TEXT("PopUpMenu"));
 352     ok(ret, "InsertMenu failed with error %d\n", GetLastError());
 353     /* first some tests that all this functions properly */
 354     mii.fMask = MIIM_SUBMENU;
 355     ret = GetMenuItemInfo( hmenu, 0, TRUE, &mii);
 356     ok( ret, "GetMenuItemInfo failed error %d\n", GetLastError());
 357     ok( mii.hSubMenu == hsubmenu, "submenu is %p\n", mii.hSubMenu);
 358     mi.fMask |= MIM_STYLE;
 359     ret = pGetMenuInfo( hsubmenu, &mi);
 360     ok( ret , "GetMenuInfo returned 0 with error %d\n", GetLastError());
 361     ret = IsMenu( hsubmenu);
 362     ok( ret , "Menu handle is not valid\n");
 363     SetLastError( 0xdeadbeef);
 364     ret = TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
 365     if( ret == (itemid & 0xffff)) {
 366         win_skip("not on 16 bit menu subsystem\n");
 367         DestroyMenu( hsubmenu);
 368     } else {
 369         gle = GetLastError();
 370         ok( ret == itemid , "TrackPopupMenu returned %d error is %d\n", ret, gle);
 371         ok( gle == 0 ||
 372                 broken( gle == 0xdeadbeef), /* win2k0 */
 373                 "Last error is %d\n", gle);
 374         /* then destroy the sub-popup */
 375         ret = DestroyMenu( hsubmenu);
 376         ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
 377         /* and repeat the tests */
 378         mii.fMask = MIIM_SUBMENU;
 379         ret = GetMenuItemInfo( hmenu, 0, TRUE, &mii);
 380         ok( ret, "GetMenuItemInfo failed error %d\n", GetLastError());
 381         /* GetMenuInfo fails now */
 382         ok( mii.hSubMenu == hsubmenu, "submenu is %p\n", mii.hSubMenu);
 383         mi.fMask |= MIM_STYLE;
 384         ret = pGetMenuInfo( hsubmenu, &mi);
 385         ok( !ret , "GetMenuInfo should have failed\n");
 386         /* IsMenu says it is not */
 387         ret = IsMenu( hsubmenu);
 388         ok( !ret , "Menu handle should be invalid\n");
 389         /* but TrackPopupMenu still works! */
 390         SetLastError( 0xdeadbeef);
 391         ret = TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
 392         gle = GetLastError();
 393         todo_wine {
 394             ok( ret == itemid , "TrackPopupMenu returned %d error is %d\n", ret, gle);
 395         }
 396         ok( gle == 0 ||
 397             broken(gle == 0xdeadbeef) || /* wow64 */
 398             broken(gle == ERROR_INVALID_PARAMETER), /* win2k0 */
 399             "Last error is %d\n", gle);
 400     }
 401     /* clean up */
 402     DestroyMenu( hmenu);
 403     DestroyWindow(hwnd);
 404 }
 405
 406 static void test_menu_ownerdraw(void)
 407 {
 408     int i,j,k;
 409     BOOL ret;
 410     HMENU hmenu;
 411     MENUITEMINFO mii;
 412     LONG leftcol;
 413     HWND hwnd = CreateWindowEx(0, MAKEINTATOM(atomMenuCheckClass), NULL,
 414                                WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
 415                                NULL, NULL, NULL, NULL);
 416     ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
 417     if( !hwnd) return;
 418     SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_ownerdraw_wnd_proc);
 419     hmenu = CreatePopupMenu();
 420     ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
 421     if( !hmenu) { DestroyWindow(hwnd);return;}
 422     k=0;
 423     for( j=0;j<2;j++) /* create columns */
 424         for(i=0;i<2;i++) { /* create rows */
 425             ret = AppendMenu( hmenu, MF_OWNERDRAW |
 426                               (i==0 ? MF_MENUBREAK : 0), k, MAKEINTRESOURCE(k));
 427             k++;
 428             ok( ret, "AppendMenu failed for %d\n", k-1);
 429         }
 430     MOD_maxid = k-1;
 431     assert( k <= sizeof(MOD_rc)/sizeof(RECT));
 432     /* display the menu */
 433     TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
 434
 435     /* columns have a 4 pixel gap between them */
 436     ok( MOD_rc[0].right + 4 ==  MOD_rc[2].left,
 437             "item rectangles are not separated by 4 pixels space\n");
 438     /* height should be what the MEASUREITEM message has returned */
 439     ok( MOD_rc[0].bottom - MOD_rc[0].top == MOD_SIZE,
 440             "menu item has wrong height: %d should be %d\n",
 441             MOD_rc[0].bottom - MOD_rc[0].top, MOD_SIZE);
 442     /* no gaps between the rows */
 443     ok( MOD_rc[0].bottom - MOD_rc[1].top == 0,
 444             "There should not be a space between the rows, gap is %d\n",
 445             MOD_rc[0].bottom - MOD_rc[1].top);
 446     /* test the correct value of the item height that was sent
 447      * by the WM_MEASUREITEM message */
 448     ok( MOD_odheight == HIWORD( GetDialogBaseUnits()) || /* WinNT,2k,XP */
 449             MOD_odheight == MOD_hic,                     /* Win95,98,ME */
 450             "Wrong height field in MEASUREITEMSTRUCT, expected %d or %d actual %d\n",
 451             HIWORD( GetDialogBaseUnits()), MOD_hic, MOD_odheight);
 452     /* test what MF_MENUBREAK did at the first position. Also show
 453      * that an MF_SEPARATOR is ignored in the height calculation. */
 454     leftcol= MOD_rc[0].left;
 455     ModifyMenu( hmenu, 0, MF_BYCOMMAND| MF_OWNERDRAW| MF_SEPARATOR, 0, 0);
 456     /* display the menu */
 457     TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
 458     /* left should be 4 pixels less now */
 459     ok( leftcol == MOD_rc[0].left + 4,
 460             "columns should be 4 pixels to the left (actual %d).\n",
 461             leftcol - MOD_rc[0].left);
 462     /* test width */
 463     ok( MOD_rc[0].right - MOD_rc[0].left == 2 * MOD_avec + MOD_SIZE,
 464             "width of owner drawn menu item is wrong. Got %d expected %d\n",
 465             MOD_rc[0].right - MOD_rc[0].left , 2*MOD_avec + MOD_SIZE);
 466     /* and height */
 467     ok( MOD_rc[0].bottom - MOD_rc[0].top == MOD_SIZE,
 468             "Height is incorrect. Got %d expected %d\n",
 469             MOD_rc[0].bottom - MOD_rc[0].top, MOD_SIZE);
 470
 471     /* test owner-drawn callback bitmap */
 472     ModifyMenu( hmenu, 1, MF_BYPOSITION | MFT_BITMAP, 1, (LPCSTR)HBMMENU_CALLBACK );
 473     mii.cbSize = sizeof(mii);
 474     mii.fMask = MIIM_BITMAP | MIIM_FTYPE | MIIM_ID;
 475     if (GetMenuItemInfoA( hmenu, 1, TRUE, &mii ))
 476     {
 477         ok( mii.fType == MFT_BITMAP, "wrong type %x\n", mii.fType );
 478         ok( mii.wID == 1, "wrong id %x\n", mii.wID );
 479         ok( mii.hbmpItem == HBMMENU_CALLBACK, "wrong data %p\n", mii.hbmpItem );
 480     }
 481     TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
 482
 483     /* test width/height of an ownerdraw menu bar as well */
 484     ret = DestroyMenu(hmenu);
 485     ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
 486     hmenu = CreateMenu();
 487     ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
 488     if( !hmenu) { DestroyWindow(hwnd);return;}
 489     MOD_maxid=1;
 490     for(i=0;i<2;i++) {
 491         ret = AppendMenu( hmenu, MF_OWNERDRAW , i, 0);
 492         ok( ret, "AppendMenu failed for %d\n", i);
 493     }
 494     ret = SetMenu( hwnd, hmenu);
 495     UpdateWindow( hwnd); /* hack for wine to draw the window + menu */
 496     ok(ret, "SetMenu failed with error %d\n", GetLastError());
 497     /* test width */
 498     ok( MOD_rc[0].right - MOD_rc[0].left == 2 * MOD_avec + MOD_SIZE,
 499             "width of owner drawn menu item is wrong. Got %d expected %d\n",
 500             MOD_rc[0].right - MOD_rc[0].left , 2*MOD_avec + MOD_SIZE);
 501     /* test hight */
 502     ok( MOD_rc[0].bottom - MOD_rc[0].top == GetSystemMetrics( SM_CYMENU) - 1,
 503             "Height of owner drawn menu item is wrong. Got %d expected %d\n",
 504             MOD_rc[0].bottom - MOD_rc[0].top, GetSystemMetrics( SM_CYMENU) - 1);
 505
 506     /* clean up */
 507     ret = DestroyMenu(hmenu);
 508     ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
 509     DestroyWindow(hwnd);
 510 }
 511
 512 /* helper for test_menu_bmp_and_string() */
 513 static void test_mbs_help( int ispop, int hassub, int mnuopt,
 514         HWND hwnd, int arrowwidth, int count, HBITMAP hbmp,
 515         SIZE bmpsize, LPCSTR text, SIZE size, SIZE sc_size)
 516 {
 517     BOOL ret;
 518     HMENU hmenu, submenu;
 519     MENUITEMINFO mii={ sizeof( MENUITEMINFO )};
 520     MENUINFO mi;
 521     RECT rc;
 522     CHAR text_copy[16];
 523     int hastab,  expect;
 524     int failed = 0;
 525
 526     MOD_GotDrawItemMsg = FALSE;
 527     mii.fMask = MIIM_FTYPE | MIIM_DATA | MIIM_STATE;
 528     mii.fType = 0;
 529     /* check the menu item unless MNS_CHECKORBMP is set */
 530     mii.fState = (mnuopt != 2 ? MFS_CHECKED : MFS_UNCHECKED);
 531     mii.dwItemData =0;
 532     MODsizes[0] = bmpsize;
 533     hastab = 0;
 534     if( text ) {
 535         char *p;
 536         mii.fMask |= MIIM_STRING;
 537         strcpy(text_copy, text);
 538         mii.dwTypeData = text_copy; /* structure member declared non-const */
 539         if( ( p = strchr( text, '\t'))) {
 540             hastab = *(p + 1) ? 2 : 1;
 541         }
 542     }
 543     /* tabs don't make sense in menubars */
 544     if(hastab && !ispop) return;
 545     if( hbmp) {
 546         mii.fMask |= MIIM_BITMAP;
 547         mii.hbmpItem = hbmp;
 548     }
 549     submenu = CreateMenu();
 550     ok( submenu != 0, "CreateMenu failed with error %d\n", GetLastError());
 551     if( ispop)
 552         hmenu = CreatePopupMenu();
 553     else
 554         hmenu = CreateMenu();
 555     ok( hmenu != 0, "Create{Popup}Menu failed with error %d\n", GetLastError());
 556     if( hassub) {
 557         mii.fMask |= MIIM_SUBMENU;
 558         mii.hSubMenu = submenu;
 559     }
 560     if( mnuopt) {
 561         mi.cbSize = sizeof(mi);
 562         mi.fMask = MIM_STYLE;
 563         pGetMenuInfo( hmenu, &mi);
 564         if( mnuopt) mi.dwStyle |= mnuopt == 1 ? MNS_NOCHECK : MNS_CHECKORBMP;
 565         ret = pSetMenuInfo( hmenu, &mi);
 566         ok( ret, "SetMenuInfo failed with error %d\n", GetLastError());
 567     }
 568     ret = InsertMenuItem( hmenu, 0, FALSE, &mii);
 569     ok( ret, "InsertMenuItem failed with error %d\n", GetLastError());
 570     failed = !ret;
 571     if( winetest_debug) {
 572         HDC hdc=GetDC(hwnd);
 573         RECT rc = {100, 50, 400, 70};
 574         char buf[100];
 575
 576         sprintf( buf,"%d text \"%s\" mnuopt %d", count, text ? text: "(nil)", mnuopt);
 577         FillRect( hdc, &rc, (HBRUSH) COLOR_WINDOW);
 578         TextOut( hdc, 10, 50, buf, strlen( buf));
 579         ReleaseDC( hwnd, hdc);
 580     }
 581     if(ispop)
 582         TrackPopupMenu( hmenu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
 583     else {
 584         ret = SetMenu( hwnd, hmenu);
 585         ok(ret, "SetMenu failed with error %d\n", GetLastError());
 586         DrawMenuBar( hwnd);
 587     }
 588     ret = GetMenuItemRect( hwnd, hmenu, 0, &rc);
 589     ok(ret, "GetMenuItemRect failed with error %d\n", GetLastError());
 590
 591     if (0)  /* comment out menu size checks, behavior is different in almost every Windows version */
 592             /* the tests should however succeed on win2000, XP and Wine (at least up to 1.1.15) */
 593             /* with a variety of dpis and desktop font sizes */
 594     {
 595         /* check menu width */
 596         if( ispop)
 597             expect = ( text || hbmp ?
 598                        4 + (mnuopt != 1 ? GetSystemMetrics(SM_CXMENUCHECK) : 0)
 599                        : 0) +
 600                        arrowwidth  + MOD_avec + (hbmp ?
 601                                     ((INT_PTR)hbmp<0||(INT_PTR)hbmp>12 ? bmpsize.cx + 2 : GetSystemMetrics( SM_CXMENUSIZE) + 2)
 602                                     : 0) +
 603                 (text && hastab ? /* TAB space */
 604                  MOD_avec + ( hastab==2 ? sc_size.cx : 0) : 0) +
 605                 (text ?  2 + (text[0] ? size.cx :0): 0) ;
 606         else
 607             expect = !(text || hbmp) ? 0 :
 608                 ( hbmp ? (text ? 2:0) + bmpsize.cx  : 0 ) +
 609                 (text ? 2 * MOD_avec + (text[0] ? size.cx :0): 0) ;
 610         ok( rc.right - rc.left == expect,
 611             "menu width wrong, got %d expected %d\n", rc.right - rc.left, expect);
 612         failed = failed || !(rc.right - rc.left == expect);
 613         /* check menu height */
 614         if( ispop)
 615             expect = max( ( !(text || hbmp) ? GetSystemMetrics( SM_CYMENUSIZE)/2 : 0),
 616                           max( (text ? max( 2 + size.cy, MOD_hic + 4) : 0),
 617                                (hbmp ?
 618                                    ((INT_PTR)hbmp<0||(INT_PTR)hbmp>12 ?
 619                                        bmpsize.cy + 2
 620                                      : GetSystemMetrics( SM_CYMENUSIZE) + 2)
 621                                  : 0)));
 622         else
 623             expect = ( !(text || hbmp) ? GetSystemMetrics( SM_CYMENUSIZE)/2 :
 624                        max( GetSystemMetrics( SM_CYMENU) - 1, (hbmp ? bmpsize.cy : 0)));
 625         ok( rc.bottom - rc.top == expect,
 626             "menu height wrong, got %d expected %d (%d)\n",
 627             rc.bottom - rc.top, expect, GetSystemMetrics( SM_CYMENU));
 628         failed = failed || !(rc.bottom - rc.top == expect);
 629         if( hbmp == HBMMENU_CALLBACK && MOD_GotDrawItemMsg) {
 630             /* check the position of the bitmap */
 631             /* horizontal */
 632             if (!ispop)
 633                 expect = 3;
 634             else if (mnuopt == 0)
 635                 expect = 4 + GetSystemMetrics(SM_CXMENUCHECK);
 636             else if (mnuopt == 1)
 637                 expect = 4;
 638             else /* mnuopt == 2 */
 639                 expect = 2;
 640             ok( expect == MOD_rc[0].left,
 641                 "bitmap left is %d expected %d\n", MOD_rc[0].left, expect);
 642             failed = failed || !(expect == MOD_rc[0].left);
 643             /* vertical */
 644             expect = (rc.bottom - rc.top - MOD_rc[0].bottom + MOD_rc[0].top) / 2;
 645             ok( expect == MOD_rc[0].top,
 646                 "bitmap top is %d expected %d\n", MOD_rc[0].top, expect);
 647             failed = failed || !(expect == MOD_rc[0].top);
 648         }
 649     }
 650     /* if there was a failure, report details */
 651     if( failed) {
 652         trace("*** count %d %s text \"%s\" bitmap %p bmsize %d,%d textsize %d+%d,%d mnuopt %d hastab %d\n",
 653                 count, (ispop? "POPUP": "MENUBAR"),text ? text: "(nil)", hbmp, bmpsize.cx, bmpsize.cy,
 654                 size.cx, size.cy, sc_size.cx, mnuopt, hastab);
 655         trace("    check %d,%d arrow %d avechar %d\n",
 656                 GetSystemMetrics(SM_CXMENUCHECK ),
 657                 GetSystemMetrics(SM_CYMENUCHECK ),arrowwidth, MOD_avec);
 658         if( hbmp == HBMMENU_CALLBACK)
 659             trace( "    rc %d,%d-%d,%d bmp.rc %d,%d-%d,%d\n",
 660                 rc.left, rc.top, rc.top, rc.bottom, MOD_rc[0].left,
 661                 MOD_rc[0].top,MOD_rc[0].right, MOD_rc[0].bottom);
 662     }
 663     /* clean up */
 664     ret = DestroyMenu(submenu);
 665     ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
 666     ret = DestroyMenu(hmenu);
 667     ok(ret, "DestroyMenu failed with error %d\n", GetLastError());
 668 }
 669
 670
 671 static void test_menu_bmp_and_string(void)
 672 {
 673     BYTE bmfill[300];
 674     HBITMAP hbm_arrow;
 675     BITMAP bm;
 676     INT arrowwidth;
 677     HWND hwnd;
 678     HMENU hsysmenu;
 679     MENUINFO mi= {sizeof(MENUINFO)};
 680     MENUITEMINFOA mii= {sizeof(MENUITEMINFOA)};
 681     int count, szidx, txtidx, bmpidx, hassub, mnuopt, ispop;
 682     BOOL got;
 683
 684     if( !pGetMenuInfo)
 685     {
 686         win_skip("GetMenuInfo is not available\n");
 687         return;
 688     }
 689
 690     memset( bmfill, 0xcc, sizeof( bmfill));
 691     hwnd = CreateWindowEx(0, MAKEINTATOM(atomMenuCheckClass), NULL, WS_SYSMENU |
 692                           WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
 693                           NULL, NULL, NULL, NULL);
 694     hbm_arrow=LoadBitmap( 0, (CHAR*)OBM_MNARROW);
 695     GetObject( hbm_arrow, sizeof(bm), &bm);
 696     arrowwidth = bm.bmWidth;
 697     ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
 698     if( !hwnd) return;
 699     /* test system menu */
 700     hsysmenu = GetSystemMenu( hwnd, FALSE);
 701     ok( hsysmenu != NULL, "GetSystemMenu failed with error %d\n", GetLastError());
 702     mi.fMask = MIM_STYLE;
 703     mi.dwStyle = 0;
 704     got = pGetMenuInfo( hsysmenu, &mi);
 705     ok( got, "GetMenuInfo failed gle=%d\n", GetLastError());
 706     ok( MNS_CHECKORBMP == mi.dwStyle, "System Menu Style is %08x, without the bit %08x\n",
 707         mi.dwStyle, MNS_CHECKORBMP);
 708     mii.fMask = MIIM_BITMAP;
 709     mii.hbmpItem = NULL;
 710     got = GetMenuItemInfoA( hsysmenu, SC_CLOSE, FALSE, &mii);
 711     ok( got, "GetMenuItemInfoA failed gle=%d\n", GetLastError());
 712     ok( HBMMENU_POPUP_CLOSE == mii.hbmpItem, "Item info did not get the right hbitmap: got %p  expected %p\n",
 713         mii.hbmpItem, HBMMENU_POPUP_CLOSE);
 714
 715     SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_ownerdraw_wnd_proc);
 716
 717     if( winetest_debug)
 718         trace("    check %d,%d arrow %d avechar %d\n",
 719                 GetSystemMetrics(SM_CXMENUCHECK ),
 720                 GetSystemMetrics(SM_CYMENUCHECK ),arrowwidth, MOD_avec);
 721     count = 0;
 722     MOD_maxid = 0;
 723     for( ispop=1; ispop >= 0; ispop--){
 724         static SIZE bmsizes[]= {
 725             {10,10},{38,38},{1,30},{55,5}};
 726         for( szidx=0; szidx < sizeof( bmsizes) / sizeof( SIZE); szidx++) {
 727             HBITMAP hbm = CreateBitmap( bmsizes[szidx].cx, bmsizes[szidx].cy,1,1,bmfill);
 728             HBITMAP bitmaps[] = { HBMMENU_CALLBACK, hbm, HBMMENU_POPUP_CLOSE, NULL  };
 729             ok( hbm != 0, "CreateBitmap failed err %d\n", GetLastError());
 730             for( txtidx = 0; txtidx < sizeof(MOD_txtsizes)/sizeof(MOD_txtsizes[0]); txtidx++) {
 731                 for( hassub = 0; hassub < 2 ; hassub++) { /* add submenu item */
 732                     for( mnuopt = 0; mnuopt < 3 ; mnuopt++){ /* test MNS_NOCHECK/MNS_CHECKORBMP */
 733                         for( bmpidx = 0; bmpidx <sizeof(bitmaps)/sizeof(HBITMAP); bmpidx++) {
 734                             /* no need to test NULL bitmaps of several sizes */
 735                             if( !bitmaps[bmpidx] && szidx > 0) continue;
 736                             /* the HBMMENU_POPUP not to test for menu bars */
 737                             if( !ispop &&
 738                                 bitmaps[bmpidx] >= HBMMENU_POPUP_CLOSE &&
 739                                 bitmaps[bmpidx] <= HBMMENU_POPUP_MINIMIZE) continue;
 740                             if( !ispop && hassub) continue;
 741                             test_mbs_help( ispop, hassub, mnuopt,
 742                                     hwnd, arrowwidth, ++count,
 743                                     bitmaps[bmpidx],
 744                                     bmsizes[szidx],
 745                                     MOD_txtsizes[txtidx].text,
 746                                     MOD_txtsizes[txtidx].size,
 747                                     MOD_txtsizes[txtidx].sc_size);
 748                         }
 749                     }
 750                 }
 751             }
 752             DeleteObject( hbm);
 753         }
 754     }
 755     /* clean up */
 756     DestroyWindow(hwnd);
 757 }
 758
 759 static void test_menu_add_string( void )
 760 {
 761     HMENU hmenu;
 762     MENUITEMINFO info;
 763     BOOL rc;
 764     int ret;
 765
 766     char string[0x80];
 767     char string2[0x80];
 768
 769     char strback[0x80];
 770     WCHAR strbackW[0x80];
 771     static CHAR blah[] = "blah";
 772     static const WCHAR expectedString[] = {'D','u','m','m','y',' ','s','t','r','i','n','g', 0};
 773
 774     hmenu = CreateMenu();
 775
 776     memset( &info, 0, sizeof info );
 777     info.cbSize = sizeof info;
 778     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_ID;
 779     info.dwTypeData = blah;
 780     info.cch = 6;
 781     info.dwItemData = 0;
 782     info.wID = 1;
 783     info.fState = 0;
 784     InsertMenuItem(hmenu, 0, TRUE, &info );
 785
 786     memset( &info, 0, sizeof info );
 787     info.cbSize = sizeof info;
 788     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_STATE | MIIM_DATA | MIIM_ID;
 789     info.dwTypeData = string;
 790     info.cch = sizeof string;
 791     string[0] = 0;
 792     GetMenuItemInfo( hmenu, 0, TRUE, &info );
 793
 794     ok( !strcmp( string, "blah" ), "menu item name differed\n");
 795
 796     /* Test combination of ownerdraw and strings with GetMenuItemString(A/W) */
 797     strcpy(string, "Dummy string");
 798     memset(&info, 0x00, sizeof(info));
 799     info.cbSize= sizeof(MENUITEMINFO);
 800     info.fMask= MIIM_FTYPE | MIIM_STRING; /* Set OwnerDraw + typeData */
 801     info.fType= MFT_OWNERDRAW;
 802     info.dwTypeData= string;
 803     rc = InsertMenuItem( hmenu, 0, TRUE, &info );
 804     ok (rc, "InsertMenuItem failed\n");
 805
 806     strcpy(string,"Garbage");
 807     ok (GetMenuString( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
 808     ok (!strcmp( strback, "Dummy string" ), "Menu text from Ansi version incorrect\n");
 809
 810     SetLastError(0xdeadbeef);
 811     ret = GetMenuStringW( hmenu, 0, strbackW, 99, MF_BYPOSITION );
 812     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 813         win_skip("GetMenuStringW is not implemented\n");
 814     else
 815     {
 816         ok (ret, "GetMenuStringW on ownerdraw entry failed\n");
 817         ok (!lstrcmpW( strbackW, expectedString ), "Menu text from Unicode version incorrect\n");
 818     }
 819
 820     /* Just change ftype to string and see what text is stored */
 821     memset(&info, 0x00, sizeof(info));
 822     info.cbSize= sizeof(MENUITEMINFO);
 823     info.fMask= MIIM_FTYPE; /* Set string type */
 824     info.fType= MFT_STRING;
 825     info.dwTypeData= (char *)0xdeadbeef;
 826     rc = SetMenuItemInfo( hmenu, 0, TRUE, &info );
 827     ok (rc, "SetMenuItemInfo failed\n");
 828
 829     /* Did we keep the old dwTypeData? */
 830     ok (GetMenuString( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
 831     ok (!strcmp( strback, "Dummy string" ), "Menu text from Ansi version incorrect\n");
 832
 833     /* Ensure change to bitmap type fails */
 834     memset(&info, 0x00, sizeof(info));
 835     info.cbSize= sizeof(MENUITEMINFO);
 836     info.fMask= MIIM_FTYPE; /* Set as bitmap type */
 837     info.fType= MFT_BITMAP;
 838     info.dwTypeData= (char *)0xdeadbee2;
 839     rc = SetMenuItemInfo( hmenu, 0, TRUE, &info );
 840     ok (!rc, "SetMenuItemInfo unexpectedly worked\n");
 841
 842     /* Just change ftype back and ensure data hasn't been freed */
 843     info.fType= MFT_OWNERDRAW; /* Set as ownerdraw type */
 844     info.dwTypeData= (char *)0xdeadbee3;
 845     rc = SetMenuItemInfo( hmenu, 0, TRUE, &info );
 846     ok (rc, "SetMenuItemInfo failed\n");
 847
 848     /* Did we keep the old dwTypeData? */
 849     ok (GetMenuString( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
 850     ok (!strcmp( strback, "Dummy string" ), "Menu text from Ansi version incorrect\n");
 851
 852     /* Just change string value (not type) */
 853     memset(&info, 0x00, sizeof(info));
 854     info.cbSize= sizeof(MENUITEMINFO);
 855     info.fMask= MIIM_STRING; /* Set typeData */
 856     strcpy(string2, "string2");
 857     info.dwTypeData= string2;
 858     rc = SetMenuItemInfo( hmenu, 0, TRUE, &info );
 859     ok (rc, "SetMenuItemInfo failed\n");
 860
 861     ok (GetMenuString( hmenu, 0, strback, 99, MF_BYPOSITION), "GetMenuString on ownerdraw entry failed\n");
 862     ok (!strcmp( strback, "string2" ), "Menu text from Ansi version incorrect\n");
 863
 864     /*  crashes with wine 0.9.5 */
 865     memset(&info, 0x00, sizeof(info));
 866     info.cbSize= sizeof(MENUITEMINFO);
 867     info.fMask= MIIM_FTYPE | MIIM_STRING; /* Set OwnerDraw + typeData */
 868     info.fType= MFT_OWNERDRAW;
 869     rc = InsertMenuItem( hmenu, 0, TRUE, &info );
 870     ok (rc, "InsertMenuItem failed\n");
 871     ok (!GetMenuString( hmenu, 0, NULL, 0, MF_BYPOSITION),
 872             "GetMenuString on ownerdraw entry succeeded.\n");
 873     SetLastError(0xdeadbeef);
 874     ret = GetMenuStringW( hmenu, 0, NULL, 0, MF_BYPOSITION);
 875     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 876         win_skip("GetMenuStringW is not implemented\n");
 877     else
 878         ok (!ret, "GetMenuStringW on ownerdraw entry succeeded.\n");
 879
 880     DestroyMenu( hmenu );
 881 }
 882
 883 /* define building blocks for the menu item info tests */
 884 static int strncmpW( const WCHAR *str1, const WCHAR *str2, int n )
 885 {
 886     if (n <= 0) return 0;
 887     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 888     return *str1 - *str2;
 889 }
 890
 891 static  WCHAR *strcpyW( WCHAR *dst, const WCHAR *src )
 892 {
 893     WCHAR *p = dst;
 894     while ((*p++ = *src++));
 895     return dst;
 896 }
 897
 898 static void insert_menu_item( int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state, UINT id,
 899                               HMENU submenu, HBITMAP checked, HBITMAP unchecked, ULONG_PTR data,
 900                               void *type_data, UINT len, HBITMAP item, BOOL expect )
 901 {
 902     MENUITEMINFOA info;
 903     BOOL ret;
 904
 905     /* magic bitmap handle to test smaller cbSize */
 906     if (item == (HBITMAP)(ULONG_PTR)0xdeadbeef)
 907         info.cbSize = FIELD_OFFSET(MENUITEMINFOA,hbmpItem);
 908     else
 909         info.cbSize = sizeof(info);
 910     info.fMask = mask;
 911     info.fType = type;
 912     info.fState = state;
 913     info.wID = id;
 914     info.hSubMenu = submenu;
 915     info.hbmpChecked = checked;
 916     info.hbmpUnchecked = unchecked;
 917     info.dwItemData = data;
 918     info.dwTypeData = type_data;
 919     info.cch = len;
 920     info.hbmpItem = item;
 921     SetLastError( 0xdeadbeef );
 922     if (ansi) ret = InsertMenuItemA( hmenu, 0, TRUE, &info );
 923     else ret = InsertMenuItemW( hmenu, 0, TRUE, (MENUITEMINFOW*)&info );
 924     if (!expect) ok_(__FILE__, line)( !ret, "InsertMenuItem should have failed.\n" );
 925     else ok_(__FILE__, line)( ret, "InsertMenuItem failed, err %u\n", GetLastError());
 926 }
 927
 928 static void check_menu_item_info( int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state,
 929                                   UINT id, HMENU submenu, HBITMAP checked, HBITMAP unchecked,
 930                                   ULONG_PTR data, void *type_data, UINT in_len, UINT out_len,
 931                                   HBITMAP item, LPCSTR expname, BOOL expect, BOOL expstring )
 932 {
 933     MENUITEMINFOA info;
 934     BOOL ret;
 935     WCHAR buffer[80];
 936
 937     SetLastError( 0xdeadbeef );
 938     memset( &info, 0xcc, sizeof(info) );
 939     info.cbSize = sizeof(info);
 940     info.fMask = mask;
 941     info.dwTypeData = type_data;
 942     info.cch = in_len;
 943
 944     ret = ansi ? GetMenuItemInfoA( hmenu, 0, TRUE, &info ) :
 945                  GetMenuItemInfoW( hmenu, 0, TRUE, (MENUITEMINFOW *)&info );
 946     if (!expect)
 947     {
 948         ok_(__FILE__, line)( !ret, "GetMenuItemInfo should have failed.\n" );
 949         return;
 950     }
 951     ok_(__FILE__, line)( ret, "GetMenuItemInfo failed, err %u\n", GetLastError());
 952     if (mask & MIIM_TYPE)
 953         ok_(__FILE__, line)( info.fType == type || info.fType == LOWORD(type),
 954                              "wrong type %x/%x\n", info.fType, type );
 955     if (mask & MIIM_STATE)
 956         ok_(__FILE__, line)( info.fState == state || info.fState == LOWORD(state),
 957                              "wrong state %x/%x\n", info.fState, state );
 958     if (mask & MIIM_ID)
 959         ok_(__FILE__, line)( info.wID == id || info.wID == LOWORD(id),
 960                              "wrong id %x/%x\n", info.wID, id );
 961     if (mask & MIIM_SUBMENU)
 962         ok_(__FILE__, line)( info.hSubMenu == submenu || (ULONG_PTR)info.hSubMenu == LOWORD(submenu),
 963                              "wrong submenu %p/%p\n", info.hSubMenu, submenu );
 964     if (mask & MIIM_CHECKMARKS)
 965     {
 966         ok_(__FILE__, line)( info.hbmpChecked == checked || (ULONG_PTR)info.hbmpChecked == LOWORD(checked),
 967                              "wrong bmpchecked %p/%p\n", info.hbmpChecked, checked );
 968         ok_(__FILE__, line)( info.hbmpUnchecked == unchecked || (ULONG_PTR)info.hbmpUnchecked == LOWORD(unchecked),
 969                              "wrong bmpunchecked %p/%p\n", info.hbmpUnchecked, unchecked );
 970     }
 971     if (mask & MIIM_DATA)
 972         ok_(__FILE__, line)( info.dwItemData == data || info.dwItemData == LOWORD(data),
 973                              "wrong item data %lx/%lx\n", info.dwItemData, data );
 974     if (mask & MIIM_BITMAP)
 975         ok_(__FILE__, line)( info.hbmpItem == item || (ULONG_PTR)info.hbmpItem == LOWORD(item),
 976                              "wrong bmpitem %p/%p\n", info.hbmpItem, item );
 977     ok_(__FILE__, line)( info.dwTypeData == type_data || (ULONG_PTR)info.dwTypeData == LOWORD(type_data),
 978                          "wrong type data %p/%p\n", info.dwTypeData, type_data );
 979     ok_(__FILE__, line)( info.cch == out_len ||
 980                          broken(! ansi && info.cch == 2 * out_len) /* East-Asian */,
 981                          "wrong len %x/%x\n", info.cch, out_len );
 982     if (expname)
 983     {
 984         if(ansi)
 985             ok_(__FILE__, line)( !strncmp( expname, info.dwTypeData, out_len ),
 986                                  "menu item name differed from '%s' '%s'\n", expname, info.dwTypeData );
 987         else
 988             ok_(__FILE__, line)( !strncmpW( (WCHAR *)expname, (WCHAR *)info.dwTypeData, out_len ),
 989                                  "menu item name wrong\n" );
 990
 991         SetLastError( 0xdeadbeef );
 992         ret = ansi ? GetMenuStringA( hmenu, 0, (char *)buffer, 80, MF_BYPOSITION ) :
 993             GetMenuStringW( hmenu, 0, buffer, 80, MF_BYPOSITION );
 994         if (expstring)
 995             ok_(__FILE__, line)( ret, "GetMenuString failed, err %u\n", GetLastError());
 996         else
 997             ok_(__FILE__, line)( !ret, "GetMenuString should have failed\n" );
 998     }
 999 }
1000
1001 static void modify_menu( int line, HMENU hmenu, BOOL ansi, UINT flags, UINT_PTR id, void *data )
1002 {
1003     BOOL ret;
1004
1005     SetLastError( 0xdeadbeef );
1006     if (ansi) ret = ModifyMenuA( hmenu, 0, flags, id, data );
1007     else ret = ModifyMenuW( hmenu, 0, flags, id, data );
1008     ok_(__FILE__,line)( ret, "ModifyMenuA failed, err %u\n", GetLastError());
1009 }
1010
1011 static void set_menu_item_info( int line, HMENU hmenu, BOOL ansi, UINT mask, UINT type, UINT state,
1012                                 UINT id, HMENU submenu, HBITMAP checked, HBITMAP unchecked, ULONG_PTR data,
1013                                 void *type_data, UINT len, HBITMAP item )
1014
1015 {
1016     MENUITEMINFOA info;
1017     BOOL ret;
1018
1019     /* magic bitmap handle to test smaller cbSize */
1020     if (item == (HBITMAP)(ULONG_PTR)0xdeadbeef)
1021         info.cbSize = FIELD_OFFSET(MENUITEMINFOA,hbmpItem);
1022     else
1023         info.cbSize = sizeof(info);
1024     info.fMask = mask;
1025     info.fType = type;
1026     info.fState = state;
1027     info.wID = id;
1028     info.hSubMenu = submenu;
1029     info.hbmpChecked = checked;
1030     info.hbmpUnchecked = unchecked;
1031     info.dwItemData = data;
1032     info.dwTypeData = type_data;
1033     info.cch = len;
1034     info.hbmpItem = item;
1035     SetLastError( 0xdeadbeef );
1036     if (ansi) ret = SetMenuItemInfoA( hmenu, 0, TRUE, &info );
1037     else ret = SetMenuItemInfoW( hmenu, 0, TRUE, (MENUITEMINFOW*)&info );
1038     ok_(__FILE__, line)( ret, "SetMenuItemInfo failed, err %u\n", GetLastError());
1039 }
1040
1041 #define TMII_INSMI( c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,eret1 )\
1042     hmenu = CreateMenu();\
1043     submenu = CreateMenu();\
1044     if(ansi)strcpy( string, init );\
1045     else strcpyW( string, init );\
1046     insert_menu_item( __LINE__, hmenu, ansi, c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1, eret1 )
1047
1048 /* GetMenuItemInfo + GetMenuString  */
1049 #define TMII_GMII( c2,l2,\
1050     d3,e3,f3,g3,h3,i3,j3,k3,l3,m3,\
1051     expname, eret2, eret3)\
1052     check_menu_item_info( __LINE__, hmenu, ansi, c2, d3, e3, f3, g3, h3, i3, j3, k3, l2, l3, m3, \
1053                           expname, eret2, eret3 )
1054
1055 #define TMII_DONE \
1056     RemoveMenu(hmenu, 0, TRUE );\
1057     DestroyMenu( hmenu );\
1058     DestroyMenu( submenu );
1059
1060 /* modify menu */
1061 #define TMII_MODM( flags, id, data ) \
1062     modify_menu( __LINE__, hmenu, ansi, flags, id, data )
1063
1064 /* SetMenuItemInfo */
1065 #define TMII_SMII( c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1 ) \
1066     set_menu_item_info( __LINE__, hmenu, ansi, c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1 )
1067
1068
1069 #define OK 1
1070 #define ER 0
1071
1072
1073 static void test_menu_iteminfo( void )
1074 {
1075   int ansi = TRUE;
1076   char txtA[]="wine";
1077   char initA[]="XYZ";
1078   char emptyA[]="";
1079   WCHAR txtW[]={'W','i','n','e',0};
1080   WCHAR initW[]={'X','Y','Z',0};
1081   WCHAR emptyW[]={0};
1082   void *txt, *init, *empty, *string;
1083   HBITMAP hbm = CreateBitmap(1,1,1,1,NULL);
1084   char stringA[0x80];
1085   HMENU hmenu, submenu;
1086   HBITMAP dummy_hbm = (HBITMAP)(ULONG_PTR)0xdeadbeef;
1087
1088   do {
1089     if( ansi) {txt=txtA;init=initA;empty=emptyA;string=stringA;}
1090     else {txt=txtW;init=initW;empty=emptyW;string=stringA;}
1091     trace( "%s string %p hbm %p txt %p\n", ansi ?  "ANSI tests:   " : "Unicode tests:", string, hbm, txt);
1092     /* test all combinations of MFT_STRING, MFT_OWNERDRAW and MFT_BITMAP */
1093     /* (since MFT_STRING is zero, there are four of them) */
1094     TMII_INSMI( MIIM_TYPE, MFT_STRING, 0, 0, 0, 0, 0, 0, txt, 0, 0, OK );
1095     TMII_GMII ( MIIM_TYPE, 80,
1096         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1097         txt, OK, OK );
1098     TMII_DONE
1099     TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1100     TMII_GMII ( MIIM_TYPE, 80,
1101         MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1102         NULL, OK, ER );
1103     TMII_DONE
1104     TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, 6, 0, OK );
1105     TMII_GMII ( MIIM_TYPE, 80,
1106         MFT_BITMAP, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1107         NULL, OK, ER );
1108     TMII_DONE
1109     TMII_INSMI( MIIM_TYPE, MFT_BITMAP|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, hbm, 6, 0, OK );
1110     TMII_GMII ( MIIM_TYPE, 80,
1111         MFT_BITMAP|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1112         NULL, OK, ER );
1113     TMII_DONE
1114     /* not enough space for name*/
1115     TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1116     TMII_GMII ( MIIM_TYPE, 0,
1117         MFT_STRING, 0, 0, 0, 0, 0, 0, NULL, 4, 0,
1118         NULL, OK, OK );
1119     TMII_DONE
1120     TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1121     TMII_GMII ( MIIM_TYPE, 5,
1122         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1123         txt, OK, OK );
1124     TMII_DONE
1125     TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1126     TMII_GMII ( MIIM_TYPE, 4,
1127         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 3, 0,
1128         txt, OK, OK );
1129     TMII_DONE
1130     TMII_INSMI( MIIM_FTYPE|MIIM_STRING, MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1131     TMII_GMII ( MIIM_TYPE, 0,
1132         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 0, 0,
1133         NULL, OK, ER );
1134     TMII_DONE
1135     /* cannot combine MIIM_TYPE with some other flags */
1136     TMII_INSMI( MIIM_TYPE|MIIM_STRING, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, ER );
1137     TMII_DONE
1138     TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1139     TMII_GMII ( MIIM_TYPE|MIIM_STRING, 80,
1140         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1141         NULL, ER, OK );
1142     TMII_DONE
1143     TMII_INSMI( MIIM_TYPE|MIIM_FTYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, ER );
1144     TMII_DONE
1145     TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1146     TMII_GMII ( MIIM_TYPE|MIIM_FTYPE, 80,
1147         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1148         NULL, ER, OK );
1149     TMII_DONE
1150     TMII_INSMI( MIIM_TYPE|MIIM_BITMAP, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, 6, hbm, ER );
1151     TMII_DONE
1152         /* but succeeds with some others */
1153     TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1154     TMII_GMII ( MIIM_TYPE|MIIM_SUBMENU, 80,
1155         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1156         txt, OK, OK );
1157     TMII_DONE
1158     TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1159     TMII_GMII ( MIIM_TYPE|MIIM_STATE, 80,
1160         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1161         txt, OK, OK );
1162     TMII_DONE
1163     TMII_INSMI( MIIM_TYPE|MIIM_ID, MFT_STRING, -1, 888, 0, 0, 0, -1, txt, 6, 0, OK );
1164     TMII_GMII ( MIIM_TYPE|MIIM_ID, 80,
1165         MFT_STRING, 0, 888, 0, 0, 0, 0, string, 4, 0,
1166         txt, OK, OK );
1167     TMII_DONE
1168     TMII_INSMI( MIIM_TYPE|MIIM_DATA, MFT_STRING, -1, -1, 0, 0, 0, 999, txt, 6, 0, OK );
1169     TMII_GMII ( MIIM_TYPE|MIIM_DATA, 80,
1170         MFT_STRING, 0, 0, 0, 0, 0, 999, string, 4, 0,
1171         txt, OK, OK );
1172     TMII_DONE
1173     /* to be continued */
1174     /* set text with MIIM_TYPE and retrieve with MIIM_STRING */
1175     TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1176     TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1177         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1178         txt, OK, OK );
1179     TMII_DONE
1180     /* set text with MIIM_TYPE and retrieve with MIIM_STRING; MFT_OWNERDRAW causes an empty string */
1181     TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1182     TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1183         MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 0, 0,
1184         empty, OK, ER );
1185     TMII_DONE
1186     TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1187     TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1188         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 0, 0,
1189         empty, OK, ER );
1190     TMII_DONE
1191     TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1192     TMII_GMII ( MIIM_FTYPE, 80,
1193         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 80, 0,
1194         init, OK, ER );
1195     TMII_DONE
1196     TMII_INSMI( MIIM_TYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1197     TMII_GMII ( 0, 80,
1198         0, 0, 0, 0, 0, 0, 0, string, 80, 0,
1199         init, OK, OK );
1200     TMII_DONE
1201     /* contrary to MIIM_TYPE,you can set the text for an owner draw menu */
1202     TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1203     TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1204         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 4, 0,
1205         txt, OK, OK );
1206     TMII_DONE
1207     /* same but retrieve with MIIM_TYPE */
1208     TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1209     TMII_GMII ( MIIM_TYPE, 80,
1210         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1211         NULL, OK, OK );
1212     TMII_DONE
1213     TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1214     TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1215         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 0, 0,
1216         empty, OK, ER );
1217     TMII_DONE
1218     TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1219     TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1220         MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 0, 0,
1221         empty, OK, ER );
1222     TMII_DONE
1223
1224     /* How is that with bitmaps? */
1225     TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1226     TMII_GMII ( MIIM_TYPE, 80,
1227         MFT_BITMAP, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1228         NULL, OK, ER );
1229     TMII_DONE
1230     TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1231     TMII_GMII ( MIIM_BITMAP|MIIM_FTYPE, 80,
1232         0, 0, 0, 0, 0, 0, 0, string, 80, hbm,
1233         init, OK, ER );
1234     TMII_DONE
1235         /* MIIM_BITMAP does not like MFT_BITMAP */
1236     TMII_INSMI( MIIM_BITMAP|MIIM_FTYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, 0, -1, hbm, ER );
1237     TMII_DONE
1238         /* no problem with OWNERDRAWN */
1239     TMII_INSMI( MIIM_BITMAP|MIIM_FTYPE, MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1240     TMII_GMII ( MIIM_BITMAP|MIIM_FTYPE, 80,
1241         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 80, hbm,
1242         init, OK, ER );
1243     TMII_DONE
1244         /* setting MFT_BITMAP with MFT_FTYPE fails anyway */
1245     TMII_INSMI( MIIM_FTYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, 0, -1, 0, ER );
1246     TMII_DONE
1247
1248     /* menu with submenu */
1249     TMII_INSMI( MIIM_SUBMENU|MIIM_FTYPE, MFT_STRING, -1, -1, submenu, 0, 0, -1, txt, 0, 0, OK );
1250     TMII_GMII ( MIIM_SUBMENU, 80,
1251         0, 0, 0, submenu, 0, 0, 0, string, 80, 0,
1252         init, OK, ER );
1253     TMII_DONE
1254     TMII_INSMI( MIIM_SUBMENU|MIIM_FTYPE, MFT_STRING, -1, -1, submenu, 0, 0, -1, empty, 0, 0, OK );
1255     TMII_GMII ( MIIM_SUBMENU, 80,
1256         0, 0, 0, submenu, 0, 0, 0, string, 80, 0,
1257         init, OK, ER );
1258     TMII_DONE
1259     /* menu with submenu, without MIIM_SUBMENU the submenufield is cleared */
1260     TMII_INSMI( MIIM_SUBMENU|MIIM_FTYPE, MFT_STRING, -1, -1, submenu, 0, 0, -1, txt, 0, 0, OK );
1261     TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1262         MFT_STRING|MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 0, 0,
1263         empty, OK, ER );
1264     TMII_GMII ( MIIM_SUBMENU|MIIM_FTYPE, 80,
1265         MFT_SEPARATOR, 0, 0, submenu, 0, 0, 0, string, 80, 0,
1266         empty, OK, ER );
1267     TMII_DONE
1268     /* menu with invalid submenu */
1269     TMII_INSMI( MIIM_SUBMENU|MIIM_FTYPE, MFT_STRING, -1, -1, (HMENU)999, 0, 0, -1, txt, 0, 0, ER );
1270     TMII_DONE
1271     /* Separator */
1272     TMII_INSMI( MIIM_TYPE, MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, txt, 0, 0, OK );
1273     TMII_GMII ( MIIM_TYPE, 80,
1274         MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1275         NULL, OK, ER );
1276     TMII_DONE
1277     TMII_INSMI( MIIM_TYPE, MFT_BITMAP|MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, hbm, 6, 0, OK );
1278     TMII_GMII ( MIIM_TYPE, 80,
1279         MFT_BITMAP|MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1280         NULL, OK, ER );
1281     TMII_DONE
1282      /* SEPARATOR and STRING go well together */
1283     /* BITMAP and STRING go well together */
1284     TMII_INSMI( MIIM_STRING|MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1285     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, 80,
1286         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, hbm,
1287         txt, OK, OK );
1288     TMII_DONE
1289      /* BITMAP, SEPARATOR and STRING go well together */
1290     TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1291     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, 80,
1292         MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 4, hbm,
1293         txt, OK, OK );
1294     TMII_DONE
1295      /* last two tests, but use MIIM_TYPE to retrieve info */
1296     TMII_INSMI( MIIM_FTYPE|MIIM_STRING, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1297     TMII_GMII ( MIIM_TYPE, 80,
1298         MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1299         NULL, OK, OK );
1300     TMII_DONE
1301     TMII_INSMI( MIIM_STRING|MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1302     TMII_GMII ( MIIM_TYPE, 80,
1303         MFT_BITMAP, 0, 0, 0, 0, 0, 0, hbm, 4, hbm,
1304         NULL, OK, OK );
1305     TMII_DONE
1306     TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1307     TMII_GMII ( MIIM_TYPE, 80,
1308         MFT_SEPARATOR|MFT_BITMAP, 0, 0, 0, 0, 0, 0, hbm, 4, hbm,
1309         NULL, OK, OK );
1310     TMII_DONE
1311      /* same three with MFT_OWNERDRAW */
1312     TMII_INSMI( MIIM_FTYPE|MIIM_STRING, MFT_SEPARATOR|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, 0, OK );
1313     TMII_GMII ( MIIM_TYPE, 80,
1314         MFT_SEPARATOR|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1315         NULL, OK, OK );
1316     TMII_DONE
1317     TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1318     TMII_GMII ( MIIM_TYPE, 80,
1319         MFT_BITMAP|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 4, hbm,
1320         NULL, OK, OK );
1321     TMII_DONE
1322     TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1323     TMII_GMII ( MIIM_TYPE, 80,
1324         MFT_SEPARATOR|MFT_BITMAP|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 4, hbm,
1325         NULL, OK, OK );
1326     TMII_DONE
1327
1328     TMII_INSMI( MIIM_STRING|MIIM_FTYPE|MIIM_ID, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1329     TMII_GMII ( MIIM_TYPE, 80,
1330         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1331         NULL,  OK, OK );
1332     TMII_DONE
1333     /* test with modifymenu: string is preserved after setting OWNERDRAW */
1334     TMII_INSMI( MIIM_STRING, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1335     TMII_MODM( MFT_OWNERDRAW, -1, (void*)787 );
1336     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_DATA, 80,
1337         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 787, string, 4, 0,
1338         txt,  OK, OK );
1339     TMII_DONE
1340     /* same with bitmap: now the text is cleared */
1341     TMII_INSMI( MIIM_STRING, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1342     TMII_MODM( MFT_BITMAP, 545, hbm );
1343     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1344         MFT_BITMAP, 0, 545, 0, 0, 0, 0, string, 0, hbm,
1345         empty,  OK, ER );
1346     TMII_DONE
1347     /* start with bitmap: now setting text clears it (though he flag is raised) */
1348     TMII_INSMI( MIIM_BITMAP, MFT_STRING, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1349     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1350         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 0, hbm,
1351         empty,  OK, ER );
1352     TMII_MODM( MFT_STRING, 545, txt );
1353     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1354         MFT_STRING, 0, 545, 0, 0, 0, 0, string, 4, 0,
1355         txt,  OK, OK );
1356     TMII_DONE
1357     /*repeat with text NULL */
1358     TMII_INSMI( MIIM_BITMAP, MFT_STRING, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1359     TMII_MODM( MFT_STRING, 545, NULL );
1360     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1361         MFT_SEPARATOR, 0, 545, 0, 0, 0, 0, string, 0, 0,
1362         empty,  OK, ER );
1363     TMII_DONE
1364     /* repeat with text "" */
1365     TMII_INSMI( MIIM_BITMAP, -1 , -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1366     TMII_MODM( MFT_STRING, 545, empty );
1367     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_ID, 80,
1368         MFT_STRING, 0, 545, 0, 0, 0, 0, string, 0, 0,
1369         empty,  OK, ER );
1370     TMII_DONE
1371     /* start with bitmap: set ownerdraw */
1372     TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, hbm, OK );
1373     TMII_MODM( MFT_OWNERDRAW, -1, (void *)232 );
1374     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP|MIIM_DATA, 80,
1375         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 232, string, 0, hbm,
1376         empty,  OK, ER );
1377     TMII_DONE
1378     /* ask nothing */
1379     TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, hbm, OK );
1380     TMII_GMII ( 0, 80,
1381                 0, 0, 0,  0, 0, 0, 0, string, 80, 0,
1382         init, OK, OK );
1383     TMII_DONE
1384     /* some tests with small cbSize: the hbmpItem is to be ignored */
1385     TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, dummy_hbm, OK );
1386     TMII_GMII ( MIIM_TYPE, 80,
1387         MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, NULL, 0, NULL,
1388         NULL, OK, ER );
1389     TMII_DONE
1390     TMII_INSMI( MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, 0, -1, dummy_hbm, OK );
1391     TMII_GMII ( MIIM_BITMAP|MIIM_FTYPE, 80,
1392         MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 80, NULL,
1393         init, OK, ER );
1394     TMII_DONE
1395     TMII_INSMI( MIIM_STRING|MIIM_BITMAP, -1, -1, -1, 0, 0, 0, -1, txt, 6, dummy_hbm, OK );
1396     TMII_GMII ( MIIM_TYPE, 80,
1397         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, NULL,
1398         txt, OK, OK );
1399     TMII_DONE
1400     TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR, -1, -1, 0, 0, 0, -1, txt, 6, dummy_hbm, OK );
1401     TMII_GMII ( MIIM_TYPE, 80,
1402         MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1403         NULL, OK, OK );
1404     TMII_DONE
1405     TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, dummy_hbm, OK );
1406     TMII_GMII ( MIIM_TYPE, 80,
1407         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1408         NULL, OK, OK );
1409     TMII_DONE
1410     TMII_INSMI( MIIM_FTYPE|MIIM_STRING|MIIM_BITMAP, MFT_SEPARATOR|MFT_OWNERDRAW, -1, -1, 0, 0, 0, -1, txt, 6, dummy_hbm, OK );
1411     TMII_GMII ( MIIM_TYPE, 80,
1412         MFT_SEPARATOR|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 4, NULL,
1413         NULL, OK, OK );
1414     TMII_DONE
1415     /* MIIM_TYPE by itself does not get/set the dwItemData for OwnerDrawn menus  */
1416     TMII_INSMI( MIIM_TYPE|MIIM_DATA, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, 343, txt, 0, 0, OK );
1417     TMII_GMII ( MIIM_TYPE|MIIM_DATA, 80,
1418         MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 343, 0, 0, 0,
1419         NULL, OK, ER );
1420     TMII_DONE
1421     TMII_INSMI( MIIM_TYPE|MIIM_DATA, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, 343, txt, 0, 0, OK );
1422     TMII_GMII ( MIIM_TYPE, 80,
1423         MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1424         NULL, OK, ER );
1425     TMII_DONE
1426     TMII_INSMI( MIIM_TYPE, MFT_STRING|MFT_OWNERDRAW, -1, -1, 0, 0, 0, 343, txt, 0, 0, OK );
1427     TMII_GMII ( MIIM_TYPE|MIIM_DATA, 80,
1428         MFT_STRING|MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1429         NULL, OK, ER );
1430     TMII_DONE
1431     /* set a string menu to ownerdraw with MIIM_TYPE */
1432     TMII_INSMI( MIIM_TYPE, MFT_STRING, -2, -2, 0, 0, 0, -2, txt, -2, 0, OK );
1433     TMII_SMII ( MIIM_TYPE, MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
1434     TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1435         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, string, 4, 0,
1436         txt, OK, OK );
1437     TMII_DONE
1438     /* test with modifymenu add submenu */
1439     TMII_INSMI( MIIM_STRING, MFT_STRING, -1, -1, 0, 0, 0, -1, txt, 0, 0, OK );
1440     TMII_MODM( MF_POPUP, (UINT_PTR)submenu, txt );
1441     TMII_GMII ( MIIM_FTYPE|MIIM_STRING|MIIM_SUBMENU, 80,
1442         MFT_STRING, 0, 0, submenu, 0, 0, 0, string, 4, 0,
1443         txt,  OK, OK );
1444     TMII_GMII ( MIIM_TYPE, 80,
1445         MFT_STRING, 0, 0, 0, 0, 0, 0, string, 4, 0,
1446         txt,  OK, OK );
1447     TMII_DONE
1448     /* MFT_SEPARATOR bit is kept when the text is added */
1449     TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1450     TMII_SMII( MIIM_STRING, 0, 0, 0, 0, 0, 0, 0, txt, 0, 0 );
1451     TMII_GMII ( MIIM_STRING|MIIM_FTYPE, 80,
1452         MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 4, 0,
1453         txt, OK, OK );
1454     TMII_DONE
1455     /* MFT_SEPARATOR bit is kept when bitmap is added */
1456     TMII_INSMI( MIIM_STRING|MIIM_FTYPE, MFT_STRING, -1, -1, 0, 0, 0, -1, NULL, 0, 0, OK );
1457     TMII_SMII( MIIM_BITMAP, 0, 0, 0, 0, 0, 0, 0, 0, 0, hbm );
1458     TMII_GMII ( MIIM_BITMAP|MIIM_FTYPE, 80,
1459         MFT_SEPARATOR, 0, 0, 0, 0, 0, 0, string, 80, hbm,
1460         init, OK, ER );
1461     TMII_DONE
1462     /* Bitmaps inserted with MIIM_TYPE and MFT_BITMAP:
1463        Only the low word of the dwTypeData is used.
1464        Use a magic bitmap here (Word 95 uses this to create its MDI menu buttons) */
1465     TMII_INSMI( MIIM_TYPE, MFT_BITMAP | MFT_RIGHTJUSTIFY, -1, -1, 0, 0, 0, -1,
1466                 (HMENU)MAKELONG(HBMMENU_MBAR_CLOSE, 0x1234), -1, 0, OK );
1467     TMII_GMII ( MIIM_TYPE, 80,
1468         MFT_BITMAP | MFT_RIGHTJUSTIFY, 0, 0, 0, 0, 0, 0, HBMMENU_MBAR_CLOSE, 0, HBMMENU_MBAR_CLOSE,
1469         NULL, OK, OK );
1470     TMII_DONE
1471     /* Type flags */
1472     TMII_INSMI( MIIM_TYPE, MFT_BITMAP | MFT_MENUBARBREAK | MFT_RADIOCHECK | MFT_RIGHTJUSTIFY | MFT_RIGHTORDER, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1473     TMII_GMII ( MIIM_TYPE, 80,
1474         MFT_BITMAP | MFT_MENUBARBREAK | MFT_RADIOCHECK | MFT_RIGHTJUSTIFY | MFT_RIGHTORDER, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1475         NULL, OK, OK );
1476     TMII_DONE
1477     /* State flags */
1478     TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1479     TMII_SMII( MIIM_STATE, -1, MFS_CHECKED | MFS_DEFAULT | MFS_GRAYED | MFS_HILITE, 0, 0, 0, 0, 0, 0, 0, 0 );
1480     TMII_GMII ( MIIM_STATE, 80,
1481         0, MFS_CHECKED | MFS_DEFAULT | MFS_GRAYED | MFS_HILITE, 0, 0, 0, 0, 0, 0, 80, 0,
1482         NULL, OK, OK );
1483     TMII_DONE
1484     /* The style MFT_RADIOCHECK cannot be set with MIIM_CHECKMARKS only */
1485     TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1486     TMII_SMII( MIIM_CHECKMARKS, MFT_RADIOCHECK, 0, 0, 0, hbm, hbm, 0, 0, 0, 0 );
1487     TMII_GMII ( MIIM_CHECKMARKS | MIIM_TYPE, 80,
1488         MFT_BITMAP, 0, 0, 0, hbm, hbm, 0, hbm, 0, hbm,
1489         NULL, OK, OK );
1490     TMII_DONE
1491     /* MFT_BITMAP is added automatically by GetMenuItemInfo() for MIIM_TYPE */
1492     TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1493     TMII_SMII( MIIM_FTYPE, MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, (HBITMAP)0x1234, 0, 0 );
1494     TMII_GMII ( MIIM_FTYPE, 80,
1495         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 80, 0,
1496         NULL, OK, OK );
1497     TMII_GMII ( MIIM_TYPE, 80,
1498         MFT_BITMAP | MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1499         NULL, OK, OK );
1500     TMII_GMII ( MIIM_FTYPE, 80,
1501         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 80, 0,
1502         NULL, OK, OK );
1503     TMII_SMII( MIIM_BITMAP, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL );
1504     TMII_GMII ( MIIM_TYPE, 80,
1505         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 0, NULL,
1506         NULL, OK, OK );
1507     TMII_DONE
1508     /* Bitmaps inserted with MIIM_TYPE and MFT_BITMAP:
1509        Only the low word of the dwTypeData is used.
1510        Use a magic bitmap here (Word 95 uses this to create its MDI menu buttons) */
1511     TMII_INSMI( MIIM_TYPE, MFT_BITMAP | MFT_RIGHTJUSTIFY, -1, -1, 0, 0, 0, -1,
1512                 (HMENU)MAKELONG(HBMMENU_MBAR_CLOSE, 0x1234), -1, 0, OK );
1513     TMII_GMII ( MIIM_TYPE, 80,
1514         MFT_BITMAP | MFT_RIGHTJUSTIFY, 0, 0, 0, 0, 0, 0, HBMMENU_MBAR_CLOSE, 0, HBMMENU_MBAR_CLOSE,
1515         NULL, OK, OK );
1516     TMII_DONE
1517     /* Type flags */
1518     TMII_INSMI( MIIM_TYPE, MFT_BITMAP | MFT_MENUBARBREAK | MFT_RADIOCHECK | MFT_RIGHTJUSTIFY | MFT_RIGHTORDER, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1519     TMII_GMII ( MIIM_TYPE, 80,
1520         MFT_BITMAP | MFT_MENUBARBREAK | MFT_RADIOCHECK | MFT_RIGHTJUSTIFY | MFT_RIGHTORDER, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1521         NULL, OK, OK );
1522     TMII_DONE
1523     /* State flags */
1524     TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1525     TMII_SMII( MIIM_STATE, -1, MFS_CHECKED | MFS_DEFAULT | MFS_GRAYED | MFS_HILITE, 0, 0, 0, 0, 0, 0, 0, 0 );
1526     TMII_GMII ( MIIM_STATE, 80,
1527         0, MFS_CHECKED | MFS_DEFAULT | MFS_GRAYED | MFS_HILITE, 0, 0, 0, 0, 0, 0, 80, 0,
1528         NULL, OK, OK );
1529     TMII_DONE
1530     /* The style MFT_RADIOCHECK cannot be set with MIIM_CHECKMARKS only */
1531     TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1532     TMII_SMII( MIIM_CHECKMARKS, MFT_RADIOCHECK, 0, 0, 0, hbm, hbm, 0, 0, 0, 0 );
1533     TMII_GMII ( MIIM_CHECKMARKS | MIIM_TYPE, 80,
1534         MFT_BITMAP, 0, 0, 0, hbm, hbm, 0, hbm, 0, hbm,
1535         NULL, OK, OK );
1536     TMII_DONE
1537     /* MFT_BITMAP is added automatically by GetMenuItemInfo() for MIIM_TYPE */
1538     TMII_INSMI( MIIM_TYPE, MFT_BITMAP, -1, -1, 0, 0, 0, -1, hbm, -1, 0, OK );
1539     TMII_SMII( MIIM_FTYPE, MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, (HBITMAP)0x1234, 0, 0 );
1540     TMII_GMII ( MIIM_FTYPE, 80,
1541         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 80, 0,
1542         NULL, OK, OK );
1543     TMII_GMII ( MIIM_TYPE, 80,
1544         MFT_BITMAP | MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, hbm, 0, hbm,
1545         NULL, OK, OK );
1546     TMII_GMII ( MIIM_FTYPE, 80,
1547         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, 0, 80, 0,
1548         NULL, OK, OK );
1549     TMII_SMII( MIIM_BITMAP, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL );
1550     TMII_GMII ( MIIM_TYPE, 80,
1551         MFT_OWNERDRAW, 0, 0, 0, 0, 0, 0, NULL, 0, NULL,
1552         NULL, OK, OK );
1553     TMII_DONE
1554   } while( !(ansi = !ansi) );
1555   DeleteObject( hbm);
1556 }
1557
1558 /*
1559    The following tests try to confirm the algorithm used to return the menu items
1560    when there is a collision between a menu item and a popup menu
1561  */
1562 static void test_menu_search_bycommand( void )
1563 {
1564     HMENU        hmenu, hmenuSub, hmenuSub2;
1565     MENUITEMINFO info;
1566     BOOL         rc;
1567     UINT         id;
1568     char         strback[0x80];
1569     char         strIn[0x80];
1570     static CHAR menuitem[]  = "MenuItem",
1571                 menuitem2[] = "MenuItem 2";
1572
1573     /* Case 1: Menu containing a menu item */
1574     hmenu = CreateMenu();
1575
1576     memset( &info, 0, sizeof info );
1577     info.cbSize = sizeof info;
1578     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1579     info.fType = MFT_STRING;
1580     strcpy(strIn, "Case 1 MenuItem");
1581     info.dwTypeData = strIn;
1582     info.wID = (UINT) 0x1234;
1583
1584     rc = InsertMenuItem(hmenu, 0, TRUE, &info );
1585     ok (rc, "Inserting the menuitem failed\n");
1586
1587     id = GetMenuItemID(hmenu, 0);
1588     ok (id == 0x1234, "Getting the menuitem id failed(gave %x)\n", id);
1589
1590     /* Confirm the menuitem was given the id supplied (getting by position) */
1591     memset( &info, 0, sizeof info );
1592     strback[0] = 0x00;
1593     info.cbSize = sizeof(MENUITEMINFO);
1594     info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1595     info.dwTypeData = strback;
1596     info.cch = sizeof(strback);
1597
1598     rc = GetMenuItemInfo(hmenu, 0, TRUE, &info); /* Get by position */
1599     ok (rc, "Getting the menu items info failed\n");
1600     ok (info.wID == 0x1234, "IDs differ for the menuitem\n");
1601     ok (!strcmp(info.dwTypeData, "Case 1 MenuItem"), "Returned item has wrong label\n");
1602
1603     /* Search by id - Should return the item */
1604     memset( &info, 0, sizeof info );
1605     strback[0] = 0x00;
1606     info.cbSize = sizeof(MENUITEMINFO);
1607     info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1608     info.dwTypeData = strback;
1609     info.cch = sizeof(strback);
1610     rc = GetMenuItemInfo(hmenu, 0x1234, FALSE, &info); /* Get by ID */
1611
1612     ok (rc, "Getting the menu items info failed\n");
1613     ok (info.wID == 0x1234, "IDs differ for the menuitem\n");
1614     ok (!strcmp(info.dwTypeData, "Case 1 MenuItem"), "Returned item has wrong label\n");
1615
1616     DestroyMenu( hmenu );
1617
1618     /* Case 2: Menu containing a popup menu */
1619     hmenu = CreateMenu();
1620     hmenuSub = CreateMenu();
1621
1622     strcpy(strIn, "Case 2 SubMenu");
1623     rc = InsertMenu(hmenu, 0, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub, strIn);
1624     ok (rc, "Inserting the popup menu into the main menu failed\n");
1625
1626     id = GetMenuItemID(hmenu, 0);
1627     ok (id == -1, "Getting the menuitem id unexpectedly worked (gave %x)\n", id);
1628
1629     /* Confirm the menuitem itself was given an id the same as the HMENU, (getting by position) */
1630     memset( &info, 0, sizeof info );
1631     strback[0] = 0x00;
1632     info.cbSize = sizeof(MENUITEMINFO);
1633     info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1634     info.dwTypeData = strback;
1635     info.cch = sizeof(strback);
1636     info.wID = 0xdeadbeef;
1637
1638     rc = GetMenuItemInfo(hmenu, 0, TRUE, &info); /* Get by position */
1639     ok (rc, "Getting the menu items info failed\n");
1640     ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for the menuitem\n");
1641     ok (!strcmp(info.dwTypeData, "Case 2 SubMenu"), "Returned item has wrong label\n");
1642
1643     /* Search by id - returns the popup menu itself */
1644     memset( &info, 0, sizeof info );
1645     strback[0] = 0x00;
1646     info.cbSize = sizeof(MENUITEMINFO);
1647     info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1648     info.dwTypeData = strback;
1649     info.cch = sizeof(strback);
1650     rc = GetMenuItemInfo(hmenu, (UINT_PTR)hmenuSub, FALSE, &info); /* Get by ID */
1651
1652     ok (rc, "Getting the menu items info failed\n");
1653     ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for the popup menu\n");
1654     ok (!strcmp(info.dwTypeData, "Case 2 SubMenu"), "Returned item has wrong label\n");
1655
1656     /*
1657         Now add an item after it with the same id
1658      */
1659     memset( &info, 0, sizeof info );
1660     info.cbSize = sizeof info;
1661     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1662     info.fType = MFT_STRING;
1663     strcpy(strIn, "Case 2 MenuItem 1");
1664     info.dwTypeData = strIn;
1665     info.wID = (UINT_PTR) hmenuSub;
1666     rc = InsertMenuItem(hmenu, -1, TRUE, &info );
1667     ok (rc, "Inserting the menuitem failed\n");
1668
1669     /* Search by id - returns the item which follows the popup menu */
1670     memset( &info, 0, sizeof info );
1671     strback[0] = 0x00;
1672     info.cbSize = sizeof(MENUITEMINFO);
1673     info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1674     info.dwTypeData = strback;
1675     info.cch = sizeof(strback);
1676     rc = GetMenuItemInfo(hmenu, (UINT_PTR)hmenuSub, FALSE, &info); /* Get by ID */
1677
1678     ok (rc, "Getting the menu items info failed\n");
1679     ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for the popup menu\n");
1680     ok (!strcmp(info.dwTypeData, "Case 2 MenuItem 1"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1681
1682     /*
1683         Now add an item before the popup (with the same id)
1684      */
1685     memset( &info, 0, sizeof info );
1686     info.cbSize = sizeof info;
1687     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1688     info.fType = MFT_STRING;
1689     strcpy(strIn, "Case 2 MenuItem 2");
1690     info.dwTypeData = strIn;
1691     info.wID = (UINT_PTR) hmenuSub;
1692     rc = InsertMenuItem(hmenu, 0, TRUE, &info );
1693     ok (rc, "Inserting the menuitem failed\n");
1694
1695     /* Search by id - returns the item which precedes the popup menu */
1696     memset( &info, 0, sizeof info );
1697     strback[0] = 0x00;
1698     info.cbSize = sizeof(MENUITEMINFO);
1699     info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING;
1700     info.dwTypeData = strback;
1701     info.cch = sizeof(strback);
1702     rc = GetMenuItemInfo(hmenu, (UINT_PTR)hmenuSub, FALSE, &info); /* Get by ID */
1703
1704     ok (rc, "Getting the menu items info failed\n");
1705     ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for the popup menu\n");
1706     ok (!strcmp(info.dwTypeData, "Case 2 MenuItem 2"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1707
1708     DestroyMenu( hmenu );
1709     DestroyMenu( hmenuSub );
1710
1711     /*
1712         Case 3: Menu containing a popup menu which in turn
1713            contains 2 items with the same id as the popup itself
1714      */
1715
1716     hmenu = CreateMenu();
1717     hmenuSub = CreateMenu();
1718
1719     memset( &info, 0, sizeof info );
1720     info.cbSize = sizeof info;
1721     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1722     info.fType = MFT_STRING;
1723     info.dwTypeData = menuitem;
1724     info.wID = (UINT_PTR) hmenuSub; /* Enforce id collisions with the hmenu of the popup submenu*/
1725
1726     rc = InsertMenu(hmenu, 0, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub, "Submenu");
1727     ok (rc, "Inserting the popup menu into the main menu failed\n");
1728
1729     rc = InsertMenuItem(hmenuSub, 0, TRUE, &info );
1730     ok (rc, "Inserting the sub menu menuitem failed\n");
1731
1732     memset( &info, 0, sizeof info );
1733     info.cbSize = sizeof info;
1734     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1735     info.fType = MFT_STRING;
1736     info.dwTypeData = menuitem2;
1737     info.wID = (UINT_PTR) hmenuSub; /* Enforce id collisions with the hmenu of the popup submenu*/
1738
1739     rc = InsertMenuItem(hmenuSub, 1, TRUE, &info );
1740     ok (rc, "Inserting the sub menu menuitem 2 failed\n");
1741
1742     /* Prove that you can't query the id of a popup directly (By position) */
1743     id = GetMenuItemID(hmenu, 0);
1744     ok (id == -1, "Getting the sub menu id should have failed because its a popup (gave %x)\n", id);
1745
1746     /* Prove getting the item info via ID returns the first item (not the popup or 2nd item)*/
1747     memset( &info, 0, sizeof info );
1748     strback[0] = 0x00;
1749     info.cbSize = sizeof(MENUITEMINFO);
1750     info.fMask = MIIM_STRING | MIIM_ID;
1751     info.dwTypeData = strback;
1752     info.cch = sizeof(strback);
1753
1754     rc = GetMenuItemInfo(hmenu, (UINT_PTR)hmenuSub, FALSE, &info);
1755     ok (rc, "Getting the menus info failed\n");
1756     ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for popup menu\n");
1757     ok (!strcmp(info.dwTypeData, "MenuItem"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1758     DestroyMenu( hmenu );
1759     DestroyMenu( hmenuSub );
1760
1761     /*
1762         Case 4: Menu containing 2 popup menus, the second
1763            contains 2 items with the same id as the first popup menu
1764      */
1765     hmenu = CreateMenu();
1766     hmenuSub = CreateMenu();
1767     hmenuSub2 = CreateMenu();
1768
1769     rc = InsertMenu(hmenu, 0, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub, "Submenu");
1770     ok (rc, "Inserting the popup menu into the main menu failed\n");
1771
1772     rc = InsertMenu(hmenu, 1, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub2, "Submenu2");
1773     ok (rc, "Inserting the popup menu into the main menu failed\n");
1774
1775     memset( &info, 0, sizeof info );
1776     info.cbSize = sizeof info;
1777     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1778     info.fType = MFT_STRING;
1779     info.dwTypeData = menuitem;
1780     info.wID = (UINT_PTR) hmenuSub; /* Enforce id collisions with the hmenu of the popup submenu*/
1781
1782     rc = InsertMenuItem(hmenuSub2, 0, TRUE, &info );
1783     ok (rc, "Inserting the sub menu menuitem failed\n");
1784
1785     memset( &info, 0, sizeof info );
1786     info.cbSize = sizeof info;
1787     info.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_ID;
1788     info.fType = MFT_STRING;
1789     info.dwTypeData = menuitem2;
1790     info.wID = (UINT_PTR) hmenuSub; /* Enforce id collisions with the hmenu of the popup submenu*/
1791
1792     rc = InsertMenuItem(hmenuSub2, 1, TRUE, &info );
1793     ok (rc, "Inserting the sub menu menuitem 2 failed\n");
1794
1795     /* Prove getting the item info via ID returns the first item (not the popup or 2nd item)*/
1796     memset( &info, 0, sizeof info );
1797     strback[0] = 0x00;
1798     info.cbSize = sizeof(MENUITEMINFO);
1799     info.fMask = MIIM_STRING | MIIM_ID;
1800     info.dwTypeData = strback;
1801     info.cch = sizeof(strback);
1802
1803     rc = GetMenuItemInfo(hmenu, (UINT_PTR)hmenuSub, FALSE, &info);
1804     ok (rc, "Getting the menus info failed\n");
1805     ok (info.wID == (UINT_PTR)hmenuSub, "IDs differ for popup menu\n");
1806     ok (!strcmp(info.dwTypeData, "MenuItem"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1807
1808     memset( &info, 0, sizeof info );
1809     strback[0] = 0x00;
1810     info.cbSize = sizeof(MENUITEMINFO);
1811     info.fMask = MIIM_STRING | MIIM_ID;
1812     info.dwTypeData = strback;
1813     info.cch = sizeof(strback);
1814
1815     rc = GetMenuItemInfo(hmenu, (UINT_PTR)hmenuSub2, FALSE, &info);
1816     ok (rc, "Getting the menus info failed\n");
1817     ok (info.wID == (UINT_PTR)hmenuSub2, "IDs differ for popup menu\n");
1818     ok (!strcmp(info.dwTypeData, "Submenu2"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1819
1820     DestroyMenu( hmenu );
1821     DestroyMenu( hmenuSub );
1822     DestroyMenu( hmenuSub2 );
1823
1824
1825     /*
1826         Case 5: Menu containing a popup menu which in turn
1827            contains an item with a different id than the popup menu.
1828            This tests the fallback to a popup menu ID.
1829      */
1830
1831     hmenu = CreateMenu();
1832     hmenuSub = CreateMenu();
1833
1834     rc = AppendMenu(hmenu, MF_POPUP | MF_STRING, (UINT_PTR)hmenuSub, "Submenu");
1835     ok (rc, "Appending the popup menu to the main menu failed\n");
1836
1837     rc = AppendMenu(hmenuSub, MF_STRING, 102, "Item");
1838     ok (rc, "Appending the item to the popup menu failed\n");
1839
1840     /* Set the ID for hmenuSub */
1841     info.cbSize = sizeof(info);
1842     info.fMask = MIIM_ID;
1843     info.wID = 101;
1844
1845     rc = SetMenuItemInfo(hmenu, 0, TRUE, &info);
1846     ok(rc, "Setting the ID for the popup menu failed\n");
1847
1848     /* Check if the ID has been set */
1849     info.wID = 0;
1850     rc = GetMenuItemInfo(hmenu, 0, TRUE, &info);
1851     ok(rc, "Getting the ID for the popup menu failed\n");
1852     ok(info.wID == 101, "The ID for the popup menu has not been set\n");
1853
1854     /* Prove getting the item info via ID returns the popup menu */
1855     memset( &info, 0, sizeof(info));
1856     strback[0] = 0x00;
1857     info.cbSize = sizeof(MENUITEMINFO);
1858     info.fMask = MIIM_STRING | MIIM_ID;
1859     info.dwTypeData = strback;
1860     info.cch = sizeof(strback);
1861
1862     rc = GetMenuItemInfo(hmenu, 101, FALSE, &info);
1863     ok (rc, "Getting the menu info failed\n");
1864     ok (info.wID == 101, "IDs differ\n");
1865     ok (!strcmp(info.dwTypeData, "Submenu"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1866
1867     /* Also look for the menu item  */
1868     memset( &info, 0, sizeof(info));
1869     strback[0] = 0x00;
1870     info.cbSize = sizeof(MENUITEMINFO);
1871     info.fMask = MIIM_STRING | MIIM_ID;
1872     info.dwTypeData = strback;
1873     info.cch = sizeof(strback);
1874
1875     rc = GetMenuItemInfo(hmenu, 102, FALSE, &info);
1876     ok (rc, "Getting the menu info failed\n");
1877     ok (info.wID == 102, "IDs differ\n");
1878     ok (!strcmp(info.dwTypeData, "Item"), "Returned item has wrong label (%s)\n", info.dwTypeData);
1879
1880     DestroyMenu(hmenu);
1881     DestroyMenu(hmenuSub);
1882 }
1883
1884 struct menu_item_pair_s {
1885     UINT uMenu; /* 1 - top level menu, [0-Menu 1-Enabled 2-Disabled]
1886                  * 2 - 2nd level menu, [0-Popup 1-Enabled 2-Disabled]
1887                  * 3 - 3rd level menu, [0-Enabled 1-Disabled] */
1888     UINT uItem;
1889 };
1890
1891 static struct menu_mouse_tests_s {
1892     DWORD type;
1893     struct menu_item_pair_s menu_item_pairs[5]; /* for mousing */
1894     WORD wVk[5]; /* keys */
1895     BOOL bMenuVisible;
1896     BOOL _todo_wine;
1897 } menu_tests[] = {
1898     /* for each test, send keys or clicks and check for menu visibility */
1899     { INPUT_KEYBOARD, {{0}}, {VK_MENU, 0}, TRUE, FALSE }, /* test 0 */
1900     { INPUT_KEYBOARD, {{0}}, {VK_ESCAPE, 0}, FALSE, FALSE },
1901     { INPUT_KEYBOARD, {{0}}, {VK_MENU, 0}, TRUE, FALSE },
1902     { INPUT_KEYBOARD, {{0}}, {'D', 0}, FALSE, FALSE },
1903     { INPUT_KEYBOARD, {{0}}, {VK_MENU, 0}, TRUE, FALSE },
1904     { INPUT_KEYBOARD, {{0}}, {'E', 0}, FALSE, FALSE },
1905     { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 0}, TRUE, FALSE },
1906     { INPUT_KEYBOARD, {{0}}, {VK_ESCAPE, VK_ESCAPE, 0}, FALSE, FALSE },
1907     { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', VK_ESCAPE, 0}, TRUE, FALSE },
1908     { INPUT_KEYBOARD, {{0}}, {VK_ESCAPE, 0}, FALSE, FALSE },
1909     { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 0}, TRUE, FALSE },
1910     { INPUT_KEYBOARD, {{0}}, {'D', 0}, FALSE, FALSE },
1911     { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 0}, TRUE, FALSE },
1912     { INPUT_KEYBOARD, {{0}}, {'E', 0}, FALSE, FALSE },
1913     { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 'P', 0}, TRUE, FALSE },
1914     { INPUT_KEYBOARD, {{0}}, {'D', 0}, FALSE, FALSE },
1915     { INPUT_KEYBOARD, {{0}}, {VK_MENU, 'M', 'P', 0}, TRUE, FALSE },
1916     { INPUT_KEYBOARD, {{0}}, {'E', 0}, FALSE, FALSE },
1917     { INPUT_KEYBOARD, {{0}}, {VK_F10, 0}, TRUE, FALSE },
1918     { INPUT_KEYBOARD, {{0}}, {VK_F10, 0}, FALSE, FALSE },
1919
1920     { INPUT_MOUSE, {{1, 2}, {0}}, {0}, TRUE, TRUE }, /* test 20 */
1921     { INPUT_MOUSE, {{1, 1}, {0}}, {0}, FALSE, FALSE },
1922     { INPUT_MOUSE, {{1, 0}, {0}}, {0}, TRUE, TRUE },
1923     { INPUT_MOUSE, {{1, 1}, {0}}, {0}, FALSE, FALSE },
1924     { INPUT_MOUSE, {{1, 0}, {2, 2}, {0}}, {0}, TRUE, TRUE },
1925     { INPUT_MOUSE, {{2, 1}, {0}}, {0}, FALSE, FALSE },
1926     { INPUT_MOUSE, {{1, 0}, {2, 0}, {0}}, {0}, TRUE, TRUE },
1927     { INPUT_MOUSE, {{3, 0}, {0}}, {0}, FALSE, FALSE },
1928     { INPUT_MOUSE, {{1, 0}, {2, 0}, {0}}, {0}, TRUE, TRUE },
1929     { INPUT_MOUSE, {{3, 1}, {0}}, {0}, TRUE, TRUE },
1930     { INPUT_MOUSE, {{1, 1}, {0}}, {0}, FALSE, FALSE },
1931     { -1 }
1932 };
1933
1934 static void send_key(WORD wVk)
1935 {
1936     TEST_INPUT i[2];
1937     memset(i, 0, sizeof(i));
1938     i[0].type = i[1].type = INPUT_KEYBOARD;
1939     i[0].u.ki.wVk = i[1].u.ki.wVk = wVk;
1940     i[1].u.ki.dwFlags = KEYEVENTF_KEYUP;
1941     pSendInput(2, (INPUT *) i, sizeof(INPUT));
1942 }
1943
1944 static BOOL click_menu(HANDLE hWnd, struct menu_item_pair_s *mi)
1945 {
1946     HMENU hMenu = hMenus[mi->uMenu];
1947     TEST_INPUT i[3];
1948     MSG msg;
1949     RECT r;
1950     int screen_w = GetSystemMetrics(SM_CXSCREEN);
1951     int screen_h = GetSystemMetrics(SM_CYSCREEN);
1952     BOOL ret = GetMenuItemRect(mi->uMenu > 2 ? NULL : hWnd, hMenu, mi->uItem, &r);
1953     if(!ret) return FALSE;
1954
1955     memset(i, 0, sizeof(i));
1956     i[0].type = i[1].type = i[2].type = INPUT_MOUSE;
1957     i[0].u.mi.dx = i[1].u.mi.dx = i[2].u.mi.dx
1958             = ((r.left + 5) * 65535) / screen_w;
1959     i[0].u.mi.dy = i[1].u.mi.dy = i[2].u.mi.dy
1960             = ((r.top + 5) * 65535) / screen_h;
1961     i[0].u.mi.dwFlags = i[1].u.mi.dwFlags = i[2].u.mi.dwFlags
1962             = MOUSEEVENTF_ABSOLUTE;
1963     i[0].u.mi.dwFlags |= MOUSEEVENTF_MOVE;
1964     i[1].u.mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
1965     i[2].u.mi.dwFlags |= MOUSEEVENTF_LEFTUP;
1966     ret = pSendInput(3, (INPUT *) i, sizeof(INPUT));
1967
1968     /* hack to prevent mouse message buildup in Wine */
1969     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
1970     return ret;
1971 }
1972
1973 static DWORD WINAPI test_menu_input_thread(LPVOID lpParameter)
1974 {
1975     int i, j;
1976     HANDLE hWnd = lpParameter;
1977
1978     Sleep(500);
1979     /* mixed keyboard/mouse test */
1980     for (i = 0; menu_tests[i].type != -1; i++)
1981     {
1982         int ret = TRUE, elapsed = 0;
1983
1984         got_input = i && menu_tests[i-1].bMenuVisible;
1985
1986         if (menu_tests[i].type == INPUT_KEYBOARD)
1987             for (j = 0; menu_tests[i].wVk[j] != 0; j++)
1988                 send_key(menu_tests[i].wVk[j]);
1989         else
1990             for (j = 0; menu_tests[i].menu_item_pairs[j].uMenu != 0; j++)
1991                 if (!(ret = click_menu(hWnd, &menu_tests[i].menu_item_pairs[j]))) break;
1992
1993         if (!ret)
1994         {
1995             skip( "test %u: failed to send input\n", i );
1996             PostMessage( hWnd, WM_CANCELMODE, 0, 0 );
1997             return 0;
1998         }
1999         while (menu_tests[i].bMenuVisible != bMenuVisible)
2000         {
2001             if (elapsed > 200)
2002                 break;
2003             elapsed += 20;
2004             Sleep(20);
2005         }
2006
2007         if (!got_input)
2008         {
2009             skip( "test %u: didn't receive input\n", i );
2010             PostMessage( hWnd, WM_CANCELMODE, 0, 0 );
2011             return 0;
2012         }
2013
2014         if (menu_tests[i]._todo_wine)
2015         {
2016             todo_wine {
2017                 ok(menu_tests[i].bMenuVisible == bMenuVisible, "test %d\n", i);
2018             }
2019         }
2020         else
2021             ok(menu_tests[i].bMenuVisible == bMenuVisible, "test %d\n", i);
2022     }
2023     return 0;
2024 }
2025
2026 static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam,
2027         LPARAM lParam)
2028 {
2029     switch (msg) {
2030         case WM_ENTERMENULOOP:
2031             bMenuVisible = TRUE;
2032             break;
2033         case WM_EXITMENULOOP:
2034             bMenuVisible = FALSE;
2035             break;
2036         case WM_KEYDOWN:
2037         case WM_SYSKEYDOWN:
2038         case WM_MOUSEMOVE:
2039         case WM_LBUTTONDOWN:
2040         case WM_LBUTTONUP:
2041         case WM_NCMOUSEMOVE:
2042         case WM_NCLBUTTONDOWN:
2043         case WM_NCLBUTTONUP:
2044             got_input = TRUE;
2045             /* fall through */
2046         default:
2047             return( DefWindowProcA( hWnd, msg, wParam, lParam ) );
2048     }
2049     return 0;
2050 }
2051
2052 static void test_menu_input(void) {
2053     MSG msg;
2054     WNDCLASSA  wclass;
2055     HINSTANCE hInstance = GetModuleHandleA( NULL );
2056     HANDLE hThread, hWnd;
2057     DWORD tid;
2058     ATOM aclass;
2059
2060     if (!pSendInput)
2061     {
2062         win_skip("SendInput is not available\n");
2063         return;
2064     }
2065
2066     wclass.lpszClassName = "MenuTestClass";
2067     wclass.style         = CS_HREDRAW | CS_VREDRAW;
2068     wclass.lpfnWndProc   = WndProc;
2069     wclass.hInstance     = hInstance;
2070     wclass.hIcon         = LoadIconA( 0, IDI_APPLICATION );
2071     wclass.hCursor       = LoadCursorA( NULL, IDC_ARROW );
2072     wclass.hbrBackground = (HBRUSH)( COLOR_WINDOW + 1 );
2073     wclass.lpszMenuName  = 0;
2074     wclass.cbClsExtra    = 0;
2075     wclass.cbWndExtra    = 0;
2076     aclass = RegisterClassA( &wclass );
2077     ok (aclass, "MenuTest class not created\n");
2078     if (!aclass) return;
2079     hWnd = CreateWindowA( wclass.lpszClassName, "MenuTest",
2080                           WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0,
2081                           400, 200, NULL, NULL, hInstance, NULL);
2082     ok (hWnd != NULL, "MenuTest window not created\n");
2083     if (!hWnd) return;
2084     /* fixed menus */
2085     hMenus[3] = CreatePopupMenu();
2086     AppendMenu(hMenus[3], MF_STRING, 0, "&Enabled");
2087     AppendMenu(hMenus[3], MF_STRING|MF_DISABLED, 0, "&Disabled");
2088
2089     hMenus[2] = CreatePopupMenu();
2090     AppendMenu(hMenus[2], MF_STRING|MF_POPUP, (UINT_PTR) hMenus[3], "&Popup");
2091     AppendMenu(hMenus[2], MF_STRING, 0, "&Enabled");
2092     AppendMenu(hMenus[2], MF_STRING|MF_DISABLED, 0, "&Disabled");
2093
2094     hMenus[1] = CreateMenu();
2095     AppendMenu(hMenus[1], MF_STRING|MF_POPUP, (UINT_PTR) hMenus[2], "&Menu");
2096     AppendMenu(hMenus[1], MF_STRING, 0, "&Enabled");
2097     AppendMenu(hMenus[1], MF_STRING|MF_DISABLED, 0, "&Disabled");
2098
2099     SetMenu(hWnd, hMenus[1]);
2100     ShowWindow(hWnd, SW_SHOW);
2101     UpdateWindow(hWnd);
2102
2103     hThread = CreateThread(NULL, 0, test_menu_input_thread, hWnd, 0, &tid);
2104     while(1)
2105     {
2106         if (WAIT_TIMEOUT != WaitForSingleObject(hThread, 50))
2107             break;
2108         while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
2109     }
2110     DestroyWindow(hWnd);
2111 }
2112
2113 static void test_menu_flags( void )
2114 {
2115     HMENU hMenu, hPopupMenu;
2116
2117     hMenu = CreateMenu();
2118     hPopupMenu = CreatePopupMenu();
2119
2120     AppendMenu(hMenu, MF_POPUP | MF_STRING, (UINT_PTR)hPopupMenu, "Popup");
2121
2122     AppendMenu(hPopupMenu, MF_STRING | MF_HILITE | MF_DEFAULT, 101, "Item 1");
2123     InsertMenu(hPopupMenu, 1, MF_BYPOSITION | MF_STRING | MF_HILITE | MF_DEFAULT, 102, "Item 2");
2124     AppendMenu(hPopupMenu, MF_STRING, 103, "Item 3");
2125     ModifyMenu(hPopupMenu, 2, MF_BYPOSITION | MF_STRING | MF_HILITE | MF_DEFAULT, 103, "Item 3");
2126
2127     ok(GetMenuState(hPopupMenu, 0, MF_BYPOSITION) & MF_HILITE,
2128       "AppendMenu should accept MF_HILITE\n");
2129     ok(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE,
2130       "InsertMenu should accept MF_HILITE\n");
2131     ok(GetMenuState(hPopupMenu, 2, MF_BYPOSITION) & MF_HILITE,
2132       "ModifyMenu should accept MF_HILITE\n");
2133
2134     ok(!(GetMenuState(hPopupMenu, 0, MF_BYPOSITION) & MF_DEFAULT),
2135       "AppendMenu must not accept MF_DEFAULT\n");
2136     ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_DEFAULT),
2137       "InsertMenu must not accept MF_DEFAULT\n");
2138     ok(!(GetMenuState(hPopupMenu, 2, MF_BYPOSITION) & MF_DEFAULT),
2139       "ModifyMenu must not accept MF_DEFAULT\n");
2140
2141     DestroyMenu(hMenu);
2142 }
2143
2144 static void test_menu_hilitemenuitem( void )
2145 {
2146     HMENU hMenu, hPopupMenu;
2147     WNDCLASSA wclass;
2148     HWND hWnd;
2149     ATOM aclass;
2150
2151     wclass.lpszClassName = "HiliteMenuTestClass";
2152     wclass.style         = CS_HREDRAW | CS_VREDRAW;
2153     wclass.lpfnWndProc   = WndProc;
2154     wclass.hInstance     = GetModuleHandleA( NULL );
2155     wclass.hIcon         = LoadIconA( 0, IDI_APPLICATION );
2156     wclass.hCursor       = LoadCursorA( NULL, IDC_ARROW );
2157     wclass.hbrBackground = (HBRUSH)( COLOR_WINDOW + 1 );
2158     wclass.lpszMenuName  = 0;
2159     wclass.cbClsExtra    = 0;
2160     wclass.cbWndExtra    = 0;
2161     aclass = RegisterClassA( &wclass );
2162     ok (aclass, "HiliteMenuTest class could not be created\n");
2163     if (!aclass) return;
2164     hWnd = CreateWindowA( wclass.lpszClassName, "HiliteMenuTest",
2165                           WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0,
2166                           400, 200, NULL, NULL, wclass.hInstance, NULL);
2167     ok (hWnd != NULL, "HiliteMenuTest window could not be created\n");
2168     if (!hWnd) return;
2169
2170     hMenu = CreateMenu();
2171     hPopupMenu = CreatePopupMenu();
2172
2173     AppendMenu(hMenu, MF_POPUP | MF_STRING, (UINT_PTR)hPopupMenu, "Popup");
2174
2175     AppendMenu(hPopupMenu, MF_STRING, 101, "Item 1");
2176     AppendMenu(hPopupMenu, MF_STRING, 102, "Item 2");
2177     AppendMenu(hPopupMenu, MF_STRING, 103, "Item 3");
2178
2179     SetMenu(hWnd, hMenu);
2180
2181     /* test invalid arguments */
2182
2183     ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2184       "HiliteMenuItem: Item 2 is hilited\n");
2185
2186     SetLastError(0xdeadbeef);
2187     todo_wine
2188     {
2189     ok(!HiliteMenuItem(NULL, hPopupMenu, 1, MF_HILITE | MF_BYPOSITION),
2190       "HiliteMenuItem: call should have failed.\n");
2191     }
2192     ok(GetLastError() == 0xdeadbeef || /* 9x */
2193        GetLastError() == ERROR_INVALID_WINDOW_HANDLE /* NT */,
2194       "HiliteMenuItem: expected error ERROR_INVALID_WINDOW_HANDLE, got: %d\n", GetLastError());
2195
2196     SetLastError(0xdeadbeef);
2197     ok(!HiliteMenuItem(hWnd, NULL, 1, MF_HILITE | MF_BYPOSITION),
2198       "HiliteMenuItem: call should have failed.\n");
2199     ok(GetLastError() == 0xdeadbeef || /* 9x */
2200        GetLastError() == ERROR_INVALID_MENU_HANDLE /* NT */,
2201       "HiliteMenuItem: expected error ERROR_INVALID_MENU_HANDLE, got: %d\n", GetLastError());
2202
2203     ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2204       "HiliteMenuItem: Item 2 is hilited\n");
2205
2206     /* either MF_HILITE or MF_UNHILITE *and* MF_BYCOMMAND or MF_BYPOSITION need to be set */
2207
2208     SetLastError(0xdeadbeef);
2209     ok(HiliteMenuItem(hWnd, hPopupMenu, 1, MF_BYPOSITION),
2210       "HiliteMenuItem: call should have succeeded.\n");
2211     ok(GetLastError() == 0xdeadbeef,
2212       "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2213
2214     ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2215       "HiliteMenuItem: Item 2 is hilited\n");
2216
2217     SetLastError(0xdeadbeef);
2218     todo_wine
2219     {
2220     ok(HiliteMenuItem(hWnd, hPopupMenu, 1, MF_HILITE),
2221       "HiliteMenuItem: call should have succeeded.\n");
2222     }
2223     ok(GetLastError() == 0xdeadbeef,
2224       "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2225
2226     ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2227       "HiliteMenuItem: Item 2 is hilited\n");
2228
2229     /* hilite a menu item (by position) */
2230
2231     SetLastError(0xdeadbeef);
2232     ok(HiliteMenuItem(hWnd, hPopupMenu, 1, MF_HILITE | MF_BYPOSITION),
2233       "HiliteMenuItem: call should not have failed.\n");
2234     ok(GetLastError() == 0xdeadbeef,
2235       "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2236
2237     todo_wine
2238     {
2239     ok(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE,
2240       "HiliteMenuItem: Item 2 is not hilited\n");
2241     }
2242
2243     /* unhilite a menu item (by position) */
2244
2245     SetLastError(0xdeadbeef);
2246     ok(HiliteMenuItem(hWnd, hPopupMenu, 1, MF_UNHILITE | MF_BYPOSITION),
2247       "HiliteMenuItem: call should not have failed.\n");
2248     ok(GetLastError() == 0xdeadbeef,
2249       "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2250
2251     ok(!(GetMenuState(hPopupMenu, 1, MF_BYPOSITION) & MF_HILITE),
2252       "HiliteMenuItem: Item 2 is hilited\n");
2253
2254     /* hilite a menu item (by command) */
2255
2256     SetLastError(0xdeadbeef);
2257     ok(HiliteMenuItem(hWnd, hPopupMenu, 103, MF_HILITE | MF_BYCOMMAND),
2258       "HiliteMenuItem: call should not have failed.\n");
2259     ok(GetLastError() == 0xdeadbeef,
2260       "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2261
2262     todo_wine
2263     {
2264     ok(GetMenuState(hPopupMenu, 2, MF_BYPOSITION) & MF_HILITE,
2265       "HiliteMenuItem: Item 3 is not hilited\n");
2266     }
2267
2268     /* unhilite a menu item (by command) */
2269
2270     SetLastError(0xdeadbeef);
2271     ok(HiliteMenuItem(hWnd, hPopupMenu, 103, MF_UNHILITE | MF_BYCOMMAND),
2272       "HiliteMenuItem: call should not have failed.\n");
2273     ok(GetLastError() == 0xdeadbeef,
2274       "HiliteMenuItem: expected error 0xdeadbeef, got: %d\n", GetLastError());
2275
2276     ok(!(GetMenuState(hPopupMenu, 2, MF_BYPOSITION) & MF_HILITE),
2277       "HiliteMenuItem: Item 3 is hilited\n");
2278
2279     DestroyWindow(hWnd);
2280 }
2281
2282 static void check_menu_items(HMENU hmenu, UINT checked_cmd, UINT checked_type,
2283                              UINT checked_state)
2284 {
2285     INT i, count;
2286
2287     count = GetMenuItemCount(hmenu);
2288     ok (count != -1, "GetMenuItemCount returned -1\n");
2289
2290     for (i = 0; i < count; i++)
2291     {
2292         BOOL ret;
2293         MENUITEMINFO mii;
2294
2295         memset(&mii, 0, sizeof(mii));
2296         mii.cbSize = sizeof(mii);
2297         mii.fMask  = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_SUBMENU;
2298         ret = GetMenuItemInfo(hmenu, i, TRUE, &mii);
2299         ok(ret, "GetMenuItemInfo(%u) failed\n", i);
2300 #if 0
2301         trace("item #%u: fType %04x, fState %04x, wID %u, hSubMenu %p\n",
2302                i, mii.fType, mii.fState, mii.wID, mii.hSubMenu);
2303 #endif
2304         if (mii.hSubMenu)
2305         {
2306             ok(mii.wID == (UINT_PTR)mii.hSubMenu, "id %u: wID should be equal to hSubMenu\n", checked_cmd);
2307             check_menu_items(mii.hSubMenu, checked_cmd, checked_type, checked_state);
2308         }
2309         else
2310         {
2311             if (mii.wID == checked_cmd)
2312             {
2313                 ok(mii.fType == checked_type, "id %u: expected fType %04x, got %04x\n", checked_cmd, checked_type, mii.fType);
2314                 ok(mii.fState == checked_state, "id %u: expected fState %04x, got %04x\n", checked_cmd, checked_state, mii.fState);
2315                 ok(mii.wID != 0, "id %u: not expected wID 0\n", checked_cmd);
2316             }
2317             else
2318             {
2319                 ok(mii.fType != MFT_RADIOCHECK, "id %u: not expected fType MFT_RADIOCHECK on cmd %u\n", checked_cmd, mii.wID);
2320
2321                 if (mii.fType == MFT_SEPARATOR)
2322                 {
2323                     ok(mii.fState == MFS_GRAYED, "id %u: expected fState MFS_GRAYED, got %04x\n", checked_cmd, mii.fState);
2324                     ok(mii.wID == 0, "id %u: expected wID 0, got %u\n", checked_cmd, mii.wID);
2325                 }
2326                 else
2327                 {
2328                     ok(mii.fState == 0, "id %u: expected fState 0, got %04x\n", checked_cmd, mii.fState);
2329                     ok(mii.wID != 0, "id %u: not expected wID 0\n", checked_cmd);
2330                 }
2331             }
2332         }
2333     }
2334 }
2335
2336 static void clear_ftype_and_state(HMENU hmenu, UINT id, UINT flags)
2337 {
2338     BOOL ret;
2339     MENUITEMINFO mii;
2340
2341     memset(&mii, 0, sizeof(mii));
2342     mii.cbSize = sizeof(mii);
2343     mii.fMask  = MIIM_FTYPE | MIIM_STATE;
2344     ret = SetMenuItemInfo(hmenu, id, (flags & MF_BYPOSITION) != 0, &mii);
2345     ok(ret, "SetMenuItemInfo(%u) failed\n", id);
2346 }
2347
2348 static void test_CheckMenuRadioItem(void)
2349 {
2350     BOOL ret;
2351     HMENU hmenu;
2352
2353     hmenu = LoadMenu(GetModuleHandle(0), MAKEINTRESOURCE(1));
2354     assert(hmenu != 0);
2355
2356     check_menu_items(hmenu, -1, 0, 0);
2357
2358     ret = CheckMenuRadioItem(hmenu, 100, 100, 100, MF_BYCOMMAND);
2359     ok(ret, "CheckMenuRadioItem failed\n");
2360     check_menu_items(hmenu, 100, MFT_RADIOCHECK, MFS_CHECKED);
2361
2362     /* MSDN is wrong, Windows does not remove MFT_RADIOCHECK */
2363     ret = CheckMenuRadioItem(hmenu, 100, 100, -1, MF_BYCOMMAND);
2364     ok(!ret, "CheckMenuRadioItem should return FALSE\n");
2365     check_menu_items(hmenu, 100, MFT_RADIOCHECK, 0);
2366
2367     /* clear check */
2368     clear_ftype_and_state(hmenu, 100, MF_BYCOMMAND);
2369     check_menu_items(hmenu, -1, 0, 0);
2370
2371     /* first and checked items are on different menus */
2372     ret = CheckMenuRadioItem(hmenu, 0, 300, 202, MF_BYCOMMAND);
2373     ok(!ret, "CheckMenuRadioItem should return FALSE\n");
2374     check_menu_items(hmenu, -1, 0, 0);
2375
2376     ret = CheckMenuRadioItem(hmenu, 200, 300, 202, MF_BYCOMMAND);
2377     ok(ret, "CheckMenuRadioItem failed\n");
2378     check_menu_items(hmenu, 202, MFT_RADIOCHECK, MFS_CHECKED);
2379
2380     /* MSDN is wrong, Windows does not remove MFT_RADIOCHECK */
2381     ret = CheckMenuRadioItem(hmenu, 202, 202, -1, MF_BYCOMMAND);
2382     ok(!ret, "CheckMenuRadioItem should return FALSE\n");
2383     check_menu_items(hmenu, 202, MFT_RADIOCHECK, 0);
2384
2385     /* clear check */
2386     clear_ftype_and_state(hmenu, 202, MF_BYCOMMAND);
2387     check_menu_items(hmenu, -1, 0, 0);
2388
2389     /* just for fun, try to check separator */
2390     ret = CheckMenuRadioItem(hmenu, 0, 300, 0, MF_BYCOMMAND);
2391     ok(!ret, "CheckMenuRadioItem should return FALSE\n");
2392     check_menu_items(hmenu, -1, 0, 0);
2393 }
2394
2395 static void test_menu_resource_layout(void)
2396 {
2397     static const struct
2398     {
2399         MENUITEMTEMPLATEHEADER mith;
2400         WORD data[14];
2401     } menu_template =
2402     {
2403         { 0, 0 }, /* versionNumber, offset */
2404         {
2405             /* mtOption, mtID, mtString[] '\0' terminated */
2406             MF_STRING, 1, 'F', 0,
2407             MF_STRING, 2, 0,
2408             MF_SEPARATOR, 3, 0,
2409             /* MF_SEPARATOR, 4, 'S', 0, FIXME: Wine ignores 'S' */
2410             MF_STRING|MF_GRAYED|MF_END, 5, 'E', 0
2411         }
2412     };
2413     static const struct
2414     {
2415         UINT type, state, id;
2416         const char *str;
2417     } menu_data[] =
2418     {
2419         { MF_STRING, MF_ENABLED, 1, "F" },
2420         { MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 2, "" },
2421         { MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 3, "" },
2422         /*{ MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 4, "S" }, FIXME: Wine ignores 'S'*/
2423         { MF_STRING, MF_GRAYED, 5, "E" },
2424         { MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 6, "" },
2425         { MF_STRING, MF_ENABLED, 7, "" },
2426         { MF_SEPARATOR, MF_GRAYED|MF_DISABLED, 8, "" }
2427     };
2428     HMENU hmenu;
2429     INT count, i;
2430     BOOL ret;
2431
2432     hmenu = LoadMenuIndirect(&menu_template);
2433     ok(hmenu != 0, "LoadMenuIndirect error %u\n", GetLastError());
2434
2435     ret = AppendMenu(hmenu, MF_STRING, 6, NULL);
2436     ok(ret, "AppendMenu failed\n");
2437     ret = AppendMenu(hmenu, MF_STRING, 7, "\0");
2438     ok(ret, "AppendMenu failed\n");
2439     ret = AppendMenu(hmenu, MF_SEPARATOR, 8, "separator");
2440     ok(ret, "AppendMenu failed\n");
2441
2442     count = GetMenuItemCount(hmenu);
2443     ok(count == sizeof(menu_data)/sizeof(menu_data[0]),
2444        "expected %u menu items, got %u\n",
2445        (UINT)(sizeof(menu_data)/sizeof(menu_data[0])), count);
2446
2447     for (i = 0; i < count; i++)
2448     {
2449         char buf[20];
2450         MENUITEMINFO mii;
2451
2452         memset(&mii, 0, sizeof(mii));
2453         mii.cbSize = sizeof(mii);
2454         mii.dwTypeData = buf;
2455         mii.cch = sizeof(buf);
2456         mii.fMask  = MIIM_FTYPE | MIIM_STATE | MIIM_ID | MIIM_STRING;
2457         ret = GetMenuItemInfo(hmenu, i, TRUE, &mii);
2458         ok(ret, "GetMenuItemInfo(%u) failed\n", i);
2459 #if 0
2460         trace("item #%u: fType %04x, fState %04x, wID %u, dwTypeData %s\n",
2461                i, mii.fType, mii.fState, mii.wID, (LPCSTR)mii.dwTypeData);
2462 #endif
2463         ok(mii.fType == menu_data[i].type,
2464            "%u: expected fType %04x, got %04x\n", i, menu_data[i].type, mii.fType);
2465         ok(mii.fState == menu_data[i].state,
2466            "%u: expected fState %04x, got %04x\n", i, menu_data[i].state, mii.fState);
2467         ok(mii.wID == menu_data[i].id,
2468            "%u: expected wID %04x, got %04x\n", i, menu_data[i].id, mii.wID);
2469         ok(mii.cch == strlen(menu_data[i].str),
2470            "%u: expected cch %u, got %u\n", i, (UINT)strlen(menu_data[i].str), mii.cch);
2471         ok(!strcmp(mii.dwTypeData, menu_data[i].str),
2472            "%u: expected dwTypeData %s, got %s\n", i, menu_data[i].str, (LPCSTR)mii.dwTypeData);
2473     }
2474
2475     DestroyMenu(hmenu);
2476 }
2477
2478 struct menu_data
2479 {
2480     UINT type, id;
2481     const char *str;
2482 };
2483
2484 static HMENU create_menu_from_data(const struct menu_data *item, INT item_count)
2485 {
2486     HMENU hmenu;
2487     INT i;
2488     BOOL ret;
2489
2490     hmenu = CreateMenu();
2491     assert(hmenu != 0);
2492
2493     for (i = 0; i < item_count; i++)
2494     {
2495         SetLastError(0xdeadbeef);
2496         ret = AppendMenu(hmenu, item[i].type, item[i].id, item[i].str);
2497         ok(ret, "%d: AppendMenu(%04x, %04x, %p) error %u\n",
2498            i, item[i].type, item[i].id, item[i].str, GetLastError());
2499     }
2500     return hmenu;
2501 }
2502
2503 /* use InsertMenuItem: does not set the MFT_BITMAP flag,
2504  * and does not accept non-magic bitmaps with invalid
2505  * bitmap handles */
2506 static HMENU create_menuitem_from_data(const struct menu_data *item, INT item_count)
2507 {
2508     HMENU hmenu;
2509     INT i;
2510     BOOL ret;
2511     MENUITEMINFO mii = { sizeof( MENUITEMINFO)};
2512
2513     hmenu = CreateMenu();
2514     assert(hmenu != 0);
2515
2516     for (i = 0; i < item_count; i++)
2517     {
2518         SetLastError(0xdeadbeef);
2519
2520         mii.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STATE;
2521         mii.fType = 0;
2522         if(  item[i].type & MFT_BITMAP)
2523         {
2524             mii.fMask |= MIIM_BITMAP;
2525             mii.hbmpItem =  (HBITMAP)item[i].str;
2526         }
2527         else if(  item[i].type & MFT_SEPARATOR)
2528             mii.fType = MFT_SEPARATOR;
2529         else
2530         {
2531             mii.fMask |= MIIM_STRING;
2532             mii.dwTypeData =  (LPSTR)item[i].str;
2533             mii.cch = strlen(  item[i].str);
2534         }
2535         mii.fState = 0;
2536         if(  item[i].type & MF_HELP) mii.fType |= MF_HELP;
2537         mii.wID = item[i].id;
2538         ret = InsertMenuItem( hmenu, -1, TRUE, &mii);
2539         ok(ret, "%d: InsertMenuItem(%04x, %04x, %p) error %u\n",
2540            i, item[i].type, item[i].id, item[i].str, GetLastError());
2541     }
2542     return hmenu;
2543 }
2544
2545 static void compare_menu_data(HMENU hmenu, const struct menu_data *item, INT item_count)
2546 {
2547     INT count, i;
2548     BOOL ret;
2549
2550     count = GetMenuItemCount(hmenu);
2551     ok(count == item_count, "expected %d, got %d menu items\n", count, item_count);
2552
2553     for (i = 0; i < count; i++)
2554     {
2555         char buf[20];
2556         MENUITEMINFO mii;
2557
2558         memset(&mii, 0, sizeof(mii));
2559         mii.cbSize = sizeof(mii);
2560         mii.dwTypeData = buf;
2561         mii.cch = sizeof(buf);
2562         mii.fMask  = MIIM_FTYPE | MIIM_ID | MIIM_STRING | MIIM_BITMAP;
2563         ret = GetMenuItemInfo(hmenu, i, TRUE, &mii);
2564         ok(ret, "GetMenuItemInfo(%u) failed\n", i);
2565 #if 0
2566         trace("item #%u: fType %04x, fState %04x, wID %04x, hbmp %p\n",
2567                i, mii.fType, mii.fState, mii.wID, mii.hbmpItem);
2568 #endif
2569         ok(mii.fType == item[i].type,
2570            "%u: expected fType %04x, got %04x\n", i, item[i].type, mii.fType);
2571         ok(mii.wID == item[i].id,
2572            "%u: expected wID %04x, got %04x\n", i, item[i].id, mii.wID);
2573         if (mii.hbmpItem || !item[i].str)
2574             /* For some reason Windows sets high word to not 0 for
2575              * not "magic" ids.
2576              */
2577             ok(LOWORD(mii.hbmpItem) == LOWORD(item[i].str),
2578                "%u: expected hbmpItem %p, got %p\n", i, item[i].str, mii.hbmpItem);
2579         else
2580         {
2581             ok(mii.cch == strlen(item[i].str),
2582                "%u: expected cch %u, got %u\n", i, (UINT)strlen(item[i].str), mii.cch);
2583             ok(!strcmp(mii.dwTypeData, item[i].str),
2584                "%u: expected dwTypeData %s, got %s\n", i, item[i].str, (LPCSTR)mii.dwTypeData);
2585         }
2586     }
2587 }
2588
2589 static void test_InsertMenu(void)
2590 {
2591     HBITMAP hbm = CreateBitmap(1,1,1,1,NULL);
2592     /* Note: XP treats only bitmap handles 1 - 6 as "magic" ones
2593      * regardless of their id.
2594      */
2595     static const struct menu_data in1[] =
2596     {
2597         { MF_STRING, 1, "File" },
2598         { MF_BITMAP|MF_HELP, SC_CLOSE, MAKEINTRESOURCE(1) },
2599         { MF_STRING|MF_HELP, 2, "Help" }
2600     };
2601     static const struct menu_data out1[] =
2602     {
2603         { MF_STRING, 1, "File" },
2604         { MF_STRING|MF_HELP, 2, "Help" },
2605         { MF_BITMAP|MF_HELP, SC_CLOSE, MAKEINTRESOURCE(1) }
2606     };
2607     static const struct menu_data out1a[] =
2608     {
2609         { MF_STRING, 1, "File" },
2610         { MF_STRING|MF_HELP, 2, "Help" },
2611         { MF_HELP, SC_CLOSE, MAKEINTRESOURCE(1) }
2612     };
2613     const struct menu_data in2[] =
2614     {
2615         { MF_STRING, 1, "File" },
2616         { MF_BITMAP|MF_HELP, SC_CLOSE, (char*)hbm },
2617         { MF_STRING|MF_HELP, 2, "Help" }
2618     };
2619     const struct menu_data out2[] =
2620     {
2621         { MF_STRING, 1, "File" },
2622         { MF_BITMAP|MF_HELP, SC_CLOSE, (char*)hbm },
2623         { MF_STRING|MF_HELP, 2, "Help" }
2624     };
2625     const struct menu_data out2a[] =
2626     {
2627         { MF_STRING, 1, "File" },
2628         { MF_HELP, SC_CLOSE, (char*)hbm },
2629         { MF_STRING|MF_HELP, 2, "Help" }
2630     };
2631     static const struct menu_data in3[] =
2632     {
2633         { MF_STRING, 1, "File" },
2634         { MF_SEPARATOR|MF_HELP, SC_CLOSE, MAKEINTRESOURCE(1) },
2635         { MF_STRING|MF_HELP, 2, "Help" }
2636     };
2637     static const struct menu_data out3[] =
2638     {
2639         { MF_STRING, 1, "File" },
2640         { MF_SEPARATOR|MF_HELP, SC_CLOSE, MAKEINTRESOURCE(0) },
2641         { MF_STRING|MF_HELP, 2, "Help" },
2642     };
2643     static const struct menu_data in4[] =
2644     {
2645         { MF_STRING, 1, "File" },
2646         { MF_BITMAP|MF_HELP, 1, MAKEINTRESOURCE(1) },
2647         { MF_STRING|MF_HELP, 2, "Help" }
2648     };
2649     static const struct menu_data out4[] =
2650     {
2651         { MF_STRING, 1, "File" },
2652         { MF_STRING|MF_HELP, 2, "Help" },
2653         { MF_BITMAP|MF_HELP, 1, MAKEINTRESOURCE(1) }
2654     };
2655     static const struct menu_data out4a[] =
2656     {
2657         { MF_STRING, 1, "File" },
2658         { MF_STRING|MF_HELP, 2, "Help" },
2659         { MF_HELP, 1, MAKEINTRESOURCE(1) }
2660     };
2661     HMENU hmenu;
2662
2663 #define create_menu(a) create_menu_from_data((a), sizeof(a)/sizeof((a)[0]))
2664 #define create_menuitem(a) create_menuitem_from_data((a), sizeof(a)/sizeof((a)[0]))
2665 #define compare_menu(h, a) compare_menu_data((h), (a), sizeof(a)/sizeof((a)[0]))
2666
2667     hmenu = create_menu(in1);
2668     compare_menu(hmenu, out1);
2669     DestroyMenu(hmenu);
2670
2671     hmenu = create_menu(in2);
2672     compare_menu(hmenu, out2);
2673     DestroyMenu(hmenu);
2674
2675     hmenu = create_menu(in3);
2676     compare_menu(hmenu, out3);
2677     DestroyMenu(hmenu);
2678
2679     hmenu = create_menu(in4);
2680     compare_menu(hmenu, out4);
2681     DestroyMenu(hmenu);
2682
2683     /* now using InsertMenuItemInfo */
2684     hmenu = create_menuitem(in1);
2685     compare_menu(hmenu, out1a);
2686     DestroyMenu(hmenu);
2687
2688     hmenu = create_menuitem(in2);
2689     compare_menu(hmenu, out2a);
2690     DestroyMenu(hmenu);
2691
2692     hmenu = create_menuitem(in3);
2693     compare_menu(hmenu, out3);
2694     DestroyMenu(hmenu);
2695
2696     hmenu = create_menuitem(in4);
2697     compare_menu(hmenu, out4a);
2698     DestroyMenu(hmenu);
2699
2700 #undef create_menu
2701 #undef create_menuitem
2702 #undef compare_menu
2703 }
2704
2705 static void test_menu_getmenuinfo(void)
2706 {
2707     HMENU hmenu;
2708     MENUINFO mi = {0};
2709     BOOL ret;
2710     DWORD gle;
2711
2712     if (!pGetMenuInfo)
2713     {
2714         win_skip("GetMenuInfo is not available\n");
2715         return;
2716     }
2717
2718     /* create a menu */
2719     hmenu = CreateMenu();
2720     assert( hmenu);
2721     /* test some parameter errors */
2722     SetLastError(0xdeadbeef);
2723     ret = pGetMenuInfo( hmenu, NULL);
2724     gle= GetLastError();
2725     ok( !ret, "GetMenuInfo() should have failed\n");
2726     ok( gle == ERROR_INVALID_PARAMETER ||
2727         broken(gle == 0xdeadbeef), /* Win98, WinME */
2728         "GetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
2729     SetLastError(0xdeadbeef);
2730     mi.cbSize = 0;
2731     ret = pGetMenuInfo( hmenu, &mi);
2732     gle= GetLastError();
2733     ok( !ret, "GetMenuInfo() should have failed\n");
2734     ok( gle == ERROR_INVALID_PARAMETER ||
2735         broken(gle == 0xdeadbeef), /* Win98, WinME */
2736         "GetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
2737     SetLastError(0xdeadbeef);
2738     mi.cbSize = sizeof( MENUINFO);
2739     ret = pGetMenuInfo( hmenu, &mi);
2740     gle= GetLastError();
2741     ok( ret, "GetMenuInfo() should have succeeded\n");
2742     ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
2743     SetLastError(0xdeadbeef);
2744     mi.cbSize = 0;
2745     ret = pGetMenuInfo( NULL, &mi);
2746     gle= GetLastError();
2747     ok( !ret, "GetMenuInfo() should have failed\n");
2748     ok( gle == ERROR_INVALID_PARAMETER ||
2749         broken(gle == 0xdeadbeef), /* Win98, WinME */
2750         "GetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
2751     /* clean up */
2752     DestroyMenu( hmenu);
2753     return;
2754 }
2755
2756 static void test_menu_setmenuinfo(void)
2757 {
2758     HMENU hmenu, hsubmenu;
2759     MENUINFO mi = {0};
2760     MENUITEMINFOA mii = {sizeof( MENUITEMINFOA)};
2761     BOOL ret;
2762     DWORD gle;
2763
2764     if (!pGetMenuInfo || !pSetMenuInfo)
2765     {
2766         win_skip("Get/SetMenuInfo are not available\n");
2767         return;
2768     }
2769
2770     /* create a menu with a submenu */
2771     hmenu = CreateMenu();
2772     hsubmenu = CreateMenu();
2773     assert( hmenu && hsubmenu);
2774     mii.fMask = MIIM_SUBMENU;
2775     mii.hSubMenu = hsubmenu;
2776     ret = InsertMenuItem( hmenu, 0, FALSE, &mii);
2777     ok( ret, "InsertMenuItem failed with error %d\n", GetLastError());
2778     /* test some parameter errors */
2779     SetLastError(0xdeadbeef);
2780     ret = pSetMenuInfo( hmenu, NULL);
2781     gle= GetLastError();
2782     ok( !ret, "SetMenuInfo() should have failed\n");
2783     ok( gle == ERROR_INVALID_PARAMETER ||
2784         broken(gle == 0xdeadbeef), /* Win98, WinME */
2785         "SetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
2786     SetLastError(0xdeadbeef);
2787     mi.cbSize = 0;
2788     ret = pSetMenuInfo( hmenu, &mi);
2789     gle= GetLastError();
2790     ok( !ret, "SetMenuInfo() should have failed\n");
2791     ok( gle == ERROR_INVALID_PARAMETER ||
2792         broken(gle == 0xdeadbeef), /* Win98, WinME */
2793         "SetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
2794     SetLastError(0xdeadbeef);
2795     mi.cbSize = sizeof( MENUINFO);
2796     ret = pSetMenuInfo( hmenu, &mi);
2797     gle= GetLastError();
2798     ok( ret, "SetMenuInfo() should have succeeded\n");
2799     ok( gle == 0xdeadbeef, "SetMenuInfo() error got %u\n", gle);
2800     SetLastError(0xdeadbeef);
2801     mi.cbSize = 0;
2802     ret = pSetMenuInfo( NULL, &mi);
2803     gle= GetLastError();
2804     ok( !ret, "SetMenuInfo() should have failed\n");
2805     ok( gle == ERROR_INVALID_PARAMETER ||
2806         broken(gle == 0xdeadbeef), /* Win98, WinME */
2807         "SetMenuInfo() error got %u expected %u\n", gle, ERROR_INVALID_PARAMETER);
2808     /* functional tests */
2809     /* menu and submenu should have the CHECKORBMP style bit cleared */
2810     SetLastError(0xdeadbeef);
2811     mi.cbSize = sizeof( MENUINFO);
2812     mi.fMask = MIM_STYLE;
2813     ret = pGetMenuInfo( hmenu, &mi);
2814     gle= GetLastError();
2815     ok( ret, "GetMenuInfo() should have succeeded\n");
2816     ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
2817     ok( !(mi.dwStyle & MNS_CHECKORBMP), "menustyle was not expected to have the MNS_CHECKORBMP flag\n");
2818     SetLastError(0xdeadbeef);
2819     mi.cbSize = sizeof( MENUINFO);
2820     mi.fMask = MIM_STYLE;
2821     ret = pGetMenuInfo( hsubmenu, &mi);
2822     gle= GetLastError();
2823     ok( ret, "GetMenuInfo() should have succeeded\n");
2824     ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
2825     ok( !(mi.dwStyle & MNS_CHECKORBMP), "menustyle was not expected to have the MNS_CHECKORBMP flag\n");
2826     /* SetMenuInfo() */
2827     SetLastError(0xdeadbeef);
2828     mi.cbSize = sizeof( MENUINFO);
2829     mi.fMask = MIM_STYLE | MIM_APPLYTOSUBMENUS;
2830     mi.dwStyle = MNS_CHECKORBMP;
2831     ret = pSetMenuInfo( hmenu, &mi);
2832     gle= GetLastError();
2833     ok( ret, "SetMenuInfo() should have succeeded\n");
2834     ok( gle == 0xdeadbeef, "SetMenuInfo() error got %u\n", gle);
2835     /* Now both menus should have the MNS_CHECKORBMP style bit set */
2836     SetLastError(0xdeadbeef);
2837     mi.cbSize = sizeof( MENUINFO);
2838     mi.fMask = MIM_STYLE;
2839     ret = pGetMenuInfo( hmenu, &mi);
2840     gle= GetLastError();
2841     ok( ret, "GetMenuInfo() should have succeeded\n");
2842     ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
2843     ok( mi.dwStyle & MNS_CHECKORBMP, "menustyle was expected to have the MNS_CHECKORBMP flag\n");
2844     SetLastError(0xdeadbeef);
2845     mi.cbSize = sizeof( MENUINFO);
2846     mi.fMask = MIM_STYLE;
2847     ret = pGetMenuInfo( hsubmenu, &mi);
2848     gle= GetLastError();
2849     ok( ret, "GetMenuInfo() should have succeeded\n");
2850     ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
2851     ok( mi.dwStyle & MNS_CHECKORBMP, "menustyle was expected to have the MNS_CHECKORBMP flag\n");
2852     /* now repeat that without the APPLYTOSUBMENUS flag and another style bit */
2853     SetLastError(0xdeadbeef);
2854     mi.cbSize = sizeof( MENUINFO);
2855     mi.fMask = MIM_STYLE ;
2856     mi.dwStyle = MNS_NOCHECK;
2857     ret = pSetMenuInfo( hmenu, &mi);
2858     gle= GetLastError();
2859     ok( ret, "SetMenuInfo() should have succeeded\n");
2860     ok( gle == 0xdeadbeef, "SetMenuInfo() error got %u\n", gle);
2861     /* Now only the top menu should have the MNS_NOCHECK style bit set */
2862     SetLastError(0xdeadbeef);
2863     mi.cbSize = sizeof( MENUINFO);
2864     mi.fMask = MIM_STYLE;
2865     ret = pGetMenuInfo( hmenu, &mi);
2866     gle= GetLastError();
2867     ok( ret, "GetMenuInfo() should have succeeded\n");
2868     ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
2869     ok( mi.dwStyle & MNS_NOCHECK, "menustyle was expected to have the MNS_NOCHECK flag\n");
2870     SetLastError(0xdeadbeef);
2871     mi.cbSize = sizeof( MENUINFO);
2872     mi.fMask = MIM_STYLE;
2873     ret = pGetMenuInfo( hsubmenu, &mi);
2874     gle= GetLastError();
2875     ok( ret, "GetMenuInfo() should have succeeded\n");
2876     ok( gle == 0xdeadbeef, "GetMenuInfo() error got %u\n", gle);
2877     ok( !(mi.dwStyle & MNS_NOCHECK), "menustyle was not expected to have the MNS_NOCHECK flag\n");
2878     /* clean up */
2879     DestroyMenu( hsubmenu);
2880     DestroyMenu( hmenu);
2881     return;
2882 }
2883
2884 /* little func to easy switch either TrackPopupMenu() or TrackPopupMenuEx() */
2885 static DWORD MyTrackPopupMenu( int ex, HMENU hmenu, UINT flags, INT x, INT y, HWND hwnd, LPTPMPARAMS ptpm)
2886 {
2887     return ex
2888         ? TrackPopupMenuEx( hmenu, flags, x, y, hwnd, ptpm)
2889         : TrackPopupMenu( hmenu, flags, x, y, 0, hwnd, NULL);
2890 }
2891
2892 /* some TrackPopupMenu and TrackPopupMenuEx tests */
2893 /* the LastError values differ between NO_ERROR and invalid handle */
2894 /* between all windows versions tested. The first value is that valid on XP  */
2895 /* Vista was the only that made returned different error values */
2896 /* between the TrackPopupMenu and TrackPopupMenuEx functions */
2897 static void test_menu_trackpopupmenu(void)
2898 {
2899     BOOL ret;
2900     HMENU hmenu;
2901     DWORD gle;
2902     int Ex;
2903     HWND hwnd = CreateWindowEx(0, MAKEINTATOM(atomMenuCheckClass), NULL,
2904             WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
2905             NULL, NULL, NULL, NULL);
2906     ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
2907     if (!hwnd) return;
2908     SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_ownerdraw_wnd_proc);
2909     for( Ex = 0; Ex < 2; Ex++)
2910     {
2911         hmenu = CreatePopupMenu();
2912         ok(hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
2913         if (!hmenu)
2914         {
2915             DestroyWindow(hwnd);
2916             return;
2917         }
2918         /* display the menu */
2919         /* start with an invalid menu handle */
2920         SetLastError(0xdeadbeef);
2921
2922         gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
2923         ret = MyTrackPopupMenu( Ex, NULL, TPM_RETURNCMD, 100,100, hwnd, NULL);
2924         gle = GetLastError();
2925         ok( !ret, "TrackPopupMenu%s should have failed\n", Ex ? "Ex" : "");
2926         ok( gle == ERROR_INVALID_MENU_HANDLE
2927             || broken (gle == 0xdeadbeef) /* win95 */
2928             || broken (gle == NO_ERROR) /* win98/ME */
2929             ,"TrackPopupMenu%s error got %u expected %u\n",
2930             Ex ? "Ex" : "", gle, ERROR_INVALID_MENU_HANDLE);
2931         ok( !(gflag_initmenupopup || gflag_entermenuloop || gflag_initmenu),
2932                 "got unexpected message(s)%s%s%s\n",
2933                 gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
2934                 gflag_entermenuloop ? "WM_INITMENULOOP ": "",
2935                 gflag_initmenu ? "WM_INITMENU": "");
2936         /* another one but not NULL */
2937         SetLastError(0xdeadbeef);
2938         gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
2939         ret = MyTrackPopupMenu( Ex, (HMENU)hwnd, TPM_RETURNCMD, 100,100, hwnd, NULL);
2940         gle = GetLastError();
2941         ok( !ret, "TrackPopupMenu%s should have failed\n", Ex ? "Ex" : "");
2942         ok( gle == ERROR_INVALID_MENU_HANDLE
2943             || broken (gle == 0xdeadbeef) /* win95 */
2944             || broken (gle == NO_ERROR) /* win98/ME */
2945             ,"TrackPopupMenu%s error got %u expected %u\n",
2946             Ex ? "Ex" : "", gle, ERROR_INVALID_MENU_HANDLE);
2947         ok( !(gflag_initmenupopup || gflag_entermenuloop || gflag_initmenu),
2948                 "got unexpected message(s)%s%s%s\n",
2949                 gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
2950                 gflag_entermenuloop ? "WM_INITMENULOOP ": "",
2951                 gflag_initmenu ? "WM_INITMENU": "");
2952
2953         /* invalid window */
2954         SetLastError(0xdeadbeef);
2955         gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
2956         ret = MyTrackPopupMenu( Ex, hmenu, TPM_RETURNCMD, 100,100, 0, NULL);
2957         gle = GetLastError();
2958         ok( !ret, "TrackPopupMenu%s should have failed\n", Ex ? "Ex" : "");
2959         ok( gle == ERROR_INVALID_WINDOW_HANDLE, "TrackPopupMenu%s error got %u\n", Ex ? "Ex" : "", gle );
2960         ok( !(gflag_initmenupopup || gflag_entermenuloop || gflag_initmenu),
2961                 "got unexpected message(s)%s%s%s\n",
2962                 gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
2963                 gflag_entermenuloop ? "WM_INITMENULOOP ": "",
2964                 gflag_initmenu ? "WM_INITMENU": "");
2965
2966         /* now a somewhat successful call */
2967         SetLastError(0xdeadbeef);
2968         gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
2969         ret = MyTrackPopupMenu( Ex, hmenu, TPM_RETURNCMD, 100,100, hwnd, NULL);
2970         gle = GetLastError();
2971         ok( ret == 0, "TrackPopupMenu%s returned %d expected zero\n", Ex ? "Ex" : "", ret);
2972         ok( gle == NO_ERROR
2973             || gle == ERROR_INVALID_MENU_HANDLE /* NT4, win2k */
2974             || broken (gle == 0xdeadbeef) /* win95 */
2975             ,"TrackPopupMenu%s error got %u expected %u or %u\n",
2976             Ex ? "Ex" : "", gle, NO_ERROR, ERROR_INVALID_MENU_HANDLE);
2977         ok( gflag_initmenupopup && gflag_entermenuloop && gflag_initmenu,
2978                 "missed expected message(s)%s%s%s\n",
2979                 !gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
2980                 !gflag_entermenuloop ? "WM_INITMENULOOP ": "",
2981                 !gflag_initmenu ? "WM_INITMENU": "");
2982         /* and another */
2983         ret = AppendMenuA( hmenu, MF_STRING, 1, "winetest");
2984         ok( ret, "AppendMenA has failed!\n");
2985         SetLastError(0xdeadbeef);
2986         gflag_initmenupopup = gflag_entermenuloop = gflag_initmenu = 0;
2987         ret = MyTrackPopupMenu( Ex, hmenu, TPM_RETURNCMD, 100,100, hwnd, NULL);
2988         gle = GetLastError();
2989         ok( ret == 0, "TrackPopupMenu%s returned %d expected zero\n", Ex ? "Ex" : "", ret);
2990         ok( gle == NO_ERROR
2991             || gle == ERROR_INVALID_MENU_HANDLE /* NT4, win2k and Vista in the TrackPopupMenuEx case */
2992             || broken (gle == 0xdeadbeef) /* win95 */
2993             ,"TrackPopupMenu%s error got %u expected %u or %u\n",
2994             Ex ? "Ex" : "", gle, NO_ERROR, ERROR_INVALID_MENU_HANDLE);
2995         ok( gflag_initmenupopup && gflag_entermenuloop && gflag_initmenu,
2996                 "missed expected message(s)%s%s%s\n",
2997                 !gflag_initmenupopup ? " WM_INITMENUPOPUP ": " ",
2998                 !gflag_entermenuloop ? "WM_INITMENULOOP ": "",
2999                 !gflag_initmenu ? "WM_INITMENU": "");
3000         DestroyMenu(hmenu);
3001     }
3002     /* clean up */
3003     DestroyWindow(hwnd);
3004 }
3005
3006 static HMENU g_hmenu;
3007
3008 static LRESULT WINAPI menu_track_again_wnd_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
3009 {
3010     switch (msg)
3011     {
3012     case WM_ENTERMENULOOP:
3013     {
3014         BOOL ret;
3015
3016         /* try a recursive call */
3017         SetLastError(0xdeadbeef);
3018         ret = TrackPopupMenu(g_hmenu, 0, 100, 100, 0, hwnd, NULL);
3019         ok(ret == FALSE, "got %d\n", ret);
3020         ok(GetLastError() == ERROR_POPUP_ALREADY_ACTIVE ||
3021            broken(GetLastError() == 0xdeadbeef) /* W9x */, "got %d\n", GetLastError());
3022
3023         /* exit menu modal loop
3024          * ( A SendMessage does not work on NT3.51 here ) */
3025         return PostMessage(hwnd, WM_CANCELMODE, 0, 0);
3026     }
3027     }
3028     return DefWindowProc(hwnd, msg, wparam, lparam);
3029 }
3030
3031 static void test_menu_trackagain(void)
3032 {
3033     HWND hwnd;
3034     BOOL ret;
3035
3036     hwnd = CreateWindowEx(0, MAKEINTATOM(atomMenuCheckClass), NULL,
3037             WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
3038             NULL, NULL, NULL, NULL);
3039     ok(hwnd != NULL, "CreateWindowEx failed with error %d\n", GetLastError());
3040     if (!hwnd) return;
3041     SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_track_again_wnd_proc);
3042
3043     g_hmenu = CreatePopupMenu();
3044     ok(g_hmenu != NULL, "CreateMenu failed with error %d\n", GetLastError());
3045
3046     ret = TrackPopupMenu( g_hmenu, 0, 100, 100, 0, hwnd, NULL);
3047     todo_wine ok(ret == FALSE, "got %d\n", ret);
3048
3049     DestroyMenu(g_hmenu);
3050     DestroyWindow(hwnd);
3051 }
3052
3053 /* test handling of WM_CANCELMODE messages */
3054 static int g_got_enteridle;
3055 static HWND g_hwndtosend;
3056 static LRESULT WINAPI menu_cancelmode_wnd_proc(HWND hwnd, UINT msg,
3057         WPARAM wparam, LPARAM lparam)
3058 {
3059     switch (msg)
3060     {
3061         case WM_ENTERMENULOOP:
3062             g_got_enteridle = 0;
3063             return SendMessage( g_hwndtosend, WM_CANCELMODE, 0, 0);
3064         case WM_ENTERIDLE:
3065             {
3066                 if( g_got_enteridle++ == 0) {
3067                     /* little hack to get another WM_ENTERIDLE message */
3068                     PostMessage( hwnd, WM_MOUSEMOVE, 0, 0);
3069                     return SendMessage( g_hwndtosend, WM_CANCELMODE, 0, 0);
3070                 }
3071                 pEndMenu();
3072                 return TRUE;
3073             }
3074     }
3075     return DefWindowProc( hwnd, msg, wparam, lparam);
3076 }
3077
3078 static void test_menu_cancelmode(void)
3079 {
3080     DWORD ret;
3081     HWND hwnd, hwndchild;
3082     HMENU menu;
3083     if( !pEndMenu) { /* win95 */
3084         win_skip( "EndMenu is not available\n");
3085         return;
3086     }
3087     hwnd = CreateWindowEx( 0, MAKEINTATOM(atomMenuCheckClass), NULL,
3088             WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 200, 200,
3089             NULL, NULL, NULL, NULL);
3090     hwndchild = CreateWindowEx( 0, MAKEINTATOM(atomMenuCheckClass), NULL,
3091             WS_VISIBLE | WS_CHILD, 10, 10, 20, 20,
3092             hwnd, NULL, NULL, NULL);
3093     ok( hwnd != NULL && hwndchild != NULL,
3094             "CreateWindowEx failed with error %d\n", GetLastError());
3095     g_hwndtosend = hwnd;
3096     SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR)menu_cancelmode_wnd_proc);
3097     SetWindowLongPtr( hwndchild, GWLP_WNDPROC, (LONG_PTR)menu_cancelmode_wnd_proc);
3098     menu = CreatePopupMenu();
3099     ok( menu != NULL, "CreatePopupMenu failed with error %d\n", GetLastError());
3100     ret = AppendMenuA( menu, MF_STRING, 1, "winetest");
3101     ok( ret, "Functie failed lasterror is %u\n", GetLastError());
3102     /* seems to be needed only on wine :( */
3103     {MSG msg;   while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessage(&msg);}
3104     /* test the effect of sending a WM_CANCELMODE message in the WM_INITMENULOOP
3105      * handler of the menu owner */
3106     /* test results is extracted from variable g_got_enteridle. Possible values:
3107      * 0 : complete conformance. Sending WM_CANCELMODE cancels a menu initializing tracking
3108      * 1 : Sending WM_CANCELMODE cancels a menu that is in tracking state
3109      * 2 : Sending WM_CANCELMODE does not work
3110      */
3111     /* menu owner is top level window */
3112     g_hwndtosend = hwnd;
3113     TrackPopupMenu( menu, TPM_RETURNCMD, 100,100, 0, hwnd, NULL);
3114     todo_wine {
3115         ok( g_got_enteridle == 0, "received %d WM_ENTERIDLE messages, none expected\n", g_got_enteridle);
3116     }
3117     ok( g_got_enteridle < 2, "received %d WM_ENTERIDLE messages, should be less than 2\n", g_got_enteridle);
3118     /* menu owner is child window */
3119     g_hwndtosend = hwndchild;
3120     TrackPopupMenu( menu, TPM_RETURNCMD, 100,100, 0, hwndchild, NULL);
3121     todo_wine {
3122         ok(g_got_enteridle == 0, "received %d WM_ENTERIDLE messages, none expected\n", g_got_enteridle);
3123     }
3124     ok(g_got_enteridle < 2, "received %d WM_ENTERIDLE messages, should be less than 2\n", g_got_enteridle);
3125     /* now send the WM_CANCELMODE messages to the WRONG window */
3126     /* those should fail ( to have any effect) */
3127     g_hwndtosend = hwnd;
3128     TrackPopupMenu( menu, TPM_RETURNCMD, 100,100, 0, hwndchild, NULL);
3129     ok( g_got_enteridle == 2, "received %d WM_ENTERIDLE messages, should be 2\n", g_got_enteridle);
3130     /* cleanup */
3131     DestroyMenu( menu);
3132     DestroyWindow( hwndchild);
3133     DestroyWindow( hwnd);
3134 }
3135
3136 /* show menu trees have a maximum depth */
3137 static void test_menu_maxdepth(void)
3138 {
3139 #define NR_MENUS 100
3140     HMENU hmenus[ NR_MENUS];
3141     int i;
3142     DWORD ret;
3143
3144     SetLastError(12345678);
3145     for( i = 0; i < NR_MENUS; i++) {
3146         hmenus[i] = CreatePopupMenu();
3147         if( !hmenus[i]) break;
3148     }
3149     ok( i == NR_MENUS, "could not create more than %d menu's\n", i);
3150     for( i = 1; i < NR_MENUS; i++) {
3151         ret = AppendMenuA( hmenus[i], MF_POPUP, (UINT_PTR)hmenus[i-1],"test");
3152         if( !ret) break;
3153     }
3154     trace("Maximum depth is %d\n", i);
3155     ok( GetLastError() == 12345678, "unexpected error %d\n",  GetLastError());
3156     ok( i < NR_MENUS ||
3157            broken( i == NR_MENUS), /* win98, NT */
3158            "no ( or very large) limit on menu depth!\n");
3159
3160     for( i = 0; i < NR_MENUS; i++)
3161         DestroyMenu( hmenus[i]);
3162 }
3163
3164 /* bug #12171 */
3165 static void test_menu_circref(void)
3166 {
3167     HMENU menu1, menu2;
3168     DWORD ret;
3169
3170     menu1 = CreatePopupMenu();
3171     menu2 = CreatePopupMenu();
3172     ok( menu1 && menu2, "error creating menus.\n");
3173     ret = AppendMenuA( menu1, MF_POPUP, (UINT_PTR)menu2, "winetest");
3174     ok( ret, "AppendMenu failed, error is %d\n", GetLastError());
3175     ret = AppendMenuA( menu1, MF_STRING | MF_HILITE, 123, "winetest");
3176     ok( ret, "AppendMenu failed, error is %d\n", GetLastError());
3177     /* app chooses an id that happens to clash with its own hmenu */
3178     ret = AppendMenuA( menu2, MF_STRING, (UINT_PTR)menu2, "winetest");
3179     ok( ret, "AppendMenu failed, error is %d\n", GetLastError());
3180     /* now attempt to change the string of the first item of menu1 */
3181     ret = ModifyMenuA( menu1, (UINT_PTR)menu2, MF_POPUP, (UINT_PTR)menu2, "menu 2");
3182     ok( !ret ||
3183             broken( ret), /* win98, NT */
3184             "ModifyMenu should have failed.\n");
3185     if( !ret) { /* will probably stack fault if the ModifyMenu succeeded */
3186         ret = GetMenuState( menu1, 123, 0);
3187         ok( ret == MF_HILITE, "GetMenuState returned %x\n",ret);
3188     }
3189     DestroyMenu( menu2);
3190     DestroyMenu( menu1);
3191 }
3192
3193 /* test how the menu texts are aligned when the menu items have
3194  * different combinations of text and bitmaps (bug #13350) */
3195 static void test_menualign(void)
3196 {
3197     BYTE bmfill[300];
3198     HMENU menu;
3199     HBITMAP hbm1, hbm2, hbm3;
3200     MENUITEMINFO mii = { sizeof(MENUITEMINFO)};
3201     DWORD ret;
3202     HWND hwnd;
3203     MENUINFO mi = { sizeof( MENUINFO)};
3204
3205     if( !winetest_interactive) {
3206         skip( "interactive alignment tests.\n");
3207         return;
3208     }
3209     hwnd = CreateWindowEx(0,
3210             "STATIC",
3211             "Menu text alignment Test\nPlease make a selection.",
3212             WS_OVERLAPPEDWINDOW,
3213             100, 100,
3214             300, 300,
3215             NULL, NULL, 0, NULL);
3216     ShowWindow( hwnd, SW_SHOW);
3217     /* create bitmaps */
3218     memset( bmfill, 0xcc, sizeof( bmfill));
3219     hbm1 = CreateBitmap( 10,10,1,1,bmfill);
3220     hbm2 = CreateBitmap( 20,20,1,1,bmfill);
3221     hbm3 = CreateBitmap( 50,6,1,1,bmfill);
3222     ok( hbm1 && hbm2 && hbm3, "Creating bitmaps failed\n");
3223     menu = CreatePopupMenu();
3224     ok( menu != NULL, "CreatePopupMenu() failed\n");
3225     if( pGetMenuInfo) {
3226         mi.fMask = MIM_STYLE;
3227         ret = pGetMenuInfo( menu, &mi);
3228         ok( ret, "GetMenuInfo failed: %d\n", GetLastError());
3229         ok( menu != NULL, "GetMenuInfo() failed\n");
3230         ok( 0 == mi.dwStyle, "menuinfo style is %x\n", mi.dwStyle);
3231     }
3232     /* test 1 */
3233     mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID;
3234     mii.wID = 1;
3235     mii.hbmpItem = hbm1;
3236     mii.dwTypeData = (LPSTR) " OK: menu texts are correctly left-aligned.";
3237     ret = InsertMenuItem( menu, -1, TRUE, &mii);
3238     ok( ret, "InsertMenuItem() failed\n");
3239     mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID ;
3240     mii.wID = 2;
3241     mii.hbmpItem = hbm2;
3242     mii.dwTypeData = (LPSTR) " FAIL: menu texts are NOT left-aligned.";
3243     ret = InsertMenuItem( menu, -1, TRUE, &mii);
3244     ok( ret, "InsertMenuItem() failed\n");
3245     ret = TrackPopupMenu( menu, TPM_RETURNCMD, 110, 200, 0, hwnd, NULL);
3246     ok( ret != 2, "User indicated that menu text alignment test 1 failed %d\n", ret);
3247     /* test 2*/
3248     mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID;
3249     mii.wID = 3;
3250     mii.hbmpItem = hbm3;
3251     mii.dwTypeData = NULL;
3252     ret = InsertMenuItem( menu, 0, TRUE, &mii);
3253     ok( ret, "InsertMenuItem() failed\n");
3254     mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID;
3255     mii.wID = 1;
3256     mii.hbmpItem = hbm1;
3257     /* make the text a bit longer, to keep it readable */
3258     /* this bug is on winXP and reproduced on wine */
3259     mii.dwTypeData = (LPSTR) " OK: menu texts are to the right of the bitmaps........";
3260     ret = SetMenuItemInfo( menu, 1, TRUE, &mii);
3261     ok( ret, "SetMenuItemInfo() failed\n");
3262     mii.wID = 2;
3263     mii.hbmpItem = hbm2;
3264     mii.dwTypeData = (LPSTR) " FAIL: menu texts are below the first bitmap.  ";
3265     ret = SetMenuItemInfo( menu, 2, TRUE, &mii);
3266     ok( ret, "SetMenuItemInfo() failed\n");
3267     ret = TrackPopupMenu( menu, TPM_RETURNCMD, 110, 200, 0, hwnd, NULL);
3268     ok( ret != 2, "User indicated that menu text alignment test 2 failed %d\n", ret);
3269     /* test 3 */
3270     mii.fMask = MIIM_TYPE | MIIM_ID;
3271     mii.wID = 3;
3272     mii.fType = MFT_BITMAP;
3273     mii.dwTypeData = (LPSTR) hbm3;
3274     ret = SetMenuItemInfo( menu, 0, TRUE, &mii);
3275     ok( ret, "SetMenuItemInfo() failed\n");
3276     mii.fMask = MIIM_BITMAP | MIIM_STRING | MIIM_ID;
3277     mii.wID = 1;
3278     mii.hbmpItem = NULL;
3279     mii.dwTypeData = (LPSTR) " OK: menu texts are below the bitmap.";
3280     ret = SetMenuItemInfo( menu, 1, TRUE, &mii);
3281     ok( ret, "SetMenuItemInfo() failed\n");
3282     mii.wID = 2;
3283     mii.hbmpItem = NULL;
3284     mii.dwTypeData = (LPSTR) " FAIL: menu texts are NOT below the bitmap.";
3285     ret = SetMenuItemInfo( menu, 2, TRUE, &mii);
3286     ok( ret, "SetMenuItemInfo() failed\n");
3287     ret = TrackPopupMenu( menu, TPM_RETURNCMD, 110, 200, 0, hwnd, NULL);
3288     ok( ret != 2, "User indicated that menu text alignment test 3 failed %d\n", ret);
3289     /* cleanup */
3290     DeleteObject( hbm1);
3291     DeleteObject( hbm2);
3292     DeleteObject( hbm3);
3293     DestroyMenu( menu);
3294     DestroyWindow( hwnd);
3295 }
3296
3297 START_TEST(menu)
3298 {
3299     init_function_pointers();
3300
3301     /* Wine defines MENUITEMINFO for W2K and above. NT4 and below can't
3302      * handle that.
3303      */
3304     if (correct_behavior())
3305     {
3306         test_menu_add_string();
3307         test_menu_iteminfo();
3308         test_menu_search_bycommand();
3309         test_CheckMenuRadioItem();
3310         test_menu_resource_layout();
3311         test_InsertMenu();
3312         test_menualign();
3313     }
3314
3315     register_menu_check_class();
3316
3317     test_menu_locked_by_window();
3318     test_subpopup_locked_by_menu();
3319     test_menu_ownerdraw();
3320     test_menu_bmp_and_string();
3321     test_menu_getmenuinfo();
3322     test_menu_setmenuinfo();
3323     test_menu_input();
3324     test_menu_flags();
3325
3326     test_menu_hilitemenuitem();
3327     test_menu_trackpopupmenu();
3328     test_menu_trackagain();
3329     test_menu_cancelmode();
3330     test_menu_maxdepth();
3331     test_menu_circref();
3332 }