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_LPSHELLEXECUTEINFOA(void)
 608 {
 609     /* LPSHELLEXECUTEINFOA */
 610     TEST_TYPE(LPSHELLEXECUTEINFOA, 4, 4);
 611 }
 612
 613 static void test_pack_LPSHELLEXECUTEINFOW(void)
 614 {
 615     /* LPSHELLEXECUTEINFOW */
 616     TEST_TYPE(LPSHELLEXECUTEINFOW, 4, 4);
 617 }
 618
 619 static void test_pack_LPSHFILEOPSTRUCTA(void)
 620 {
 621     /* LPSHFILEOPSTRUCTA */
 622     TEST_TYPE(LPSHFILEOPSTRUCTA, 4, 4);
 623     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTA, 30, 1);
 624 }
 625
 626 static void test_pack_LPSHFILEOPSTRUCTW(void)
 627 {
 628     /* LPSHFILEOPSTRUCTW */
 629     TEST_TYPE(LPSHFILEOPSTRUCTW, 4, 4);
 630     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTW, 30, 1);
 631 }
 632
 633 static void test_pack_LPSHNAMEMAPPINGA(void)
 634 {
 635     /* LPSHNAMEMAPPINGA */
 636     TEST_TYPE(LPSHNAMEMAPPINGA, 4, 4);
 637     TEST_TYPE_POINTER(LPSHNAMEMAPPINGA, 16, 1);
 638 }
 639
 640 static void test_pack_LPSHNAMEMAPPINGW(void)
 641 {
 642     /* LPSHNAMEMAPPINGW */
 643     TEST_TYPE(LPSHNAMEMAPPINGW, 4, 4);
 644     TEST_TYPE_POINTER(LPSHNAMEMAPPINGW, 16, 1);
 645 }
 646
 647 static void test_pack_NOTIFYICONDATAA(void)
 648 {
 649     /* NOTIFYICONDATAA (pack 1) */
 650     TEST_FIELD(NOTIFYICONDATAA, DWORD, cbSize, 0, 4, 1);
 651     TEST_FIELD(NOTIFYICONDATAA, HWND, hWnd, 4, 4, 1);
 652     TEST_FIELD(NOTIFYICONDATAA, UINT, uID, 8, 4, 1);
 653     TEST_FIELD(NOTIFYICONDATAA, UINT, uFlags, 12, 4, 1);
 654     TEST_FIELD(NOTIFYICONDATAA, UINT, uCallbackMessage, 16, 4, 1);
 655     TEST_FIELD(NOTIFYICONDATAA, HICON, hIcon, 20, 4, 1);
 656     TEST_FIELD(NOTIFYICONDATAA, CHAR[128], szTip, 24, 128, 1);
 657     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwState, 152, 4, 1);
 658     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwStateMask, 156, 4, 1);
 659     TEST_FIELD(NOTIFYICONDATAA, CHAR[256], szInfo, 160, 256, 1);
 660 }
 661
 662 static void test_pack_NOTIFYICONDATAW(void)
 663 {
 664     /* NOTIFYICONDATAW (pack 1) */
 665     TEST_FIELD(NOTIFYICONDATAW, DWORD, cbSize, 0, 4, 1);
 666     TEST_FIELD(NOTIFYICONDATAW, HWND, hWnd, 4, 4, 1);
 667     TEST_FIELD(NOTIFYICONDATAW, UINT, uID, 8, 4, 1);
 668     TEST_FIELD(NOTIFYICONDATAW, UINT, uFlags, 12, 4, 1);
 669     TEST_FIELD(NOTIFYICONDATAW, UINT, uCallbackMessage, 16, 4, 1);
 670     TEST_FIELD(NOTIFYICONDATAW, HICON, hIcon, 20, 4, 1);
 671     TEST_FIELD(NOTIFYICONDATAW, WCHAR[128], szTip, 24, 256, 1);
 672     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwState, 280, 4, 1);
 673     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwStateMask, 284, 4, 1);
 674     TEST_FIELD(NOTIFYICONDATAW, WCHAR[256], szInfo, 288, 512, 1);
 675 }
 676
 677 static void test_pack_PAPPBARDATA(void)
 678 {
 679     /* PAPPBARDATA */
 680     TEST_TYPE(PAPPBARDATA, 4, 4);
 681     TEST_TYPE_POINTER(PAPPBARDATA, 36, 1);
 682 }
 683
 684 static void test_pack_PNOTIFYICONDATAA(void)
 685 {
 686     /* PNOTIFYICONDATAA */
 687     TEST_TYPE(PNOTIFYICONDATAA, 4, 4);
 688 }
 689
 690 static void test_pack_PNOTIFYICONDATAW(void)
 691 {
 692     /* PNOTIFYICONDATAW */
 693     TEST_TYPE(PNOTIFYICONDATAW, 4, 4);
 694 }
 695
 696 static void test_pack_PRINTEROP_FLAGS(void)
 697 {
 698     /* PRINTEROP_FLAGS */
 699     TEST_TYPE(PRINTEROP_FLAGS, 2, 2);
 700     TEST_TYPE_UNSIGNED(PRINTEROP_FLAGS);
 701 }
 702
 703 static void test_pack_SHELLEXECUTEINFOA(void)
 704 {
 705     /* SHELLEXECUTEINFOA (pack 1) */
 706     TEST_FIELD(SHELLEXECUTEINFOA, DWORD, cbSize, 0, 4, 1);
 707     TEST_FIELD(SHELLEXECUTEINFOA, ULONG, fMask, 4, 4, 1);
 708     TEST_FIELD(SHELLEXECUTEINFOA, HWND, hwnd, 8, 4, 1);
 709     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpVerb, 12, 4, 1);
 710     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpFile, 16, 4, 1);
 711     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpParameters, 20, 4, 1);
 712     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpDirectory, 24, 4, 1);
 713     TEST_FIELD(SHELLEXECUTEINFOA, INT, nShow, 28, 4, 1);
 714     TEST_FIELD(SHELLEXECUTEINFOA, HINSTANCE, hInstApp, 32, 4, 1);
 715     TEST_FIELD(SHELLEXECUTEINFOA, LPVOID, lpIDList, 36, 4, 1);
 716     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpClass, 40, 4, 1);
 717     TEST_FIELD(SHELLEXECUTEINFOA, HKEY, hkeyClass, 44, 4, 1);
 718     TEST_FIELD(SHELLEXECUTEINFOA, DWORD, dwHotKey, 48, 4, 1);
 719 }
 720
 721 static void test_pack_SHELLEXECUTEINFOW(void)
 722 {
 723     /* SHELLEXECUTEINFOW (pack 1) */
 724     TEST_FIELD(SHELLEXECUTEINFOW, DWORD, cbSize, 0, 4, 1);
 725     TEST_FIELD(SHELLEXECUTEINFOW, ULONG, fMask, 4, 4, 1);
 726     TEST_FIELD(SHELLEXECUTEINFOW, HWND, hwnd, 8, 4, 1);
 727     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpVerb, 12, 4, 1);
 728     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpFile, 16, 4, 1);
 729     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpParameters, 20, 4, 1);
 730     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpDirectory, 24, 4, 1);
 731     TEST_FIELD(SHELLEXECUTEINFOW, INT, nShow, 28, 4, 1);
 732     TEST_FIELD(SHELLEXECUTEINFOW, HINSTANCE, hInstApp, 32, 4, 1);
 733     TEST_FIELD(SHELLEXECUTEINFOW, LPVOID, lpIDList, 36, 4, 1);
 734     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpClass, 40, 4, 1);
 735     TEST_FIELD(SHELLEXECUTEINFOW, HKEY, hkeyClass, 44, 4, 1);
 736     TEST_FIELD(SHELLEXECUTEINFOW, DWORD, dwHotKey, 48, 4, 1);
 737 }
 738
 739 static void test_pack_SHFILEINFOA(void)
 740 {
 741     /* SHFILEINFOA (pack 1) */
 742     TEST_TYPE(SHFILEINFOA, 352, 1);
 743     TEST_FIELD(SHFILEINFOA, HICON, hIcon, 0, 4, 1);
 744     TEST_FIELD(SHFILEINFOA, int, iIcon, 4, 4, 1);
 745     TEST_FIELD(SHFILEINFOA, DWORD, dwAttributes, 8, 4, 1);
 746     TEST_FIELD(SHFILEINFOA, CHAR[MAX_PATH], szDisplayName, 12, 260, 1);
 747     TEST_FIELD(SHFILEINFOA, CHAR[80], szTypeName, 272, 80, 1);
 748 }
 749
 750 static void test_pack_SHFILEINFOW(void)
 751 {
 752     /* SHFILEINFOW (pack 1) */
 753     TEST_TYPE(SHFILEINFOW, 692, 1);
 754     TEST_FIELD(SHFILEINFOW, HICON, hIcon, 0, 4, 1);
 755     TEST_FIELD(SHFILEINFOW, int, iIcon, 4, 4, 1);
 756     TEST_FIELD(SHFILEINFOW, DWORD, dwAttributes, 8, 4, 1);
 757     TEST_FIELD(SHFILEINFOW, WCHAR[MAX_PATH], szDisplayName, 12, 520, 1);
 758     TEST_FIELD(SHFILEINFOW, WCHAR[80], szTypeName, 532, 160, 1);
 759 }
 760
 761 static void test_pack_SHFILEOPSTRUCTA(void)
 762 {
 763     /* SHFILEOPSTRUCTA (pack 1) */
 764     TEST_TYPE(SHFILEOPSTRUCTA, 30, 1);
 765     TEST_FIELD(SHFILEOPSTRUCTA, HWND, hwnd, 0, 4, 1);
 766     TEST_FIELD(SHFILEOPSTRUCTA, UINT, wFunc, 4, 4, 1);
 767     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pFrom, 8, 4, 1);
 768     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pTo, 12, 4, 1);
 769     TEST_FIELD(SHFILEOPSTRUCTA, FILEOP_FLAGS, fFlags, 16, 2, 1);
 770     TEST_FIELD(SHFILEOPSTRUCTA, BOOL, fAnyOperationsAborted, 18, 4, 1);
 771     TEST_FIELD(SHFILEOPSTRUCTA, LPVOID, hNameMappings, 22, 4, 1);
 772     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, lpszProgressTitle, 26, 4, 1);
 773 }
 774
 775 static void test_pack_SHFILEOPSTRUCTW(void)
 776 {
 777     /* SHFILEOPSTRUCTW (pack 1) */
 778     TEST_TYPE(SHFILEOPSTRUCTW, 30, 1);
 779     TEST_FIELD(SHFILEOPSTRUCTW, HWND, hwnd, 0, 4, 1);
 780     TEST_FIELD(SHFILEOPSTRUCTW, UINT, wFunc, 4, 4, 1);
 781     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pFrom, 8, 4, 1);
 782     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pTo, 12, 4, 1);
 783     TEST_FIELD(SHFILEOPSTRUCTW, FILEOP_FLAGS, fFlags, 16, 2, 1);
 784     TEST_FIELD(SHFILEOPSTRUCTW, BOOL, fAnyOperationsAborted, 18, 4, 1);
 785     TEST_FIELD(SHFILEOPSTRUCTW, LPVOID, hNameMappings, 22, 4, 1);
 786     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, lpszProgressTitle, 26, 4, 1);
 787 }
 788
 789 static void test_pack_SHNAMEMAPPINGA(void)
 790 {
 791     /* SHNAMEMAPPINGA (pack 1) */
 792     TEST_TYPE(SHNAMEMAPPINGA, 16, 1);
 793     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszOldPath, 0, 4, 1);
 794     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszNewPath, 4, 4, 1);
 795     TEST_FIELD(SHNAMEMAPPINGA, int, cchOldPath, 8, 4, 1);
 796     TEST_FIELD(SHNAMEMAPPINGA, int, cchNewPath, 12, 4, 1);
 797 }
 798
 799 static void test_pack_SHNAMEMAPPINGW(void)
 800 {
 801     /* SHNAMEMAPPINGW (pack 1) */
 802     TEST_TYPE(SHNAMEMAPPINGW, 16, 1);
 803     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszOldPath, 0, 4, 1);
 804     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszNewPath, 4, 4, 1);
 805     TEST_FIELD(SHNAMEMAPPINGW, int, cchOldPath, 8, 4, 1);
 806     TEST_FIELD(SHNAMEMAPPINGW, int, cchNewPath, 12, 4, 1);
 807 }
 808
 809 static void test_pack_ITEMIDLIST(void)
 810 {
 811     /* ITEMIDLIST (pack 1) */
 812     TEST_TYPE(ITEMIDLIST, 3, 1);
 813     TEST_FIELD(ITEMIDLIST, SHITEMID, mkid, 0, 3, 1);
 814 }
 815
 816 static void test_pack_LPCITEMIDLIST(void)
 817 {
 818     /* LPCITEMIDLIST */
 819     TEST_TYPE(LPCITEMIDLIST, 4, 4);
 820     TEST_TYPE_POINTER(LPCITEMIDLIST, 3, 1);
 821 }
 822
 823 static void test_pack_LPITEMIDLIST(void)
 824 {
 825     /* LPITEMIDLIST */
 826     TEST_TYPE(LPITEMIDLIST, 4, 4);
 827     TEST_TYPE_POINTER(LPITEMIDLIST, 3, 1);
 828 }
 829
 830 static void test_pack_LPSHITEMID(void)
 831 {
 832     /* LPSHITEMID */
 833     TEST_TYPE(LPSHITEMID, 4, 4);
 834     TEST_TYPE_POINTER(LPSHITEMID, 3, 1);
 835 }
 836
 837 static void test_pack_SHITEMID(void)
 838 {
 839     /* SHITEMID (pack 1) */
 840     TEST_TYPE(SHITEMID, 3, 1);
 841     TEST_FIELD(SHITEMID, WORD, cb, 0, 2, 1);
 842     TEST_FIELD(SHITEMID, BYTE[1], abID, 2, 1, 1);
 843 }
 844
 845 static void test_pack_AUTO_SCROLL_DATA(void)
 846 {
 847     /* AUTO_SCROLL_DATA (pack 1) */
 848     TEST_TYPE(AUTO_SCROLL_DATA, 48, 1);
 849     TEST_FIELD(AUTO_SCROLL_DATA, int, iNextSample, 0, 4, 1);
 850     TEST_FIELD(AUTO_SCROLL_DATA, DWORD, dwLastScroll, 4, 4, 1);
 851     TEST_FIELD(AUTO_SCROLL_DATA, BOOL, bFull, 8, 4, 1);
 852     TEST_FIELD(AUTO_SCROLL_DATA, POINT[NUM_POINTS], pts, 12, 24, 1);
 853     TEST_FIELD(AUTO_SCROLL_DATA, DWORD[NUM_POINTS], dwTimes, 36, 12, 1);
 854 }
 855
 856 static void test_pack_BFFCALLBACK(void)
 857 {
 858     /* BFFCALLBACK */
 859     TEST_TYPE(BFFCALLBACK, 4, 4);
 860 }
 861
 862 static void test_pack_BROWSEINFOA(void)
 863 {
 864     /* BROWSEINFOA (pack 8) */
 865     TEST_TYPE(BROWSEINFOA, 32, 4);
 866     TEST_FIELD(BROWSEINFOA, HWND, hwndOwner, 0, 4, 4);
 867     TEST_FIELD(BROWSEINFOA, LPCITEMIDLIST, pidlRoot, 4, 4, 4);
 868     TEST_FIELD(BROWSEINFOA, LPSTR, pszDisplayName, 8, 4, 4);
 869     TEST_FIELD(BROWSEINFOA, LPCSTR, lpszTitle, 12, 4, 4);
 870     TEST_FIELD(BROWSEINFOA, UINT, ulFlags, 16, 4, 4);
 871     TEST_FIELD(BROWSEINFOA, BFFCALLBACK, lpfn, 20, 4, 4);
 872     TEST_FIELD(BROWSEINFOA, LPARAM, lParam, 24, 4, 4);
 873     TEST_FIELD(BROWSEINFOA, INT, iImage, 28, 4, 4);
 874 }
 875
 876 static void test_pack_BROWSEINFOW(void)
 877 {
 878     /* BROWSEINFOW (pack 8) */
 879     TEST_TYPE(BROWSEINFOW, 32, 4);
 880     TEST_FIELD(BROWSEINFOW, HWND, hwndOwner, 0, 4, 4);
 881     TEST_FIELD(BROWSEINFOW, LPCITEMIDLIST, pidlRoot, 4, 4, 4);
 882     TEST_FIELD(BROWSEINFOW, LPWSTR, pszDisplayName, 8, 4, 4);
 883     TEST_FIELD(BROWSEINFOW, LPCWSTR, lpszTitle, 12, 4, 4);
 884     TEST_FIELD(BROWSEINFOW, UINT, ulFlags, 16, 4, 4);
 885     TEST_FIELD(BROWSEINFOW, BFFCALLBACK, lpfn, 20, 4, 4);
 886     TEST_FIELD(BROWSEINFOW, LPARAM, lParam, 24, 4, 4);
 887     TEST_FIELD(BROWSEINFOW, INT, iImage, 28, 4, 4);
 888 }
 889
 890 static void test_pack_CABINETSTATE(void)
 891 {
 892     /* CABINETSTATE (pack 1) */
 893     TEST_TYPE(CABINETSTATE, 12, 1);
 894     TEST_FIELD(CABINETSTATE, WORD, cLength, 0, 2, 1);
 895     TEST_FIELD(CABINETSTATE, WORD, nVersion, 2, 2, 1);
 896     TEST_FIELD(CABINETSTATE, UINT, fMenuEnumFilter, 8, 4, 1);
 897 }
 898
 899 static void test_pack_CIDA(void)
 900 {
 901     /* CIDA (pack 1) */
 902     TEST_TYPE(CIDA, 8, 1);
 903     TEST_FIELD(CIDA, UINT, cidl, 0, 4, 1);
 904     TEST_FIELD(CIDA, UINT[1], aoffset, 4, 4, 1);
 905 }
 906
 907 static void test_pack_DROPFILES(void)
 908 {
 909     /* DROPFILES (pack 1) */
 910     TEST_TYPE(DROPFILES, 20, 1);
 911     TEST_FIELD(DROPFILES, DWORD, pFiles, 0, 4, 1);
 912     TEST_FIELD(DROPFILES, POINT, pt, 4, 8, 1);
 913     TEST_FIELD(DROPFILES, BOOL, fNC, 12, 4, 1);
 914     TEST_FIELD(DROPFILES, BOOL, fWide, 16, 4, 1);
 915 }
 916
 917 static void test_pack_FILEDESCRIPTORA(void)
 918 {
 919     /* FILEDESCRIPTORA (pack 1) */
 920     TEST_TYPE(FILEDESCRIPTORA, 332, 1);
 921     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFlags, 0, 4, 1);
 922     TEST_FIELD(FILEDESCRIPTORA, CLSID, clsid, 4, 16, 1);
 923     TEST_FIELD(FILEDESCRIPTORA, SIZEL, sizel, 20, 8, 1);
 924     TEST_FIELD(FILEDESCRIPTORA, POINTL, pointl, 28, 8, 1);
 925     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFileAttributes, 36, 4, 1);
 926     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftCreationTime, 40, 8, 1);
 927     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastAccessTime, 48, 8, 1);
 928     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastWriteTime, 56, 8, 1);
 929     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeHigh, 64, 4, 1);
 930     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeLow, 68, 4, 1);
 931     TEST_FIELD(FILEDESCRIPTORA, CHAR[MAX_PATH], cFileName, 72, 260, 1);
 932 }
 933
 934 static void test_pack_FILEDESCRIPTORW(void)
 935 {
 936     /* FILEDESCRIPTORW (pack 1) */
 937     TEST_TYPE(FILEDESCRIPTORW, 592, 1);
 938     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFlags, 0, 4, 1);
 939     TEST_FIELD(FILEDESCRIPTORW, CLSID, clsid, 4, 16, 1);
 940     TEST_FIELD(FILEDESCRIPTORW, SIZEL, sizel, 20, 8, 1);
 941     TEST_FIELD(FILEDESCRIPTORW, POINTL, pointl, 28, 8, 1);
 942     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFileAttributes, 36, 4, 1);
 943     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftCreationTime, 40, 8, 1);
 944     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastAccessTime, 48, 8, 1);
 945     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastWriteTime, 56, 8, 1);
 946     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeHigh, 64, 4, 1);
 947     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeLow, 68, 4, 1);
 948     TEST_FIELD(FILEDESCRIPTORW, WCHAR[MAX_PATH], cFileName, 72, 520, 1);
 949 }
 950
 951 static void test_pack_FILEGROUPDESCRIPTORA(void)
 952 {
 953     /* FILEGROUPDESCRIPTORA (pack 1) */
 954     TEST_TYPE(FILEGROUPDESCRIPTORA, 336, 1);
 955     TEST_FIELD(FILEGROUPDESCRIPTORA, UINT, cItems, 0, 4, 1);
 956     TEST_FIELD(FILEGROUPDESCRIPTORA, FILEDESCRIPTORA[1], fgd, 4, 332, 1);
 957 }
 958
 959 static void test_pack_FILEGROUPDESCRIPTORW(void)
 960 {
 961     /* FILEGROUPDESCRIPTORW (pack 1) */
 962     TEST_TYPE(FILEGROUPDESCRIPTORW, 596, 1);
 963     TEST_FIELD(FILEGROUPDESCRIPTORW, UINT, cItems, 0, 4, 1);
 964     TEST_FIELD(FILEGROUPDESCRIPTORW, FILEDESCRIPTORW[1], fgd, 4, 592, 1);
 965 }
 966
 967 static void test_pack_IFileSystemBindData(void)
 968 {
 969     /* IFileSystemBindData */
 970 }
 971
 972 static void test_pack_IFileSystemBindDataVtbl(void)
 973 {
 974     /* IFileSystemBindDataVtbl */
 975 }
 976
 977 static void test_pack_IShellChangeNotify(void)
 978 {
 979     /* IShellChangeNotify */
 980 }
 981
 982 static void test_pack_IShellIcon(void)
 983 {
 984     /* IShellIcon */
 985 }
 986
 987 static void test_pack_LPBROWSEINFOA(void)
 988 {
 989     /* LPBROWSEINFOA */
 990     TEST_TYPE(LPBROWSEINFOA, 4, 4);
 991     TEST_TYPE_POINTER(LPBROWSEINFOA, 32, 4);
 992 }
 993
 994 static void test_pack_LPBROWSEINFOW(void)
 995 {
 996     /* LPBROWSEINFOW */
 997     TEST_TYPE(LPBROWSEINFOW, 4, 4);
 998     TEST_TYPE_POINTER(LPBROWSEINFOW, 32, 4);
 999 }
