user32/tests: Fix VK_RMENU input tests on localized Windows.
[wine] / dlls / user32 / tests / cursoricon.c
1 /*
2  * Unit test suite for cursors and icons.
3  *
4  * Copyright 2006 Michael Kaufmann
5  * Copyright 2007 Dmitry Timoshkov
6  * Copyright 2007-2008 Andrew Riedi
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include <assert.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27
28 #include "wine/test.h"
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winreg.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34
35 #include "pshpack1.h"
36
37 typedef struct
38 {
39     BYTE bWidth;
40     BYTE bHeight;
41     BYTE bColorCount;
42     BYTE bReserved;
43     WORD xHotspot;
44     WORD yHotspot;
45     DWORD dwDIBSize;
46     DWORD dwDIBOffset;
47 } CURSORICONFILEDIRENTRY;
48
49 typedef struct
50 {
51     WORD idReserved;
52     WORD idType;
53     WORD idCount;
54     CURSORICONFILEDIRENTRY idEntries[1];
55 } CURSORICONFILEDIR;
56
57 #include "poppack.h"
58
59 static char **test_argv;
60 static int test_argc;
61 static HWND child = 0;
62 static HWND parent = 0;
63 static HANDLE child_process;
64
65 #define PROC_INIT (WM_USER+1)
66
67 static LRESULT CALLBACK callback_child(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
68 {
69     BOOL ret;
70     DWORD error;
71
72     switch (msg)
73     {
74         /* Destroy the cursor. */
75         case WM_USER+1:
76             SetLastError(0xdeadbeef);
77             ret = DestroyCursor((HCURSOR) lParam);
78             error = GetLastError();
79             todo_wine ok(!ret || broken(ret) /* win9x */, "DestroyCursor on the active cursor succeeded.\n");
80             ok(error == ERROR_DESTROY_OBJECT_OF_OTHER_THREAD ||
81                error == 0xdeadbeef,  /* vista */
82                 "Last error: %u\n", error);
83             return TRUE;
84         case WM_DESTROY:
85             PostQuitMessage(0);
86             return 0;
87     }
88
89     return DefWindowProc(hwnd, msg, wParam, lParam);
90 }
91
92 static LRESULT CALLBACK callback_parent(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
93 {
94     if (msg == PROC_INIT)
95     {
96         child = (HWND) wParam;
97         return TRUE;
98     }
99
100     return DefWindowProc(hwnd, msg, wParam, lParam);
101 }
102
103 static void do_child(void)
104 {
105     WNDCLASS class;
106     MSG msg;
107     BOOL ret;
108
109     /* Register a new class. */
110     class.style = CS_GLOBALCLASS;
111     class.lpfnWndProc = callback_child;
112     class.cbClsExtra = 0;
113     class.cbWndExtra = 0;
114     class.hInstance = GetModuleHandle(NULL);
115     class.hIcon = NULL;
116     class.hCursor = NULL;
117     class.hbrBackground = NULL;
118     class.lpszMenuName = NULL;
119     class.lpszClassName = "cursor_child";
120
121     SetLastError(0xdeadbeef);
122     ret = RegisterClass(&class);
123     ok(ret, "Failed to register window class.  Error: %u\n", GetLastError());
124
125     /* Create a window. */
126     child = CreateWindowA("cursor_child", "cursor_child", WS_POPUP | WS_VISIBLE,
127         0, 0, 200, 200, 0, 0, 0, NULL);
128     ok(child != 0, "CreateWindowA failed.  Error: %u\n", GetLastError());
129
130     /* Let the parent know our HWND. */
131     PostMessage(parent, PROC_INIT, (WPARAM) child, 0);
132
133     /* Receive messages. */
134     while ((ret = GetMessage(&msg, 0, 0, 0)))
135     {
136         ok(ret != -1, "GetMessage failed.  Error: %u\n", GetLastError());
137         TranslateMessage(&msg);
138         DispatchMessage(&msg);
139     }
140 }
141
142 static void do_parent(void)
143 {
144     char path_name[MAX_PATH];
145     PROCESS_INFORMATION info;
146     STARTUPINFOA startup;
147     WNDCLASS class;
148     MSG msg;
149     BOOL ret;
150
151     /* Register a new class. */
152     class.style = CS_GLOBALCLASS;
153     class.lpfnWndProc = callback_parent;
154     class.cbClsExtra = 0;
155     class.cbWndExtra = 0;
156     class.hInstance = GetModuleHandle(NULL);
157     class.hIcon = NULL;
158     class.hCursor = NULL;
159     class.hbrBackground = NULL;
160     class.lpszMenuName = NULL;
161     class.lpszClassName = "cursor_parent";
162
163     SetLastError(0xdeadbeef);
164     ret = RegisterClass(&class);
165     ok(ret, "Failed to register window class.  Error: %u\n", GetLastError());
166
167     /* Create a window. */
168     parent = CreateWindowA("cursor_parent", "cursor_parent", WS_POPUP | WS_VISIBLE,
169         0, 0, 200, 200, 0, 0, 0, NULL);
170     ok(parent != 0, "CreateWindowA failed.  Error: %u\n", GetLastError());
171
172     /* Start child process. */
173     memset(&startup, 0, sizeof(startup));
174     startup.cb = sizeof(startup);
175     startup.dwFlags = STARTF_USESHOWWINDOW;
176     startup.wShowWindow = SW_SHOWNORMAL;
177
178     sprintf(path_name, "%s cursoricon %lx", test_argv[0], (INT_PTR)parent);
179     ok(CreateProcessA(NULL, path_name, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess failed.\n");
180     child_process = info.hProcess;
181
182     /* Wait for child window handle. */
183     while ((child == 0) && (ret = GetMessage(&msg, parent, 0, 0)))
184     {
185         ok(ret != -1, "GetMessage failed.  Error: %u\n", GetLastError());
186         TranslateMessage(&msg);
187         DispatchMessage(&msg);
188     }
189 }
190
191 static void finish_child_process(void)
192 {
193     SendMessage(child, WM_CLOSE, 0, 0);
194     winetest_wait_child_process( child_process );
195     CloseHandle(child_process);
196 }
197
198 static void test_child_process(void)
199 {
200     static const BYTE bmp_bits[4096];
201     HCURSOR cursor;
202     ICONINFO cursorInfo;
203     UINT display_bpp;
204     HDC hdc;
205
206     /* Create and set a dummy cursor. */
207     hdc = GetDC(0);
208     display_bpp = GetDeviceCaps(hdc, BITSPIXEL);
209     ReleaseDC(0, hdc);
210
211     cursorInfo.fIcon = FALSE;
212     cursorInfo.xHotspot = 0;
213     cursorInfo.yHotspot = 0;
214     cursorInfo.hbmMask = CreateBitmap(32, 32, 1, 1, bmp_bits);
215     cursorInfo.hbmColor = CreateBitmap(32, 32, 1, display_bpp, bmp_bits);
216
217     cursor = CreateIconIndirect(&cursorInfo);
218     ok(cursor != NULL, "CreateIconIndirect returned %p.\n", cursor);
219
220     SetCursor(cursor);
221
222     /* Destroy the cursor. */
223     SendMessage(child, WM_USER+1, 0, (LPARAM) cursor);
224 }
225
226 static void test_CopyImage_Check(HBITMAP bitmap, UINT flags, INT copyWidth, INT copyHeight,
227                                   INT expectedWidth, INT expectedHeight, WORD expectedDepth, BOOL dibExpected)
228 {
229     HBITMAP copy;
230     BITMAP origBitmap;
231     BITMAP copyBitmap;
232     BOOL orig_is_dib;
233     BOOL copy_is_dib;
234
235     copy = CopyImage(bitmap, IMAGE_BITMAP, copyWidth, copyHeight, flags);
236     ok(copy != NULL, "CopyImage() failed\n");
237     if (copy != NULL)
238     {
239         GetObject(bitmap, sizeof(origBitmap), &origBitmap);
240         GetObject(copy, sizeof(copyBitmap), &copyBitmap);
241         orig_is_dib = (origBitmap.bmBits != NULL);
242         copy_is_dib = (copyBitmap.bmBits != NULL);
243
244         if (copy_is_dib && dibExpected
245             && copyBitmap.bmBitsPixel == 24
246             && (expectedDepth == 16 || expectedDepth == 32))
247         {
248             /* Windows 95 doesn't create DIBs with a depth of 16 or 32 bit */
249             if (GetVersion() & 0x80000000)
250             {
251                 expectedDepth = 24;
252             }
253         }
254
255         if (copy_is_dib && !dibExpected && !(flags & LR_CREATEDIBSECTION))
256         {
257             /* It's not forbidden to create a DIB section if the flag
258                LR_CREATEDIBSECTION is absent.
259                Windows 9x does this if the bitmap has a depth that doesn't
260                match the screen depth, Windows NT doesn't */
261             dibExpected = TRUE;
262             expectedDepth = origBitmap.bmBitsPixel;
263         }
264
265         ok((!(dibExpected ^ copy_is_dib)
266              && (copyBitmap.bmWidth == expectedWidth)
267              && (copyBitmap.bmHeight == expectedHeight)
268              && (copyBitmap.bmBitsPixel == expectedDepth)),
269              "CopyImage ((%s, %dx%d, %u bpp), %d, %d, %#x): Expected (%s, %dx%d, %u bpp), got (%s, %dx%d, %u bpp)\n",
270                   orig_is_dib ? "DIB" : "DDB", origBitmap.bmWidth, origBitmap.bmHeight, origBitmap.bmBitsPixel,
271                   copyWidth, copyHeight, flags,
272                   dibExpected ? "DIB" : "DDB", expectedWidth, expectedHeight, expectedDepth,
273                   copy_is_dib ? "DIB" : "DDB", copyBitmap.bmWidth, copyBitmap.bmHeight, copyBitmap.bmBitsPixel);
274
275         DeleteObject(copy);
276     }
277 }
278
279 static void test_CopyImage_Bitmap(int depth)
280 {
281     HBITMAP ddb, dib;
282     HDC screenDC;
283     BITMAPINFO * info;
284     VOID * bits;
285     int screen_depth;
286     unsigned int i;
287
288     /* Create a device-independent bitmap (DIB) */
289     info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
290     info->bmiHeader.biSize = sizeof(info->bmiHeader);
291     info->bmiHeader.biWidth = 2;
292     info->bmiHeader.biHeight = 2;
293     info->bmiHeader.biPlanes = 1;
294     info->bmiHeader.biBitCount = depth;
295     info->bmiHeader.biCompression = BI_RGB;
296
297     for (i=0; i < 256; i++)
298     {
299         info->bmiColors[i].rgbRed = i;
300         info->bmiColors[i].rgbGreen = i;
301         info->bmiColors[i].rgbBlue = 255 - i;
302         info->bmiColors[i].rgbReserved = 0;
303     }
304
305     dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
306
307     /* Create a device-dependent bitmap (DDB) */
308     screenDC = GetDC(NULL);
309     screen_depth = GetDeviceCaps(screenDC, BITSPIXEL);
310     if (depth == 1 || depth == screen_depth)
311     {
312         ddb = CreateBitmap(2, 2, 1, depth, NULL);
313     }
314     else
315     {
316         ddb = NULL;
317     }
318     ReleaseDC(NULL, screenDC);
319
320     if (ddb != NULL)
321     {
322         test_CopyImage_Check(ddb, 0, 0, 0, 2, 2, depth == 1 ? 1 : screen_depth, FALSE);
323         test_CopyImage_Check(ddb, 0, 0, 5, 2, 5, depth == 1 ? 1 : screen_depth, FALSE);
324         test_CopyImage_Check(ddb, 0, 5, 0, 5, 2, depth == 1 ? 1 : screen_depth, FALSE);
325         test_CopyImage_Check(ddb, 0, 5, 5, 5, 5, depth == 1 ? 1 : screen_depth, FALSE);
326
327         test_CopyImage_Check(ddb, LR_MONOCHROME, 0, 0, 2, 2, 1, FALSE);
328         test_CopyImage_Check(ddb, LR_MONOCHROME, 5, 0, 5, 2, 1, FALSE);
329         test_CopyImage_Check(ddb, LR_MONOCHROME, 0, 5, 2, 5, 1, FALSE);
330         test_CopyImage_Check(ddb, LR_MONOCHROME, 5, 5, 5, 5, 1, FALSE);
331
332         test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE);
333         test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE);
334         test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE);
335         test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE);
336
337         /* LR_MONOCHROME is ignored if LR_CREATEDIBSECTION is present */
338         test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE);
339         test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE);
340         test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE);
341         test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE);
342
343         DeleteObject(ddb);
344     }
345
346     if (depth != 1)
347     {
348         test_CopyImage_Check(dib, 0, 0, 0, 2, 2, screen_depth, FALSE);
349         test_CopyImage_Check(dib, 0, 5, 0, 5, 2, screen_depth, FALSE);
350         test_CopyImage_Check(dib, 0, 0, 5, 2, 5, screen_depth, FALSE);
351         test_CopyImage_Check(dib, 0, 5, 5, 5, 5, screen_depth, FALSE);
352     }
353
354     test_CopyImage_Check(dib, LR_MONOCHROME, 0, 0, 2, 2, 1, FALSE);
355     test_CopyImage_Check(dib, LR_MONOCHROME, 5, 0, 5, 2, 1, FALSE);
356     test_CopyImage_Check(dib, LR_MONOCHROME, 0, 5, 2, 5, 1, FALSE);
357     test_CopyImage_Check(dib, LR_MONOCHROME, 5, 5, 5, 5, 1, FALSE);
358
359     test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE);
360     test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE);
361     test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE);
362     test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE);
363
364     /* LR_MONOCHROME is ignored if LR_CREATEDIBSECTION is present */
365     test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE);
366     test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE);
367     test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE);
368     test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE);
369
370     DeleteObject(dib);
371
372     if (depth == 1)
373     {
374         /* Special case: A monochrome DIB is converted to a monochrome DDB if
375            the colors in the color table are black and white.
376
377            Skip this test on Windows 95, it always creates a monochrome DDB
378            in this case */
379
380         if (!(GetVersion() & 0x80000000))
381         {
382             info->bmiHeader.biBitCount = 1;
383             info->bmiColors[0].rgbRed = 0xFF;
384             info->bmiColors[0].rgbGreen = 0;
385             info->bmiColors[0].rgbBlue = 0;
386             info->bmiColors[1].rgbRed = 0;
387             info->bmiColors[1].rgbGreen = 0xFF;
388             info->bmiColors[1].rgbBlue = 0;
389
390             dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
391             test_CopyImage_Check(dib, 0, 0, 0, 2, 2, screen_depth, FALSE);
392             test_CopyImage_Check(dib, 0, 5, 0, 5, 2, screen_depth, FALSE);
393             test_CopyImage_Check(dib, 0, 0, 5, 2, 5, screen_depth, FALSE);
394             test_CopyImage_Check(dib, 0, 5, 5, 5, 5, screen_depth, FALSE);
395             DeleteObject(dib);
396
397             info->bmiHeader.biBitCount = 1;
398             info->bmiColors[0].rgbRed = 0;
399             info->bmiColors[0].rgbGreen = 0;
400             info->bmiColors[0].rgbBlue = 0;
401             info->bmiColors[1].rgbRed = 0xFF;
402             info->bmiColors[1].rgbGreen = 0xFF;
403             info->bmiColors[1].rgbBlue = 0xFF;
404
405             dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
406             test_CopyImage_Check(dib, 0, 0, 0, 2, 2, 1, FALSE);
407             test_CopyImage_Check(dib, 0, 5, 0, 5, 2, 1, FALSE);
408             test_CopyImage_Check(dib, 0, 0, 5, 2, 5, 1, FALSE);
409             test_CopyImage_Check(dib, 0, 5, 5, 5, 5, 1, FALSE);
410             DeleteObject(dib);
411
412             info->bmiHeader.biBitCount = 1;
413             info->bmiColors[0].rgbRed = 0xFF;
414             info->bmiColors[0].rgbGreen = 0xFF;
415             info->bmiColors[0].rgbBlue = 0xFF;
416             info->bmiColors[1].rgbRed = 0;
417             info->bmiColors[1].rgbGreen = 0;
418             info->bmiColors[1].rgbBlue = 0;
419
420             dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
421             test_CopyImage_Check(dib, 0, 0, 0, 2, 2, 1, FALSE);
422             test_CopyImage_Check(dib, 0, 5, 0, 5, 2, 1, FALSE);
423             test_CopyImage_Check(dib, 0, 0, 5, 2, 5, 1, FALSE);
424             test_CopyImage_Check(dib, 0, 5, 5, 5, 5, 1, FALSE);
425             DeleteObject(dib);
426         }
427     }
428
429     HeapFree(GetProcessHeap(), 0, info);
430 }
431
432 static void test_initial_cursor(void)
433 {
434     HCURSOR cursor, cursor2;
435     DWORD error;
436
437     cursor = GetCursor();
438
439     /* Check what handle GetCursor() returns if a cursor is not set yet. */
440     SetLastError(0xdeadbeef);
441     cursor2 = LoadCursor(NULL, IDC_WAIT);
442     todo_wine {
443         ok(cursor == cursor2, "cursor (%p) is not IDC_WAIT (%p).\n", cursor, cursor2);
444     }
445     error = GetLastError();
446     ok(error == 0xdeadbeef, "Last error: 0x%08x\n", error);
447 }
448
449 static void test_icon_info_dbg(HICON hIcon, UINT exp_cx, UINT exp_cy, UINT exp_bpp, int line)
450 {
451     ICONINFO info;
452     DWORD ret;
453     BITMAP bmMask, bmColor;
454
455     ret = GetIconInfo(hIcon, &info);
456     ok_(__FILE__, line)(ret, "GetIconInfo failed\n");
457
458     /* CreateIcon under XP causes info.fIcon to be 0 */
459     ok_(__FILE__, line)(info.xHotspot == exp_cx/2, "info.xHotspot = %u\n", info.xHotspot);
460     ok_(__FILE__, line)(info.yHotspot == exp_cy/2, "info.yHotspot = %u\n", info.yHotspot);
461     ok_(__FILE__, line)(info.hbmMask != 0, "info.hbmMask is NULL\n");
462
463     ret = GetObject(info.hbmMask, sizeof(bmMask), &bmMask);
464     ok_(__FILE__, line)(ret == sizeof(bmMask), "GetObject(info.hbmMask) failed, ret %u\n", ret);
465
466     if (exp_bpp == 1)
467         ok_(__FILE__, line)(info.hbmColor == 0, "info.hbmColor should be NULL\n");
468
469     if (info.hbmColor)
470     {
471         HDC hdc;
472         UINT display_bpp;
473
474         hdc = GetDC(0);
475         display_bpp = GetDeviceCaps(hdc, BITSPIXEL);
476         ReleaseDC(0, hdc);
477
478         ret = GetObject(info.hbmColor, sizeof(bmColor), &bmColor);
479         ok_(__FILE__, line)(ret == sizeof(bmColor), "GetObject(info.hbmColor) failed, ret %u\n", ret);
480
481         ok_(__FILE__, line)(bmColor.bmBitsPixel == display_bpp /* XP */ ||
482            bmColor.bmBitsPixel == exp_bpp /* Win98 */,
483            "bmColor.bmBitsPixel = %d\n", bmColor.bmBitsPixel);
484         ok_(__FILE__, line)(bmColor.bmWidth == exp_cx, "bmColor.bmWidth = %d\n", bmColor.bmWidth);
485         ok_(__FILE__, line)(bmColor.bmHeight == exp_cy, "bmColor.bmHeight = %d\n", bmColor.bmHeight);
486
487         ok_(__FILE__, line)(bmMask.bmBitsPixel == 1, "bmMask.bmBitsPixel = %d\n", bmMask.bmBitsPixel);
488         ok_(__FILE__, line)(bmMask.bmWidth == exp_cx, "bmMask.bmWidth = %d\n", bmMask.bmWidth);
489         ok_(__FILE__, line)(bmMask.bmHeight == exp_cy, "bmMask.bmHeight = %d\n", bmMask.bmHeight);
490     }
491     else
492     {
493         ok_(__FILE__, line)(bmMask.bmBitsPixel == 1, "bmMask.bmBitsPixel = %d\n", bmMask.bmBitsPixel);
494         ok_(__FILE__, line)(bmMask.bmWidth == exp_cx, "bmMask.bmWidth = %d\n", bmMask.bmWidth);
495         ok_(__FILE__, line)(bmMask.bmHeight == exp_cy * 2, "bmMask.bmHeight = %d\n", bmMask.bmHeight);
496     }
497 }
498
499 #define test_icon_info(a,b,c,d) test_icon_info_dbg((a),(b),(c),(d),__LINE__)
500
501 static void test_CreateIcon(void)
502 {
503     static const BYTE bmp_bits[1024];
504     HICON hIcon;
505     HBITMAP hbmMask, hbmColor;
506     BITMAPINFO *bmpinfo;
507     ICONINFO info;
508     HDC hdc;
509     void *bits;
510     UINT display_bpp;
511
512     hdc = GetDC(0);
513     display_bpp = GetDeviceCaps(hdc, BITSPIXEL);
514
515     /* these crash under XP
516     hIcon = CreateIcon(0, 16, 16, 1, 1, bmp_bits, NULL);
517     hIcon = CreateIcon(0, 16, 16, 1, 1, NULL, bmp_bits);
518     */
519
520     hIcon = CreateIcon(0, 16, 16, 1, 1, bmp_bits, bmp_bits);
521     ok(hIcon != 0, "CreateIcon failed\n");
522     test_icon_info(hIcon, 16, 16, 1);
523     DestroyIcon(hIcon);
524
525     hIcon = CreateIcon(0, 16, 16, 1, display_bpp, bmp_bits, bmp_bits);
526     ok(hIcon != 0, "CreateIcon failed\n");
527     test_icon_info(hIcon, 16, 16, display_bpp);
528     DestroyIcon(hIcon);
529
530     hbmMask = CreateBitmap(16, 16, 1, 1, bmp_bits);
531     ok(hbmMask != 0, "CreateBitmap failed\n");
532     hbmColor = CreateBitmap(16, 16, 1, display_bpp, bmp_bits);
533     ok(hbmColor != 0, "CreateBitmap failed\n");
534
535     info.fIcon = TRUE;
536     info.xHotspot = 8;
537     info.yHotspot = 8;
538     info.hbmMask = 0;
539     info.hbmColor = 0;
540     SetLastError(0xdeadbeaf);
541     hIcon = CreateIconIndirect(&info);
542     ok(!hIcon, "CreateIconIndirect should fail\n");
543     ok(GetLastError() == 0xdeadbeaf, "wrong error %u\n", GetLastError());
544
545     info.fIcon = TRUE;
546     info.xHotspot = 8;
547     info.yHotspot = 8;
548     info.hbmMask = 0;
549     info.hbmColor = hbmColor;
550     SetLastError(0xdeadbeaf);
551     hIcon = CreateIconIndirect(&info);
552     ok(!hIcon, "CreateIconIndirect should fail\n");
553     ok(GetLastError() == 0xdeadbeaf, "wrong error %u\n", GetLastError());
554
555     info.fIcon = TRUE;
556     info.xHotspot = 8;
557     info.yHotspot = 8;
558     info.hbmMask = hbmMask;
559     info.hbmColor = hbmColor;
560     hIcon = CreateIconIndirect(&info);
561     ok(hIcon != 0, "CreateIconIndirect failed\n");
562     test_icon_info(hIcon, 16, 16, display_bpp);
563     DestroyIcon(hIcon);
564
565     DeleteObject(hbmMask);
566     DeleteObject(hbmColor);
567
568     hbmMask = CreateBitmap(16, 32, 1, 1, bmp_bits);
569     ok(hbmMask != 0, "CreateBitmap failed\n");
570
571     info.fIcon = TRUE;
572     info.xHotspot = 8;
573     info.yHotspot = 8;
574     info.hbmMask = hbmMask;
575     info.hbmColor = 0;
576     SetLastError(0xdeadbeaf);
577     hIcon = CreateIconIndirect(&info);
578     ok(hIcon != 0, "CreateIconIndirect failed\n");
579     test_icon_info(hIcon, 16, 16, 1);
580     DestroyIcon(hIcon);
581
582     DeleteObject(hbmMask);
583     DeleteObject(hbmColor);
584
585     /* test creating an icon from a DIB section */
586
587     bmpinfo = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, FIELD_OFFSET(BITMAPINFO,bmiColors[256]));
588     bmpinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
589     bmpinfo->bmiHeader.biWidth = 32;
590     bmpinfo->bmiHeader.biHeight = 32;
591     bmpinfo->bmiHeader.biPlanes = 1;
592     bmpinfo->bmiHeader.biBitCount = 8;
593     bmpinfo->bmiHeader.biCompression = BI_RGB;
594     hbmColor = CreateDIBSection( hdc, bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
595     ok(hbmColor != NULL, "Expected a handle to the DIB\n");
596     if (bits)
597         memset( bits, 0x55, 32 * 32 * bmpinfo->bmiHeader.biBitCount / 8 );
598     bmpinfo->bmiHeader.biBitCount = 1;
599     hbmMask = CreateDIBSection( hdc, bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
600     ok(hbmMask != NULL, "Expected a handle to the DIB\n");
601     if (bits)
602         memset( bits, 0x55, 32 * 32 * bmpinfo->bmiHeader.biBitCount / 8 );
603
604     info.fIcon = TRUE;
605     info.xHotspot = 8;
606     info.yHotspot = 8;
607     info.hbmMask = hbmColor;
608     info.hbmColor = hbmMask;
609     SetLastError(0xdeadbeaf);
610     hIcon = CreateIconIndirect(&info);
611     ok(hIcon != 0, "CreateIconIndirect failed\n");
612     test_icon_info(hIcon, 32, 32, 8);
613     DestroyIcon(hIcon);
614     DeleteObject(hbmColor);
615
616     bmpinfo->bmiHeader.biBitCount = 16;
617     hbmColor = CreateDIBSection( hdc, bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
618     ok(hbmColor != NULL, "Expected a handle to the DIB\n");
619     if (bits)
620         memset( bits, 0x55, 32 * 32 * bmpinfo->bmiHeader.biBitCount / 8 );
621
622     info.fIcon = TRUE;
623     info.xHotspot = 8;
624     info.yHotspot = 8;
625     info.hbmMask = hbmColor;
626     info.hbmColor = hbmMask;
627     SetLastError(0xdeadbeaf);
628     hIcon = CreateIconIndirect(&info);
629     ok(hIcon != 0, "CreateIconIndirect failed\n");
630     test_icon_info(hIcon, 32, 32, 8);
631     DestroyIcon(hIcon);
632     DeleteObject(hbmColor);
633
634     bmpinfo->bmiHeader.biBitCount = 32;
635     hbmColor = CreateDIBSection( hdc, bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
636     ok(hbmColor != NULL, "Expected a handle to the DIB\n");
637     if (bits)
638         memset( bits, 0x55, 32 * 32 * bmpinfo->bmiHeader.biBitCount / 8 );
639
640     info.fIcon = TRUE;
641     info.xHotspot = 8;
642     info.yHotspot = 8;
643     info.hbmMask = hbmColor;
644     info.hbmColor = hbmMask;
645     SetLastError(0xdeadbeaf);
646     hIcon = CreateIconIndirect(&info);
647     ok(hIcon != 0, "CreateIconIndirect failed\n");
648     test_icon_info(hIcon, 32, 32, 8);
649     DestroyIcon(hIcon);
650
651     DeleteObject(hbmMask);
652     DeleteObject(hbmColor);
653     HeapFree( GetProcessHeap(), 0, bmpinfo );
654
655     ReleaseDC(0, hdc);
656 }
657
658 /* Shamelessly ripped from dlls/oleaut32/tests/olepicture.c */
659 /* 1x1 pixel gif */
660 static const unsigned char gifimage[35] = {
661 0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xff,0xff,0xff,
662 0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
663 0x01,0x00,0x3b
664 };
665
666 /* 1x1 pixel jpg */
667 static const unsigned char jpgimage[285] = {
668 0xff,0xd8,0xff,0xe0,0x00,0x10,0x4a,0x46,0x49,0x46,0x00,0x01,0x01,0x01,0x01,0x2c,
669 0x01,0x2c,0x00,0x00,0xff,0xdb,0x00,0x43,0x00,0x05,0x03,0x04,0x04,0x04,0x03,0x05,
670 0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x07,0x0c,0x08,0x07,0x07,0x07,0x07,0x0f,0x0b,
671 0x0b,0x09,0x0c,0x11,0x0f,0x12,0x12,0x11,0x0f,0x11,0x11,0x13,0x16,0x1c,0x17,0x13,
672 0x14,0x1a,0x15,0x11,0x11,0x18,0x21,0x18,0x1a,0x1d,0x1d,0x1f,0x1f,0x1f,0x13,0x17,
673 0x22,0x24,0x22,0x1e,0x24,0x1c,0x1e,0x1f,0x1e,0xff,0xdb,0x00,0x43,0x01,0x05,0x05,
674 0x05,0x07,0x06,0x07,0x0e,0x08,0x08,0x0e,0x1e,0x14,0x11,0x14,0x1e,0x1e,0x1e,0x1e,
675 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
676 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
677 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0xff,0xc0,
678 0x00,0x11,0x08,0x00,0x01,0x00,0x01,0x03,0x01,0x22,0x00,0x02,0x11,0x01,0x03,0x11,
679 0x01,0xff,0xc4,0x00,0x15,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
680 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0xff,0xc4,0x00,0x14,0x10,0x01,0x00,0x00,
681 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xc4,
682 0x00,0x14,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
683 0x00,0x00,0x00,0x00,0xff,0xc4,0x00,0x14,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
684 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xda,0x00,0x0c,0x03,0x01,
685 0x00,0x02,0x11,0x03,0x11,0x00,0x3f,0x00,0xb2,0xc0,0x07,0xff,0xd9
686 };
687
688 /* 1x1 pixel png */
689 static const unsigned char pngimage[285] = {
690 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
691 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
692 0xde,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,
693 0x13,0x01,0x00,0x9a,0x9c,0x18,0x00,0x00,0x00,0x07,0x74,0x49,0x4d,0x45,0x07,0xd5,
694 0x06,0x03,0x0f,0x07,0x2d,0x12,0x10,0xf0,0xfd,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,
695 0x54,0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,
696 0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
697 };
698
699 /* 1x1 pixel bmp */
700 static const unsigned char bmpimage[66] = {
701 0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
702 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
703 0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
704 0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,
705 0x00,0x00
706 };
707
708 /* 2x2 pixel gif */
709 static const unsigned char gif4pixel[42] = {
710 0x47,0x49,0x46,0x38,0x37,0x61,0x02,0x00,0x02,0x00,0xa1,0x00,0x00,0x00,0x00,0x00,
711 0x39,0x62,0xfc,0xff,0x1a,0xe5,0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x02,0x00,
712 0x02,0x00,0x00,0x02,0x03,0x14,0x16,0x05,0x00,0x3b
713 };
714
715 static void test_LoadImageFile(const unsigned char * image_data,
716     unsigned int image_size, const char * ext, BOOL expect_success)
717 {
718     HANDLE handle;
719     BOOL ret;
720     DWORD error, bytes_written;
721     char filename[64];
722
723     strcpy(filename, "test.");
724     strcat(filename, ext);
725
726     /* Create the test image. */
727     handle = CreateFileA(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_NEW,
728         FILE_ATTRIBUTE_NORMAL, NULL);
729     ok(handle != INVALID_HANDLE_VALUE, "CreateFileA failed. %u\n", GetLastError());
730     ret = WriteFile(handle, image_data, image_size, &bytes_written, NULL);
731     ok(bytes_written == image_size, "test file created improperly.\n");
732     CloseHandle(handle);
733
734     /* Load as cursor. For all tested formats, this should fail */
735     SetLastError(0xdeadbeef);
736     handle = LoadImageA(NULL, filename, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
737     ok(handle == NULL, "LoadImage(%s) as IMAGE_CURSOR succeeded incorrectly.\n", ext);
738     error = GetLastError();
739     ok(error == 0 ||
740         broken(error == 0xdeadbeef) || /* Win9x */
741         broken(error == ERROR_BAD_PATHNAME), /* Win98, WinMe */
742         "Last error: %u\n", error);
743     if (handle != NULL) DestroyCursor(handle);
744
745     /* Load as icon. For all tested formats, this should fail */
746     SetLastError(0xdeadbeef);
747     handle = LoadImageA(NULL, filename, IMAGE_ICON, 0, 0, LR_LOADFROMFILE);
748     ok(handle == NULL, "LoadImage(%s) as IMAGE_ICON succeeded incorrectly.\n", ext);
749     error = GetLastError();
750     ok(error == 0 ||
751         broken(error == 0xdeadbeef) || /* Win9x */
752         broken(error == ERROR_BAD_PATHNAME), /* Win98, WinMe */
753         "Last error: %u\n", error);
754     if (handle != NULL) DestroyIcon(handle);
755
756     /* Load as bitmap. Should succeed if bmp, fail for everything else */
757     SetLastError(0xdeadbeef);
758     handle = LoadImageA(NULL, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
759     if (expect_success)
760         ok(handle != NULL, "LoadImage(%s) as IMAGE_BITMAP failed.\n", ext);
761     else ok(handle == NULL, "LoadImage(%s) as IMAGE_BITMAP succeeded incorrectly.\n", ext);
762     error = GetLastError();
763     ok(error == 0 ||
764         error == 0xdeadbeef, /* Win9x, WinMe */
765         "Last error: %u\n", error);
766     if (handle != NULL) DeleteObject(handle);
767
768     DeleteFileA(filename);
769 }
770
771 static void test_LoadImage(void)
772 {
773     HANDLE handle;
774     BOOL ret;
775     DWORD error, bytes_written;
776     CURSORICONFILEDIR *icon_data;
777     CURSORICONFILEDIRENTRY *icon_entry;
778     BITMAPINFOHEADER *icon_header;
779     ICONINFO icon_info;
780
781 #define ICON_WIDTH 32
782 #define ICON_HEIGHT 32
783 #define ICON_AND_SIZE (ICON_WIDTH*ICON_HEIGHT/8)
784 #define ICON_BPP 32
785 #define ICON_SIZE \
786     (sizeof(CURSORICONFILEDIR) + sizeof(BITMAPINFOHEADER) \
787     + ICON_AND_SIZE + ICON_AND_SIZE*ICON_BPP)
788
789     /* Set icon data. */
790     icon_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ICON_SIZE);
791     icon_data->idReserved = 0;
792     icon_data->idType = 1;
793     icon_data->idCount = 1;
794
795     icon_entry = icon_data->idEntries;
796     icon_entry->bWidth = ICON_WIDTH;
797     icon_entry->bHeight = ICON_HEIGHT;
798     icon_entry->bColorCount = 0;
799     icon_entry->bReserved = 0;
800     icon_entry->xHotspot = 1;
801     icon_entry->yHotspot = 1;
802     icon_entry->dwDIBSize = ICON_SIZE - sizeof(CURSORICONFILEDIR);
803     icon_entry->dwDIBOffset = sizeof(CURSORICONFILEDIR);
804
805     icon_header = (BITMAPINFOHEADER *) ((BYTE *) icon_data + icon_entry->dwDIBOffset);
806     icon_header->biSize = sizeof(BITMAPINFOHEADER);
807     icon_header->biWidth = ICON_WIDTH;
808     icon_header->biHeight = ICON_HEIGHT*2;
809     icon_header->biPlanes = 1;
810     icon_header->biBitCount = ICON_BPP;
811     icon_header->biSizeImage = 0; /* Uncompressed bitmap. */
812
813     /* Create the icon. */
814     handle = CreateFileA("icon.ico", GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_NEW,
815         FILE_ATTRIBUTE_NORMAL, NULL);
816     ok(handle != INVALID_HANDLE_VALUE, "CreateFileA failed. %u\n", GetLastError());
817     ret = WriteFile(handle, icon_data, ICON_SIZE, &bytes_written, NULL);
818     ok(bytes_written == ICON_SIZE, "icon.ico created improperly.\n");
819     CloseHandle(handle);
820
821     /* Test loading an icon as a cursor. */
822     SetLastError(0xdeadbeef);
823     handle = LoadImageA(NULL, "icon.ico", IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
824     ok(handle != NULL, "LoadImage() failed.\n");
825     error = GetLastError();
826     ok(error == 0 ||
827         broken(error == 0xdeadbeef) || /* Win9x */
828         broken(error == ERROR_BAD_PATHNAME), /* Win98, WinMe */
829         "Last error: %u\n", error);
830
831     /* Test the icon information. */
832     SetLastError(0xdeadbeef);
833     ret = GetIconInfo(handle, &icon_info);
834     ok(ret, "GetIconInfo() failed.\n");
835     error = GetLastError();
836     ok(error == 0xdeadbeef, "Last error: %u\n", error);
837
838     if (ret)
839     {
840         ok(icon_info.fIcon == FALSE, "fIcon != FALSE.\n");
841         ok(icon_info.xHotspot == 1, "xHotspot is %u.\n", icon_info.xHotspot);
842         ok(icon_info.yHotspot == 1, "yHotspot is %u.\n", icon_info.yHotspot);
843         ok(icon_info.hbmColor != NULL || broken(!icon_info.hbmColor) /* no color cursor support */,
844            "No hbmColor!\n");
845         ok(icon_info.hbmMask != NULL, "No hbmMask!\n");
846     }
847
848     /* Clean up. */
849     SetLastError(0xdeadbeef);
850     ret = DestroyCursor(handle);
851     ok(ret, "DestroyCursor() failed.\n");
852     error = GetLastError();
853     ok(error == 0xdeadbeef, "Last error: %u\n", error);
854
855     HeapFree(GetProcessHeap(), 0, icon_data);
856     DeleteFileA("icon.ico");
857
858     test_LoadImageFile(bmpimage, sizeof(bmpimage), "bmp", 1);
859     test_LoadImageFile(gifimage, sizeof(gifimage), "gif", 0);
860     test_LoadImageFile(gif4pixel, sizeof(gif4pixel), "gif", 0);
861     test_LoadImageFile(jpgimage, sizeof(jpgimage), "jpg", 0);
862     test_LoadImageFile(pngimage, sizeof(pngimage), "png", 0);
863 }
864
865 static void test_CreateIconFromResource(void)
866 {
867     HANDLE handle;
868     BOOL ret;
869     DWORD error;
870     BITMAPINFOHEADER *icon_header;
871     INT16 *hotspot;
872     ICONINFO icon_info;
873
874 #define ICON_RES_WIDTH 32
875 #define ICON_RES_HEIGHT 32
876 #define ICON_RES_AND_SIZE (ICON_WIDTH*ICON_HEIGHT/8)
877 #define ICON_RES_BPP 32
878 #define ICON_RES_SIZE \
879     (sizeof(BITMAPINFOHEADER) + ICON_AND_SIZE + ICON_AND_SIZE*ICON_BPP)
880 #define CRSR_RES_SIZE (2*sizeof(INT16) + ICON_RES_SIZE)
881
882     /* Set icon data. */
883     hotspot = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, CRSR_RES_SIZE);
884
885     /* Cursor resources have an extra hotspot, icon resources not. */
886     hotspot[0] = 3;
887     hotspot[1] = 3;
888
889     icon_header = (BITMAPINFOHEADER *) (hotspot + 2);
890     icon_header->biSize = sizeof(BITMAPINFOHEADER);
891     icon_header->biWidth = ICON_WIDTH;
892     icon_header->biHeight = ICON_HEIGHT*2;
893     icon_header->biPlanes = 1;
894     icon_header->biBitCount = ICON_BPP;
895     icon_header->biSizeImage = 0; /* Uncompressed bitmap. */
896
897     /* Test creating a cursor. */
898     SetLastError(0xdeadbeef);
899     handle = CreateIconFromResource((PBYTE) hotspot, CRSR_RES_SIZE, FALSE, 0x00030000);
900     ok(handle != NULL, "Create cursor failed.\n");
901
902     /* Test the icon information. */
903     SetLastError(0xdeadbeef);
904     ret = GetIconInfo(handle, &icon_info);
905     ok(ret, "GetIconInfo() failed.\n");
906     error = GetLastError();
907     ok(error == 0xdeadbeef, "Last error: %u\n", error);
908
909     if (ret)
910     {
911         ok(icon_info.fIcon == FALSE, "fIcon != FALSE.\n");
912         ok(icon_info.xHotspot == 3, "xHotspot is %u.\n", icon_info.xHotspot);
913         ok(icon_info.yHotspot == 3, "yHotspot is %u.\n", icon_info.yHotspot);
914         ok(icon_info.hbmColor != NULL || broken(!icon_info.hbmColor) /* no color cursor support */,
915            "No hbmColor!\n");
916         ok(icon_info.hbmMask != NULL, "No hbmMask!\n");
917     }
918
919     /* Clean up. */
920     SetLastError(0xdeadbeef);
921     ret = DestroyCursor(handle);
922     ok(ret, "DestroyCursor() failed.\n");
923     error = GetLastError();
924     ok(error == 0xdeadbeef, "Last error: %u\n", error);
925
926     /* Test creating an icon. */
927     SetLastError(0xdeadbeef);
928     handle = CreateIconFromResource((PBYTE) icon_header, ICON_RES_SIZE, TRUE,
929                                     0x00030000);
930     ok(handle != NULL, "Create icon failed.\n");
931
932     /* Test the icon information. */
933     SetLastError(0xdeadbeef);
934     ret = GetIconInfo(handle, &icon_info);
935     ok(ret, "GetIconInfo() failed.\n");
936     error = GetLastError();
937     ok(error == 0xdeadbeef, "Last error: %u\n", error);
938
939     if (ret)
940     {
941         ok(icon_info.fIcon == TRUE, "fIcon != TRUE.\n");
942         /* Icons always have hotspot in the middle */
943         ok(icon_info.xHotspot == ICON_WIDTH/2, "xHotspot is %u.\n", icon_info.xHotspot);
944         ok(icon_info.yHotspot == ICON_HEIGHT/2, "yHotspot is %u.\n", icon_info.yHotspot);
945         ok(icon_info.hbmColor != NULL, "No hbmColor!\n");
946         ok(icon_info.hbmMask != NULL, "No hbmMask!\n");
947     }
948
949     /* Clean up. */
950     SetLastError(0xdeadbeef);
951     ret = DestroyCursor(handle);
952     ok(ret, "DestroyCursor() failed.\n");
953     error = GetLastError();
954     ok(error == 0xdeadbeef, "Last error: %u\n", error);
955
956     HeapFree(GetProcessHeap(), 0, hotspot);
957 }
958
959 static void test_DestroyCursor(void)
960 {
961     static const BYTE bmp_bits[4096];
962     ICONINFO cursorInfo;
963     HCURSOR cursor, cursor2;
964     BOOL ret;
965     DWORD error;
966     UINT display_bpp;
967     HDC hdc;
968
969     hdc = GetDC(0);
970     display_bpp = GetDeviceCaps(hdc, BITSPIXEL);
971     ReleaseDC(0, hdc);
972
973     cursorInfo.fIcon = FALSE;
974     cursorInfo.xHotspot = 0;
975     cursorInfo.yHotspot = 0;
976     cursorInfo.hbmMask = CreateBitmap(32, 32, 1, 1, bmp_bits);
977     cursorInfo.hbmColor = CreateBitmap(32, 32, 1, display_bpp, bmp_bits);
978
979     cursor = CreateIconIndirect(&cursorInfo);
980     ok(cursor != NULL, "CreateIconIndirect returned %p\n", cursor);
981     if(!cursor) {
982         return;
983     }
984     SetCursor(cursor);
985
986     SetLastError(0xdeadbeef);
987     ret = DestroyCursor(cursor);
988     ok(!ret || broken(ret)  /* succeeds on win9x */, "DestroyCursor on the active cursor succeeded\n");
989     error = GetLastError();
990     ok(error == 0xdeadbeef, "Last error: %u\n", error);
991     if (!ret)
992     {
993         cursor2 = GetCursor();
994         ok(cursor2 == cursor, "Active was set to %p when trying to destroy it\n", cursor2);
995         SetCursor(NULL);
996
997         /* Trying to destroy the cursor properly fails now with
998          * ERROR_INVALID_CURSOR_HANDLE.  This happens because we called
999          * DestroyCursor() 2+ times after calling SetCursor().  The calls to
1000          * GetCursor() and SetCursor(NULL) in between make no difference. */
1001         ret = DestroyCursor(cursor);
1002         todo_wine {
1003             ok(!ret, "DestroyCursor succeeded.\n");
1004             error = GetLastError();
1005             ok(error == ERROR_INVALID_CURSOR_HANDLE || error == 0xdeadbeef, /* vista */
1006                "Last error: 0x%08x\n", error);
1007         }
1008     }
1009
1010     DeleteObject(cursorInfo.hbmMask);
1011     DeleteObject(cursorInfo.hbmColor);
1012
1013     /* Try testing DestroyCursor() now using LoadCursor() cursors. */
1014     cursor = LoadCursor(NULL, IDC_ARROW);
1015
1016     SetLastError(0xdeadbeef);
1017     ret = DestroyCursor(cursor);
1018     ok(ret || broken(!ret) /* fails on win9x */, "DestroyCursor on the active cursor failed.\n");
1019     error = GetLastError();
1020     ok(error == 0xdeadbeef, "Last error: 0x%08x\n", error);
1021
1022     /* Try setting the cursor to a destroyed OEM cursor. */
1023     SetLastError(0xdeadbeef);
1024     SetCursor(cursor);
1025     error = GetLastError();
1026     todo_wine {
1027         ok(error == 0xdeadbeef, "Last error: 0x%08x\n", error);
1028     }
1029
1030     /* Check if LoadCursor() returns the same handle with the same icon. */
1031     cursor2 = LoadCursor(NULL, IDC_ARROW);
1032     ok(cursor2 == cursor, "cursor == %p, cursor2 == %p\n", cursor, cursor2);
1033
1034     /* Check if LoadCursor() returns the same handle with a different icon. */
1035     cursor2 = LoadCursor(NULL, IDC_WAIT);
1036     ok(cursor2 != cursor, "cursor == %p, cursor2 == %p\n", cursor, cursor2);
1037 }
1038
1039 START_TEST(cursoricon)
1040 {
1041     test_argc = winetest_get_mainargs(&test_argv);
1042
1043     if (test_argc >= 3)
1044     {
1045         /* Child process. */
1046         sscanf (test_argv[2], "%x", (unsigned int *) &parent);
1047
1048         ok(parent != NULL, "Parent not found.\n");
1049         if (parent == NULL)
1050             ExitProcess(1);
1051
1052         do_child();
1053         return;
1054     }
1055
1056     test_CopyImage_Bitmap(1);
1057     test_CopyImage_Bitmap(4);
1058     test_CopyImage_Bitmap(8);
1059     test_CopyImage_Bitmap(16);
1060     test_CopyImage_Bitmap(24);
1061     test_CopyImage_Bitmap(32);
1062     test_initial_cursor();
1063     test_CreateIcon();
1064     test_LoadImage();
1065     test_CreateIconFromResource();
1066     test_DestroyCursor();
1067     do_parent();
1068     test_child_process();
1069     finish_child_process();
1070 }