dlls/user32/tests/resource.c

   1 /* Unit test suite for resources.
   2  *
   3  * Copyright 2004 Ferenc Wagner
   4  * Copyright 2003, 2004 Mike McCormack
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22 #include <windows.h>
  23
  24 #include "wine/test.h"
  25
  26 static UINT (WINAPI *pPrivateExtractIconsA)(LPCSTR, int, int, int, HICON *, UINT *, UINT, UINT) = NULL;
  27
  28 static void init_function_pointers(void)
  29 {
  30     HMODULE hmod = GetModuleHandleA("user32.dll");
  31     pPrivateExtractIconsA = (void*)GetProcAddress(hmod, "PrivateExtractIconsA");
  32 }
  33
  34 static void test_LoadStringW(void)
  35 {
  36     HINSTANCE hInst = GetModuleHandleA(NULL);
  37     WCHAR copiedstringw[128], returnedstringw[128], *resourcepointer = NULL;
  38     char copiedstring[128], returnedstring[128];
  39     int length1, length2, retvalue;
  40
  41     /* Check that the string which is returned by LoadStringW matches
  42        the string at the pointer returned by LoadStringW when called with buflen = 0 */
  43     SetLastError(0xdeadbeef);
  44     length1 = LoadStringW(hInst, 2, (WCHAR *) &resourcepointer, 0); /* get pointer to resource. */
  45     if (!length1)
  46     {
  47         if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
  48             win_skip( "LoadStringW not implemented\n" );
  49         else
  50             win_skip( "LoadStringW does not return a pointer to the resource\n" );
  51         return;
  52     }
  53     length2 = LoadStringW(hInst, 2, returnedstringw, sizeof(returnedstringw) /sizeof(WCHAR)); /* get resource string */
  54     ok(length2 > 0, "LoadStringW failed to load resource 2, ret %d, err %d\n", length2, GetLastError());
  55     ok(length1 == length2, "LoadStringW returned different values dependent on buflen. ret1 %d, ret2 %d\n",
  56         length1, length2);
  57     ok(length1 > 0 && resourcepointer != NULL, "LoadStringW failed to get pointer to resource 2, ret %d, err %d\n",
  58         length1, GetLastError());
  59
  60     /* Copy the resource since it is not '\0' terminated, and add '\0' to the end */
  61     if(resourcepointer != NULL) /* Check that the resource pointer was loaded to avoid access violation */
  62     {
  63         memcpy(copiedstringw, resourcepointer, length1 * sizeof(WCHAR));
  64         copiedstringw[length1] = '\0';
  65         /* check that strings match */
  66         WideCharToMultiByte( CP_ACP, 0, returnedstringw, -1, returnedstring, 128, NULL, NULL );
  67         WideCharToMultiByte( CP_ACP, 0, copiedstringw, -1, copiedstring, 128, NULL, NULL );
  68         ok(!memcmp(copiedstringw, returnedstringw, (length2 + 1)*sizeof(WCHAR)),
  69            "strings don't match: returnedstring = %s, copiedstring = %s\n", returnedstring, copiedstring);
  70     }
  71
  72     /* check that calling LoadStringW with buffer = NULL returns zero */
  73     retvalue = LoadStringW(hInst, 2, NULL, 0);
  74     ok(!retvalue, "LoadStringW returned a non-zero value when called with buffer = NULL, retvalue = %d\n", retvalue);
  75     /* check again, with a different buflen value, that calling LoadStringW with buffer = NULL returns zero */
  76     retvalue = LoadStringW(hInst, 2, NULL, 128);
  77     ok(!retvalue, "LoadStringW returned a non-zero value when called with buffer = NULL, retvalue = %d\n", retvalue);
  78 }
  79
  80 static void test_LoadStringA (void)
  81 {
  82     HINSTANCE hInst = GetModuleHandleA(NULL);
  83     static const char str[] = "String resource"; /* same in resource.rc */
  84     char buf[128];
  85     struct string_test {
  86         unsigned int bufsiz;
  87         unsigned int expected;
  88     };
  89     struct string_test tests[] = {{sizeof buf, sizeof str - 1},
  90                                   {sizeof str, sizeof str - 1},
  91                                   {sizeof str - 1, sizeof str - 2}};
  92     unsigned int i;
  93     int ret, ret2;
  94
  95     assert (sizeof str < sizeof buf);
  96     for (i = 0; i < sizeof tests / sizeof tests[0]; i++) {
  97         const unsigned int bufsiz = tests[i].bufsiz;
  98         const unsigned int expected = tests[i].expected;
  99         const int len = LoadStringA (hInst, 0, buf, bufsiz);
 100
 101         ok (len == expected, "bufsiz=%d: got %d, expected %d\n",
 102             bufsiz, len, expected);
 103         if (len != expected) continue;
 104         ok (!memcmp (buf, str, len),
 105             "bufsiz=%d: got '%s', expected '%.*s'\n",
 106             bufsiz, buf, len, str);
 107         ok (buf[len] == 0, "bufsiz=%d: NUL termination missing\n",
 108             bufsiz);
 109     }
 110
 111     ret = LoadStringA(hInst, 1, buf, sizeof(buf) );
 112     ok( ret > 0, "LoadString failed: ret %d err %d\n", ret, GetLastError());
 113     ret2 = LoadStringA( hInst, MAKELONG( 1, 0x8000 ), buf, sizeof(buf));
 114     ok( ret2 == ret, "LoadString failed: ret %d err %d\n", ret, GetLastError());
 115     ret2 = LoadStringA( hInst, MAKELONG( 1, 0xffff ), buf, sizeof(buf));
 116     ok( ret2 == ret, "LoadString failed: ret %d err %d\n", ret, GetLastError());
 117
 118     ret = LoadStringA(hInst, 65534, buf, sizeof(buf) );
 119     ok( ret > 0, "LoadString failed: ret %d err %d\n", ret, GetLastError());
 120     ret2 = LoadStringA( hInst, MAKELONG( 65534, 0x8000 ), buf, sizeof(buf));
 121     ok( ret2 == ret, "LoadString failed: ret %d err %d\n", ret, GetLastError());
 122     ret2 = LoadStringA( hInst, MAKELONG( 65534, 0xffff ), buf, sizeof(buf));
 123     ok( ret2 == ret, "LoadString failed: ret %d err %d\n", ret, GetLastError());
 124
 125     ret = LoadStringA(hInst, 0, buf, 0);
 126     ok( ret == -1 || broken(ret == 0),
 127         "LoadStringA did not return -1 when called with buflen = 0, got %d, err %d\n",
 128         ret, GetLastError());
 129
 130     SetLastError(0xdeadbeef);
 131     buf[0] = 'a';
 132     ret = LoadStringA(hInst, 1, buf, 1);
 133     ok( !ret, "LoadString returned %d\n", ret);
 134     ok( buf[0] == 0, "buf[0] = %c (%x)\n", buf[0], buf[0]);
 135     ok( GetLastError() == 0xdeadbeef, "GetLastError() = %d\n", GetLastError());
 136 }
 137
 138 static void test_accel1(void)
 139 {
 140     UINT r, n;
 141     HACCEL hAccel;
 142     ACCEL ac[10];
 143
 144     /* now create our own valid accelerator table */
 145     n = 0;
 146     ac[n].cmd = 1000;
 147     ac[n].key = 'A';
 148     ac[n++].fVirt = FVIRTKEY | FNOINVERT;
 149
 150     ac[n].cmd = 1001;
 151     ac[n].key = 'B';
 152     ac[n++].fVirt = FNOINVERT;
 153
 154     ac[n].cmd = 0;
 155     ac[n].key = 0;
 156     ac[n++].fVirt = 0;
 157
 158     hAccel = CreateAcceleratorTableA( &ac[0], n );
 159     ok( hAccel != NULL, "create accelerator table\n");
 160
 161     r = DestroyAcceleratorTable( hAccel );
 162     ok( r, "destroy accelerator table\n");
 163
 164     /* now try create an invalid one */
 165     n = 0;
 166     ac[n].cmd = 1000;
 167     ac[n].key = 'A';
 168     ac[n++].fVirt = FVIRTKEY | FNOINVERT;
 169
 170     ac[n].cmd = 0xffff;
 171     ac[n].key = 0xffff;
 172     ac[n++].fVirt = (SHORT) 0xffff;
 173
 174     ac[n].cmd = 0xfff0;
 175     ac[n].key = 0xffff;
 176     ac[n++].fVirt = (SHORT) 0xfff0;
 177
 178     ac[n].cmd = 0xfff0;
 179     ac[n].key = 0xffff;
 180     ac[n++].fVirt = 0x0000;
 181
 182     ac[n].cmd = 0xfff0;
 183     ac[n].key = 0xffff;
 184     ac[n++].fVirt = 0x0001;
 185
 186     hAccel = CreateAcceleratorTableA( &ac[0], n );
 187     ok( hAccel != NULL, "create accelerator table\n");
 188
 189     r = CopyAcceleratorTableA( hAccel, NULL, 0 );
 190     ok( r == n, "two entries in table %u/%u\n", r, n);
 191
 192     r = CopyAcceleratorTableA( hAccel, &ac[0], n );
 193     ok( r == n, "still should be two entries in table %u/%u\n", r, n);
 194
 195     n=0;
 196     ok( ac[n].cmd == 1000, "cmd 0 not preserved got %x\n", ac[n].cmd);
 197     ok( ac[n].key == 'A', "key 0 not preserved got %x\n", ac[n].key);
 198     ok( ac[n].fVirt == (FVIRTKEY | FNOINVERT), "fVirt 0 not preserved got %x\n", ac[n].fVirt);
 199
 200     if (++n == r) goto done;
 201     ok( ac[n].cmd == 0xffff, "cmd 1 not preserved got %x\n", ac[n].cmd);
 202     ok( ac[n].key == 0xffff, "key 1 not preserved got %x\n", ac[n].key);
 203     ok( ac[n].fVirt == 0x007f, "fVirt 1 wrong got %x\n", ac[n].fVirt);
 204
 205     if (++n == r) goto done;
 206     ok( ac[n].cmd == 0xfff0, "cmd 2 not preserved got %x\n", ac[n].cmd);
 207     ok( (ac[n].key & 0xff) == 0xff, "key 2 not preserved got %x\n", ac[n].key);
 208     ok( ac[n].fVirt == 0x0070, "fVirt 2 wrong got %x\n", ac[n].fVirt);
 209
 210     if (++n == r) goto done;
 211     ok( ac[n].cmd == 0xfff0, "cmd 3 not preserved got %x\n", ac[n].cmd);
 212     ok( (ac[n].key & 0xff) == 0xff, "key 3 not preserved got %x\n", ac[n].key);
 213     ok( ac[n].fVirt == 0x0000, "fVirt 3 wrong got %x\n", ac[n].fVirt);
 214
 215     if (++n == r) goto done;
 216     ok( ac[n].cmd == 0xfff0, "cmd 4 not preserved got %x\n", ac[n].cmd);
 217     ok( ac[n].key == 0xffff, "key 4 not preserved got %x\n", ac[n].key);
 218     ok( ac[n].fVirt == 0x0001, "fVirt 4 wrong  got %x\n", ac[n].fVirt);
 219 done:
 220     r = DestroyAcceleratorTable( hAccel );
 221     ok( r, "destroy accelerator table\n");
 222
 223     hAccel = CreateAcceleratorTableA( &ac[0], 0 );
 224     ok( !hAccel || broken(hAccel != NULL), /* nt4 */ "zero elements should fail\n");
 225
 226     /* these will on crash win2k
 227     hAccel = CreateAcceleratorTable( NULL, 1 );
 228     hAccel = CreateAcceleratorTable( &ac[0], -1 );
 229     */
 230 }
 231
 232 /*
 233  *  memcmp on the tables works in Windows, but does not work in wine, as
 234  *  there is an extra undefined and unused byte between fVirt and the key
 235  */
 236 static void test_accel2(void)
 237 {
 238     ACCEL ac[2], out[2];
 239     HACCEL hac;
 240     int res;
 241
 242     ac[0].cmd   = 0;
 243     ac[0].fVirt = 0;
 244     ac[0].key   = 0;
 245
 246     ac[1].cmd   = 0;
 247     ac[1].fVirt = 0;
 248     ac[1].key   = 0;
 249
 250     /*
 251      * crashes on win2k
 252      * hac = CreateAcceleratorTable( NULL, 1 );
 253      */
 254
 255     /* try a zero count */
 256     hac = CreateAcceleratorTableA( &ac[0], 0 );
 257     ok( !hac || broken(hac != NULL), /* nt4 */ "fail\n");
 258     if (!hac) ok( !DestroyAcceleratorTable( hac ), "destroy failed\n");
 259
 260     /* creating one accelerator should work */
 261     hac = CreateAcceleratorTableA( &ac[0], 1 );
 262     ok( hac != NULL , "fail\n");
 263     ok( 1 == CopyAcceleratorTableA( hac, out, 1 ), "copy failed\n");
 264     ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
 265
 266     /* how about two of the same type? */
 267     hac = CreateAcceleratorTableA( &ac[0], 2);
 268     ok( hac != NULL , "fail\n");
 269     res = CopyAcceleratorTableA( hac, NULL, 100 );
 270     ok( res == 2, "copy null failed %d\n", res);
 271     res = CopyAcceleratorTableA( hac, NULL, 0 );
 272     ok( res == 2, "copy null failed %d\n", res);
 273     res = CopyAcceleratorTableA( hac, NULL, 1 );
 274     ok( res == 2, "copy null failed %d\n", res);
 275     ok( 1 == CopyAcceleratorTableA( hac, out, 1 ), "copy 1 failed\n");
 276     ok( 2 == CopyAcceleratorTableA( hac, out, 2 ), "copy 2 failed\n");
 277     ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
 278     /* ok( !memcmp( ac, out, sizeof ac ), "tables different\n"); */
 279
 280     /* how about two of the same type with a non-zero key? */
 281     ac[0].key = 0x20;
 282     ac[1].key = 0x20;
 283     hac = CreateAcceleratorTableA( &ac[0], 2);
 284     ok( hac != NULL , "fail\n");
 285     ok( 2 == CopyAcceleratorTableA( hac, out, 2 ), "copy 2 failed\n");
 286     ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
 287     /* ok( !memcmp( ac, out, sizeof ac ), "tables different\n"); */
 288
 289     /* how about two of the same type with a non-zero virtual key? */
 290     ac[0].fVirt = FVIRTKEY;
 291     ac[0].key = 0x40;
 292     ac[1].fVirt = FVIRTKEY;
 293     ac[1].key = 0x40;
 294     hac = CreateAcceleratorTableA( &ac[0], 2);
 295     ok( hac != NULL , "fail\n");
 296     ok( 2 == CopyAcceleratorTableA( hac, out, 2 ), "copy 2 failed\n");
 297     /* ok( !memcmp( ac, out, sizeof ac ), "tables different\n"); */
 298     ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
 299
 300     /* how virtual key codes */
 301     ac[0].fVirt = FVIRTKEY;
 302     hac = CreateAcceleratorTableA( &ac[0], 1);
 303     ok( hac != NULL , "fail\n");
 304     ok( 1 == CopyAcceleratorTableA( hac, out, 2 ), "copy 2 failed\n");
 305     /* ok( !memcmp( ac, out, sizeof ac/2 ), "tables different\n"); */
 306     ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
 307
 308     /* how turning on all bits? */
 309     ac[0].cmd   = 0xffff;
 310     ac[0].fVirt = 0xff;
 311     ac[0].key   = 0xffff;
 312     hac = CreateAcceleratorTableA( &ac[0], 1);
 313     ok( hac != NULL , "fail\n");
 314     ok( 1 == CopyAcceleratorTableA( hac, out, 1 ), "copy 1 failed\n");
 315     /* ok( memcmp( ac, out, sizeof ac/2 ), "tables not different\n"); */
 316     ok( out[0].cmd == ac[0].cmd, "cmd modified\n");
 317     ok( out[0].fVirt == (ac[0].fVirt&0x7f), "fVirt not modified\n");
 318     ok( out[0].key == ac[0].key, "key modified\n");
 319     ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
 320
 321     /* how turning on all bits? */
 322     memset( ac, 0xff, sizeof ac );
 323     hac = CreateAcceleratorTableA( &ac[0], 2);
 324     ok( hac != NULL , "fail\n");
 325     res = CopyAcceleratorTableA( hac, out, 2 );
 326     ok( res == 2, "copy 2 failed %d\n", res);
 327     /* ok( memcmp( ac, out, sizeof ac ), "tables not different\n"); */
 328     ok( out[0].cmd == ac[0].cmd, "cmd modified\n");
 329     ok( out[0].fVirt == (ac[0].fVirt&0x7f), "fVirt not modified\n");
 330     ok( out[0].key == ac[0].key, "key modified\n");
 331     if (res == 2)
 332     {
 333         ok( out[1].cmd == ac[1].cmd, "cmd modified\n");
 334         ok( out[1].fVirt == (ac[1].fVirt&0x7f), "fVirt not modified\n");
 335         ok( out[1].key == ac[1].key, "key modified\n");
 336     }
 337     ok( DestroyAcceleratorTable( hac ), "destroy failed\n");
 338 }
 339
 340 static void test_PrivateExtractIcons(void) {
 341     const CHAR szShell32Dll[] = "shell32.dll";
 342     HICON ahIcon[256];
 343     UINT i, aIconId[256], cIcons, cIcons2;
 344
 345     if (!pPrivateExtractIconsA) return;
 346
 347     cIcons = pPrivateExtractIconsA("", 0, 16, 16, ahIcon, aIconId, 1, 0);
 348     ok(cIcons == ~0u, "got %u\n", cIcons);
 349
 350     cIcons = pPrivateExtractIconsA("notepad.exe", 0, 16, 16, NULL, NULL, 1, 0);
 351     ok(cIcons == 1 || broken(cIcons == 2) /* win2k */, "got %u\n", cIcons);
 352
 353     ahIcon[0] = (HICON)0xdeadbeef;
 354     cIcons = pPrivateExtractIconsA("notepad.exe", 0, 16, 16, ahIcon, NULL, 1, 0);
 355     ok(cIcons == 1, "got %u\n", cIcons);
 356     ok(ahIcon[0] != (HICON)0xdeadbeef, "icon not set\n");
 357     DestroyIcon(ahIcon[0]);
 358
 359     ahIcon[0] = (HICON)0xdeadbeef;
 360     aIconId[0] = 0xdeadbeef;
 361     cIcons = pPrivateExtractIconsA("notepad.exe", 0, 16, 16, ahIcon, aIconId, 1, 0);
 362     ok(cIcons == 1, "got %u\n", cIcons);
 363     ok(ahIcon[0] != (HICON)0xdeadbeef, "icon not set\n");
 364     ok(aIconId[0] != 0xdeadbeef, "id not set\n");
 365     DestroyIcon(ahIcon[0]);
 366
 367     cIcons = pPrivateExtractIconsA(szShell32Dll, 0, 16, 16, NULL, NULL, 0, 0);
 368     cIcons2 = pPrivateExtractIconsA(szShell32Dll, 4, MAKELONG(32,16), MAKELONG(32,16),
 369                                    NULL, NULL, 256, 0);
 370     ok((cIcons == cIcons2) && (cIcons > 0),
 371        "Icon count should be independent of requested icon sizes and base icon index! "
 372        "(cIcons=%d, cIcons2=%d)\n", cIcons, cIcons2);
 373
 374     cIcons = pPrivateExtractIconsA(szShell32Dll, 0, 16, 16, ahIcon, aIconId, 0, 0);
 375     ok(cIcons == 0, "Zero icons requested, got cIcons=%d\n", cIcons);
 376
 377     cIcons = pPrivateExtractIconsA(szShell32Dll, 0, 16, 16, ahIcon, aIconId, 3, 0);
 378     ok(cIcons == 3, "Three icons requested got cIcons=%d\n", cIcons);
 379     for (i = 0; i < cIcons; i++) DestroyIcon(ahIcon[i]);
 380
 381     /* count must be a multiple of two when getting two sizes */
 382     cIcons = pPrivateExtractIconsA(szShell32Dll, 0, MAKELONG(16,32), MAKELONG(16,32),
 383                                    ahIcon, aIconId, 3, 0);
 384     ok(cIcons == 0 /* vista */ || cIcons == 4, "Three icons requested got cIcons=%d\n", cIcons);
 385     for (i = 0; i < cIcons; i++) DestroyIcon(ahIcon[i]);
 386
 387     cIcons = pPrivateExtractIconsA(szShell32Dll, 0, MAKELONG(16,32), MAKELONG(16,32),
 388                                    ahIcon, aIconId, 4, 0);
 389     ok(cIcons == 4, "Four icons requested got cIcons=%d\n", cIcons);
 390     for (i = 0; i < cIcons; i++) DestroyIcon(ahIcon[i]);
 391 }
 392
 393 static void test_LoadImage(void)
 394 {
 395     HBITMAP bmp;
 396     HRSRC hres;
 397
 398     bmp = LoadBitmapA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(100));
 399     ok(bmp != NULL, "Could not load a bitmap resource\n");
 400     if (bmp) DeleteObject(bmp);
 401
 402     hres = FindResourceA(GetModuleHandleA(NULL), "#100", (LPCSTR)RT_BITMAP);
 403     ok(hres != NULL, "Could not find a bitmap resource with a numeric string\n");
 404
 405     bmp = LoadBitmapA(GetModuleHandleA(NULL), "#100");
 406     ok(bmp != NULL, "Could not load a bitmap resource with a numeric string\n");
 407     if (bmp) DeleteObject(bmp);
 408 }
 409
 410 START_TEST(resource)
 411 {
 412     init_function_pointers();
 413     test_LoadStringA();
 414     test_LoadStringW();
 415     test_accel1();
 416     test_accel2();
 417     test_PrivateExtractIcons();
 418     test_LoadImage();
 419 }