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

   1 /* Unit test suite for cursors and icons.
   2  *
   3  * Copyright 2006 Michael Kaufmann
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <assert.h>
  21 #include <stdlib.h>
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24
  25 #include "wine/test.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winreg.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31
  32 static void test_CopyImage_Check(HBITMAP bitmap, UINT flags, INT copyWidth, INT copyHeight,
  33                                   INT expectedWidth, INT expectedHeight, WORD expectedDepth, BOOL dibExpected)
  34 {
  35     HBITMAP copy;
  36     BITMAP origBitmap;
  37     BITMAP copyBitmap;
  38     BOOL orig_is_dib;
  39     BOOL copy_is_dib;
  40
  41     copy = (HBITMAP) CopyImage(bitmap, IMAGE_BITMAP, copyWidth, copyHeight, flags);
  42     ok(copy != NULL, "CopyImage() failed\n");
  43     if (copy != NULL)
  44     {
  45         GetObject(bitmap, sizeof(origBitmap), &origBitmap);
  46         GetObject(copy, sizeof(copyBitmap), &copyBitmap);
  47         orig_is_dib = (origBitmap.bmBits != NULL);
  48         copy_is_dib = (copyBitmap.bmBits != NULL);
  49
  50         if (copy_is_dib && dibExpected
  51             && copyBitmap.bmBitsPixel == 24
  52             && (expectedDepth == 16 || expectedDepth == 32))
  53         {
  54             /* Windows 95 doesn't create DIBs with a depth of 16 or 32 bit */
  55             if (GetVersion() & 0x80000000)
  56             {
  57                 expectedDepth = 24;
  58             }
  59         }
  60
  61         if (copy_is_dib && !dibExpected && !(flags & LR_CREATEDIBSECTION))
  62         {
  63             /* It's not forbidden to create a DIB section if the flag
  64                LR_CREATEDIBSECTION is absent.
  65                Windows 9x does this if the bitmap has a depth that doesn't
  66                match the screen depth, Windows NT doesn't */
  67             dibExpected = TRUE;
  68             expectedDepth = origBitmap.bmBitsPixel;
  69         }
  70
  71         ok((!(dibExpected ^ copy_is_dib)
  72              && (copyBitmap.bmWidth == expectedWidth)
  73              && (copyBitmap.bmHeight == expectedHeight)
  74              && (copyBitmap.bmBitsPixel == expectedDepth)),
  75              "CopyImage ((%s, %dx%d, %u bpp), %d, %d, %#x): Expected (%s, %dx%d, %u bpp), got (%s, %dx%d, %u bpp)\n",
  76                   orig_is_dib ? "DIB" : "DDB", origBitmap.bmWidth, origBitmap.bmHeight, origBitmap.bmBitsPixel,
  77                   copyWidth, copyHeight, flags,
  78                   dibExpected ? "DIB" : "DDB", expectedWidth, expectedHeight, expectedDepth,
  79                   copy_is_dib ? "DIB" : "DDB", copyBitmap.bmWidth, copyBitmap.bmHeight, copyBitmap.bmBitsPixel);
  80
  81         DeleteObject(copy);
  82     }
  83 }
  84
  85 static void test_CopyImage_Bitmap(int depth)
  86 {
  87     HBITMAP ddb, dib;
  88     HDC screenDC;
  89     BITMAPINFO * info;
  90     VOID * bits;
  91     int screen_depth;
  92     unsigned int i;
  93
  94     /* Create a device-independent bitmap (DIB) */
  95     info = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
  96     info->bmiHeader.biSize = sizeof(info->bmiHeader);
  97     info->bmiHeader.biWidth = 2;
  98     info->bmiHeader.biHeight = 2;
  99     info->bmiHeader.biPlanes = 1;
 100     info->bmiHeader.biBitCount = depth;
 101     info->bmiHeader.biCompression = BI_RGB;
 102
 103     for (i=0; i < 256; i++)
 104     {
 105         info->bmiColors[i].rgbRed = i;
 106         info->bmiColors[i].rgbGreen = i;
 107         info->bmiColors[i].rgbBlue = 255 - i;
 108         info->bmiColors[i].rgbReserved = 0;
 109     }
 110
 111     dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
 112
 113     /* Create a device-dependent bitmap (DDB) */
 114     screenDC = GetDC(NULL);
 115     screen_depth = GetDeviceCaps(screenDC, BITSPIXEL);
 116     if (depth == 1 || depth == screen_depth)
 117     {
 118         ddb = CreateBitmap(2, 2, 1, depth, NULL);
 119     }
 120     else
 121     {
 122         ddb = NULL;
 123     }
 124     ReleaseDC(NULL, screenDC);
 125
 126     if (ddb != NULL)
 127     {
 128         test_CopyImage_Check(ddb, 0, 0, 0, 2, 2, depth == 1 ? 1 : screen_depth, FALSE);
 129         test_CopyImage_Check(ddb, 0, 0, 5, 2, 5, depth == 1 ? 1 : screen_depth, FALSE);
 130         test_CopyImage_Check(ddb, 0, 5, 0, 5, 2, depth == 1 ? 1 : screen_depth, FALSE);
 131         test_CopyImage_Check(ddb, 0, 5, 5, 5, 5, depth == 1 ? 1 : screen_depth, FALSE);
 132
 133         test_CopyImage_Check(ddb, LR_MONOCHROME, 0, 0, 2, 2, 1, FALSE);
 134         test_CopyImage_Check(ddb, LR_MONOCHROME, 5, 0, 5, 2, 1, FALSE);
 135         test_CopyImage_Check(ddb, LR_MONOCHROME, 0, 5, 2, 5, 1, FALSE);
 136         test_CopyImage_Check(ddb, LR_MONOCHROME, 5, 5, 5, 5, 1, FALSE);
 137
 138         test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE);
 139         test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE);
 140         test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE);
 141         test_CopyImage_Check(ddb, LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE);
 142
 143         /* LR_MONOCHROME is ignored if LR_CREATEDIBSECTION is present */
 144         test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE);
 145         test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE);
 146         test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE);
 147         test_CopyImage_Check(ddb, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE);
 148
 149         DeleteObject(ddb);
 150     }
 151
 152     if (depth != 1)
 153     {
 154         test_CopyImage_Check(dib, 0, 0, 0, 2, 2, screen_depth, FALSE);
 155         test_CopyImage_Check(dib, 0, 5, 0, 5, 2, screen_depth, FALSE);
 156         test_CopyImage_Check(dib, 0, 0, 5, 2, 5, screen_depth, FALSE);
 157         test_CopyImage_Check(dib, 0, 5, 5, 5, 5, screen_depth, FALSE);
 158     }
 159
 160     test_CopyImage_Check(dib, LR_MONOCHROME, 0, 0, 2, 2, 1, FALSE);
 161     test_CopyImage_Check(dib, LR_MONOCHROME, 5, 0, 5, 2, 1, FALSE);
 162     test_CopyImage_Check(dib, LR_MONOCHROME, 0, 5, 2, 5, 1, FALSE);
 163     test_CopyImage_Check(dib, LR_MONOCHROME, 5, 5, 5, 5, 1, FALSE);
 164
 165     test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE);
 166     test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE);
 167     test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE);
 168     test_CopyImage_Check(dib, LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE);
 169
 170     /* LR_MONOCHROME is ignored if LR_CREATEDIBSECTION is present */
 171     test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 0, 2, 2, depth, TRUE);
 172     test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 0, 5, 2, depth, TRUE);
 173     test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 0, 5, 2, 5, depth, TRUE);
 174     test_CopyImage_Check(dib, LR_MONOCHROME | LR_CREATEDIBSECTION, 5, 5, 5, 5, depth, TRUE);
 175
 176     DeleteObject(dib);
 177
 178     if (depth == 1)
 179     {
 180         /* Special case: A monochrome DIB is converted to a monochrome DDB if
 181            the colors in the color table are black and white.
 182
 183            Skip this test on Windows 95, it always creates a monochrome DDB
 184            in this case */
 185
 186         if (!(GetVersion() & 0x80000000))
 187         {
 188             info->bmiHeader.biBitCount = 1;
 189             info->bmiColors[0].rgbRed = 0xFF;
 190             info->bmiColors[0].rgbGreen = 0;
 191             info->bmiColors[0].rgbBlue = 0;
 192             info->bmiColors[1].rgbRed = 0;
 193             info->bmiColors[1].rgbGreen = 0xFF;
 194             info->bmiColors[1].rgbBlue = 0;
 195
 196             dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
 197             test_CopyImage_Check(dib, 0, 0, 0, 2, 2, screen_depth, FALSE);
 198             test_CopyImage_Check(dib, 0, 5, 0, 5, 2, screen_depth, FALSE);
 199             test_CopyImage_Check(dib, 0, 0, 5, 2, 5, screen_depth, FALSE);
 200             test_CopyImage_Check(dib, 0, 5, 5, 5, 5, screen_depth, FALSE);
 201             DeleteObject(dib);
 202
 203             info->bmiHeader.biBitCount = 1;
 204             info->bmiColors[0].rgbRed = 0;
 205             info->bmiColors[0].rgbGreen = 0;
 206             info->bmiColors[0].rgbBlue = 0;
 207             info->bmiColors[1].rgbRed = 0xFF;
 208             info->bmiColors[1].rgbGreen = 0xFF;
 209             info->bmiColors[1].rgbBlue = 0xFF;
 210
 211             dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
 212             test_CopyImage_Check(dib, 0, 0, 0, 2, 2, 1, FALSE);
 213             test_CopyImage_Check(dib, 0, 5, 0, 5, 2, 1, FALSE);
 214             test_CopyImage_Check(dib, 0, 0, 5, 2, 5, 1, FALSE);
 215             test_CopyImage_Check(dib, 0, 5, 5, 5, 5, 1, FALSE);
 216             DeleteObject(dib);
 217
 218             info->bmiHeader.biBitCount = 1;
 219             info->bmiColors[0].rgbRed = 0xFF;
 220             info->bmiColors[0].rgbGreen = 0xFF;
 221             info->bmiColors[0].rgbBlue = 0xFF;
 222             info->bmiColors[1].rgbRed = 0;
 223             info->bmiColors[1].rgbGreen = 0;
 224             info->bmiColors[1].rgbBlue = 0;
 225
 226             dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
 227             test_CopyImage_Check(dib, 0, 0, 0, 2, 2, 1, FALSE);
 228             test_CopyImage_Check(dib, 0, 5, 0, 5, 2, 1, FALSE);
 229             test_CopyImage_Check(dib, 0, 0, 5, 2, 5, 1, FALSE);
 230             test_CopyImage_Check(dib, 0, 5, 5, 5, 5, 1, FALSE);
 231             DeleteObject(dib);
 232         }
 233     }
 234
 235     HeapFree(GetProcessHeap(), 0, info);
 236 }
 237
 238 START_TEST(cursoricon)
 239 {
 240     test_CopyImage_Bitmap(1);
 241     test_CopyImage_Bitmap(4);
 242     test_CopyImage_Bitmap(8);
 243     test_CopyImage_Bitmap(16);
 244     test_CopyImage_Bitmap(24);
 245     test_CopyImage_Bitmap(32);
 246 }