1000
1001 static void test_pack_LPCABINETSTATE(void)
1002 {
1003     /* LPCABINETSTATE */
1004     TEST_TYPE(LPCABINETSTATE, 4, 4);
1005     TEST_TYPE_POINTER(LPCABINETSTATE, 12, 1);
1006 }
1007
1008 static void test_pack_LPDROPFILES(void)
1009 {
1010     /* LPDROPFILES */
1011     TEST_TYPE(LPDROPFILES, 4, 4);
1012     TEST_TYPE_POINTER(LPDROPFILES, 20, 1);
1013 }
1014
1015 static void test_pack_LPFILEDESCRIPTORA(void)
1016 {
1017     /* LPFILEDESCRIPTORA */
1018     TEST_TYPE(LPFILEDESCRIPTORA, 4, 4);
1019     TEST_TYPE_POINTER(LPFILEDESCRIPTORA, 332, 1);
1020 }
1021
1022 static void test_pack_LPFILEDESCRIPTORW(void)
1023 {
1024     /* LPFILEDESCRIPTORW */
1025     TEST_TYPE(LPFILEDESCRIPTORW, 4, 4);
1026     TEST_TYPE_POINTER(LPFILEDESCRIPTORW, 592, 1);
1027 }
1028
1029 static void test_pack_LPFILEGROUPDESCRIPTORA(void)
1030 {
1031     /* LPFILEGROUPDESCRIPTORA */
1032     TEST_TYPE(LPFILEGROUPDESCRIPTORA, 4, 4);
1033     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORA, 336, 1);
1034 }
1035
1036 static void test_pack_LPFILEGROUPDESCRIPTORW(void)
1037 {
1038     /* LPFILEGROUPDESCRIPTORW */
1039     TEST_TYPE(LPFILEGROUPDESCRIPTORW, 4, 4);
1040     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORW, 596, 1);
1041 }
1042
1043 static void test_pack_LPIDA(void)
1044 {
1045     /* LPIDA */
1046     TEST_TYPE(LPIDA, 4, 4);
1047     TEST_TYPE_POINTER(LPIDA, 8, 1);
1048 }
1049
1050 static void test_pack_LPSHChangeDWORDAsIDList(void)
1051 {
1052     /* LPSHChangeDWORDAsIDList */
1053     TEST_TYPE(LPSHChangeDWORDAsIDList, 4, 4);
1054     TEST_TYPE_POINTER(LPSHChangeDWORDAsIDList, 12, 1);
1055 }
1056
1057 static void test_pack_LPSHChangeProductKeyAsIDList(void)
1058 {
1059     /* LPSHChangeProductKeyAsIDList */
1060     TEST_TYPE(LPSHChangeProductKeyAsIDList, 4, 4);
1061     TEST_TYPE_POINTER(LPSHChangeProductKeyAsIDList, 82, 1);
1062 }
1063
1064 static void test_pack_LPSHDESCRIPTIONID(void)
1065 {
1066     /* LPSHDESCRIPTIONID */
1067     TEST_TYPE(LPSHDESCRIPTIONID, 4, 4);
1068     TEST_TYPE_POINTER(LPSHDESCRIPTIONID, 20, 4);
1069 }
1070
1071 static void test_pack_LPSHELLFLAGSTATE(void)
1072 {
1073     /* LPSHELLFLAGSTATE */
1074     TEST_TYPE(LPSHELLFLAGSTATE, 4, 4);
1075     TEST_TYPE_POINTER(LPSHELLFLAGSTATE, 4, 1);
1076 }
1077
1078 static void test_pack_LPSHELLSTATE(void)
1079 {
1080     /* LPSHELLSTATE */
1081     TEST_TYPE(LPSHELLSTATE, 4, 4);
1082     TEST_TYPE_POINTER(LPSHELLSTATE, 32, 1);
1083 }
1084
1085 static void test_pack_PBROWSEINFOA(void)
1086 {
1087     /* PBROWSEINFOA */
1088     TEST_TYPE(PBROWSEINFOA, 4, 4);
1089     TEST_TYPE_POINTER(PBROWSEINFOA, 32, 4);
1090 }
1091
1092 static void test_pack_PBROWSEINFOW(void)
1093 {
1094     /* PBROWSEINFOW */
1095     TEST_TYPE(PBROWSEINFOW, 4, 4);
1096     TEST_TYPE_POINTER(PBROWSEINFOW, 32, 4);
1097 }
1098
1099 static void test_pack_SHChangeDWORDAsIDList(void)
1100 {
1101     /* SHChangeDWORDAsIDList (pack 1) */
1102     TEST_TYPE(SHChangeDWORDAsIDList, 12, 1);
1103     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cb, 0, 2, 1);
1104     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem1, 2, 4, 1);
1105     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem2, 6, 4, 1);
1106     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cbZero, 10, 2, 1);
1107 }
1108
1109 static void test_pack_SHChangeNotifyEntry(void)
1110 {
1111     /* SHChangeNotifyEntry (pack 1) */
1112     TEST_TYPE(SHChangeNotifyEntry, 8, 1);
1113     TEST_FIELD(SHChangeNotifyEntry, LPCITEMIDLIST, pidl, 0, 4, 1);
1114     TEST_FIELD(SHChangeNotifyEntry, BOOL, fRecursive, 4, 4, 1);
1115 }
1116
1117 static void test_pack_SHChangeProductKeyAsIDList(void)
1118 {
1119     /* SHChangeProductKeyAsIDList (pack 1) */
1120     TEST_TYPE(SHChangeProductKeyAsIDList, 82, 1);
1121     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cb, 0, 2, 1);
1122     TEST_FIELD(SHChangeProductKeyAsIDList, WCHAR[39], wszProductKey, 2, 78, 1);
1123     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cbZero, 80, 2, 1);
1124 }
1125
1126 static void test_pack_SHDESCRIPTIONID(void)
1127 {
1128     /* SHDESCRIPTIONID (pack 8) */
1129     TEST_TYPE(SHDESCRIPTIONID, 20, 4);
1130     TEST_FIELD(SHDESCRIPTIONID, DWORD, dwDescriptionId, 0, 4, 4);
1131     TEST_FIELD(SHDESCRIPTIONID, CLSID, clsid, 4, 16, 4);
1132 }
1133
1134 static void test_pack_SHELLFLAGSTATE(void)
1135 {
1136     /* SHELLFLAGSTATE (pack 1) */
1137     TEST_TYPE(SHELLFLAGSTATE, 4, 1);
1138 }
1139
1140 static void test_pack_SHELLSTATE(void)
1141 {
1142     /* SHELLSTATE (pack 1) */
1143     TEST_TYPE(SHELLSTATE, 32, 1);
1144     TEST_FIELD(SHELLSTATE, DWORD, dwWin95Unused, 4, 4, 1);
1145     TEST_FIELD(SHELLSTATE, UINT, uWin95Unused, 8, 4, 1);
1146     TEST_FIELD(SHELLSTATE, LONG, lParamSort, 12, 4, 1);
1147     TEST_FIELD(SHELLSTATE, int, iSortDirection, 16, 4, 1);
1148     TEST_FIELD(SHELLSTATE, UINT, version, 20, 4, 1);
1149     TEST_FIELD(SHELLSTATE, UINT, uNotUsed, 24, 4, 1);
1150 }
1151
1152 static void test_pack_SHELLVIEWID(void)
1153 {
1154     /* SHELLVIEWID */
1155     TEST_TYPE(SHELLVIEWID, 16, 4);
1156 }
1157
1158 static void test_pack(void)
1159 {
1160     test_pack_APPBARDATA();
1161     test_pack_AUTO_SCROLL_DATA();
1162     test_pack_BFFCALLBACK();
1163     test_pack_BLOB();
1164     test_pack_BROWSEINFOA();
1165     test_pack_BROWSEINFOW();
1166     test_pack_BSTR();
1167     test_pack_BSTRBLOB();
1168     test_pack_BYTE_BLOB();
1169     test_pack_BYTE_SIZEDARR();
1170     test_pack_CABINETSTATE();
1171     test_pack_CIDA();
1172     test_pack_CLIPDATA();
1173     test_pack_CLIPFORMAT();
1174     test_pack_CLSID();
1175     test_pack_COAUTHIDENTITY();
1176     test_pack_COAUTHINFO();
1177     test_pack_COSERVERINFO();
1178     test_pack_DRAGINFOA();
1179     test_pack_DRAGINFOW();
1180     test_pack_DROPFILES();
1181     test_pack_DWORD_SIZEDARR();
1182     test_pack_FILEDESCRIPTORA();
1183     test_pack_FILEDESCRIPTORW();
1184     test_pack_FILEGROUPDESCRIPTORA();
1185     test_pack_FILEGROUPDESCRIPTORW();
1186     test_pack_FILEOP_FLAGS();
1187     test_pack_FLAGGED_BYTE_BLOB();
1188     test_pack_FLAGGED_WORD_BLOB();
1189     test_pack_FMTID();
1190     test_pack_GUID();
1191     test_pack_HMETAFILEPICT();
1192     test_pack_HYPER_SIZEDARR();
1193     test_pack_IFileSystemBindData();
1194     test_pack_IFileSystemBindDataVtbl();
1195     test_pack_IID();
1196     test_pack_IShellChangeNotify();
1197     test_pack_IShellIcon();
1198     test_pack_ITEMIDLIST();
1199     test_pack_LPBLOB();
1200     test_pack_LPBROWSEINFOA();
1201     test_pack_LPBROWSEINFOW();
1202     test_pack_LPBSTR();
1203     test_pack_LPBSTRBLOB();
1204     test_pack_LPCABINETSTATE();
1205     test_pack_LPCITEMIDLIST();
1206     test_pack_LPCOLESTR();
1207     test_pack_LPCY();
1208     test_pack_LPDECIMAL();
1209     test_pack_LPDRAGINFOA();
1210     test_pack_LPDRAGINFOW();
1211     test_pack_LPDROPFILES();
1212     test_pack_LPFILEDESCRIPTORA();
1213     test_pack_LPFILEDESCRIPTORW();
1214     test_pack_LPFILEGROUPDESCRIPTORA();
1215     test_pack_LPFILEGROUPDESCRIPTORW();
1216     test_pack_LPGUID();
1217     test_pack_LPIDA();
1218     test_pack_LPITEMIDLIST();
1219     test_pack_LPOLESTR();
1220     test_pack_LPSHChangeDWORDAsIDList();
1221     test_pack_LPSHChangeProductKeyAsIDList();
1222     test_pack_LPSHDESCRIPTIONID();
1223     test_pack_LPSHELLEXECUTEINFOA();
1224     test_pack_LPSHELLEXECUTEINFOW();
1225     test_pack_LPSHELLFLAGSTATE();
1226     test_pack_LPSHELLSTATE();
1227     test_pack_LPSHFILEOPSTRUCTA();
1228     test_pack_LPSHFILEOPSTRUCTW();
1229     test_pack_LPSHITEMID();
1230     test_pack_LPSHNAMEMAPPINGA();
1231     test_pack_LPSHNAMEMAPPINGW();
1232     test_pack_NOTIFYICONDATAA();
1233     test_pack_NOTIFYICONDATAW();
1234     test_pack_OLECHAR();
1235     test_pack_PAPPBARDATA();
1236     test_pack_PBROWSEINFOA();
1237     test_pack_PBROWSEINFOW();
1238     test_pack_PNOTIFYICONDATAA();
1239     test_pack_PNOTIFYICONDATAW();
1240     test_pack_PRINTEROP_FLAGS();
1241     test_pack_PROPID();
1242     test_pack_RemHBITMAP();
1243     test_pack_RemHENHMETAFILE();
1244     test_pack_RemHGLOBAL();
1245     test_pack_RemHMETAFILEPICT();
1246     test_pack_RemHPALETTE();
1247     test_pack_SCODE();
1248     test_pack_SHChangeDWORDAsIDList();
1249     test_pack_SHChangeNotifyEntry();
1250     test_pack_SHChangeProductKeyAsIDList();
1251     test_pack_SHDESCRIPTIONID();
1252     test_pack_SHELLEXECUTEINFOA();
1253     test_pack_SHELLEXECUTEINFOW();
1254     test_pack_SHELLFLAGSTATE();
1255     test_pack_SHELLSTATE();
1256     test_pack_SHELLVIEWID();
1257     test_pack_SHFILEINFOA();
1258     test_pack_SHFILEINFOW();
1259     test_pack_SHFILEOPSTRUCTA();
1260     test_pack_SHFILEOPSTRUCTW();
1261     test_pack_SHITEMID();
1262     test_pack_SHNAMEMAPPINGA();
1263     test_pack_SHNAMEMAPPINGW();
1264     test_pack_UP_BYTE_BLOB();
1265     test_pack_UP_FLAGGED_BYTE_BLOB();
1266     test_pack_UP_FLAGGED_WORD_BLOB();
1267     test_pack_VARIANT_BOOL();
1268     test_pack_VARTYPE();
1269     test_pack_WORD_SIZEDARR();
1270     test_pack_remoteMETAFILEPICT();
1271     test_pack_userBITMAP();
1272     test_pack_userCLIPFORMAT();
1273     test_pack_userHBITMAP();
1274     test_pack_userHENHMETAFILE();
1275     test_pack_userHGLOBAL();
1276     test_pack_userHMETAFILE();
1277     test_pack_userHMETAFILEPICT();
1278     test_pack_userHPALETTE();
1279     test_pack_wireBSTR();
1280     test_pack_wireCLIPFORMAT();
1281     test_pack_wireHBITMAP();
1282     test_pack_wireHENHMETAFILE();
1283     test_pack_wireHGLOBAL();
1284     test_pack_wireHMETAFILE();
1285     test_pack_wireHMETAFILEPICT();
1286     test_pack_wireHPALETTE();
1287 }
1288
1289 START_TEST(generated)
1290 {
1291     test_pack();
1292 }