git.oblomov.eu Git - wine/blob - dlls/shell32/tests/generated.c

   1 /* File generated automatically from tools/winapi/test.dat; do not edit! */
   2 /* This file can be copied, modified and distributed without restriction. */
   3
   4 /*
   5  * Unit tests for data structure packing
   6  */
   7
   8 #define WINVER 0x0501
   9 #define _WIN32_IE 0x0501
  10 #define _WIN32_WINNT 0x0501
  11
  12 #define WINE_NOWINSOCK
  13
  14 #include <stdarg.h>
  15 #include "windef.h"
  16 #include "winbase.h"
  17 #include "wtypes.h"
  18 #include "shellapi.h"
  19 #include "winuser.h"
  20 #include "wingdi.h"
  21 #include "shlobj.h"
  22
  23 #include "wine/test.h"
  24
  25 /***********************************************************************
  26  * Compability macros
  27  */
  28
  29 #define DWORD_PTR UINT_PTR
  30 #define LONG_PTR INT_PTR
  31 #define ULONG_PTR UINT_PTR
  32
  33 /***********************************************************************
  34  * Windows API extension
  35  */
  36
  37 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
  38 # define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
  39 #elif defined(__GNUC__)
  40 # define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
  41 #else
  42 /* FIXME: Not sure if is possible to do without compiler extension */
  43 #endif
  44
  45 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
  46 # define _TYPE_ALIGNMENT(type) __alignof(type)
  47 #elif defined(__GNUC__)
  48 # define _TYPE_ALIGNMENT(type) __alignof__(type)
  49 #else
  50 /*
  51  * FIXME: Not sure if is possible to do without compiler extension
  52  *        (if type is not just a name that is, if so the normal)
  53  *         TYPE_ALIGNMENT can be used)
  54  */
  55 #endif
  56
  57 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
  58 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
  59 #endif
  60
  61 /***********************************************************************
  62  * Test helper macros
  63  */
  64
  65 #ifdef FIELD_ALIGNMENT
  66 # define TEST_FIELD_ALIGNMENT(type, field, align) \
  67    ok(FIELD_ALIGNMENT(type, field) == align, \
  68        "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")\n", \
  69            FIELD_ALIGNMENT(type, field))
  70 #else
  71 # define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
  72 #endif
  73
  74 #define TEST_FIELD_OFFSET(type, field, offset) \
  75     ok(FIELD_OFFSET(type, field) == offset, \
  76         "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")\n", \
  77              FIELD_OFFSET(type, field))
  78
  79 #ifdef _TYPE_ALIGNMENT
  80 #define TEST__TYPE_ALIGNMENT(type, align) \
  81     ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", _TYPE_ALIGNMENT(type))
  82 #else
  83 # define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
  84 #endif
  85
  86 #ifdef TYPE_ALIGNMENT
  87 #define TEST_TYPE_ALIGNMENT(type, align) \
  88     ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", TYPE_ALIGNMENT(type))
  89 #else
  90 # define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
  91 #endif
  92
  93 #define TEST_TYPE_SIZE(type, size) \
  94     ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")\n", sizeof(type))
  95
  96 /***********************************************************************
  97  * Test macros
  98  */
  99
 100 #define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
 101   TEST_TYPE_SIZE(field_type, field_size); \
 102   TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
 103   TEST_FIELD_OFFSET(type, field_name, field_offset); \
 104
 105 #define TEST_TYPE(type, size, align) \
 106   TEST_TYPE_ALIGNMENT(type, align); \
 107   TEST_TYPE_SIZE(type, size)
 108
 109 #define TEST_TYPE_POINTER(type, size, align) \
 110     TEST__TYPE_ALIGNMENT(*(type)0, align); \
 111     TEST_TYPE_SIZE(*(type)0, size)
 112
 113 #define TEST_TYPE_SIGNED(type) \
 114     ok((type) -1 < 0, "(" #type ") -1 < 0\n");
 115
 116 #define TEST_TYPE_UNSIGNED(type) \
 117      ok((type) -1 > 0, "(" #type ") -1 > 0\n");
 118
 119 static void test_pack_BLOB(void)
 120 {
 121     /* BLOB (pack 4) */
 122     TEST_TYPE(BLOB, 8, 4);
 123     TEST_FIELD(BLOB, ULONG, cbSize, 0, 4, 4);
 124     TEST_FIELD(BLOB, BYTE *, pBlobData, 4, 4, 4);
 125 }
 126
 127 static void test_pack_BSTR(void)
 128 {
 129     /* BSTR */
 130     TEST_TYPE(BSTR, 4, 4);
 131     TEST_TYPE_POINTER(BSTR, 2, 2);
 132 }
 133
 134 static void test_pack_BSTRBLOB(void)
 135 {
 136     /* BSTRBLOB (pack 4) */
 137     TEST_TYPE(BSTRBLOB, 8, 4);
 138     TEST_FIELD(BSTRBLOB, ULONG, cbSize, 0, 4, 4);
 139     TEST_FIELD(BSTRBLOB, BYTE *, pData, 4, 4, 4);
 140 }
 141
 142 static void test_pack_BYTE_BLOB(void)
 143 {
 144     /* BYTE_BLOB (pack 4) */
 145     TEST_TYPE(BYTE_BLOB, 8, 4);
 146     TEST_FIELD(BYTE_BLOB, unsigned long, clSize, 0, 4, 4);
 147     TEST_FIELD(BYTE_BLOB, byte[1], abData, 4, 1, 1);
 148 }
 149
 150 static void test_pack_BYTE_SIZEDARR(void)
 151 {
 152     /* BYTE_SIZEDARR (pack 4) */
 153     TEST_TYPE(BYTE_SIZEDARR, 8, 4);
 154     TEST_FIELD(BYTE_SIZEDARR, unsigned long, clSize, 0, 4, 4);
 155     TEST_FIELD(BYTE_SIZEDARR, byte *, pData, 4, 4, 4);
 156 }
 157
 158 static void test_pack_CLIPDATA(void)
 159 {
 160     /* CLIPDATA (pack 4) */
 161     TEST_TYPE(CLIPDATA, 12, 4);
 162     TEST_FIELD(CLIPDATA, ULONG, cbSize, 0, 4, 4);
 163     TEST_FIELD(CLIPDATA, long, ulClipFmt, 4, 4, 4);
 164     TEST_FIELD(CLIPDATA, BYTE *, pClipData, 8, 4, 4);
 165 }
 166
 167 static void test_pack_CLIPFORMAT(void)
 168 {
 169     /* CLIPFORMAT */
 170     TEST_TYPE(CLIPFORMAT, 2, 2);
 171     TEST_TYPE_UNSIGNED(CLIPFORMAT);
 172 }
 173
 174 static void test_pack_COAUTHIDENTITY(void)
 175 {
 176     /* COAUTHIDENTITY (pack 4) */
 177     TEST_TYPE(COAUTHIDENTITY, 28, 4);
 178     TEST_FIELD(COAUTHIDENTITY, USHORT *, User, 0, 4, 4);
 179     TEST_FIELD(COAUTHIDENTITY, ULONG, UserLength, 4, 4, 4);
 180     TEST_FIELD(COAUTHIDENTITY, USHORT *, Domain, 8, 4, 4);
 181     TEST_FIELD(COAUTHIDENTITY, ULONG, DomainLength, 12, 4, 4);
 182     TEST_FIELD(COAUTHIDENTITY, USHORT *, Password, 16, 4, 4);
 183     TEST_FIELD(COAUTHIDENTITY, ULONG, PasswordLength, 20, 4, 4);
 184     TEST_FIELD(COAUTHIDENTITY, ULONG, Flags, 24, 4, 4);
 185 }
 186
 187 static void test_pack_COAUTHINFO(void)
 188 {
 189     /* COAUTHINFO (pack 4) */
 190     TEST_TYPE(COAUTHINFO, 28, 4);
 191     TEST_FIELD(COAUTHINFO, DWORD, dwAuthnSvc, 0, 4, 4);
 192     TEST_FIELD(COAUTHINFO, DWORD, dwAuthzSvc, 4, 4, 4);
 193     TEST_FIELD(COAUTHINFO, LPWSTR, pwszServerPrincName, 8, 4, 4);
 194     TEST_FIELD(COAUTHINFO, DWORD, dwAuthnLevel, 12, 4, 4);
 195     TEST_FIELD(COAUTHINFO, DWORD, dwImpersonationLevel, 16, 4, 4);
 196     TEST_FIELD(COAUTHINFO, COAUTHIDENTITY *, pAuthIdentityData, 20, 4, 4);
 197     TEST_FIELD(COAUTHINFO, DWORD, dwCapabilities, 24, 4, 4);
 198 }
 199
 200 static void test_pack_COSERVERINFO(void)
 201 {
 202     /* COSERVERINFO (pack 4) */
 203     TEST_TYPE(COSERVERINFO, 16, 4);
 204     TEST_FIELD(COSERVERINFO, DWORD, dwReserved1, 0, 4, 4);
 205     TEST_FIELD(COSERVERINFO, LPWSTR, pwszName, 4, 4, 4);
 206     TEST_FIELD(COSERVERINFO, COAUTHINFO *, pAuthInfo, 8, 4, 4);
 207     TEST_FIELD(COSERVERINFO, DWORD, dwReserved2, 12, 4, 4);
 208 }
 209
 210 static void test_pack_DWORD_SIZEDARR(void)
 211 {
 212     /* DWORD_SIZEDARR (pack 4) */
 213     TEST_TYPE(DWORD_SIZEDARR, 8, 4);
 214     TEST_FIELD(DWORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
 215     TEST_FIELD(DWORD_SIZEDARR, unsigned long *, pData, 4, 4, 4);
 216 }
 217
 218 static void test_pack_FLAGGED_BYTE_BLOB(void)
 219 {
 220     /* FLAGGED_BYTE_BLOB (pack 4) */
 221     TEST_TYPE(FLAGGED_BYTE_BLOB, 12, 4);
 222     TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, fFlags, 0, 4, 4);
 223     TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, clSize, 4, 4, 4);
 224     TEST_FIELD(FLAGGED_BYTE_BLOB, byte[1], abData, 8, 1, 1);
 225 }
 226
 227 static void test_pack_FLAGGED_WORD_BLOB(void)
 228 {
 229     /* FLAGGED_WORD_BLOB (pack 4) */
 230     TEST_TYPE(FLAGGED_WORD_BLOB, 12, 4);
 231     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, fFlags, 0, 4, 4);
 232     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, clSize, 4, 4, 4);
 233     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned short[1], asData, 8, 2, 2);
 234 }
 235
 236 static void test_pack_HMETAFILEPICT(void)
 237 {
 238     /* HMETAFILEPICT */
 239     TEST_TYPE(HMETAFILEPICT, 4, 4);
 240 }
 241
 242 static void test_pack_HYPER_SIZEDARR(void)
 243 {
 244     /* HYPER_SIZEDARR (pack 4) */
 245     TEST_TYPE(HYPER_SIZEDARR, 8, 4);
 246     TEST_FIELD(HYPER_SIZEDARR, unsigned long, clSize, 0, 4, 4);
 247     TEST_FIELD(HYPER_SIZEDARR, hyper *, pData, 4, 4, 4);
 248 }
 249
 250 static void test_pack_LPBLOB(void)
 251 {
 252     /* LPBLOB */
 253     TEST_TYPE(LPBLOB, 4, 4);
 254     TEST_TYPE_POINTER(LPBLOB, 8, 4);
 255 }
 256
 257 static void test_pack_LPBSTR(void)
 258 {
 259     /* LPBSTR */
 260     TEST_TYPE(LPBSTR, 4, 4);
 261     TEST_TYPE_POINTER(LPBSTR, 4, 4);
 262 }
 263
 264 static void test_pack_LPBSTRBLOB(void)
 265 {
 266     /* LPBSTRBLOB */
 267     TEST_TYPE(LPBSTRBLOB, 4, 4);
 268     TEST_TYPE_POINTER(LPBSTRBLOB, 8, 4);
 269 }
 270
 271 static void test_pack_LPCOLESTR(void)
 272 {
 273     /* LPCOLESTR */
 274     TEST_TYPE(LPCOLESTR, 4, 4);
 275     TEST_TYPE_POINTER(LPCOLESTR, 2, 2);
 276 }
 277
 278 static void test_pack_LPCY(void)
 279 {
 280     /* LPCY */
 281     TEST_TYPE(LPCY, 4, 4);
 282 }
 283
 284 static void test_pack_LPDECIMAL(void)
 285 {
 286     /* LPDECIMAL */
 287     TEST_TYPE(LPDECIMAL, 4, 4);
 288 }
 289
 290 static void test_pack_LPOLESTR(void)
 291 {
 292     /* LPOLESTR */
 293     TEST_TYPE(LPOLESTR, 4, 4);
 294     TEST_TYPE_POINTER(LPOLESTR, 2, 2);
 295 }
 296
 297 static void test_pack_OLECHAR(void)
 298 {
 299     /* OLECHAR */
 300     TEST_TYPE(OLECHAR, 2, 2);
 301 }
 302
 303 static void test_pack_PROPID(void)
 304 {
 305     /* PROPID */
 306     TEST_TYPE(PROPID, 4, 4);
 307 }
 308
 309 static void test_pack_RemHBITMAP(void)
 310 {
 311     /* RemHBITMAP (pack 4) */
 312     TEST_TYPE(RemHBITMAP, 8, 4);
 313     TEST_FIELD(RemHBITMAP, unsigned long, cbData, 0, 4, 4);
 314     TEST_FIELD(RemHBITMAP, byte[1], data, 4, 1, 1);
 315 }
 316
 317 static void test_pack_RemHENHMETAFILE(void)
 318 {
 319     /* RemHENHMETAFILE (pack 4) */
 320     TEST_TYPE(RemHENHMETAFILE, 8, 4);
 321     TEST_FIELD(RemHENHMETAFILE, unsigned long, cbData, 0, 4, 4);
 322     TEST_FIELD(RemHENHMETAFILE, byte[1], data, 4, 1, 1);
 323 }
 324
 325 static void test_pack_RemHGLOBAL(void)
 326 {
 327     /* RemHGLOBAL (pack 4) */
 328     TEST_TYPE(RemHGLOBAL, 12, 4);
 329     TEST_FIELD(RemHGLOBAL, long, fNullHGlobal, 0, 4, 4);
 330     TEST_FIELD(RemHGLOBAL, unsigned long, cbData, 4, 4, 4);
 331     TEST_FIELD(RemHGLOBAL, byte[1], data, 8, 1, 1);
 332 }
 333
 334 static void test_pack_RemHMETAFILEPICT(void)
 335 {
 336     /* RemHMETAFILEPICT (pack 4) */
 337     TEST_TYPE(RemHMETAFILEPICT, 20, 4);
 338     TEST_FIELD(RemHMETAFILEPICT, long, mm, 0, 4, 4);
 339     TEST_FIELD(RemHMETAFILEPICT, long, xExt, 4, 4, 4);
 340     TEST_FIELD(RemHMETAFILEPICT, long, yExt, 8, 4, 4);
 341     TEST_FIELD(RemHMETAFILEPICT, unsigned long, cbData, 12, 4, 4);
 342     TEST_FIELD(RemHMETAFILEPICT, byte[1], data, 16, 1, 1);
 343 }
 344
 345 static void test_pack_RemHPALETTE(void)
 346 {
 347     /* RemHPALETTE (pack 4) */
 348     TEST_TYPE(RemHPALETTE, 8, 4);
 349     TEST_FIELD(RemHPALETTE, unsigned long, cbData, 0, 4, 4);
 350     TEST_FIELD(RemHPALETTE, byte[1], data, 4, 1, 1);
 351 }
 352
 353 static void test_pack_SCODE(void)
 354 {
 355     /* SCODE */
 356     TEST_TYPE(SCODE, 4, 4);
 357 }
 358
 359 static void test_pack_UP_BYTE_BLOB(void)
 360 {
 361     /* UP_BYTE_BLOB */
 362     TEST_TYPE(UP_BYTE_BLOB, 4, 4);
 363     TEST_TYPE_POINTER(UP_BYTE_BLOB, 8, 4);
 364 }
 365
 366 static void test_pack_UP_FLAGGED_BYTE_BLOB(void)
 367 {
 368     /* UP_FLAGGED_BYTE_BLOB */
 369     TEST_TYPE(UP_FLAGGED_BYTE_BLOB, 4, 4);
 370     TEST_TYPE_POINTER(UP_FLAGGED_BYTE_BLOB, 12, 4);
 371 }
 372
 373 static void test_pack_UP_FLAGGED_WORD_BLOB(void)
 374 {
 375     /* UP_FLAGGED_WORD_BLOB */
 376     TEST_TYPE(UP_FLAGGED_WORD_BLOB, 4, 4);
 377     TEST_TYPE_POINTER(UP_FLAGGED_WORD_BLOB, 12, 4);
 378 }
 379
 380 static void test_pack_VARIANT_BOOL(void)
 381 {
 382     /* VARIANT_BOOL */
 383     TEST_TYPE(VARIANT_BOOL, 2, 2);
 384     TEST_TYPE_SIGNED(VARIANT_BOOL);
 385 }
 386
 387 static void test_pack_VARTYPE(void)
 388 {
 389     /* VARTYPE */
 390     TEST_TYPE(VARTYPE, 2, 2);
 391     TEST_TYPE_UNSIGNED(VARTYPE);
 392 }
 393
 394 static void test_pack_WORD_SIZEDARR(void)
 395 {
 396     /* WORD_SIZEDARR (pack 4) */
 397     TEST_TYPE(WORD_SIZEDARR, 8, 4);
 398     TEST_FIELD(WORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
 399     TEST_FIELD(WORD_SIZEDARR, unsigned short *, pData, 4, 4, 4);
 400 }
 401
 402 static void test_pack_remoteMETAFILEPICT(void)
 403 {
 404     /* remoteMETAFILEPICT (pack 4) */
 405     TEST_TYPE(remoteMETAFILEPICT, 16, 4);
 406     TEST_FIELD(remoteMETAFILEPICT, long, mm, 0, 4, 4);
 407     TEST_FIELD(remoteMETAFILEPICT, long, xExt, 4, 4, 4);
 408     TEST_FIELD(remoteMETAFILEPICT, long, yExt, 8, 4, 4);
 409     TEST_FIELD(remoteMETAFILEPICT, userHMETAFILE *, hMF, 12, 4, 4);
 410 }
 411
 412 static void test_pack_userBITMAP(void)
 413 {
 414     /* userBITMAP (pack 4) */
 415     TEST_TYPE(userBITMAP, 28, 4);
 416     TEST_FIELD(userBITMAP, LONG, bmType, 0, 4, 4);
 417     TEST_FIELD(userBITMAP, LONG, bmWidth, 4, 4, 4);
 418     TEST_FIELD(userBITMAP, LONG, bmHeight, 8, 4, 4);
 419     TEST_FIELD(userBITMAP, LONG, bmWidthBytes, 12, 4, 4);
 420     TEST_FIELD(userBITMAP, WORD, bmPlanes, 16, 2, 2);
 421     TEST_FIELD(userBITMAP, WORD, bmBitsPixel, 18, 2, 2);
 422     TEST_FIELD(userBITMAP, ULONG, cbSize, 20, 4, 4);
 423     TEST_FIELD(userBITMAP, byte[1], pBuffer, 24, 1, 1);
 424 }
 425
 426 static void test_pack_userCLIPFORMAT(void)
 427 {
 428     /* userCLIPFORMAT (pack 4) */
 429     TEST_FIELD(userCLIPFORMAT, long, fContext, 0, 4, 4);
 430 }
 431
 432 static void test_pack_userHBITMAP(void)
 433 {
 434     /* userHBITMAP (pack 4) */
 435     TEST_FIELD(userHBITMAP, long, fContext, 0, 4, 4);
 436 }
 437
 438 static void test_pack_userHENHMETAFILE(void)
 439 {
 440     /* userHENHMETAFILE (pack 4) */
 441     TEST_FIELD(userHENHMETAFILE, long, fContext, 0, 4, 4);
 442 }
 443
 444 static void test_pack_userHGLOBAL(void)
 445 {
 446     /* userHGLOBAL (pack 4) */
 447     TEST_FIELD(userHGLOBAL, long, fContext, 0, 4, 4);
 448 }
 449
 450 static void test_pack_userHMETAFILE(void)
 451 {
 452     /* userHMETAFILE (pack 4) */
 453     TEST_FIELD(userHMETAFILE, long, fContext, 0, 4, 4);
 454 }
 455
 456 static void test_pack_userHMETAFILEPICT(void)
 457 {
 458     /* userHMETAFILEPICT (pack 4) */
 459     TEST_FIELD(userHMETAFILEPICT, long, fContext, 0, 4, 4);
 460 }
 461
 462 static void test_pack_userHPALETTE(void)
 463 {
 464     /* userHPALETTE (pack 4) */
 465     TEST_FIELD(userHPALETTE, long, fContext, 0, 4, 4);
 466 }
 467
 468 static void test_pack_wireBSTR(void)
 469 {
 470     /* wireBSTR */
 471     TEST_TYPE(wireBSTR, 4, 4);
 472     TEST_TYPE_POINTER(wireBSTR, 12, 4);
 473 }
 474
 475 static void test_pack_wireCLIPFORMAT(void)
 476 {
 477     /* wireCLIPFORMAT */
 478     TEST_TYPE(wireCLIPFORMAT, 4, 4);
 479 }
 480
 481 static void test_pack_wireHBITMAP(void)
 482 {
 483     /* wireHBITMAP */
 484     TEST_TYPE(wireHBITMAP, 4, 4);
 485 }
 486
 487 static void test_pack_wireHENHMETAFILE(void)
 488 {
 489     /* wireHENHMETAFILE */
 490     TEST_TYPE(wireHENHMETAFILE, 4, 4);
 491 }
 492
 493 static void test_pack_wireHGLOBAL(void)
 494 {
 495     /* wireHGLOBAL */
 496     TEST_TYPE(wireHGLOBAL, 4, 4);
 497 }
 498
 499 static void test_pack_wireHMETAFILE(void)
 500 {
 501     /* wireHMETAFILE */
 502     TEST_TYPE(wireHMETAFILE, 4, 4);
 503 }
 504
 505 static void test_pack_wireHMETAFILEPICT(void)
 506 {
 507     /* wireHMETAFILEPICT */
 508     TEST_TYPE(wireHMETAFILEPICT, 4, 4);
 509 }
 510
 511 static void test_pack_wireHPALETTE(void)
 512 {
 513     /* wireHPALETTE */
 514     TEST_TYPE(wireHPALETTE, 4, 4);
 515 }
 516
 517 static void test_pack_CLSID(void)
 518 {
 519     /* CLSID */
 520     TEST_TYPE(CLSID, 16, 4);
 521 }
 522
 523 static void test_pack_FMTID(void)
 524 {
 525     /* FMTID */
 526     TEST_TYPE(FMTID, 16, 4);
 527 }
 528
 529 static void test_pack_GUID(void)
 530 {
 531     /* GUID (pack 4) */
 532     TEST_TYPE(GUID, 16, 4);
 533     TEST_FIELD(GUID, unsigned long, Data1, 0, 4, 4);
 534     TEST_FIELD(GUID, unsigned short, Data2, 4, 2, 2);
 535     TEST_FIELD(GUID, unsigned short, Data3, 6, 2, 2);
 536     TEST_FIELD(GUID, unsigned char[ 8 ], Data4, 8, 8, 1);
 537 }
 538
 539 static void test_pack_IID(void)
 540 {
 541     /* IID */
 542     TEST_TYPE(IID, 16, 4);
 543 }
 544
 545 static void test_pack_LPGUID(void)
 546 {
 547     /* LPGUID */
 548     TEST_TYPE(LPGUID, 4, 4);
 549     TEST_TYPE_POINTER(LPGUID, 16, 4);
 550 }
 551
 552 static void test_pack_APPBARDATA(void)
 553 {
 554     /* APPBARDATA (pack 1) */
 555     TEST_TYPE(APPBARDATA, 36, 1);
 556     TEST_FIELD(APPBARDATA, DWORD, cbSize, 0, 4, 1);
 557     TEST_FIELD(APPBARDATA, HWND, hWnd, 4, 4, 1);
 558     TEST_FIELD(APPBARDATA, UINT, uCallbackMessage, 8, 4, 1);
 559     TEST_FIELD(APPBARDATA, UINT, uEdge, 12, 4, 1);
 560     TEST_FIELD(APPBARDATA, RECT, rc, 16, 16, 1);
 561     TEST_FIELD(APPBARDATA, LPARAM, lParam, 32, 4, 1);
 562 }
 563
 564 static void test_pack_DRAGINFOA(void)
 565 {
 566     /* DRAGINFOA (pack 1) */
 567     TEST_TYPE(DRAGINFOA, 24, 1);
 568     TEST_FIELD(DRAGINFOA, UINT, uSize, 0, 4, 1);
 569     TEST_FIELD(DRAGINFOA, POINT, pt, 4, 8, 1);
 570     TEST_FIELD(DRAGINFOA, BOOL, fNC, 12, 4, 1);
 571     TEST_FIELD(DRAGINFOA, LPSTR, lpFileList, 16, 4, 1);
 572     TEST_FIELD(DRAGINFOA, DWORD, grfKeyState, 20, 4, 1);
 573 }
 574
 575 static void test_pack_DRAGINFOW(void)
 576 {
 577     /* DRAGINFOW (pack 1) */
 578     TEST_TYPE(DRAGINFOW, 24, 1);
 579     TEST_FIELD(DRAGINFOW, UINT, uSize, 0, 4, 1);
 580     TEST_FIELD(DRAGINFOW, POINT, pt, 4, 8, 1);
 581     TEST_FIELD(DRAGINFOW, BOOL, fNC, 12, 4, 1);
 582     TEST_FIELD(DRAGINFOW, LPWSTR, lpFileList, 16, 4, 1);
 583     TEST_FIELD(DRAGINFOW, DWORD, grfKeyState, 20, 4, 1);
 584 }
 585
 586 static void test_pack_FILEOP_FLAGS(void)
 587 {
 588     /* FILEOP_FLAGS */
 589     TEST_TYPE(FILEOP_FLAGS, 2, 2);
 590     TEST_TYPE_UNSIGNED(FILEOP_FLAGS);
 591 }
 592
 593 static void test_pack_LPDRAGINFOA(void)
 594 {
 595     /* LPDRAGINFOA */
 596     TEST_TYPE(LPDRAGINFOA, 4, 4);
 597     TEST_TYPE_POINTER(LPDRAGINFOA, 24, 1);
 598 }
 599
 600 static void test_pack_LPDRAGINFOW(void)
 601 {
 602     /* LPDRAGINFOW */
 603     TEST_TYPE(LPDRAGINFOW, 4, 4);
 604     TEST_TYPE_POINTER(LPDRAGINFOW, 24, 1);
 605 }
 606
 607 static void test_pack_LPSHFILEOPSTRUCTA(void)
 608 {
 609     /* LPSHFILEOPSTRUCTA */
 610     TEST_TYPE(LPSHFILEOPSTRUCTA, 4, 4);
 611     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTA, 30, 1);
 612 }
 613
 614 static void test_pack_LPSHFILEOPSTRUCTW(void)
 615 {
 616     /* LPSHFILEOPSTRUCTW */
 617     TEST_TYPE(LPSHFILEOPSTRUCTW, 4, 4);
 618     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTW, 30, 1);
 619 }
 620
 621 static void test_pack_LPSHNAMEMAPPINGA(void)
 622 {
 623     /* LPSHNAMEMAPPINGA */
 624     TEST_TYPE(LPSHNAMEMAPPINGA, 4, 4);
 625     TEST_TYPE_POINTER(LPSHNAMEMAPPINGA, 16, 1);
 626 }
 627
 628 static void test_pack_LPSHNAMEMAPPINGW(void)
 629 {
 630     /* LPSHNAMEMAPPINGW */
 631     TEST_TYPE(LPSHNAMEMAPPINGW, 4, 4);
 632     TEST_TYPE_POINTER(LPSHNAMEMAPPINGW, 16, 1);
 633 }
 634
 635 static void test_pack_NOTIFYICONDATAA(void)
 636 {
 637     /* NOTIFYICONDATAA (pack 1) */
 638     TEST_FIELD(NOTIFYICONDATAA, DWORD, cbSize, 0, 4, 1);
 639     TEST_FIELD(NOTIFYICONDATAA, HWND, hWnd, 4, 4, 1);
 640     TEST_FIELD(NOTIFYICONDATAA, UINT, uID, 8, 4, 1);
 641     TEST_FIELD(NOTIFYICONDATAA, UINT, uFlags, 12, 4, 1);
 642     TEST_FIELD(NOTIFYICONDATAA, UINT, uCallbackMessage, 16, 4, 1);
 643     TEST_FIELD(NOTIFYICONDATAA, HICON, hIcon, 20, 4, 1);
 644     TEST_FIELD(NOTIFYICONDATAA, CHAR[128], szTip, 24, 128, 1);
 645     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwState, 152, 4, 1);
 646     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwStateMask, 156, 4, 1);
 647     TEST_FIELD(NOTIFYICONDATAA, CHAR[256], szInfo, 160, 256, 1);
 648 }
 649
 650 static void test_pack_NOTIFYICONDATAW(void)
 651 {
 652     /* NOTIFYICONDATAW (pack 1) */
 653     TEST_FIELD(NOTIFYICONDATAW, DWORD, cbSize, 0, 4, 1);
 654     TEST_FIELD(NOTIFYICONDATAW, HWND, hWnd, 4, 4, 1);
 655     TEST_FIELD(NOTIFYICONDATAW, UINT, uID, 8, 4, 1);
 656     TEST_FIELD(NOTIFYICONDATAW, UINT, uFlags, 12, 4, 1);
 657     TEST_FIELD(NOTIFYICONDATAW, UINT, uCallbackMessage, 16, 4, 1);
 658     TEST_FIELD(NOTIFYICONDATAW, HICON, hIcon, 20, 4, 1);
 659     TEST_FIELD(NOTIFYICONDATAW, WCHAR[128], szTip, 24, 256, 1);
 660     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwState, 280, 4, 1);
 661     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwStateMask, 284, 4, 1);
 662     TEST_FIELD(NOTIFYICONDATAW, WCHAR[256], szInfo, 288, 512, 1);
 663 }
 664
 665 static void test_pack_PAPPBARDATA(void)
 666 {
 667     /* PAPPBARDATA */
 668     TEST_TYPE(PAPPBARDATA, 4, 4);
 669     TEST_TYPE_POINTER(PAPPBARDATA, 36, 1);
 670 }
 671
 672 static void test_pack_PNOTIFYICONDATAA(void)
 673 {
 674     /* PNOTIFYICONDATAA */
 675     TEST_TYPE(PNOTIFYICONDATAA, 4, 4);
 676 }
 677
 678 static void test_pack_PNOTIFYICONDATAW(void)
 679 {
 680     /* PNOTIFYICONDATAW */
 681     TEST_TYPE(PNOTIFYICONDATAW, 4, 4);
 682 }
 683
 684 static void test_pack_PRINTEROP_FLAGS(void)
 685 {
 686     /* PRINTEROP_FLAGS */
 687     TEST_TYPE(PRINTEROP_FLAGS, 2, 2);
 688     TEST_TYPE_UNSIGNED(PRINTEROP_FLAGS);
 689 }
 690
 691 static void test_pack_SHFILEINFOA(void)
 692 {
 693     /* SHFILEINFOA (pack 1) */
 694     TEST_TYPE(SHFILEINFOA, 352, 1);
 695     TEST_FIELD(SHFILEINFOA, HICON, hIcon, 0, 4, 1);
 696     TEST_FIELD(SHFILEINFOA, int, iIcon, 4, 4, 1);
 697     TEST_FIELD(SHFILEINFOA, DWORD, dwAttributes, 8, 4, 1);
 698     TEST_FIELD(SHFILEINFOA, CHAR[MAX_PATH], szDisplayName, 12, 260, 1);
 699     TEST_FIELD(SHFILEINFOA, CHAR[80], szTypeName, 272, 80, 1);
 700 }
 701
 702 static void test_pack_SHFILEINFOW(void)
 703 {
 704     /* SHFILEINFOW (pack 1) */
 705     TEST_TYPE(SHFILEINFOW, 692, 1);
 706     TEST_FIELD(SHFILEINFOW, HICON, hIcon, 0, 4, 1);
 707     TEST_FIELD(SHFILEINFOW, int, iIcon, 4, 4, 1);
 708     TEST_FIELD(SHFILEINFOW, DWORD, dwAttributes, 8, 4, 1);
 709     TEST_FIELD(SHFILEINFOW, WCHAR[MAX_PATH], szDisplayName, 12, 520, 1);
 710     TEST_FIELD(SHFILEINFOW, WCHAR[80], szTypeName, 532, 160, 1);
 711 }
 712
 713 static void test_pack_SHFILEOPSTRUCTA(void)
 714 {
 715     /* SHFILEOPSTRUCTA (pack 1) */
 716     TEST_TYPE(SHFILEOPSTRUCTA, 30, 1);
 717     TEST_FIELD(SHFILEOPSTRUCTA, HWND, hwnd, 0, 4, 1);
 718     TEST_FIELD(SHFILEOPSTRUCTA, UINT, wFunc, 4, 4, 1);
 719     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pFrom, 8, 4, 1);
 720     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pTo, 12, 4, 1);
 721     TEST_FIELD(SHFILEOPSTRUCTA, FILEOP_FLAGS, fFlags, 16, 2, 1);
 722     TEST_FIELD(SHFILEOPSTRUCTA, BOOL, fAnyOperationsAborted, 18, 4, 1);
 723     TEST_FIELD(SHFILEOPSTRUCTA, LPVOID, hNameMappings, 22, 4, 1);
 724     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, lpszProgressTitle, 26, 4, 1);
 725 }
 726
 727 static void test_pack_SHFILEOPSTRUCTW(void)
 728 {
 729     /* SHFILEOPSTRUCTW (pack 1) */
 730     TEST_TYPE(SHFILEOPSTRUCTW, 30, 1);
 731     TEST_FIELD(SHFILEOPSTRUCTW, HWND, hwnd, 0, 4, 1);
 732     TEST_FIELD(SHFILEOPSTRUCTW, UINT, wFunc, 4, 4, 1);
 733     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pFrom, 8, 4, 1);
 734     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pTo, 12, 4, 1);
 735     TEST_FIELD(SHFILEOPSTRUCTW, FILEOP_FLAGS, fFlags, 16, 2, 1);
 736     TEST_FIELD(SHFILEOPSTRUCTW, BOOL, fAnyOperationsAborted, 18, 4, 1);
 737     TEST_FIELD(SHFILEOPSTRUCTW, LPVOID, hNameMappings, 22, 4, 1);
 738     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, lpszProgressTitle, 26, 4, 1);
 739 }
 740
 741 static void test_pack_SHNAMEMAPPINGA(void)
 742 {
 743     /* SHNAMEMAPPINGA (pack 1) */
 744     TEST_TYPE(SHNAMEMAPPINGA, 16, 1);
 745     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszOldPath, 0, 4, 1);
 746     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszNewPath, 4, 4, 1);
 747     TEST_FIELD(SHNAMEMAPPINGA, int, cchOldPath, 8, 4, 1);
 748     TEST_FIELD(SHNAMEMAPPINGA, int, cchNewPath, 12, 4, 1);
 749 }
 750
 751 static void test_pack_SHNAMEMAPPINGW(void)
 752 {
 753     /* SHNAMEMAPPINGW (pack 1) */
 754     TEST_TYPE(SHNAMEMAPPINGW, 16, 1);
 755     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszOldPath, 0, 4, 1);
 756     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszNewPath, 4, 4, 1);
 757     TEST_FIELD(SHNAMEMAPPINGW, int, cchOldPath, 8, 4, 1);
 758     TEST_FIELD(SHNAMEMAPPINGW, int, cchNewPath, 12, 4, 1);
 759 }
 760
 761 static void test_pack_AUTO_SCROLL_DATA(void)
 762 {
 763     /* AUTO_SCROLL_DATA (pack 1) */
 764     TEST_TYPE(AUTO_SCROLL_DATA, 48, 1);
 765     TEST_FIELD(AUTO_SCROLL_DATA, int, iNextSample, 0, 4, 1);
 766     TEST_FIELD(AUTO_SCROLL_DATA, DWORD, dwLastScroll, 4, 4, 1);
 767     TEST_FIELD(AUTO_SCROLL_DATA, BOOL, bFull, 8, 4, 1);
 768     TEST_FIELD(AUTO_SCROLL_DATA, POINT[NUM_POINTS], pts, 12, 24, 1);
 769     TEST_FIELD(AUTO_SCROLL_DATA, DWORD[NUM_POINTS], dwTimes, 36, 12, 1);
 770 }
 771
 772 static void test_pack_BFFCALLBACK(void)
 773 {
 774     /* BFFCALLBACK */
 775     TEST_TYPE(BFFCALLBACK, 4, 4);
 776 }
 777
 778 static void test_pack_CABINETSTATE(void)
 779 {
 780     /* CABINETSTATE (pack 1) */
 781     TEST_TYPE(CABINETSTATE, 12, 1);
 782     TEST_FIELD(CABINETSTATE, WORD, cLength, 0, 2, 1);
 783     TEST_FIELD(CABINETSTATE, WORD, nVersion, 2, 2, 1);
 784     TEST_FIELD(CABINETSTATE, UINT, fMenuEnumFilter, 8, 4, 1);
 785 }
 786
 787 static void test_pack_CIDA(void)
 788 {
 789     /* CIDA (pack 1) */
 790     TEST_TYPE(CIDA, 8, 1);
 791     TEST_FIELD(CIDA, UINT, cidl, 0, 4, 1);
 792     TEST_FIELD(CIDA, UINT[1], aoffset, 4, 4, 1);
 793 }
 794
 795 static void test_pack_DROPFILES(void)
 796 {
 797     /* DROPFILES (pack 1) */
 798     TEST_TYPE(DROPFILES, 20, 1);
 799     TEST_FIELD(DROPFILES, DWORD, pFiles, 0, 4, 1);
 800     TEST_FIELD(DROPFILES, POINT, pt, 4, 8, 1);
 801     TEST_FIELD(DROPFILES, BOOL, fNC, 12, 4, 1);
 802     TEST_FIELD(DROPFILES, BOOL, fWide, 16, 4, 1);
 803 }
 804
 805 static void test_pack_FILEDESCRIPTORA(void)
 806 {
 807     /* FILEDESCRIPTORA (pack 1) */
 808     TEST_TYPE(FILEDESCRIPTORA, 332, 1);
 809     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFlags, 0, 4, 1);
 810     TEST_FIELD(FILEDESCRIPTORA, CLSID, clsid, 4, 16, 1);
 811     TEST_FIELD(FILEDESCRIPTORA, SIZEL, sizel, 20, 8, 1);
 812     TEST_FIELD(FILEDESCRIPTORA, POINTL, pointl, 28, 8, 1);
 813     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFileAttributes, 36, 4, 1);
 814     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftCreationTime, 40, 8, 1);
 815     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastAccessTime, 48, 8, 1);
 816     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastWriteTime, 56, 8, 1);
 817     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeHigh, 64, 4, 1);
 818     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeLow, 68, 4, 1);
 819     TEST_FIELD(FILEDESCRIPTORA, CHAR[MAX_PATH], cFileName, 72, 260, 1);
 820 }
 821
 822 static void test_pack_FILEDESCRIPTORW(void)
 823 {
 824     /* FILEDESCRIPTORW (pack 1) */
 825     TEST_TYPE(FILEDESCRIPTORW, 592, 1);
 826     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFlags, 0, 4, 1);
 827     TEST_FIELD(FILEDESCRIPTORW, CLSID, clsid, 4, 16, 1);
 828     TEST_FIELD(FILEDESCRIPTORW, SIZEL, sizel, 20, 8, 1);
 829     TEST_FIELD(FILEDESCRIPTORW, POINTL, pointl, 28, 8, 1);
 830     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFileAttributes, 36, 4, 1);
 831     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftCreationTime, 40, 8, 1);
 832     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastAccessTime, 48, 8, 1);
 833     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastWriteTime, 56, 8, 1);
 834     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeHigh, 64, 4, 1);
 835     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeLow, 68, 4, 1);
 836     TEST_FIELD(FILEDESCRIPTORW, WCHAR[MAX_PATH], cFileName, 72, 520, 1);
 837 }
 838
 839 static void test_pack_FILEGROUPDESCRIPTORA(void)
 840 {
 841     /* FILEGROUPDESCRIPTORA (pack 1) */
 842     TEST_TYPE(FILEGROUPDESCRIPTORA, 336, 1);
 843     TEST_FIELD(FILEGROUPDESCRIPTORA, UINT, cItems, 0, 4, 1);
 844     TEST_FIELD(FILEGROUPDESCRIPTORA, FILEDESCRIPTORA[1], fgd, 4, 332, 1);
 845 }
 846
 847 static void test_pack_FILEGROUPDESCRIPTORW(void)
 848 {
 849     /* FILEGROUPDESCRIPTORW (pack 1) */
 850     TEST_TYPE(FILEGROUPDESCRIPTORW, 596, 1);
 851     TEST_FIELD(FILEGROUPDESCRIPTORW, UINT, cItems, 0, 4, 1);
 852     TEST_FIELD(FILEGROUPDESCRIPTORW, FILEDESCRIPTORW[1], fgd, 4, 592, 1);
 853 }
 854
 855 static void test_pack_IFileSystemBindData(void)
 856 {
 857     /* IFileSystemBindData */
 858 }
 859
 860 static void test_pack_IFileSystemBindDataVtbl(void)
 861 {
 862     /* IFileSystemBindDataVtbl */
 863 }
 864
 865 static void test_pack_IShellChangeNotify(void)
 866 {
 867     /* IShellChangeNotify */
 868 }
 869
 870 static void test_pack_IShellIcon(void)
 871 {
 872     /* IShellIcon */
 873 }
 874
 875 static void test_pack_LPCABINETSTATE(void)
 876 {
 877     /* LPCABINETSTATE */
 878     TEST_TYPE(LPCABINETSTATE, 4, 4);
 879     TEST_TYPE_POINTER(LPCABINETSTATE, 12, 1);
 880 }
 881
 882 static void test_pack_LPDROPFILES(void)
 883 {
 884     /* LPDROPFILES */
 885     TEST_TYPE(LPDROPFILES, 4, 4);
 886     TEST_TYPE_POINTER(LPDROPFILES, 20, 1);
 887 }
 888
 889 static void test_pack_LPFILEDESCRIPTORA(void)
 890 {
 891     /* LPFILEDESCRIPTORA */
 892     TEST_TYPE(LPFILEDESCRIPTORA, 4, 4);
 893     TEST_TYPE_POINTER(LPFILEDESCRIPTORA, 332, 1);
 894 }
 895
 896 static void test_pack_LPFILEDESCRIPTORW(void)
 897 {
 898     /* LPFILEDESCRIPTORW */
 899     TEST_TYPE(LPFILEDESCRIPTORW, 4, 4);
 900     TEST_TYPE_POINTER(LPFILEDESCRIPTORW, 592, 1);
 901 }
 902
 903 static void test_pack_LPFILEGROUPDESCRIPTORA(void)
 904 {
 905     /* LPFILEGROUPDESCRIPTORA */
 906     TEST_TYPE(LPFILEGROUPDESCRIPTORA, 4, 4);
 907     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORA, 336, 1);
 908 }
 909
 910 static void test_pack_LPFILEGROUPDESCRIPTORW(void)
 911 {
 912     /* LPFILEGROUPDESCRIPTORW */
 913     TEST_TYPE(LPFILEGROUPDESCRIPTORW, 4, 4);
 914     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORW, 596, 1);
 915 }
 916
 917 static void test_pack_LPIDA(void)
 918 {
 919     /* LPIDA */
 920     TEST_TYPE(LPIDA, 4, 4);
 921     TEST_TYPE_POINTER(LPIDA, 8, 1);
 922 }
 923
 924 static void test_pack_LPSHChangeDWORDAsIDList(void)
 925 {
 926     /* LPSHChangeDWORDAsIDList */
 927     TEST_TYPE(LPSHChangeDWORDAsIDList, 4, 4);
 928     TEST_TYPE_POINTER(LPSHChangeDWORDAsIDList, 12, 1);
 929 }
 930
 931 static void test_pack_LPSHChangeProductKeyAsIDList(void)
 932 {
 933     /* LPSHChangeProductKeyAsIDList */
 934     TEST_TYPE(LPSHChangeProductKeyAsIDList, 4, 4);
 935     TEST_TYPE_POINTER(LPSHChangeProductKeyAsIDList, 82, 1);
 936 }
 937
 938 static void test_pack_LPSHDESCRIPTIONID(void)
 939 {
 940     /* LPSHDESCRIPTIONID */
 941     TEST_TYPE(LPSHDESCRIPTIONID, 4, 4);
 942     TEST_TYPE_POINTER(LPSHDESCRIPTIONID, 20, 4);
 943 }
 944
 945 static void test_pack_LPSHELLFLAGSTATE(void)
 946 {
 947     /* LPSHELLFLAGSTATE */
 948     TEST_TYPE(LPSHELLFLAGSTATE, 4, 4);
 949     TEST_TYPE_POINTER(LPSHELLFLAGSTATE, 4, 1);
 950 }
 951
 952 static void test_pack_LPSHELLSTATE(void)
 953 {
 954     /* LPSHELLSTATE */
 955     TEST_TYPE(LPSHELLSTATE, 4, 4);
 956     TEST_TYPE_POINTER(LPSHELLSTATE, 32, 1);
 957 }
 958
 959 static void test_pack_SHChangeDWORDAsIDList(void)
 960 {
 961     /* SHChangeDWORDAsIDList (pack 1) */
 962     TEST_TYPE(SHChangeDWORDAsIDList, 12, 1);
 963     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cb, 0, 2, 1);
 964     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem1, 2, 4, 1);
 965     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem2, 6, 4, 1);
 966     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cbZero, 10, 2, 1);
 967 }
 968
 969 static void test_pack_SHChangeNotifyEntry(void)
 970 {
 971     /* SHChangeNotifyEntry (pack 1) */
 972 }
 973
 974 static void test_pack_SHChangeProductKeyAsIDList(void)
 975 {
 976     /* SHChangeProductKeyAsIDList (pack 1) */
 977     TEST_TYPE(SHChangeProductKeyAsIDList, 82, 1);
 978     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cb, 0, 2, 1);
 979     TEST_FIELD(SHChangeProductKeyAsIDList, WCHAR[39], wszProductKey, 2, 78, 1);
 980     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cbZero, 80, 2, 1);
 981 }
 982
 983 static void test_pack_SHDESCRIPTIONID(void)
 984 {
 985     /* SHDESCRIPTIONID (pack 1) */
 986     TEST_TYPE(SHDESCRIPTIONID, 20, 4);
 987     TEST_FIELD(SHDESCRIPTIONID, DWORD, dwDescriptionId, 0, 4, 4);
 988     TEST_FIELD(SHDESCRIPTIONID, CLSID, clsid, 4, 16, 4);
 989 }
 990
 991 static void test_pack_SHELLFLAGSTATE(void)
 992 {
 993     /* SHELLFLAGSTATE (pack 1) */
 994     TEST_TYPE(SHELLFLAGSTATE, 4, 1);
 995 }
 996
 997 static void test_pack_SHELLSTATE(void)
 998 {
 999     /* SHELLSTATE (pack 1) */
1000     TEST_TYPE(SHELLSTATE, 32, 1);
1001     TEST_FIELD(SHELLSTATE, DWORD, dwWin95Unused, 4, 4, 1);
1002     TEST_FIELD(SHELLSTATE, UINT, uWin95Unused, 8, 4, 1);
1003     TEST_FIELD(SHELLSTATE, LONG, lParamSort, 12, 4, 1);
1004     TEST_FIELD(SHELLSTATE, int, iSortDirection, 16, 4, 1);
1005     TEST_FIELD(SHELLSTATE, UINT, version, 20, 4, 1);
1006     TEST_FIELD(SHELLSTATE, UINT, uNotUsed, 24, 4, 1);
1007 }
1008
1009 static void test_pack_SHELLVIEWID(void)
1010 {
1011     /* SHELLVIEWID */
1012     TEST_TYPE(SHELLVIEWID, 16, 4);
1013 }
1014
1015 static void test_pack_SHELLVIEWPROC(void)
1016 {
1017     /* SHELLVIEWPROC */
1018     TEST_TYPE(SHELLVIEWPROC, 4, 4);
1019 }
1020
1021 static void test_pack(void)
1022 {
1023     test_pack_APPBARDATA();
1024     test_pack_AUTO_SCROLL_DATA();
1025     test_pack_BFFCALLBACK();
1026     test_pack_BLOB();
1027     test_pack_BSTR();
1028     test_pack_BSTRBLOB();
1029     test_pack_BYTE_BLOB();
1030     test_pack_BYTE_SIZEDARR();
1031     test_pack_CABINETSTATE();
1032     test_pack_CIDA();
1033     test_pack_CLIPDATA();
1034     test_pack_CLIPFORMAT();
1035     test_pack_CLSID();
1036     test_pack_COAUTHIDENTITY();
1037     test_pack_COAUTHINFO();
1038     test_pack_COSERVERINFO();
1039     test_pack_DRAGINFOA();
1040     test_pack_DRAGINFOW();
1041     test_pack_DROPFILES();
1042     test_pack_DWORD_SIZEDARR();
1043     test_pack_FILEDESCRIPTORA();
1044     test_pack_FILEDESCRIPTORW();
1045     test_pack_FILEGROUPDESCRIPTORA();
1046     test_pack_FILEGROUPDESCRIPTORW();
1047     test_pack_FILEOP_FLAGS();
1048     test_pack_FLAGGED_BYTE_BLOB();
1049     test_pack_FLAGGED_WORD_BLOB();
1050     test_pack_FMTID();
1051     test_pack_GUID();
1052     test_pack_HMETAFILEPICT();
1053     test_pack_HYPER_SIZEDARR();
1054     test_pack_IFileSystemBindData();
1055     test_pack_IFileSystemBindDataVtbl();
1056     test_pack_IID();
1057     test_pack_IShellChangeNotify();
1058     test_pack_IShellIcon();
1059     test_pack_LPBLOB();
1060     test_pack_LPBSTR();
1061     test_pack_LPBSTRBLOB();
1062     test_pack_LPCABINETSTATE();
1063     test_pack_LPCOLESTR();
1064     test_pack_LPCY();
1065     test_pack_LPDECIMAL();
1066     test_pack_LPDRAGINFOA();
1067     test_pack_LPDRAGINFOW();
1068     test_pack_LPDROPFILES();
1069     test_pack_LPFILEDESCRIPTORA();
1070     test_pack_LPFILEDESCRIPTORW();
1071     test_pack_LPFILEGROUPDESCRIPTORA();
1072     test_pack_LPFILEGROUPDESCRIPTORW();
1073     test_pack_LPGUID();
1074     test_pack_LPIDA();
1075     test_pack_LPOLESTR();
1076     test_pack_LPSHChangeDWORDAsIDList();
1077     test_pack_LPSHChangeProductKeyAsIDList();
1078     test_pack_LPSHDESCRIPTIONID();
1079     test_pack_LPSHELLFLAGSTATE();
1080     test_pack_LPSHELLSTATE();
1081     test_pack_LPSHFILEOPSTRUCTA();
1082     test_pack_LPSHFILEOPSTRUCTW();
1083     test_pack_LPSHNAMEMAPPINGA();
1084     test_pack_LPSHNAMEMAPPINGW();
1085     test_pack_NOTIFYICONDATAA();
1086     test_pack_NOTIFYICONDATAW();
1087     test_pack_OLECHAR();
1088     test_pack_PAPPBARDATA();
1089     test_pack_PNOTIFYICONDATAA();
1090     test_pack_PNOTIFYICONDATAW();
1091     test_pack_PRINTEROP_FLAGS();
1092     test_pack_PROPID();
1093     test_pack_RemHBITMAP();
1094     test_pack_RemHENHMETAFILE();
1095     test_pack_RemHGLOBAL();
1096     test_pack_RemHMETAFILEPICT();
1097     test_pack_RemHPALETTE();
1098     test_pack_SCODE();
1099     test_pack_SHChangeDWORDAsIDList();
1100     test_pack_SHChangeNotifyEntry();
1101     test_pack_SHChangeProductKeyAsIDList();
1102     test_pack_SHDESCRIPTIONID();
1103     test_pack_SHELLFLAGSTATE();
1104     test_pack_SHELLSTATE();
1105     test_pack_SHELLVIEWID();
1106     test_pack_SHELLVIEWPROC();
1107     test_pack_SHFILEINFOA();
1108     test_pack_SHFILEINFOW();
1109     test_pack_SHFILEOPSTRUCTA();
1110     test_pack_SHFILEOPSTRUCTW();
1111     test_pack_SHNAMEMAPPINGA();
1112     test_pack_SHNAMEMAPPINGW();
1113     test_pack_UP_BYTE_BLOB();
1114     test_pack_UP_FLAGGED_BYTE_BLOB();
1115     test_pack_UP_FLAGGED_WORD_BLOB();
1116     test_pack_VARIANT_BOOL();
1117     test_pack_VARTYPE();
1118     test_pack_WORD_SIZEDARR();
1119     test_pack_remoteMETAFILEPICT();
1120     test_pack_userBITMAP();
1121     test_pack_userCLIPFORMAT();
1122     test_pack_userHBITMAP();
1123     test_pack_userHENHMETAFILE();
1124     test_pack_userHGLOBAL();
1125     test_pack_userHMETAFILE();
1126     test_pack_userHMETAFILEPICT();
1127     test_pack_userHPALETTE();
1128     test_pack_wireBSTR();
1129     test_pack_wireCLIPFORMAT();
1130     test_pack_wireHBITMAP();
1131     test_pack_wireHENHMETAFILE();
1132     test_pack_wireHGLOBAL();
1133     test_pack_wireHMETAFILE();
1134     test_pack_wireHMETAFILEPICT();
1135     test_pack_wireHPALETTE();
1136 }
1137
1138 START_TEST(generated)
1139 {
1140     test_pack();
1141 }