| /* |
| * Unit test suite for cursors and icons. |
| * |
| * Copyright 2006 Michael Kaufmann |
| * Copyright 2007 Dmitry Timoshkov |
| * Copyright 2007 Andrew Riedi |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| |
| #include "wine/test.h" |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winreg.h" |
| #include "wingdi.h" |
| #include "winuser.h" |
| |
| static void test_CopyImage_Check(HBITMAP bitmap, UINT flags, INT copyWidth, INT copyHeight, |
| INT expectedWidth, INT expectedHeight, WORD expectedDepth, BOOL dibExpected) |
| { |
| HBITMAP copy; |
| BITMAP origBitmap; |
| BITMAP copyBitmap; |
| BOOL orig_is_dib; |
| BOOL copy_is_dib; |
| |
| copy = (HBITMAP) CopyImage(bitmap, IMAGE_BITMAP, copyWidth, copyHeight, flags); |
| ok(copy != NULL, "CopyImage() failed\n"); |
| if (copy != NULL) |
| { |
| GetObject(bitmap, sizeof(origBitmap), &origBitmap); |
| GetObject(copy, sizeof(copyBitmap), ©Bitmap); |
| orig_is_dib = (origBitmap.bmBits != NULL); |
| copy_is_dib = (copyBitmap.bmBits != NULL); |
| |
| if (copy_is_dib && dibExpected |
| && copyBitmap.bmBitsPixel == 24 |
| && (expectedDepth == 16 || expectedDepth == 32)) |
| { |
| /* Windows 95 doesn't create DIBs with a depth of 16 or 32 bit */ |
| if (GetVersion() & 0x80000000) |
| { |
| expectedDepth = 24; |
| } |
| } |
| |
| if (copy_is_dib && !dibExpected && !(flags & LR_CREATEDIBSECTION)) |
| { |
| /* It's not forbidden to create a DIB section if the flag |
| LR_CREATEDIBSECTION is absent. |
| Windows 9x does this if the bitmap has a depth that doesn't |
| match the screen depth, Windows NT doesn't */ |
| dibExpected = TRUE; |
| expectedDepth = origBitmap.bmBitsPixel; |
| } |
| |
| ok((!(dibExpected ^ copy_is_dib) |
| && (copyBitmap.bmWidth == expectedWidth) |
| && (copyBitmap.bmHeight == expectedHeight) |
| && (copyBitmap.bmBitsPixel == expectedDepth)), |
| "CopyImage ((%s, %dx%d, %u bpp), %d, %d, %#x): Expected (%s, %dx%d, %u bpp), got (%s, %dx%d, %u bpp)\n", |
| orig_is_dib ? "DIB" : "DDB", origBitmap.bmWidth, origBitmap.bmHeight, origBitmap.bmBitsPixel, |
| copyWidth, copyHeight, flags, |
| dibExpected ? "DIB" : "DDB", expectedWidth, expectedHeight, expectedDepth, |
| copy_is_dib ? "DIB" : "DDB", copyBitmap.bmWidth, copyBitmap.bmHeight, copyBitmap.bmBitsPixel); |
| |
| DeleteObject(copy); |
| } |
| } |
| |
| static void test_CopyImage_Bitmap(int depth) |
| { |
| HBITMAP ddb, dib; |
| HDC screenDC; |
| BITMAPINFO * info; |
| VOID * bits; |
| int screen_depth; |
| unsigned int i; |
| |
| /* Create a device-independent bitmap (DIB) */ |
| info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)); |
| info->bmiHeader.biSize = sizeof(info->bmiHeader); |
| info->bmiHeader.biWidth = 2; |
| info->bmiHeader.biHeight = 2; |
| info->bmiHeader.biPlanes = 1; |
| info->bmiHeader.biBitCount = depth; |
| info->bmiHeader.biCompression = BI_RGB; |
| |
| for (i=0; i < 256; i++) |
| { |
| info->bmiColors[i].rgbRed = i; |
| info->bmiColors[i].rgbGreen = i; |
| info->bmiColors[i].rgbBlue = 255 - i; |
| info->bmiColors[i].rgbReserved = 0; |
| } |
| |
| dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0); |
| |
| /* Create a device-dependent bitmap (DDB) */ |
| screenDC = GetDC(NULL); |
| screen_depth = GetDeviceCaps(screenDC, BITSPIXEL); |
| if (depth == 1 || depth == screen_depth) |
| { |
| ddb = CreateBitmap(2, 2, 1, depth, NULL); |
| } |
| else |
| { |
| ddb = NULL; |
| } |
| ReleaseDC(NULL, screenDC); |
| |
| if (ddb != NULL) |
| { |
| test_CopyImage_Check(ddb, 0, 0, 0, 2, 2, depth == 1 ? 1 : screen_depth, FALSE); |
| test_CopyImage_Check(ddb, 0, 0, 5, 2, 5, depth == 1 ? 1 : screen_depth, FALSE); |
| test_CopyImage_Check(ddb, 0, 5, 0, 5, 2, depth == 1 ? 1 : screen_depth, FALSE); |
| test_CopyImage_Check(ddb, 0, 5, 5, 5, 5, depth == 1 ? 1 : screen_depth, FALSE); |
| |
| test_CopyImage_Check(ddb, LR_MONOCHROME, 0, 0, 2, 2, 1, FALSE); |
| test_CopyImage_Check(ddb, LR_MONOCHROME, 5, 0, 5, 2, 1, FALSE); |
| test_CopyImage_Check(ddb, LR_MONOCHROME, 0, 5, 2, 5, 1, FALSE); |
| test_CopyImage_Check(ddb, LR_MONOCHROME, 5, 5, 5, 5, 1, FALSE); |
| |
| test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE); |
| test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE); |
| test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE); |
| test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE); |
| |
| /* LR_MONOCHROME is ignored if LR_CREATEDIBSECTION is present */ |
| test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE); |
| test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE); |
| test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE); |
| test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE); |
| |
| DeleteObject(ddb); |
| } |
| |
| if (depth != 1) |
| { |
| test_CopyImage_Check(dib, 0, 0, 0, 2, 2, screen_depth, FALSE); |
| test_CopyImage_Check(dib, 0, 5, 0, 5, 2, screen_depth, FALSE); |
| test_CopyImage_Check(dib, 0, 0, 5, 2, 5, screen_depth, FALSE); |
| test_CopyImage_Check(dib, 0, 5, 5, 5, 5, screen_depth, FALSE); |
| } |
| |
| test_CopyImage_Check(dib, LR_MONOCHROME, 0, 0, 2, 2, 1, FALSE); |
| test_CopyImage_Check(dib, LR_MONOCHROME, 5, 0, 5, 2, 1, FALSE); |
| test_CopyImage_Check(dib, LR_MONOCHROME, 0, 5, 2, 5, 1, FALSE); |
| test_CopyImage_Check(dib, LR_MONOCHROME, 5, 5, 5, 5, 1, FALSE); |
| |
| test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE); |
| test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE); |
| test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE); |
| test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE); |
| |
| /* LR_MONOCHROME is ignored if LR_CREATEDIBSECTION is present */ |
| test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE); |
| test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE); |
| test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE); |
| test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE); |
| |
| DeleteObject(dib); |
| |
| if (depth == 1) |
| { |
| /* Special case: A monochrome DIB is converted to a monochrome DDB if |
| the colors in the color table are black and white. |
| |
| Skip this test on Windows 95, it always creates a monochrome DDB |
| in this case */ |
| |
| if (!(GetVersion() & 0x80000000)) |
| { |
| info->bmiHeader.biBitCount = 1; |
| info->bmiColors[0].rgbRed = 0xFF; |
| info->bmiColors[0].rgbGreen = 0; |
| info->bmiColors[0].rgbBlue = 0; |
| info->bmiColors[1].rgbRed = 0; |
| info->bmiColors[1].rgbGreen = 0xFF; |
| info->bmiColors[1].rgbBlue = 0; |
| |
| dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0); |
| test_CopyImage_Check(dib, 0, 0, 0, 2, 2, screen_depth, FALSE); |
| test_CopyImage_Check(dib, 0, 5, 0, 5, 2, screen_depth, FALSE); |
| test_CopyImage_Check(dib, 0, 0, 5, 2, 5, screen_depth, FALSE); |
| test_CopyImage_Check(dib, 0, 5, 5, 5, 5, screen_depth, FALSE); |
| DeleteObject(dib); |
| |
| info->bmiHeader.biBitCount = 1; |
| info->bmiColors[0].rgbRed = 0; |
| info->bmiColors[0].rgbGreen = 0; |
| info->bmiColors[0].rgbBlue = 0; |
| info->bmiColors[1].rgbRed = 0xFF; |
| info->bmiColors[1].rgbGreen = 0xFF; |
| info->bmiColors[1].rgbBlue = 0xFF; |
| |
| dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0); |
| test_CopyImage_Check(dib, 0, 0, 0, 2, 2, 1, FALSE); |
| test_CopyImage_Check(dib, 0, 5, 0, 5, 2, 1, FALSE); |
| test_CopyImage_Check(dib, 0, 0, 5, 2, 5, 1, FALSE); |
| test_CopyImage_Check(dib, 0, 5, 5, 5, 5, 1, FALSE); |
| DeleteObject(dib); |
| |
| info->bmiHeader.biBitCount = 1; |
| info->bmiColors[0].rgbRed = 0xFF; |
| info->bmiColors[0].rgbGreen = 0xFF; |
| info->bmiColors[0].rgbBlue = 0xFF; |
| info->bmiColors[1].rgbRed = 0; |
| info->bmiColors[1].rgbGreen = 0; |
| info->bmiColors[1].rgbBlue = 0; |
| |
| dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0); |
| test_CopyImage_Check(dib, 0, 0, 0, 2, 2, 1, FALSE); |
| test_CopyImage_Check(dib, 0, 5, 0, 5, 2, 1, FALSE); |
| test_CopyImage_Check(dib, 0, 0, 5, 2, 5, 1, FALSE); |
| test_CopyImage_Check(dib, 0, 5, 5, 5, 5, 1, FALSE); |
| DeleteObject(dib); |
| } |
| } |
| |
| HeapFree(GetProcessHeap(), 0, info); |
| } |
| |
| static void test_initial_cursor(void) |
| { |
| HCURSOR cursor, cursor2; |
| DWORD error; |
| |
| cursor = GetCursor(); |
| |
| /* Check what handle GetCursor() returns if a cursor is not set yet. */ |
| SetLastError(0xdeadbeef); |
| cursor2 = LoadCursor(NULL, IDC_WAIT); |
| todo_wine { |
| ok(cursor == cursor2, "cursor (%p) is not IDC_WAIT (%p).\n", cursor, cursor2); |
| } |
| error = GetLastError(); |
| ok(error == 0xdeadbeef, "Last error: 0x%08x\n", error); |
| } |
| |
| static void test_icon_info_dbg(HICON hIcon, UINT exp_cx, UINT exp_cy, UINT exp_bpp, int line) |
| { |
| ICONINFO info; |
| DWORD ret; |
| BITMAP bmMask, bmColor; |
| |
| ret = GetIconInfo(hIcon, &info); |
| ok_(__FILE__, line)(ret, "GetIconInfo failed\n"); |
| |
| /* CreateIcon under XP causes info.fIcon to be 0 */ |
| ok_(__FILE__, line)(info.xHotspot == exp_cx/2, "info.xHotspot = %u\n", info.xHotspot); |
| ok_(__FILE__, line)(info.yHotspot == exp_cy/2, "info.yHotspot = %u\n", info.yHotspot); |
| ok_(__FILE__, line)(info.hbmMask != 0, "info.hbmMask is NULL\n"); |
| |
| ret = GetObject(info.hbmMask, sizeof(bmMask), &bmMask); |
| ok_(__FILE__, line)(ret == sizeof(bmMask), "GetObject(info.hbmMask) failed, ret %u\n", ret); |
| |
| if (exp_bpp == 1) |
| ok_(__FILE__, line)(info.hbmColor == 0, "info.hbmColor should be NULL\n"); |
| |
| if (info.hbmColor) |
| { |
| HDC hdc; |
| UINT display_bpp; |
| |
| hdc = GetDC(0); |
| display_bpp = GetDeviceCaps(hdc, BITSPIXEL); |
| ReleaseDC(0, hdc); |
| |
| ret = GetObject(info.hbmColor, sizeof(bmColor), &bmColor); |
| ok_(__FILE__, line)(ret == sizeof(bmColor), "GetObject(info.hbmColor) failed, ret %u\n", ret); |
| |
| ok_(__FILE__, line)(bmColor.bmBitsPixel == display_bpp /* XP */ || |
| bmColor.bmBitsPixel == exp_bpp /* Win98 */, |
| "bmColor.bmBitsPixel = %d\n", bmColor.bmBitsPixel); |
| ok_(__FILE__, line)(bmColor.bmWidth == exp_cx, "bmColor.bmWidth = %d\n", bmColor.bmWidth); |
| ok_(__FILE__, line)(bmColor.bmHeight == exp_cy, "bmColor.bmHeight = %d\n", bmColor.bmHeight); |
| |
| ok_(__FILE__, line)(bmMask.bmBitsPixel == 1, "bmMask.bmBitsPixel = %d\n", bmMask.bmBitsPixel); |
| ok_(__FILE__, line)(bmMask.bmWidth == exp_cx, "bmMask.bmWidth = %d\n", bmMask.bmWidth); |
| ok_(__FILE__, line)(bmMask.bmHeight == exp_cy, "bmMask.bmHeight = %d\n", bmMask.bmHeight); |
| } |
| else |
| { |
| ok_(__FILE__, line)(bmMask.bmBitsPixel == 1, "bmMask.bmBitsPixel = %d\n", bmMask.bmBitsPixel); |
| ok_(__FILE__, line)(bmMask.bmWidth == exp_cx, "bmMask.bmWidth = %d\n", bmMask.bmWidth); |
| ok_(__FILE__, line)(bmMask.bmHeight == exp_cy * 2, "bmMask.bmHeight = %d\n", bmMask.bmHeight); |
| } |
| } |
| |
| #define test_icon_info(a,b,c,d) test_icon_info_dbg((a),(b),(c),(d),__LINE__) |
| |
| static void test_CreateIcon(void) |
| { |
| static const BYTE bmp_bits[1024]; |
| HICON hIcon; |
| HBITMAP hbmMask, hbmColor; |
| ICONINFO info; |
| HDC hdc; |
| UINT display_bpp; |
| |
| hdc = GetDC(0); |
| display_bpp = GetDeviceCaps(hdc, BITSPIXEL); |
| ReleaseDC(0, hdc); |
| |
| /* these crash under XP |
| hIcon = CreateIcon(0, 16, 16, 1, 1, bmp_bits, NULL); |
| hIcon = CreateIcon(0, 16, 16, 1, 1, NULL, bmp_bits); |
| */ |
| |
| hIcon = CreateIcon(0, 16, 16, 1, 1, bmp_bits, bmp_bits); |
| ok(hIcon != 0, "CreateIcon failed\n"); |
| test_icon_info(hIcon, 16, 16, 1); |
| DestroyIcon(hIcon); |
| |
| hIcon = CreateIcon(0, 16, 16, 1, display_bpp, bmp_bits, bmp_bits); |
| ok(hIcon != 0, "CreateIcon failed\n"); |
| test_icon_info(hIcon, 16, 16, display_bpp); |
| DestroyIcon(hIcon); |
| |
| hbmMask = CreateBitmap(16, 16, 1, 1, bmp_bits); |
| ok(hbmMask != 0, "CreateBitmap failed\n"); |
| hbmColor = CreateBitmap(16, 16, 1, display_bpp, bmp_bits); |
| ok(hbmColor != 0, "CreateBitmap failed\n"); |
| |
| info.fIcon = TRUE; |
| info.xHotspot = 8; |
| info.yHotspot = 8; |
| info.hbmMask = 0; |
| info.hbmColor = 0; |
| SetLastError(0xdeadbeaf); |
| hIcon = CreateIconIndirect(&info); |
| ok(!hIcon, "CreateIconIndirect should fail\n"); |
| ok(GetLastError() == 0xdeadbeaf, "wrong error %u\n", GetLastError()); |
| |
| info.fIcon = TRUE; |
| info.xHotspot = 8; |
| info.yHotspot = 8; |
| info.hbmMask = 0; |
| info.hbmColor = hbmColor; |
| SetLastError(0xdeadbeaf); |
| hIcon = CreateIconIndirect(&info); |
| ok(!hIcon, "CreateIconIndirect should fail\n"); |
| ok(GetLastError() == 0xdeadbeaf, "wrong error %u\n", GetLastError()); |
| |
| info.fIcon = TRUE; |
| info.xHotspot = 8; |
| info.yHotspot = 8; |
| info.hbmMask = hbmMask; |
| info.hbmColor = hbmColor; |
| hIcon = CreateIconIndirect(&info); |
| ok(hIcon != 0, "CreateIconIndirect failed\n"); |
| test_icon_info(hIcon, 16, 16, display_bpp); |
| DestroyIcon(hIcon); |
| |
| DeleteObject(hbmMask); |
| DeleteObject(hbmColor); |
| |
| hbmMask = CreateBitmap(16, 32, 1, 1, bmp_bits); |
| ok(hbmMask != 0, "CreateBitmap failed\n"); |
| |
| info.fIcon = TRUE; |
| info.xHotspot = 8; |
| info.yHotspot = 8; |
| info.hbmMask = hbmMask; |
| info.hbmColor = 0; |
| SetLastError(0xdeadbeaf); |
| hIcon = CreateIconIndirect(&info); |
| ok(hIcon != 0, "CreateIconIndirect failed\n"); |
| test_icon_info(hIcon, 16, 16, 1); |
| DestroyIcon(hIcon); |
| |
| DeleteObject(hbmMask); |
| DeleteObject(hbmColor); |
| } |
| |
| static void test_DestroyCursor(void) |
| { |
| static const BYTE bmp_bits[4096]; |
| ICONINFO cursorInfo; |
| HCURSOR cursor, cursor2; |
| BOOL ret; |
| DWORD error; |
| UINT display_bpp; |
| HDC hdc; |
| |
| hdc = GetDC(0); |
| display_bpp = GetDeviceCaps(hdc, BITSPIXEL); |
| ReleaseDC(0, hdc); |
| |
| cursorInfo.fIcon = FALSE; |
| cursorInfo.xHotspot = 0; |
| cursorInfo.yHotspot = 0; |
| cursorInfo.hbmMask = CreateBitmap(32, 32, 1, 1, bmp_bits); |
| cursorInfo.hbmColor = CreateBitmap(32, 32, 1, display_bpp, bmp_bits); |
| |
| cursor = CreateIconIndirect(&cursorInfo); |
| ok(cursor != NULL, "CreateIconIndirect returned %p\n", cursor); |
| if(!cursor) { |
| return; |
| } |
| SetCursor(cursor); |
| |
| SetLastError(0xdeadbeef); |
| ret = DestroyCursor(cursor); |
| ok(!ret, "DestroyCursor on the active cursor succeeded\n"); |
| error = GetLastError(); |
| ok(error == 0xdeadbeef, "Last error: %u\n", error); |
| |
| cursor2 = GetCursor(); |
| ok(cursor2 == cursor, "Active was set to %p when trying to destroy it\n", cursor2); |
| |
| SetCursor(NULL); |
| |
| /* Trying to destroy the cursor properly fails now with |
| * ERROR_INVALID_CURSOR_HANDLE. This happens because we called |
| * DestroyCursor() 2+ times after calling SetCursor(). The calls to |
| * GetCursor() and SetCursor(NULL) in between make no difference. */ |
| ret = DestroyCursor(cursor); |
| todo_wine { |
| ok(!ret, "DestroyCursor succeeded.\n"); |
| error = GetLastError(); |
| ok(error == ERROR_INVALID_CURSOR_HANDLE, "Last error: 0x%08x\n", error); |
| } |
| |
| DeleteObject(cursorInfo.hbmMask); |
| DeleteObject(cursorInfo.hbmColor); |
| |
| /* Try testing DestroyCursor() now using LoadCursor() cursors. */ |
| cursor = LoadCursor(NULL, IDC_ARROW); |
| |
| SetLastError(0xdeadbeef); |
| ret = DestroyCursor(cursor); |
| ok(ret, "DestroyCursor on the active cursor failed.\n"); |
| error = GetLastError(); |
| ok(error == 0xdeadbeef, "Last error: 0x%08x\n", error); |
| |
| /* Try setting the cursor to a destroyed OEM cursor. */ |
| SetLastError(0xdeadbeef); |
| SetCursor(cursor); |
| error = GetLastError(); |
| todo_wine { |
| ok(error == 0xdeadbeef, "Last error: 0x%08x\n", error); |
| } |
| |
| /* Check if LoadCursor() returns the same handle with the same icon. */ |
| cursor2 = LoadCursor(NULL, IDC_ARROW); |
| ok(cursor2 == cursor, "cursor == %p, cursor2 == %p\n", cursor, cursor2); |
| |
| /* Check if LoadCursor() returns the same handle with a different icon. */ |
| cursor2 = LoadCursor(NULL, IDC_WAIT); |
| ok(cursor2 != cursor, "cursor == %p, cursor2 == %p\n", cursor, cursor2); |
| } |
| |
| START_TEST(cursoricon) |
| { |
| test_CopyImage_Bitmap(1); |
| test_CopyImage_Bitmap(4); |
| test_CopyImage_Bitmap(8); |
| test_CopyImage_Bitmap(16); |
| test_CopyImage_Bitmap(24); |
| test_CopyImage_Bitmap(32); |
| test_initial_cursor(); |
| test_CreateIcon(); |
| test_DestroyCursor(); |
| } |
