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__VARIANT_BOOL(void)
 403 {
 404     /* _VARIANT_BOOL */
 405     TEST_TYPE(_VARIANT_BOOL, 2, 2);
 406 }
 407
 408 static void test_pack_remoteMETAFILEPICT(void)
 409 {
 410     /* remoteMETAFILEPICT (pack 4) */
 411     TEST_TYPE(remoteMETAFILEPICT, 16, 4);
 412     TEST_FIELD(remoteMETAFILEPICT, long, mm, 0, 4, 4);
 413     TEST_FIELD(remoteMETAFILEPICT, long, xExt, 4, 4, 4);
 414     TEST_FIELD(remoteMETAFILEPICT, long, yExt, 8, 4, 4);
 415     TEST_FIELD(remoteMETAFILEPICT, userHMETAFILE *, hMF, 12, 4, 4);
 416 }
 417
 418 static void test_pack_rpcLOGPALETTE(void)
 419 {
 420     /* rpcLOGPALETTE (pack 4) */
 421     TEST_TYPE(rpcLOGPALETTE, 8, 2);
 422     TEST_FIELD(rpcLOGPALETTE, WORD, palVersion, 0, 2, 2);
 423     TEST_FIELD(rpcLOGPALETTE, WORD, palNumEntries, 2, 2, 2);
 424     TEST_FIELD(rpcLOGPALETTE, PALETTEENTRY[1], palPalEntry, 4, 4, 1);
 425 }
 426
 427 static void test_pack_userBITMAP(void)
 428 {
 429     /* userBITMAP (pack 4) */
 430     TEST_TYPE(userBITMAP, 28, 4);
 431     TEST_FIELD(userBITMAP, LONG, bmType, 0, 4, 4);
 432     TEST_FIELD(userBITMAP, LONG, bmWidth, 4, 4, 4);
 433     TEST_FIELD(userBITMAP, LONG, bmHeight, 8, 4, 4);
 434     TEST_FIELD(userBITMAP, LONG, bmWidthBytes, 12, 4, 4);
 435     TEST_FIELD(userBITMAP, WORD, bmPlanes, 16, 2, 2);
 436     TEST_FIELD(userBITMAP, WORD, bmBitsPixel, 18, 2, 2);
 437     TEST_FIELD(userBITMAP, ULONG, cbSize, 20, 4, 4);
 438     TEST_FIELD(userBITMAP, byte[1], pBuffer, 24, 1, 1);
 439 }
 440
 441 static void test_pack_userCLIPFORMAT(void)
 442 {
 443     /* userCLIPFORMAT (pack 4) */
 444     TEST_FIELD(userCLIPFORMAT, long, fContext, 0, 4, 4);
 445 }
 446
 447 static void test_pack_userHBITMAP(void)
 448 {
 449     /* userHBITMAP (pack 4) */
 450     TEST_FIELD(userHBITMAP, long, fContext, 0, 4, 4);
 451 }
 452
 453 static void test_pack_userHENHMETAFILE(void)
 454 {
 455     /* userHENHMETAFILE (pack 4) */
 456     TEST_FIELD(userHENHMETAFILE, long, fContext, 0, 4, 4);
 457 }
 458
 459 static void test_pack_userHGLOBAL(void)
 460 {
 461     /* userHGLOBAL (pack 4) */
 462     TEST_FIELD(userHGLOBAL, long, fContext, 0, 4, 4);
 463 }
 464
 465 static void test_pack_userHMETAFILE(void)
 466 {
 467     /* userHMETAFILE (pack 4) */
 468     TEST_FIELD(userHMETAFILE, long, fContext, 0, 4, 4);
 469 }
 470
 471 static void test_pack_userHMETAFILEPICT(void)
 472 {
 473     /* userHMETAFILEPICT (pack 4) */
 474     TEST_FIELD(userHMETAFILEPICT, long, fContext, 0, 4, 4);
 475 }
 476
 477 static void test_pack_userHPALETTE(void)
 478 {
 479     /* userHPALETTE (pack 4) */
 480     TEST_FIELD(userHPALETTE, long, fContext, 0, 4, 4);
 481 }
 482
 483 static void test_pack_wireBSTR(void)
 484 {
 485     /* wireBSTR */
 486     TEST_TYPE(wireBSTR, 4, 4);
 487     TEST_TYPE_POINTER(wireBSTR, 12, 4);
 488 }
 489
 490 static void test_pack_wireCLIPFORMAT(void)
 491 {
 492     /* wireCLIPFORMAT */
 493     TEST_TYPE(wireCLIPFORMAT, 4, 4);
 494 }
 495
 496 static void test_pack_wireHBITMAP(void)
 497 {
 498     /* wireHBITMAP */
 499     TEST_TYPE(wireHBITMAP, 4, 4);
 500 }
 501
 502 static void test_pack_wireHENHMETAFILE(void)
 503 {
 504     /* wireHENHMETAFILE */
 505     TEST_TYPE(wireHENHMETAFILE, 4, 4);
 506 }
 507
 508 static void test_pack_wireHGLOBAL(void)
 509 {
 510     /* wireHGLOBAL */
 511     TEST_TYPE(wireHGLOBAL, 4, 4);
 512 }
 513
 514 static void test_pack_wireHMETAFILE(void)
 515 {
 516     /* wireHMETAFILE */
 517     TEST_TYPE(wireHMETAFILE, 4, 4);
 518 }
 519
 520 static void test_pack_wireHMETAFILEPICT(void)
 521 {
 522     /* wireHMETAFILEPICT */
 523     TEST_TYPE(wireHMETAFILEPICT, 4, 4);
 524 }
 525
 526 static void test_pack_wireHPALETTE(void)
 527 {
 528     /* wireHPALETTE */
 529     TEST_TYPE(wireHPALETTE, 4, 4);
 530 }
 531
 532 static void test_pack_CLSID(void)
 533 {
 534     /* CLSID */
 535     TEST_TYPE(CLSID, 16, 4);
 536 }
 537
 538 static void test_pack_FMTID(void)
 539 {
 540     /* FMTID */
 541     TEST_TYPE(FMTID, 16, 4);
 542 }
 543
 544 static void test_pack_GUID(void)
 545 {
 546     /* GUID (pack 4) */
 547     TEST_TYPE(GUID, 16, 4);
 548     TEST_FIELD(GUID, unsigned long, Data1, 0, 4, 4);
 549     TEST_FIELD(GUID, unsigned short, Data2, 4, 2, 2);
 550     TEST_FIELD(GUID, unsigned short, Data3, 6, 2, 2);
 551     TEST_FIELD(GUID, unsigned char[ 8 ], Data4, 8, 8, 1);
 552 }
 553
 554 static void test_pack_IID(void)
 555 {
 556     /* IID */
 557     TEST_TYPE(IID, 16, 4);
 558 }
 559
 560 static void test_pack_LPGUID(void)
 561 {
 562     /* LPGUID */
 563     TEST_TYPE(LPGUID, 4, 4);
 564     TEST_TYPE_POINTER(LPGUID, 16, 4);
 565 }
 566
 567 static void test_pack_APPBARDATA(void)
 568 {
 569     /* APPBARDATA (pack 1) */
 570     TEST_TYPE(APPBARDATA, 36, 1);
 571     TEST_FIELD(APPBARDATA, DWORD, cbSize, 0, 4, 1);
 572     TEST_FIELD(APPBARDATA, HWND, hWnd, 4, 4, 1);
 573     TEST_FIELD(APPBARDATA, UINT, uCallbackMessage, 8, 4, 1);
 574     TEST_FIELD(APPBARDATA, UINT, uEdge, 12, 4, 1);
 575     TEST_FIELD(APPBARDATA, RECT, rc, 16, 16, 1);
 576     TEST_FIELD(APPBARDATA, LPARAM, lParam, 32, 4, 1);
 577 }
 578
 579 static void test_pack_DRAGINFOA(void)
 580 {
 581     /* DRAGINFOA (pack 1) */
 582     TEST_TYPE(DRAGINFOA, 24, 1);
 583     TEST_FIELD(DRAGINFOA, UINT, uSize, 0, 4, 1);
 584     TEST_FIELD(DRAGINFOA, POINT, pt, 4, 8, 1);
 585     TEST_FIELD(DRAGINFOA, BOOL, fNC, 12, 4, 1);
 586     TEST_FIELD(DRAGINFOA, LPSTR, lpFileList, 16, 4, 1);
 587     TEST_FIELD(DRAGINFOA, DWORD, grfKeyState, 20, 4, 1);
 588 }
 589
 590 static void test_pack_DRAGINFOW(void)
 591 {
 592     /* DRAGINFOW (pack 1) */
 593     TEST_TYPE(DRAGINFOW, 24, 1);
 594     TEST_FIELD(DRAGINFOW, UINT, uSize, 0, 4, 1);
 595     TEST_FIELD(DRAGINFOW, POINT, pt, 4, 8, 1);
 596     TEST_FIELD(DRAGINFOW, BOOL, fNC, 12, 4, 1);
 597     TEST_FIELD(DRAGINFOW, LPWSTR, lpFileList, 16, 4, 1);
 598     TEST_FIELD(DRAGINFOW, DWORD, grfKeyState, 20, 4, 1);
 599 }
 600
 601 static void test_pack_FILEOP_FLAGS(void)
 602 {
 603     /* FILEOP_FLAGS */
 604     TEST_TYPE(FILEOP_FLAGS, 2, 2);
 605     TEST_TYPE_UNSIGNED(FILEOP_FLAGS);
 606 }
 607
 608 static void test_pack_LPDRAGINFOA(void)
 609 {
 610     /* LPDRAGINFOA */
 611     TEST_TYPE(LPDRAGINFOA, 4, 4);
 612     TEST_TYPE_POINTER(LPDRAGINFOA, 24, 1);
 613 }
 614
 615 static void test_pack_LPDRAGINFOW(void)
 616 {
 617     /* LPDRAGINFOW */
 618     TEST_TYPE(LPDRAGINFOW, 4, 4);
 619     TEST_TYPE_POINTER(LPDRAGINFOW, 24, 1);
 620 }
 621
 622 static void test_pack_LPSHFILEOPSTRUCTA(void)
 623 {
 624     /* LPSHFILEOPSTRUCTA */
 625     TEST_TYPE(LPSHFILEOPSTRUCTA, 4, 4);
 626     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTA, 30, 1);
 627 }
 628
 629 static void test_pack_LPSHFILEOPSTRUCTW(void)
 630 {
 631     /* LPSHFILEOPSTRUCTW */
 632     TEST_TYPE(LPSHFILEOPSTRUCTW, 4, 4);
 633     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTW, 30, 1);
 634 }
 635
 636 static void test_pack_LPSHNAMEMAPPINGA(void)
 637 {
 638     /* LPSHNAMEMAPPINGA */
 639     TEST_TYPE(LPSHNAMEMAPPINGA, 4, 4);
 640     TEST_TYPE_POINTER(LPSHNAMEMAPPINGA, 16, 1);
 641 }
 642
 643 static void test_pack_LPSHNAMEMAPPINGW(void)
 644 {
 645     /* LPSHNAMEMAPPINGW */
 646     TEST_TYPE(LPSHNAMEMAPPINGW, 4, 4);
 647     TEST_TYPE_POINTER(LPSHNAMEMAPPINGW, 16, 1);
 648 }
 649
 650 static void test_pack_NOTIFYICONDATAA(void)
 651 {
 652     /* NOTIFYICONDATAA (pack 1) */
 653     TEST_TYPE(NOTIFYICONDATAA, 88, 1);
 654     TEST_FIELD(NOTIFYICONDATAA, DWORD, cbSize, 0, 4, 1);
 655     TEST_FIELD(NOTIFYICONDATAA, HWND, hWnd, 4, 4, 1);
 656     TEST_FIELD(NOTIFYICONDATAA, UINT, uID, 8, 4, 1);
 657     TEST_FIELD(NOTIFYICONDATAA, UINT, uFlags, 12, 4, 1);
 658     TEST_FIELD(NOTIFYICONDATAA, UINT, uCallbackMessage, 16, 4, 1);
 659     TEST_FIELD(NOTIFYICONDATAA, HICON, hIcon, 20, 4, 1);
 660     TEST_FIELD(NOTIFYICONDATAA, CHAR[64], szTip, 24, 64, 1);
 661 }
 662
 663 static void test_pack_NOTIFYICONDATAW(void)
 664 {
 665     /* NOTIFYICONDATAW (pack 1) */
 666     TEST_TYPE(NOTIFYICONDATAW, 152, 1);
 667     TEST_FIELD(NOTIFYICONDATAW, DWORD, cbSize, 0, 4, 1);
 668     TEST_FIELD(NOTIFYICONDATAW, HWND, hWnd, 4, 4, 1);
 669     TEST_FIELD(NOTIFYICONDATAW, UINT, uID, 8, 4, 1);
 670     TEST_FIELD(NOTIFYICONDATAW, UINT, uFlags, 12, 4, 1);
 671     TEST_FIELD(NOTIFYICONDATAW, UINT, uCallbackMessage, 16, 4, 1);
 672     TEST_FIELD(NOTIFYICONDATAW, HICON, hIcon, 20, 4, 1);
 673     TEST_FIELD(NOTIFYICONDATAW, WCHAR[64], szTip, 24, 128, 1);
 674 }
 675
 676 static void test_pack_PAPPBARDATA(void)
 677 {
 678     /* PAPPBARDATA */
 679     TEST_TYPE(PAPPBARDATA, 4, 4);
 680     TEST_TYPE_POINTER(PAPPBARDATA, 36, 1);
 681 }
 682
 683 static void test_pack_PNOTIFYICONDATAA(void)
 684 {
 685     /* PNOTIFYICONDATAA */
 686     TEST_TYPE(PNOTIFYICONDATAA, 4, 4);
 687     TEST_TYPE_POINTER(PNOTIFYICONDATAA, 88, 1);
 688 }
 689
 690 static void test_pack_PNOTIFYICONDATAW(void)
 691 {
 692     /* PNOTIFYICONDATAW */
 693     TEST_TYPE(PNOTIFYICONDATAW, 4, 4);
 694     TEST_TYPE_POINTER(PNOTIFYICONDATAW, 152, 1);
 695 }
 696
 697 static void test_pack_PRINTEROP_FLAGS(void)
 698 {
 699     /* PRINTEROP_FLAGS */
 700     TEST_TYPE(PRINTEROP_FLAGS, 2, 2);
 701     TEST_TYPE_UNSIGNED(PRINTEROP_FLAGS);
 702 }
 703
 704 static void test_pack_SHFILEINFOA(void)
 705 {
 706     /* SHFILEINFOA (pack 1) */
 707     TEST_TYPE(SHFILEINFOA, 352, 1);
 708     TEST_FIELD(SHFILEINFOA, HICON, hIcon, 0, 4, 1);
 709     TEST_FIELD(SHFILEINFOA, int, iIcon, 4, 4, 1);
 710     TEST_FIELD(SHFILEINFOA, DWORD, dwAttributes, 8, 4, 1);
 711     TEST_FIELD(SHFILEINFOA, CHAR[MAX_PATH], szDisplayName, 12, 260, 1);
 712     TEST_FIELD(SHFILEINFOA, CHAR[80], szTypeName, 272, 80, 1);
 713 }
 714
 715 static void test_pack_SHFILEINFOW(void)
 716 {
 717     /* SHFILEINFOW (pack 1) */
 718     TEST_TYPE(SHFILEINFOW, 692, 1);
 719     TEST_FIELD(SHFILEINFOW, HICON, hIcon, 0, 4, 1);
 720     TEST_FIELD(SHFILEINFOW, int, iIcon, 4, 4, 1);
 721     TEST_FIELD(SHFILEINFOW, DWORD, dwAttributes, 8, 4, 1);
 722     TEST_FIELD(SHFILEINFOW, WCHAR[MAX_PATH], szDisplayName, 12, 520, 1);
 723     TEST_FIELD(SHFILEINFOW, WCHAR[80], szTypeName, 532, 160, 1);
 724 }
 725
 726 static void test_pack_SHFILEOPSTRUCTA(void)
 727 {
 728     /* SHFILEOPSTRUCTA (pack 1) */
 729     TEST_TYPE(SHFILEOPSTRUCTA, 30, 1);
 730     TEST_FIELD(SHFILEOPSTRUCTA, HWND, hwnd, 0, 4, 1);
 731     TEST_FIELD(SHFILEOPSTRUCTA, UINT, wFunc, 4, 4, 1);
 732     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pFrom, 8, 4, 1);
 733     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pTo, 12, 4, 1);
 734     TEST_FIELD(SHFILEOPSTRUCTA, FILEOP_FLAGS, fFlags, 16, 2, 1);
 735     TEST_FIELD(SHFILEOPSTRUCTA, BOOL, fAnyOperationsAborted, 18, 4, 1);
 736     TEST_FIELD(SHFILEOPSTRUCTA, LPVOID, hNameMappings, 22, 4, 1);
 737     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, lpszProgressTitle, 26, 4, 1);
 738 }
 739
 740 static void test_pack_SHFILEOPSTRUCTW(void)
 741 {
 742     /* SHFILEOPSTRUCTW (pack 1) */
 743     TEST_TYPE(SHFILEOPSTRUCTW, 30, 1);
 744     TEST_FIELD(SHFILEOPSTRUCTW, HWND, hwnd, 0, 4, 1);
 745     TEST_FIELD(SHFILEOPSTRUCTW, UINT, wFunc, 4, 4, 1);
 746     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pFrom, 8, 4, 1);
 747     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pTo, 12, 4, 1);
 748     TEST_FIELD(SHFILEOPSTRUCTW, FILEOP_FLAGS, fFlags, 16, 2, 1);
 749     TEST_FIELD(SHFILEOPSTRUCTW, BOOL, fAnyOperationsAborted, 18, 4, 1);
 750     TEST_FIELD(SHFILEOPSTRUCTW, LPVOID, hNameMappings, 22, 4, 1);
 751     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, lpszProgressTitle, 26, 4, 1);
 752 }
 753
 754 static void test_pack_SHNAMEMAPPINGA(void)
 755 {
 756     /* SHNAMEMAPPINGA (pack 1) */
 757     TEST_TYPE(SHNAMEMAPPINGA, 16, 1);
 758     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszOldPath, 0, 4, 1);
 759     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszNewPath, 4, 4, 1);
 760     TEST_FIELD(SHNAMEMAPPINGA, int, cchOldPath, 8, 4, 1);
 761     TEST_FIELD(SHNAMEMAPPINGA, int, cchNewPath, 12, 4, 1);
 762 }
 763
 764 static void test_pack_SHNAMEMAPPINGW(void)
 765 {
 766     /* SHNAMEMAPPINGW (pack 1) */
 767     TEST_TYPE(SHNAMEMAPPINGW, 16, 1);
 768     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszOldPath, 0, 4, 1);
 769     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszNewPath, 4, 4, 1);
 770     TEST_FIELD(SHNAMEMAPPINGW, int, cchOldPath, 8, 4, 1);
 771     TEST_FIELD(SHNAMEMAPPINGW, int, cchNewPath, 12, 4, 1);
 772 }
 773
 774 static void test_pack_AUTO_SCROLL_DATA(void)
 775 {
 776     /* AUTO_SCROLL_DATA (pack 4) */
 777     TEST_FIELD(AUTO_SCROLL_DATA, int, iNextSample, 0, 4, 4);
 778     TEST_FIELD(AUTO_SCROLL_DATA, DWORD, dwLastScroll, 4, 4, 4);
 779     TEST_FIELD(AUTO_SCROLL_DATA, BOOL, bFull, 8, 4, 4);
 780 }
 781
 782 static void test_pack_BFFCALLBACK(void)
 783 {
 784     /* BFFCALLBACK */
 785     TEST_TYPE(BFFCALLBACK, 4, 4);
 786 }
 787
 788 static void test_pack_CABINETSTATE(void)
 789 {
 790     /* CABINETSTATE (pack 1) */
 791     TEST_TYPE(CABINETSTATE, 10, 1);
 792     TEST_FIELD(CABINETSTATE, WORD, cLength, 0, 2, 1);
 793     TEST_FIELD(CABINETSTATE, WORD, nVersion, 2, 2, 1);
 794     TEST_FIELD(CABINETSTATE, UINT, fMenuEnumFilter, 6, 4, 1);
 795 }
 796
 797 static void test_pack_CIDA(void)
 798 {
 799     /* CIDA (pack 1) */
 800     TEST_TYPE(CIDA, 8, 1);
 801     TEST_FIELD(CIDA, UINT, cidl, 0, 4, 1);
 802     TEST_FIELD(CIDA, UINT[1], aoffset, 4, 4, 1);
 803 }
 804
 805 static void test_pack_DROPFILES(void)
 806 {
 807     /* DROPFILES (pack 1) */
 808     TEST_TYPE(DROPFILES, 20, 1);
 809     TEST_FIELD(DROPFILES, DWORD, pFiles, 0, 4, 1);
 810     TEST_FIELD(DROPFILES, POINT, pt, 4, 8, 1);
 811     TEST_FIELD(DROPFILES, BOOL, fNC, 12, 4, 1);
 812     TEST_FIELD(DROPFILES, BOOL, fWide, 16, 4, 1);
 813 }
 814
 815 static void test_pack_FILEDESCRIPTORA(void)
 816 {
 817     /* FILEDESCRIPTORA (pack 1) */
 818     TEST_TYPE(FILEDESCRIPTORA, 332, 1);
 819     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFlags, 0, 4, 1);
 820     TEST_FIELD(FILEDESCRIPTORA, CLSID, clsid, 4, 16, 1);
 821     TEST_FIELD(FILEDESCRIPTORA, SIZEL, sizel, 20, 8, 1);
 822     TEST_FIELD(FILEDESCRIPTORA, POINTL, pointl, 28, 8, 1);
 823     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFileAttributes, 36, 4, 1);
 824     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftCreationTime, 40, 8, 1);
 825     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastAccessTime, 48, 8, 1);
 826     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastWriteTime, 56, 8, 1);
 827     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeHigh, 64, 4, 1);
 828     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeLow, 68, 4, 1);
 829     TEST_FIELD(FILEDESCRIPTORA, CHAR[MAX_PATH], cFileName, 72, 260, 1);
 830 }
 831
 832 static void test_pack_FILEDESCRIPTORW(void)
 833 {
 834     /* FILEDESCRIPTORW (pack 1) */
 835     TEST_TYPE(FILEDESCRIPTORW, 592, 1);
 836     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFlags, 0, 4, 1);
 837     TEST_FIELD(FILEDESCRIPTORW, CLSID, clsid, 4, 16, 1);
 838     TEST_FIELD(FILEDESCRIPTORW, SIZEL, sizel, 20, 8, 1);
 839     TEST_FIELD(FILEDESCRIPTORW, POINTL, pointl, 28, 8, 1);
 840     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFileAttributes, 36, 4, 1);
 841     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftCreationTime, 40, 8, 1);
 842     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastAccessTime, 48, 8, 1);
 843     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastWriteTime, 56, 8, 1);
 844     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeHigh, 64, 4, 1);
 845     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeLow, 68, 4, 1);
 846     TEST_FIELD(FILEDESCRIPTORW, WCHAR[MAX_PATH], cFileName, 72, 520, 1);
 847 }
 848
 849 static void test_pack_FILEGROUPDESCRIPTORA(void)
 850 {
 851     /* FILEGROUPDESCRIPTORA (pack 1) */
 852     TEST_TYPE(FILEGROUPDESCRIPTORA, 336, 1);
 853     TEST_FIELD(FILEGROUPDESCRIPTORA, UINT, cItems, 0, 4, 1);
 854     TEST_FIELD(FILEGROUPDESCRIPTORA, FILEDESCRIPTORA[1], fgd, 4, 332, 1);
 855 }
 856
 857 static void test_pack_FILEGROUPDESCRIPTORW(void)
 858 {
 859     /* FILEGROUPDESCRIPTORW (pack 1) */
 860     TEST_TYPE(FILEGROUPDESCRIPTORW, 596, 1);
 861     TEST_FIELD(FILEGROUPDESCRIPTORW, UINT, cItems, 0, 4, 1);
 862     TEST_FIELD(FILEGROUPDESCRIPTORW, FILEDESCRIPTORW[1], fgd, 4, 592, 1);
 863 }
 864
 865 static void test_pack_IFileSystemBindData(void)
 866 {
 867     /* IFileSystemBindData */
 868 }
 869
 870 static void test_pack_IFileSystemBindDataVtbl(void)
 871 {
 872     /* IFileSystemBindDataVtbl */
 873 }
 874
 875 static void test_pack_IShellChangeNotify(void)
 876 {
 877     /* IShellChangeNotify */
 878 }
 879
 880 static void test_pack_IShellIcon(void)
 881 {
 882     /* IShellIcon */
 883 }
 884
 885 static void test_pack_LPCABINETSTATE(void)
 886 {
 887     /* LPCABINETSTATE */
 888     TEST_TYPE(LPCABINETSTATE, 4, 4);
 889     TEST_TYPE_POINTER(LPCABINETSTATE, 10, 1);
 890 }
 891
 892 static void test_pack_LPDROPFILES(void)
 893 {
 894     /* LPDROPFILES */
 895     TEST_TYPE(LPDROPFILES, 4, 4);
 896     TEST_TYPE_POINTER(LPDROPFILES, 20, 1);
 897 }
 898
 899 static void test_pack_LPFILEDESCRIPTORA(void)
 900 {
 901     /* LPFILEDESCRIPTORA */
 902     TEST_TYPE(LPFILEDESCRIPTORA, 4, 4);
 903     TEST_TYPE_POINTER(LPFILEDESCRIPTORA, 332, 1);
 904 }
 905
 906 static void test_pack_LPFILEDESCRIPTORW(void)
 907 {
 908     /* LPFILEDESCRIPTORW */
 909     TEST_TYPE(LPFILEDESCRIPTORW, 4, 4);
 910     TEST_TYPE_POINTER(LPFILEDESCRIPTORW, 592, 1);
 911 }
 912
 913 static void test_pack_LPFILEGROUPDESCRIPTORA(void)
 914 {
 915     /* LPFILEGROUPDESCRIPTORA */
 916     TEST_TYPE(LPFILEGROUPDESCRIPTORA, 4, 4);
 917     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORA, 336, 1);
 918 }
 919
 920 static void test_pack_LPFILEGROUPDESCRIPTORW(void)
 921 {
 922     /* LPFILEGROUPDESCRIPTORW */
 923     TEST_TYPE(LPFILEGROUPDESCRIPTORW, 4, 4);
 924     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORW, 596, 1);
 925 }
 926
 927 static void test_pack_LPFILESYSTEMBINDDATA(void)
 928 {
 929     /* LPFILESYSTEMBINDDATA */
 930     TEST_TYPE(LPFILESYSTEMBINDDATA, 4, 4);
 931 }
 932
 933 static void test_pack_LPIDA(void)
 934 {
 935     /* LPIDA */
 936     TEST_TYPE(LPIDA, 4, 4);
 937     TEST_TYPE_POINTER(LPIDA, 8, 1);
 938 }
 939
 940 static void test_pack_LPSHChangeDWORDAsIDList(void)
 941 {
 942     /* LPSHChangeDWORDAsIDList */
 943     TEST_TYPE(LPSHChangeDWORDAsIDList, 4, 4);
 944     TEST_TYPE_POINTER(LPSHChangeDWORDAsIDList, 12, 1);
 945 }
 946
 947 static void test_pack_LPSHChangeProductKeyAsIDList(void)
 948 {
 949     /* LPSHChangeProductKeyAsIDList */
 950     TEST_TYPE(LPSHChangeProductKeyAsIDList, 4, 4);
 951     TEST_TYPE_POINTER(LPSHChangeProductKeyAsIDList, 82, 1);
 952 }
 953
 954 static void test_pack_LPSHDESCRIPTIONID(void)
 955 {
 956     /* LPSHDESCRIPTIONID */
 957     TEST_TYPE(LPSHDESCRIPTIONID, 4, 4);
 958     TEST_TYPE_POINTER(LPSHDESCRIPTIONID, 20, 1);
 959 }
 960
 961 static void test_pack_LPSHELLFLAGSTATE(void)
 962 {
 963     /* LPSHELLFLAGSTATE */
 964     TEST_TYPE(LPSHELLFLAGSTATE, 4, 4);
 965     TEST_TYPE_POINTER(LPSHELLFLAGSTATE, 2, 1);
 966 }
 967
 968 static void test_pack_LPSHELLSTATE(void)
 969 {
 970     /* LPSHELLSTATE */
 971     TEST_TYPE(LPSHELLSTATE, 4, 4);
 972     TEST_TYPE_POINTER(LPSHELLSTATE, 29, 1);
 973 }
 974
 975 static void test_pack_SHChangeDWORDAsIDList(void)
 976 {
 977     /* SHChangeDWORDAsIDList (pack 1) */
 978     TEST_TYPE(SHChangeDWORDAsIDList, 12, 1);
 979     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cb, 0, 2, 1);
 980     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem1, 2, 4, 1);
 981     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem2, 6, 4, 1);
 982     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cbZero, 10, 2, 1);
 983 }
 984
 985 static void test_pack_SHChangeNotifyEntry(void)
 986 {
 987     /* SHChangeNotifyEntry (pack 1) */
 988 }
 989
 990 static void test_pack_SHChangeProductKeyAsIDList(void)
 991 {
 992     /* SHChangeProductKeyAsIDList (pack 1) */
 993     TEST_TYPE(SHChangeProductKeyAsIDList, 82, 1);
 994     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cb, 0, 2, 1);
 995     TEST_FIELD(SHChangeProductKeyAsIDList, WCHAR[39], wszProductKey, 2, 78, 1);
 996     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cbZero, 80, 2, 1);
 997 }
 998
 999 static void test_pack_SHDESCRIPTIONID(void)
