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_TYPE(AUTO_SCROLL_DATA, 48, 4);
 778     TEST_FIELD(AUTO_SCROLL_DATA, int, iNextSample, 0, 4, 4);
 779     TEST_FIELD(AUTO_SCROLL_DATA, DWORD, dwLastScroll, 4, 4, 4);
 780     TEST_FIELD(AUTO_SCROLL_DATA, BOOL, bFull, 8, 4, 4);
 781     TEST_FIELD(AUTO_SCROLL_DATA, POINT[NUM_POINTS], pts, 12, 24, 4);
 782     TEST_FIELD(AUTO_SCROLL_DATA, DWORD[NUM_POINTS], dwTimes, 36, 12, 4);
 783 }
 784
 785 static void test_pack_BFFCALLBACK(void)
 786 {
 787     /* BFFCALLBACK */
 788     TEST_TYPE(BFFCALLBACK, 4, 4);
 789 }
 790
 791 static void test_pack_CABINETSTATE(void)
 792 {
 793     /* CABINETSTATE (pack 1) */
 794     TEST_TYPE(CABINETSTATE, 10, 1);
 795     TEST_FIELD(CABINETSTATE, WORD, cLength, 0, 2, 1);
 796     TEST_FIELD(CABINETSTATE, WORD, nVersion, 2, 2, 1);
 797     TEST_FIELD(CABINETSTATE, UINT, fMenuEnumFilter, 6, 4, 1);
 798 }
 799
 800 static void test_pack_CIDA(void)
 801 {
 802     /* CIDA (pack 1) */
 803     TEST_TYPE(CIDA, 8, 1);
 804     TEST_FIELD(CIDA, UINT, cidl, 0, 4, 1);
 805     TEST_FIELD(CIDA, UINT[1], aoffset, 4, 4, 1);
 806 }
 807
 808 static void test_pack_DROPFILES(void)
 809 {
 810     /* DROPFILES (pack 1) */
 811     TEST_TYPE(DROPFILES, 20, 1);
 812     TEST_FIELD(DROPFILES, DWORD, pFiles, 0, 4, 1);
 813     TEST_FIELD(DROPFILES, POINT, pt, 4, 8, 1);
 814     TEST_FIELD(DROPFILES, BOOL, fNC, 12, 4, 1);
 815     TEST_FIELD(DROPFILES, BOOL, fWide, 16, 4, 1);
 816 }
 817
 818 static void test_pack_FILEDESCRIPTORA(void)
 819 {
 820     /* FILEDESCRIPTORA (pack 1) */
 821     TEST_TYPE(FILEDESCRIPTORA, 332, 1);
 822     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFlags, 0, 4, 1);
 823     TEST_FIELD(FILEDESCRIPTORA, CLSID, clsid, 4, 16, 1);
 824     TEST_FIELD(FILEDESCRIPTORA, SIZEL, sizel, 20, 8, 1);
 825     TEST_FIELD(FILEDESCRIPTORA, POINTL, pointl, 28, 8, 1);
 826     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFileAttributes, 36, 4, 1);
 827     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftCreationTime, 40, 8, 1);
 828     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastAccessTime, 48, 8, 1);
 829     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastWriteTime, 56, 8, 1);
 830     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeHigh, 64, 4, 1);
 831     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeLow, 68, 4, 1);
 832     TEST_FIELD(FILEDESCRIPTORA, CHAR[MAX_PATH], cFileName, 72, 260, 1);
 833 }
 834
 835 static void test_pack_FILEDESCRIPTORW(void)
 836 {
 837     /* FILEDESCRIPTORW (pack 1) */
 838     TEST_TYPE(FILEDESCRIPTORW, 592, 1);
 839     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFlags, 0, 4, 1);
 840     TEST_FIELD(FILEDESCRIPTORW, CLSID, clsid, 4, 16, 1);
 841     TEST_FIELD(FILEDESCRIPTORW, SIZEL, sizel, 20, 8, 1);
 842     TEST_FIELD(FILEDESCRIPTORW, POINTL, pointl, 28, 8, 1);
 843     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFileAttributes, 36, 4, 1);
 844     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftCreationTime, 40, 8, 1);
 845     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastAccessTime, 48, 8, 1);
 846     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastWriteTime, 56, 8, 1);
 847     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeHigh, 64, 4, 1);
 848     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeLow, 68, 4, 1);
 849     TEST_FIELD(FILEDESCRIPTORW, WCHAR[MAX_PATH], cFileName, 72, 520, 1);
 850 }
 851
 852 static void test_pack_FILEGROUPDESCRIPTORA(void)
 853 {
 854     /* FILEGROUPDESCRIPTORA (pack 1) */
 855     TEST_TYPE(FILEGROUPDESCRIPTORA, 336, 1);
 856     TEST_FIELD(FILEGROUPDESCRIPTORA, UINT, cItems, 0, 4, 1);
 857     TEST_FIELD(FILEGROUPDESCRIPTORA, FILEDESCRIPTORA[1], fgd, 4, 332, 1);
 858 }
 859
 860 static void test_pack_FILEGROUPDESCRIPTORW(void)
 861 {
 862     /* FILEGROUPDESCRIPTORW (pack 1) */
 863     TEST_TYPE(FILEGROUPDESCRIPTORW, 596, 1);
 864     TEST_FIELD(FILEGROUPDESCRIPTORW, UINT, cItems, 0, 4, 1);
 865     TEST_FIELD(FILEGROUPDESCRIPTORW, FILEDESCRIPTORW[1], fgd, 4, 592, 1);
 866 }
 867
 868 static void test_pack_IFileSystemBindData(void)
 869 {
 870     /* IFileSystemBindData */
 871 }
 872
 873 static void test_pack_IFileSystemBindDataVtbl(void)
 874 {
 875     /* IFileSystemBindDataVtbl */
 876 }
 877
 878 static void test_pack_IShellChangeNotify(void)
 879 {
 880     /* IShellChangeNotify */
 881 }
 882
 883 static void test_pack_IShellIcon(void)
 884 {
 885     /* IShellIcon */
 886 }
 887
 888 static void test_pack_LPCABINETSTATE(void)
 889 {
 890     /* LPCABINETSTATE */
 891     TEST_TYPE(LPCABINETSTATE, 4, 4);
 892     TEST_TYPE_POINTER(LPCABINETSTATE, 10, 1);
 893 }
 894
 895 static void test_pack_LPDROPFILES(void)
 896 {
 897     /* LPDROPFILES */
 898     TEST_TYPE(LPDROPFILES, 4, 4);
 899     TEST_TYPE_POINTER(LPDROPFILES, 20, 1);
 900 }
 901
 902 static void test_pack_LPFILEDESCRIPTORA(void)
 903 {
 904     /* LPFILEDESCRIPTORA */
 905     TEST_TYPE(LPFILEDESCRIPTORA, 4, 4);
 906     TEST_TYPE_POINTER(LPFILEDESCRIPTORA, 332, 1);
 907 }
 908
 909 static void test_pack_LPFILEDESCRIPTORW(void)
 910 {
 911     /* LPFILEDESCRIPTORW */
 912     TEST_TYPE(LPFILEDESCRIPTORW, 4, 4);
 913     TEST_TYPE_POINTER(LPFILEDESCRIPTORW, 592, 1);
 914 }
 915
 916 static void test_pack_LPFILEGROUPDESCRIPTORA(void)
 917 {
 918     /* LPFILEGROUPDESCRIPTORA */
 919     TEST_TYPE(LPFILEGROUPDESCRIPTORA, 4, 4);
 920     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORA, 336, 1);
 921 }
 922
 923 static void test_pack_LPFILEGROUPDESCRIPTORW(void)
 924 {
 925     /* LPFILEGROUPDESCRIPTORW */
 926     TEST_TYPE(LPFILEGROUPDESCRIPTORW, 4, 4);
 927     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORW, 596, 1);
 928 }
 929
 930 static void test_pack_LPIDA(void)
 931 {
 932     /* LPIDA */
 933     TEST_TYPE(LPIDA, 4, 4);
 934     TEST_TYPE_POINTER(LPIDA, 8, 1);
 935 }
 936
 937 static void test_pack_LPSHChangeDWORDAsIDList(void)
 938 {
 939     /* LPSHChangeDWORDAsIDList */
 940     TEST_TYPE(LPSHChangeDWORDAsIDList, 4, 4);
 941     TEST_TYPE_POINTER(LPSHChangeDWORDAsIDList, 12, 1);
 942 }
 943
 944 static void test_pack_LPSHChangeProductKeyAsIDList(void)
 945 {
 946     /* LPSHChangeProductKeyAsIDList */
 947     TEST_TYPE(LPSHChangeProductKeyAsIDList, 4, 4);
 948     TEST_TYPE_POINTER(LPSHChangeProductKeyAsIDList, 82, 1);
 949 }
 950
 951 static void test_pack_LPSHDESCRIPTIONID(void)
 952 {
 953     /* LPSHDESCRIPTIONID */
 954     TEST_TYPE(LPSHDESCRIPTIONID, 4, 4);
 955     TEST_TYPE_POINTER(LPSHDESCRIPTIONID, 20, 1);
 956 }
 957
 958 static void test_pack_LPSHELLFLAGSTATE(void)
 959 {
 960     /* LPSHELLFLAGSTATE */
 961     TEST_TYPE(LPSHELLFLAGSTATE, 4, 4);
 962     TEST_TYPE_POINTER(LPSHELLFLAGSTATE, 2, 1);
 963 }
 964
 965 static void test_pack_LPSHELLSTATE(void)
 966 {
 967     /* LPSHELLSTATE */
 968     TEST_TYPE(LPSHELLSTATE, 4, 4);
 969     TEST_TYPE_POINTER(LPSHELLSTATE, 29, 1);
 970 }
 971
 972 static void test_pack_SHChangeDWORDAsIDList(void)
 973 {
 974     /* SHChangeDWORDAsIDList (pack 1) */
 975     TEST_TYPE(SHChangeDWORDAsIDList, 12, 1);
 976     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cb, 0, 2, 1);
 977     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem1, 2, 4, 1);
 978     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem2, 6, 4, 1);
 979     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cbZero, 10, 2, 1);
 980 }
 981
 982 static void test_pack_SHChangeNotifyEntry(void)
 983 {
 984     /* SHChangeNotifyEntry (pack 1) */
 985 }
 986
 987 static void test_pack_SHChangeProductKeyAsIDList(void)
 988 {
 989     /* SHChangeProductKeyAsIDList (pack 1) */
 990     TEST_TYPE(SHChangeProductKeyAsIDList, 82, 1);
 991     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cb, 0, 2, 1);
 992     TEST_FIELD(SHChangeProductKeyAsIDList, WCHAR[39], wszProductKey, 2, 78, 1);
 993     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cbZero, 80, 2, 1);
 994 }
 995
 996 static void test_pack_SHDESCRIPTIONID(void)
 997 {
 998     /* SHDESCRIPTIONID (pack 1) */
 999     TEST_TYPE(SHDESCRIPTIONID, 20, 1);
1000     TEST_FIELD(SHDESCRIPTIONID, DWORD, dwDescriptionId, 0, 4, 1);
1001     TEST_FIELD(SHDESCRIPTIONID, CLSID, clsid, 4, 16, 1);
1002 }
1003
1004 static void test_pack_SHELLFLAGSTATE(void)
1005 {
1006     /* SHELLFLAGSTATE (pack 1) */
1007     TEST_TYPE(SHELLFLAGSTATE, 2, 1);
1008 }
1009
1010 static void test_pack_SHELLSTATE(void)
1011 {
1012     /* SHELLSTATE (pack 1) */
1013     TEST_TYPE(SHELLSTATE, 29, 1);
1014     TEST_FIELD(SHELLSTATE, DWORD, dwWin95Unused, 3, 4, 1);
1015     TEST_FIELD(SHELLSTATE, UINT, uWin95Unused, 7, 4, 1);
1016     TEST_FIELD(SHELLSTATE, LONG, lParamSort, 11, 4, 1);
1017     TEST_FIELD(SHELLSTATE, int, iSortDirection, 15, 4, 1);
1018     TEST_FIELD(SHELLSTATE, UINT, version, 19, 4, 1);
1019     TEST_FIELD(SHELLSTATE, UINT, uNotUsed, 23, 4, 1);
1020 }
1021
1022 static void test_pack_SHELLVIEWID(void)
1023 {
1024     /* SHELLVIEWID */
1025     TEST_TYPE(SHELLVIEWID, 16, 4);
1026 }
1027
1028 static void test_pack_SHELLVIEWPROC(void)
1029 {
1030     /* SHELLVIEWPROC */
1031     TEST_TYPE(SHELLVIEWPROC, 4, 4);
1032 }
1033
1034 static void test_pack(void)
1035 {
1036     test_pack_APPBARDATA();
1037     test_pack_AUTO_SCROLL_DATA();
1038     test_pack_BFFCALLBACK();
1039     test_pack_BLOB();
1040     test_pack_BSTR();
1041     test_pack_BSTRBLOB();
1042     test_pack_BYTE_BLOB();
1043     test_pack_BYTE_SIZEDARR();
1044     test_pack_CABINETSTATE();
1045     test_pack_CIDA();
1046     test_pack_CLIPDATA();
1047     test_pack_CLIPFORMAT();
1048     test_pack_CLSID();
1049     test_pack_COAUTHIDENTITY();
1050     test_pack_COAUTHINFO();
1051     test_pack_COSERVERINFO();
1052     test_pack_DRAGINFOA();
1053     test_pack_DRAGINFOW();
1054     test_pack_DROPFILES();
1055     test_pack_DWORD_SIZEDARR();
1056     test_pack_FILEDESCRIPTORA();
1057     test_pack_FILEDESCRIPTORW();
1058     test_pack_FILEGROUPDESCRIPTORA();
1059     test_pack_FILEGROUPDESCRIPTORW();
1060     test_pack_FILEOP_FLAGS();
1061     test_pack_FLAGGED_BYTE_BLOB();
1062     test_pack_FLAGGED_WORD_BLOB();
1063     test_pack_FMTID();
1064     test_pack_GUID();
1065     test_pack_HMETAFILEPICT();
1066     test_pack_HYPER_SIZEDARR();
1067     test_pack_IFileSystemBindData();
1068     test_pack_IFileSystemBindDataVtbl();
1069     test_pack_IID();
1070     test_pack_IShellChangeNotify();
1071     test_pack_IShellIcon();
1072     test_pack_LPBLOB();
1073     test_pack_LPBSTR();
1074     test_pack_LPBSTRBLOB();
1075     test_pack_LPCABINETSTATE();
1076     test_pack_LPCOLESTR();
1077     test_pack_LPCY();
1078     test_pack_LPDECIMAL();
1079     test_pack_LPDRAGINFOA();
1080     test_pack_LPDRAGINFOW();
1081     test_pack_LPDROPFILES();
1082     test_pack_LPFILEDESCRIPTORA();
1083     test_pack_LPFILEDESCRIPTORW();
1084     test_pack_LPFILEGROUPDESCRIPTORA();
1085     test_pack_LPFILEGROUPDESCRIPTORW();
1086     test_pack_LPGUID();
1087     test_pack_LPIDA();
1088     test_pack_LPOLESTR();
1089     test_pack_LPSHChangeDWORDAsIDList();
1090     test_pack_LPSHChangeProductKeyAsIDList();
1091     test_pack_LPSHDESCRIPTIONID();
1092     test_pack_LPSHELLFLAGSTATE();
1093     test_pack_LPSHELLSTATE();
1094     test_pack_LPSHFILEOPSTRUCTA();
1095     test_pack_LPSHFILEOPSTRUCTW();
1096     test_pack_LPSHNAMEMAPPINGA();
1097     test_pack_LPSHNAMEMAPPINGW();
1098     test_pack_NOTIFYICONDATAA();
1099     test_pack_NOTIFYICONDATAW();
1100     test_pack_OLECHAR();
1101     test_pack_PAPPBARDATA();
1102     test_pack_PNOTIFYICONDATAA();
1103     test_pack_PNOTIFYICONDATAW();
1104     test_pack_PRINTEROP_FLAGS();
1105     test_pack_PROPID();
1106     test_pack_RemHBITMAP();
1107     test_pack_RemHENHMETAFILE();
1108     test_pack_RemHGLOBAL();
1109     test_pack_RemHMETAFILEPICT();
1110     test_pack_RemHPALETTE();
1111     test_pack_SCODE();
1112     test_pack_SHChangeDWORDAsIDList();
1113     test_pack_SHChangeNotifyEntry();
1114     test_pack_SHChangeProductKeyAsIDList();
1115     test_pack_SHDESCRIPTIONID();
1116     test_pack_SHELLFLAGSTATE();
1117     test_pack_SHELLSTATE();
1118     test_pack_SHELLVIEWID();
1119     test_pack_SHELLVIEWPROC();
1120     test_pack_SHFILEINFOA();
1121     test_pack_SHFILEINFOW();
1122     test_pack_SHFILEOPSTRUCTA();
1123     test_pack_SHFILEOPSTRUCTW();
1124     test_pack_SHNAMEMAPPINGA();
1125     test_pack_SHNAMEMAPPINGW();
1126     test_pack_UP_BYTE_BLOB();
1127     test_pack_UP_FLAGGED_BYTE_BLOB();
1128     test_pack_UP_FLAGGED_WORD_BLOB();
1129     test_pack_VARIANT_BOOL();
1130     test_pack_VARTYPE();
1131     test_pack_WORD_SIZEDARR();
1132     test_pack__VARIANT_BOOL();
1133     test_pack_remoteMETAFILEPICT();
1134     test_pack_rpcLOGPALETTE();
1135     test_pack_userBITMAP();
1136     test_pack_userCLIPFORMAT();
1137     test_pack_userHBITMAP();
1138     test_pack_userHENHMETAFILE();
1139     test_pack_userHGLOBAL();
1140     test_pack_userHMETAFILE();
1141     test_pack_userHMETAFILEPICT();
1142     test_pack_userHPALETTE();
1143     test_pack_wireBSTR();
1144     test_pack_wireCLIPFORMAT();
1145     test_pack_wireHBITMAP();
1146     test_pack_wireHENHMETAFILE();
1147     test_pack_wireHGLOBAL();
1148     test_pack_wireHMETAFILE();
1149     test_pack_wireHMETAFILEPICT();
1150     test_pack_wireHPALETTE();
1151 }
1152
1153 START_TEST(generated)
1154 {
1155     test_pack();
1156 }