1000 {
1001     /* SHDESCRIPTIONID (pack 1) */
1002     TEST_TYPE(SHDESCRIPTIONID, 20, 1);
1003     TEST_FIELD(SHDESCRIPTIONID, DWORD, dwDescriptionId, 0, 4, 1);
1004     TEST_FIELD(SHDESCRIPTIONID, CLSID, clsid, 4, 16, 1);
1005 }
1006
1007 static void test_pack_SHELLFLAGSTATE(void)
1008 {
1009     /* SHELLFLAGSTATE (pack 1) */
1010     TEST_TYPE(SHELLFLAGSTATE, 2, 1);
1011 }
1012
1013 static void test_pack_SHELLSTATE(void)
1014 {
1015     /* SHELLSTATE (pack 1) */
1016     TEST_TYPE(SHELLSTATE, 29, 1);
1017     TEST_FIELD(SHELLSTATE, DWORD, dwWin95Unused, 3, 4, 1);
1018     TEST_FIELD(SHELLSTATE, UINT, uWin95Unused, 7, 4, 1);
1019     TEST_FIELD(SHELLSTATE, LONG, lParamSort, 11, 4, 1);
1020     TEST_FIELD(SHELLSTATE, int, iSortDirection, 15, 4, 1);
1021     TEST_FIELD(SHELLSTATE, UINT, version, 19, 4, 1);
1022     TEST_FIELD(SHELLSTATE, UINT, uNotUsed, 23, 4, 1);
1023 }
1024
1025 static void test_pack_SHELLVIEWID(void)
1026 {
1027     /* SHELLVIEWID */
1028     TEST_TYPE(SHELLVIEWID, 16, 4);
1029 }
1030
1031 static void test_pack_SHELLVIEWPROC(void)
1032 {
1033     /* SHELLVIEWPROC */
1034     TEST_TYPE(SHELLVIEWPROC, 4, 4);
1035 }
1036
1037 static void test_pack(void)
1038 {
1039     test_pack_APPBARDATA();
1040     test_pack_AUTO_SCROLL_DATA();
1041     test_pack_BFFCALLBACK();
1042     test_pack_BLOB();
1043     test_pack_BSTR();
1044     test_pack_BSTRBLOB();
1045     test_pack_BYTE_BLOB();
1046     test_pack_BYTE_SIZEDARR();
1047     test_pack_CABINETSTATE();
1048     test_pack_CIDA();
1049     test_pack_CLIPDATA();
1050     test_pack_CLIPFORMAT();
1051     test_pack_CLSID();
1052     test_pack_COAUTHIDENTITY();
1053     test_pack_COAUTHINFO();
1054     test_pack_COSERVERINFO();
1055     test_pack_DRAGINFOA();
1056     test_pack_DRAGINFOW();
1057     test_pack_DROPFILES();
1058     test_pack_DWORD_SIZEDARR();
1059     test_pack_FILEDESCRIPTORA();
1060     test_pack_FILEDESCRIPTORW();
1061     test_pack_FILEGROUPDESCRIPTORA();
1062     test_pack_FILEGROUPDESCRIPTORW();
1063     test_pack_FILEOP_FLAGS();
1064     test_pack_FLAGGED_BYTE_BLOB();
1065     test_pack_FLAGGED_WORD_BLOB();
1066     test_pack_FMTID();
1067     test_pack_GUID();
1068     test_pack_HMETAFILEPICT();
1069     test_pack_HYPER_SIZEDARR();
1070     test_pack_IFileSystemBindData();
1071     test_pack_IFileSystemBindDataVtbl();
1072     test_pack_IID();
1073     test_pack_IShellChangeNotify();
1074     test_pack_IShellIcon();
1075     test_pack_LPBLOB();
1076     test_pack_LPBSTR();
1077     test_pack_LPBSTRBLOB();
1078     test_pack_LPCABINETSTATE();
1079     test_pack_LPCOLESTR();
1080     test_pack_LPCY();
1081     test_pack_LPDECIMAL();
1082     test_pack_LPDRAGINFOA();
1083     test_pack_LPDRAGINFOW();
1084     test_pack_LPDROPFILES();
1085     test_pack_LPFILEDESCRIPTORA();
1086     test_pack_LPFILEDESCRIPTORW();
1087     test_pack_LPFILEGROUPDESCRIPTORA();
1088     test_pack_LPFILEGROUPDESCRIPTORW();
1089     test_pack_LPFILESYSTEMBINDDATA();
1090     test_pack_LPGUID();
1091     test_pack_LPIDA();
1092     test_pack_LPOLESTR();
1093     test_pack_LPSHChangeDWORDAsIDList();
1094     test_pack_LPSHChangeProductKeyAsIDList();
1095     test_pack_LPSHDESCRIPTIONID();
1096     test_pack_LPSHELLFLAGSTATE();
1097     test_pack_LPSHELLSTATE();
1098     test_pack_LPSHFILEOPSTRUCTA();
1099     test_pack_LPSHFILEOPSTRUCTW();
1100     test_pack_LPSHNAMEMAPPINGA();
1101     test_pack_LPSHNAMEMAPPINGW();
1102     test_pack_NOTIFYICONDATAA();
1103     test_pack_NOTIFYICONDATAW();
1104     test_pack_OLECHAR();
1105     test_pack_PAPPBARDATA();
1106     test_pack_PNOTIFYICONDATAA();
1107     test_pack_PNOTIFYICONDATAW();
1108     test_pack_PRINTEROP_FLAGS();
1109     test_pack_PROPID();
1110     test_pack_RemHBITMAP();
1111     test_pack_RemHENHMETAFILE();
1112     test_pack_RemHGLOBAL();
1113     test_pack_RemHMETAFILEPICT();
1114     test_pack_RemHPALETTE();
1115     test_pack_SCODE();
1116     test_pack_SHChangeDWORDAsIDList();
1117     test_pack_SHChangeNotifyEntry();
1118     test_pack_SHChangeProductKeyAsIDList();
1119     test_pack_SHDESCRIPTIONID();
1120     test_pack_SHELLFLAGSTATE();
1121     test_pack_SHELLSTATE();
1122     test_pack_SHELLVIEWID();
1123     test_pack_SHELLVIEWPROC();
1124     test_pack_SHFILEINFOA();
1125     test_pack_SHFILEINFOW();
1126     test_pack_SHFILEOPSTRUCTA();
1127     test_pack_SHFILEOPSTRUCTW();
1128     test_pack_SHNAMEMAPPINGA();
1129     test_pack_SHNAMEMAPPINGW();
1130     test_pack_UP_BYTE_BLOB();
1131     test_pack_UP_FLAGGED_BYTE_BLOB();
1132     test_pack_UP_FLAGGED_WORD_BLOB();
1133     test_pack_VARIANT_BOOL();
1134     test_pack_VARTYPE();
1135     test_pack_WORD_SIZEDARR();
1136     test_pack__VARIANT_BOOL();
1137     test_pack_remoteMETAFILEPICT();
1138     test_pack_rpcLOGPALETTE();
1139     test_pack_userBITMAP();
1140     test_pack_userCLIPFORMAT();
1141     test_pack_userHBITMAP();
1142     test_pack_userHENHMETAFILE();
1143     test_pack_userHGLOBAL();
1144     test_pack_userHMETAFILE();
1145     test_pack_userHMETAFILEPICT();
1146     test_pack_userHPALETTE();
1147     test_pack_wireBSTR();
1148     test_pack_wireCLIPFORMAT();
1149     test_pack_wireHBITMAP();
1150     test_pack_wireHENHMETAFILE();
1151     test_pack_wireHGLOBAL();
1152     test_pack_wireHMETAFILE();
1153     test_pack_wireHMETAFILEPICT();
1154     test_pack_wireHPALETTE();
1155 }
1156
1157 START_TEST(generated)
1158 {
1159     test_pack();
1160 }