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

   1 /* File generated automatically from tools/winapi/tests.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  * Compatibility 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 _TYPE_ALIGNMENT(type) __alignof(type)
  39 #elif defined(__GNUC__)
  40 # define _TYPE_ALIGNMENT(type) __alignof__(type)
  41 #else
  42 /*
  43  * FIXME: May not be possible without a compiler extension
  44  *        (if type is not just a name that is, otherwise the normal
  45  *         TYPE_ALIGNMENT can be used)
  46  */
  47 #endif
  48
  49 #if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)
  50 #pragma warning(disable:4116)
  51 #endif
  52
  53 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
  54 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
  55 #endif
  56
  57 /***********************************************************************
  58  * Test helper macros
  59  */
  60
  61 #ifdef FIELD_ALIGNMENT
  62 # define TEST_FIELD_ALIGNMENT(type, field, align) \
  63    ok(_TYPE_ALIGNMENT(((type*)0)->field) == align, \
  64        "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")\n", \
  65            (int)_TYPE_ALIGNMENT(((type*)0)->field))
  66 #else
  67 # define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
  68 #endif
  69
  70 #define TEST_FIELD_OFFSET(type, field, offset) \
  71     ok(FIELD_OFFSET(type, field) == offset, \
  72         "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")\n", \
  73              (long int)FIELD_OFFSET(type, field))
  74
  75 #ifdef _TYPE_ALIGNMENT
  76 #define TEST__TYPE_ALIGNMENT(type, align) \
  77     ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)_TYPE_ALIGNMENT(type))
  78 #else
  79 # define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
  80 #endif
  81
  82 #ifdef TYPE_ALIGNMENT
  83 #define TEST_TYPE_ALIGNMENT(type, align) \
  84     ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)TYPE_ALIGNMENT(type))
  85 #else
  86 # define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
  87 #endif
  88
  89 #define TEST_TYPE_SIZE(type, size) \
  90     ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")\n", ((int) sizeof(type)))
  91
  92 /***********************************************************************
  93  * Test macros
  94  */
  95
  96 #define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
  97   TEST_TYPE_SIZE(field_type, field_size); \
  98   TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
  99   TEST_FIELD_OFFSET(type, field_name, field_offset); \
 100
 101 #define TEST_TYPE(type, size, align) \
 102   TEST_TYPE_ALIGNMENT(type, align); \
 103   TEST_TYPE_SIZE(type, size)
 104
 105 #define TEST_TYPE_POINTER(type, size, align) \
 106     TEST__TYPE_ALIGNMENT(*(type)0, align); \
 107     TEST_TYPE_SIZE(*(type)0, size)
 108
 109 #define TEST_TYPE_SIGNED(type) \
 110     ok((type) -1 < 0, "(" #type ") -1 < 0\n");
 111
 112 #define TEST_TYPE_UNSIGNED(type) \
 113      ok((type) -1 > 0, "(" #type ") -1 > 0\n");
 114
 115 static void test_pack_BLOB(void)
 116 {
 117     /* BLOB (pack 4) */
 118     TEST_TYPE(BLOB, 8, 4);
 119     TEST_FIELD(BLOB, ULONG, cbSize, 0, 4, 4);
 120     TEST_FIELD(BLOB, BYTE *, pBlobData, 4, 4, 4);
 121 }
 122
 123 static void test_pack_BSTR(void)
 124 {
 125     /* BSTR */
 126     TEST_TYPE(BSTR, 4, 4);
 127     TEST_TYPE_POINTER(BSTR, 2, 2);
 128 }
 129
 130 static void test_pack_BSTRBLOB(void)
 131 {
 132     /* BSTRBLOB (pack 4) */
 133     TEST_TYPE(BSTRBLOB, 8, 4);
 134     TEST_FIELD(BSTRBLOB, ULONG, cbSize, 0, 4, 4);
 135     TEST_FIELD(BSTRBLOB, BYTE *, pData, 4, 4, 4);
 136 }
 137
 138 static void test_pack_BYTE_BLOB(void)
 139 {
 140     /* BYTE_BLOB (pack 4) */
 141     TEST_TYPE(BYTE_BLOB, 8, 4);
 142     TEST_FIELD(BYTE_BLOB, unsigned long, clSize, 0, 4, 4);
 143     TEST_FIELD(BYTE_BLOB, byte[1], abData, 4, 1, 1);
 144 }
 145
 146 static void test_pack_BYTE_SIZEDARR(void)
 147 {
 148     /* BYTE_SIZEDARR (pack 4) */
 149     TEST_TYPE(BYTE_SIZEDARR, 8, 4);
 150     TEST_FIELD(BYTE_SIZEDARR, unsigned long, clSize, 0, 4, 4);
 151     TEST_FIELD(BYTE_SIZEDARR, byte *, pData, 4, 4, 4);
 152 }
 153
 154 static void test_pack_CLIPDATA(void)
 155 {
 156     /* CLIPDATA (pack 4) */
 157     TEST_TYPE(CLIPDATA, 12, 4);
 158     TEST_FIELD(CLIPDATA, ULONG, cbSize, 0, 4, 4);
 159     TEST_FIELD(CLIPDATA, long, ulClipFmt, 4, 4, 4);
 160     TEST_FIELD(CLIPDATA, BYTE *, pClipData, 8, 4, 4);
 161 }
 162
 163 static void test_pack_CLIPFORMAT(void)
 164 {
 165     /* CLIPFORMAT */
 166     TEST_TYPE(CLIPFORMAT, 2, 2);
 167     TEST_TYPE_UNSIGNED(CLIPFORMAT);
 168 }
 169
 170 static void test_pack_COAUTHIDENTITY(void)
 171 {
 172     /* COAUTHIDENTITY (pack 4) */
 173     TEST_TYPE(COAUTHIDENTITY, 28, 4);
 174     TEST_FIELD(COAUTHIDENTITY, USHORT *, User, 0, 4, 4);
 175     TEST_FIELD(COAUTHIDENTITY, ULONG, UserLength, 4, 4, 4);
 176     TEST_FIELD(COAUTHIDENTITY, USHORT *, Domain, 8, 4, 4);
 177     TEST_FIELD(COAUTHIDENTITY, ULONG, DomainLength, 12, 4, 4);
 178     TEST_FIELD(COAUTHIDENTITY, USHORT *, Password, 16, 4, 4);
 179     TEST_FIELD(COAUTHIDENTITY, ULONG, PasswordLength, 20, 4, 4);
 180     TEST_FIELD(COAUTHIDENTITY, ULONG, Flags, 24, 4, 4);
 181 }
 182
 183 static void test_pack_COAUTHINFO(void)
 184 {
 185     /* COAUTHINFO (pack 4) */
 186     TEST_TYPE(COAUTHINFO, 28, 4);
 187     TEST_FIELD(COAUTHINFO, DWORD, dwAuthnSvc, 0, 4, 4);
 188     TEST_FIELD(COAUTHINFO, DWORD, dwAuthzSvc, 4, 4, 4);
 189     TEST_FIELD(COAUTHINFO, LPWSTR, pwszServerPrincName, 8, 4, 4);
 190     TEST_FIELD(COAUTHINFO, DWORD, dwAuthnLevel, 12, 4, 4);
 191     TEST_FIELD(COAUTHINFO, DWORD, dwImpersonationLevel, 16, 4, 4);
 192     TEST_FIELD(COAUTHINFO, COAUTHIDENTITY *, pAuthIdentityData, 20, 4, 4);
 193     TEST_FIELD(COAUTHINFO, DWORD, dwCapabilities, 24, 4, 4);
 194 }
 195
 196 static void test_pack_DATE(void)
 197 {
 198     /* DATE */
 199     TEST_TYPE(DATE, 8, 8);
 200 }
 201
 202 static void test_pack_DOUBLE(void)
 203 {
 204     /* DOUBLE */
 205     TEST_TYPE(DOUBLE, 8, 8);
 206 }
 207
 208 static void test_pack_DWORD_SIZEDARR(void)
 209 {
 210     /* DWORD_SIZEDARR (pack 4) */
 211     TEST_TYPE(DWORD_SIZEDARR, 8, 4);
 212     TEST_FIELD(DWORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
 213     TEST_FIELD(DWORD_SIZEDARR, unsigned long *, pData, 4, 4, 4);
 214 }
 215
 216 static void test_pack_FLAGGED_BYTE_BLOB(void)
 217 {
 218     /* FLAGGED_BYTE_BLOB (pack 4) */
 219     TEST_TYPE(FLAGGED_BYTE_BLOB, 12, 4);
 220     TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, fFlags, 0, 4, 4);
 221     TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, clSize, 4, 4, 4);
 222     TEST_FIELD(FLAGGED_BYTE_BLOB, byte[1], abData, 8, 1, 1);
 223 }
 224
 225 static void test_pack_FLAGGED_WORD_BLOB(void)
 226 {
 227     /* FLAGGED_WORD_BLOB (pack 4) */
 228     TEST_TYPE(FLAGGED_WORD_BLOB, 12, 4);
 229     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, fFlags, 0, 4, 4);
 230     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, clSize, 4, 4, 4);
 231     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned short[1], asData, 8, 2, 2);
 232 }
 233
 234 static void test_pack_HMETAFILEPICT(void)
 235 {
 236     /* HMETAFILEPICT */
 237     TEST_TYPE(HMETAFILEPICT, 4, 4);
 238 }
 239
 240 static void test_pack_HYPER_SIZEDARR(void)
 241 {
 242     /* HYPER_SIZEDARR (pack 4) */
 243     TEST_TYPE(HYPER_SIZEDARR, 8, 4);
 244     TEST_FIELD(HYPER_SIZEDARR, unsigned long, clSize, 0, 4, 4);
 245     TEST_FIELD(HYPER_SIZEDARR, hyper *, pData, 4, 4, 4);
 246 }
 247
 248 static void test_pack_LPBLOB(void)
 249 {
 250     /* LPBLOB */
 251     TEST_TYPE(LPBLOB, 4, 4);
 252 }
 253
 254 static void test_pack_LPBSTR(void)
 255 {
 256     /* LPBSTR */
 257     TEST_TYPE(LPBSTR, 4, 4);
 258     TEST_TYPE_POINTER(LPBSTR, 4, 4);
 259 }
 260
 261 static void test_pack_LPBSTRBLOB(void)
 262 {
 263     /* LPBSTRBLOB */
 264     TEST_TYPE(LPBSTRBLOB, 4, 4);
 265 }
 266
 267 static void test_pack_LPCOLESTR(void)
 268 {
 269     /* LPCOLESTR */
 270     TEST_TYPE(LPCOLESTR, 4, 4);
 271     TEST_TYPE_POINTER(LPCOLESTR, 2, 2);
 272 }
 273
 274 static void test_pack_LPCY(void)
 275 {
 276     /* LPCY */
 277     TEST_TYPE(LPCY, 4, 4);
 278 }
 279
 280 static void test_pack_LPDECIMAL(void)
 281 {
 282     /* LPDECIMAL */
 283     TEST_TYPE(LPDECIMAL, 4, 4);
 284 }
 285
 286 static void test_pack_LPOLESTR(void)
 287 {
 288     /* LPOLESTR */
 289     TEST_TYPE(LPOLESTR, 4, 4);
 290     TEST_TYPE_POINTER(LPOLESTR, 2, 2);
 291 }
 292
 293 static void test_pack_OLECHAR(void)
 294 {
 295     /* OLECHAR */
 296     TEST_TYPE(OLECHAR, 2, 2);
 297 }
 298
 299 static void test_pack_PROPID(void)
 300 {
 301     /* PROPID */
 302     TEST_TYPE(PROPID, 4, 4);
 303 }
 304
 305 static void test_pack_RemHBITMAP(void)
 306 {
 307     /* RemHBITMAP (pack 4) */
 308     TEST_TYPE(RemHBITMAP, 8, 4);
 309     TEST_FIELD(RemHBITMAP, unsigned long, cbData, 0, 4, 4);
 310     TEST_FIELD(RemHBITMAP, byte[1], data, 4, 1, 1);
 311 }
 312
 313 static void test_pack_RemHENHMETAFILE(void)
 314 {
 315     /* RemHENHMETAFILE (pack 4) */
 316     TEST_TYPE(RemHENHMETAFILE, 8, 4);
 317     TEST_FIELD(RemHENHMETAFILE, unsigned long, cbData, 0, 4, 4);
 318     TEST_FIELD(RemHENHMETAFILE, byte[1], data, 4, 1, 1);
 319 }
 320
 321 static void test_pack_RemHGLOBAL(void)
 322 {
 323     /* RemHGLOBAL (pack 4) */
 324     TEST_TYPE(RemHGLOBAL, 12, 4);
 325     TEST_FIELD(RemHGLOBAL, long, fNullHGlobal, 0, 4, 4);
 326     TEST_FIELD(RemHGLOBAL, unsigned long, cbData, 4, 4, 4);
 327     TEST_FIELD(RemHGLOBAL, byte[1], data, 8, 1, 1);
 328 }
 329
 330 static void test_pack_RemHMETAFILEPICT(void)
 331 {
 332     /* RemHMETAFILEPICT (pack 4) */
 333     TEST_TYPE(RemHMETAFILEPICT, 20, 4);
 334     TEST_FIELD(RemHMETAFILEPICT, long, mm, 0, 4, 4);
 335     TEST_FIELD(RemHMETAFILEPICT, long, xExt, 4, 4, 4);
 336     TEST_FIELD(RemHMETAFILEPICT, long, yExt, 8, 4, 4);
 337     TEST_FIELD(RemHMETAFILEPICT, unsigned long, cbData, 12, 4, 4);
 338     TEST_FIELD(RemHMETAFILEPICT, byte[1], data, 16, 1, 1);
 339 }
 340
 341 static void test_pack_RemHPALETTE(void)
 342 {
 343     /* RemHPALETTE (pack 4) */
 344     TEST_TYPE(RemHPALETTE, 8, 4);
 345     TEST_FIELD(RemHPALETTE, unsigned long, cbData, 0, 4, 4);
 346     TEST_FIELD(RemHPALETTE, byte[1], data, 4, 1, 1);
 347 }
 348
 349 static void test_pack_SCODE(void)
 350 {
 351     /* SCODE */
 352     TEST_TYPE(SCODE, 4, 4);
 353 }
 354
 355 static void test_pack_UP_BYTE_BLOB(void)
 356 {
 357     /* UP_BYTE_BLOB */
 358     TEST_TYPE(UP_BYTE_BLOB, 4, 4);
 359     TEST_TYPE_POINTER(UP_BYTE_BLOB, 8, 4);
 360 }
 361
 362 static void test_pack_UP_FLAGGED_BYTE_BLOB(void)
 363 {
 364     /* UP_FLAGGED_BYTE_BLOB */
 365     TEST_TYPE(UP_FLAGGED_BYTE_BLOB, 4, 4);
 366     TEST_TYPE_POINTER(UP_FLAGGED_BYTE_BLOB, 12, 4);
 367 }
 368
 369 static void test_pack_UP_FLAGGED_WORD_BLOB(void)
 370 {
 371     /* UP_FLAGGED_WORD_BLOB */
 372     TEST_TYPE(UP_FLAGGED_WORD_BLOB, 4, 4);
 373     TEST_TYPE_POINTER(UP_FLAGGED_WORD_BLOB, 12, 4);
 374 }
 375
 376 static void test_pack_VARIANT_BOOL(void)
 377 {
 378     /* VARIANT_BOOL */
 379     TEST_TYPE(VARIANT_BOOL, 2, 2);
 380     TEST_TYPE_SIGNED(VARIANT_BOOL);
 381 }
 382
 383 static void test_pack_VARTYPE(void)
 384 {
 385     /* VARTYPE */
 386     TEST_TYPE(VARTYPE, 2, 2);
 387     TEST_TYPE_UNSIGNED(VARTYPE);
 388 }
 389
 390 static void test_pack_WORD_SIZEDARR(void)
 391 {
 392     /* WORD_SIZEDARR (pack 4) */
 393     TEST_TYPE(WORD_SIZEDARR, 8, 4);
 394     TEST_FIELD(WORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
 395     TEST_FIELD(WORD_SIZEDARR, unsigned short *, pData, 4, 4, 4);
 396 }
 397
 398 static void test_pack_remoteMETAFILEPICT(void)
 399 {
 400     /* remoteMETAFILEPICT (pack 4) */
 401     TEST_TYPE(remoteMETAFILEPICT, 16, 4);
 402     TEST_FIELD(remoteMETAFILEPICT, long, mm, 0, 4, 4);
 403     TEST_FIELD(remoteMETAFILEPICT, long, xExt, 4, 4, 4);
 404     TEST_FIELD(remoteMETAFILEPICT, long, yExt, 8, 4, 4);
 405     TEST_FIELD(remoteMETAFILEPICT, userHMETAFILE *, hMF, 12, 4, 4);
 406 }
 407
 408 static void test_pack_userBITMAP(void)
 409 {
 410     /* userBITMAP (pack 4) */
 411     TEST_TYPE(userBITMAP, 28, 4);
 412     TEST_FIELD(userBITMAP, LONG, bmType, 0, 4, 4);
 413     TEST_FIELD(userBITMAP, LONG, bmWidth, 4, 4, 4);
 414     TEST_FIELD(userBITMAP, LONG, bmHeight, 8, 4, 4);
 415     TEST_FIELD(userBITMAP, LONG, bmWidthBytes, 12, 4, 4);
 416     TEST_FIELD(userBITMAP, WORD, bmPlanes, 16, 2, 2);
 417     TEST_FIELD(userBITMAP, WORD, bmBitsPixel, 18, 2, 2);
 418     TEST_FIELD(userBITMAP, ULONG, cbSize, 20, 4, 4);
 419     TEST_FIELD(userBITMAP, byte[1], pBuffer, 24, 1, 1);
 420 }
 421
 422 static void test_pack_userCLIPFORMAT(void)
 423 {
 424     /* userCLIPFORMAT (pack 4) */
 425     TEST_FIELD(userCLIPFORMAT, long, fContext, 0, 4, 4);
 426 }
 427
 428 static void test_pack_userHBITMAP(void)
 429 {
 430     /* userHBITMAP (pack 4) */
 431     TEST_FIELD(userHBITMAP, long, fContext, 0, 4, 4);
 432 }
 433
 434 static void test_pack_userHENHMETAFILE(void)
 435 {
 436     /* userHENHMETAFILE (pack 4) */
 437     TEST_FIELD(userHENHMETAFILE, long, fContext, 0, 4, 4);
 438 }
 439
 440 static void test_pack_userHGLOBAL(void)
 441 {
 442     /* userHGLOBAL (pack 4) */
 443     TEST_FIELD(userHGLOBAL, long, fContext, 0, 4, 4);
 444 }
 445
 446 static void test_pack_userHMETAFILE(void)
 447 {
 448     /* userHMETAFILE (pack 4) */
 449     TEST_FIELD(userHMETAFILE, long, fContext, 0, 4, 4);
 450 }
 451
 452 static void test_pack_userHMETAFILEPICT(void)
 453 {
 454     /* userHMETAFILEPICT (pack 4) */
 455     TEST_FIELD(userHMETAFILEPICT, long, fContext, 0, 4, 4);
 456 }
 457
 458 static void test_pack_userHPALETTE(void)
 459 {
 460     /* userHPALETTE (pack 4) */
 461     TEST_FIELD(userHPALETTE, long, fContext, 0, 4, 4);
 462 }
 463
 464 static void test_pack_wireBSTR(void)
 465 {
 466     /* wireBSTR */
 467     TEST_TYPE(wireBSTR, 4, 4);
 468     TEST_TYPE_POINTER(wireBSTR, 12, 4);
 469 }
 470
 471 static void test_pack_wireCLIPFORMAT(void)
 472 {
 473     /* wireCLIPFORMAT */
 474     TEST_TYPE(wireCLIPFORMAT, 4, 4);
 475 }
 476
 477 static void test_pack_wireHBITMAP(void)
 478 {
 479     /* wireHBITMAP */
 480     TEST_TYPE(wireHBITMAP, 4, 4);
 481 }
 482
 483 static void test_pack_wireHENHMETAFILE(void)
 484 {
 485     /* wireHENHMETAFILE */
 486     TEST_TYPE(wireHENHMETAFILE, 4, 4);
 487 }
 488
 489 static void test_pack_wireHGLOBAL(void)
 490 {
 491     /* wireHGLOBAL */
 492     TEST_TYPE(wireHGLOBAL, 4, 4);
 493 }
 494
 495 static void test_pack_wireHMETAFILE(void)
 496 {
 497     /* wireHMETAFILE */
 498     TEST_TYPE(wireHMETAFILE, 4, 4);
 499 }
 500
 501 static void test_pack_wireHMETAFILEPICT(void)
 502 {
 503     /* wireHMETAFILEPICT */
 504     TEST_TYPE(wireHMETAFILEPICT, 4, 4);
 505 }
 506
 507 static void test_pack_wireHPALETTE(void)
 508 {
 509     /* wireHPALETTE */
 510     TEST_TYPE(wireHPALETTE, 4, 4);
 511 }
 512
 513 static void test_pack_CLSID(void)
 514 {
 515     /* CLSID */
 516     TEST_TYPE(CLSID, 16, 4);
 517 }
 518
 519 static void test_pack_FMTID(void)
 520 {
 521     /* FMTID */
 522     TEST_TYPE(FMTID, 16, 4);
 523 }
 524
 525 static void test_pack_IID(void)
 526 {
 527     /* IID */
 528     TEST_TYPE(IID, 16, 4);
 529 }
 530
 531 static void test_pack_APPBARDATA(void)
 532 {
 533     /* APPBARDATA (pack 1) */
 534     TEST_TYPE(APPBARDATA, 36, 1);
 535     TEST_FIELD(APPBARDATA, DWORD, cbSize, 0, 4, 1);
 536     TEST_FIELD(APPBARDATA, HWND, hWnd, 4, 4, 1);
 537     TEST_FIELD(APPBARDATA, UINT, uCallbackMessage, 8, 4, 1);
 538     TEST_FIELD(APPBARDATA, UINT, uEdge, 12, 4, 1);
 539     TEST_FIELD(APPBARDATA, RECT, rc, 16, 16, 1);
 540     TEST_FIELD(APPBARDATA, LPARAM, lParam, 32, 4, 1);
 541 }
 542
 543 static void test_pack_DRAGINFOA(void)
 544 {
 545     /* DRAGINFOA (pack 1) */
 546     TEST_TYPE(DRAGINFOA, 24, 1);
 547     TEST_FIELD(DRAGINFOA, UINT, uSize, 0, 4, 1);
 548     TEST_FIELD(DRAGINFOA, POINT, pt, 4, 8, 1);
 549     TEST_FIELD(DRAGINFOA, BOOL, fNC, 12, 4, 1);
 550     TEST_FIELD(DRAGINFOA, LPSTR, lpFileList, 16, 4, 1);
 551     TEST_FIELD(DRAGINFOA, DWORD, grfKeyState, 20, 4, 1);
 552 }
 553
 554 static void test_pack_DRAGINFOW(void)
 555 {
 556     /* DRAGINFOW (pack 1) */
 557     TEST_TYPE(DRAGINFOW, 24, 1);
 558     TEST_FIELD(DRAGINFOW, UINT, uSize, 0, 4, 1);
 559     TEST_FIELD(DRAGINFOW, POINT, pt, 4, 8, 1);
 560     TEST_FIELD(DRAGINFOW, BOOL, fNC, 12, 4, 1);
 561     TEST_FIELD(DRAGINFOW, LPWSTR, lpFileList, 16, 4, 1);
 562     TEST_FIELD(DRAGINFOW, DWORD, grfKeyState, 20, 4, 1);
 563 }
 564
 565 static void test_pack_FILEOP_FLAGS(void)
 566 {
 567     /* FILEOP_FLAGS */
 568     TEST_TYPE(FILEOP_FLAGS, 2, 2);
 569     TEST_TYPE_UNSIGNED(FILEOP_FLAGS);
 570 }
 571
 572 static void test_pack_LPDRAGINFOA(void)
 573 {
 574     /* LPDRAGINFOA */
 575     TEST_TYPE(LPDRAGINFOA, 4, 4);
 576     TEST_TYPE_POINTER(LPDRAGINFOA, 24, 1);
 577 }
 578
 579 static void test_pack_LPDRAGINFOW(void)
 580 {
 581     /* LPDRAGINFOW */
 582     TEST_TYPE(LPDRAGINFOW, 4, 4);
 583     TEST_TYPE_POINTER(LPDRAGINFOW, 24, 1);
 584 }
 585
 586 static void test_pack_LPSHELLEXECUTEINFOA(void)
 587 {
 588     /* LPSHELLEXECUTEINFOA */
 589     TEST_TYPE(LPSHELLEXECUTEINFOA, 4, 4);
 590 }
 591
 592 static void test_pack_LPSHELLEXECUTEINFOW(void)
 593 {
 594     /* LPSHELLEXECUTEINFOW */
 595     TEST_TYPE(LPSHELLEXECUTEINFOW, 4, 4);
 596 }
 597
 598 static void test_pack_LPSHFILEOPSTRUCTA(void)
 599 {
 600     /* LPSHFILEOPSTRUCTA */
 601     TEST_TYPE(LPSHFILEOPSTRUCTA, 4, 4);
 602     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTA, 30, 1);
 603 }
 604
 605 static void test_pack_LPSHFILEOPSTRUCTW(void)
 606 {
 607     /* LPSHFILEOPSTRUCTW */
 608     TEST_TYPE(LPSHFILEOPSTRUCTW, 4, 4);
 609     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTW, 30, 1);
 610 }
 611
 612 static void test_pack_LPSHNAMEMAPPINGA(void)
 613 {
 614     /* LPSHNAMEMAPPINGA */
 615     TEST_TYPE(LPSHNAMEMAPPINGA, 4, 4);
 616     TEST_TYPE_POINTER(LPSHNAMEMAPPINGA, 16, 1);
 617 }
 618
 619 static void test_pack_LPSHNAMEMAPPINGW(void)
 620 {
 621     /* LPSHNAMEMAPPINGW */
 622     TEST_TYPE(LPSHNAMEMAPPINGW, 4, 4);
 623     TEST_TYPE_POINTER(LPSHNAMEMAPPINGW, 16, 1);
 624 }
 625
 626 static void test_pack_NOTIFYICONDATAA(void)
 627 {
 628     /* NOTIFYICONDATAA (pack 1) */
 629     TEST_FIELD(NOTIFYICONDATAA, DWORD, cbSize, 0, 4, 1);
 630     TEST_FIELD(NOTIFYICONDATAA, HWND, hWnd, 4, 4, 1);
 631     TEST_FIELD(NOTIFYICONDATAA, UINT, uID, 8, 4, 1);
 632     TEST_FIELD(NOTIFYICONDATAA, UINT, uFlags, 12, 4, 1);
 633     TEST_FIELD(NOTIFYICONDATAA, UINT, uCallbackMessage, 16, 4, 1);
 634     TEST_FIELD(NOTIFYICONDATAA, HICON, hIcon, 20, 4, 1);
 635     TEST_FIELD(NOTIFYICONDATAA, CHAR[128], szTip, 24, 128, 1);
 636     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwState, 152, 4, 1);
 637     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwStateMask, 156, 4, 1);
 638     TEST_FIELD(NOTIFYICONDATAA, CHAR[256], szInfo, 160, 256, 1);
 639 }
 640
 641 static void test_pack_NOTIFYICONDATAW(void)
 642 {
 643     /* NOTIFYICONDATAW (pack 1) */
 644     TEST_FIELD(NOTIFYICONDATAW, DWORD, cbSize, 0, 4, 1);
 645     TEST_FIELD(NOTIFYICONDATAW, HWND, hWnd, 4, 4, 1);
 646     TEST_FIELD(NOTIFYICONDATAW, UINT, uID, 8, 4, 1);
 647     TEST_FIELD(NOTIFYICONDATAW, UINT, uFlags, 12, 4, 1);
 648     TEST_FIELD(NOTIFYICONDATAW, UINT, uCallbackMessage, 16, 4, 1);
 649     TEST_FIELD(NOTIFYICONDATAW, HICON, hIcon, 20, 4, 1);
 650     TEST_FIELD(NOTIFYICONDATAW, WCHAR[128], szTip, 24, 256, 1);
 651     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwState, 280, 4, 1);
 652     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwStateMask, 284, 4, 1);
 653     TEST_FIELD(NOTIFYICONDATAW, WCHAR[256], szInfo, 288, 512, 1);
 654 }
 655
 656 static void test_pack_PAPPBARDATA(void)
 657 {
 658     /* PAPPBARDATA */
 659     TEST_TYPE(PAPPBARDATA, 4, 4);
 660     TEST_TYPE_POINTER(PAPPBARDATA, 36, 1);
 661 }
 662
 663 static void test_pack_PNOTIFYICONDATAA(void)
 664 {
 665     /* PNOTIFYICONDATAA */
 666     TEST_TYPE(PNOTIFYICONDATAA, 4, 4);
 667 }
 668
 669 static void test_pack_PNOTIFYICONDATAW(void)
 670 {
 671     /* PNOTIFYICONDATAW */
 672     TEST_TYPE(PNOTIFYICONDATAW, 4, 4);
 673 }
 674
 675 static void test_pack_PRINTEROP_FLAGS(void)
 676 {
 677     /* PRINTEROP_FLAGS */
 678     TEST_TYPE(PRINTEROP_FLAGS, 2, 2);
 679     TEST_TYPE_UNSIGNED(PRINTEROP_FLAGS);
 680 }
 681
 682 static void test_pack_SHELLEXECUTEINFOA(void)
 683 {
 684     /* SHELLEXECUTEINFOA (pack 1) */
 685     TEST_FIELD(SHELLEXECUTEINFOA, DWORD, cbSize, 0, 4, 1);
 686     TEST_FIELD(SHELLEXECUTEINFOA, ULONG, fMask, 4, 4, 1);
 687     TEST_FIELD(SHELLEXECUTEINFOA, HWND, hwnd, 8, 4, 1);
 688     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpVerb, 12, 4, 1);
 689     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpFile, 16, 4, 1);
 690     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpParameters, 20, 4, 1);
 691     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpDirectory, 24, 4, 1);
 692     TEST_FIELD(SHELLEXECUTEINFOA, INT, nShow, 28, 4, 1);
 693     TEST_FIELD(SHELLEXECUTEINFOA, HINSTANCE, hInstApp, 32, 4, 1);
 694     TEST_FIELD(SHELLEXECUTEINFOA, LPVOID, lpIDList, 36, 4, 1);
 695     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpClass, 40, 4, 1);
 696     TEST_FIELD(SHELLEXECUTEINFOA, HKEY, hkeyClass, 44, 4, 1);
 697     TEST_FIELD(SHELLEXECUTEINFOA, DWORD, dwHotKey, 48, 4, 1);
 698 }
 699
 700 static void test_pack_SHELLEXECUTEINFOW(void)
 701 {
 702     /* SHELLEXECUTEINFOW (pack 1) */
 703     TEST_FIELD(SHELLEXECUTEINFOW, DWORD, cbSize, 0, 4, 1);
 704     TEST_FIELD(SHELLEXECUTEINFOW, ULONG, fMask, 4, 4, 1);
 705     TEST_FIELD(SHELLEXECUTEINFOW, HWND, hwnd, 8, 4, 1);
 706     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpVerb, 12, 4, 1);
 707     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpFile, 16, 4, 1);
 708     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpParameters, 20, 4, 1);
 709     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpDirectory, 24, 4, 1);
 710     TEST_FIELD(SHELLEXECUTEINFOW, INT, nShow, 28, 4, 1);
 711     TEST_FIELD(SHELLEXECUTEINFOW, HINSTANCE, hInstApp, 32, 4, 1);
 712     TEST_FIELD(SHELLEXECUTEINFOW, LPVOID, lpIDList, 36, 4, 1);
 713     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpClass, 40, 4, 1);
 714     TEST_FIELD(SHELLEXECUTEINFOW, HKEY, hkeyClass, 44, 4, 1);
 715     TEST_FIELD(SHELLEXECUTEINFOW, DWORD, dwHotKey, 48, 4, 1);
 716 }
 717
 718 static void test_pack_SHFILEINFOA(void)
 719 {
 720     /* SHFILEINFOA (pack 1) */
 721     TEST_TYPE(SHFILEINFOA, 352, 1);
 722     TEST_FIELD(SHFILEINFOA, HICON, hIcon, 0, 4, 1);
 723     TEST_FIELD(SHFILEINFOA, int, iIcon, 4, 4, 1);
 724     TEST_FIELD(SHFILEINFOA, DWORD, dwAttributes, 8, 4, 1);
 725     TEST_FIELD(SHFILEINFOA, CHAR[MAX_PATH], szDisplayName, 12, 260, 1);
 726     TEST_FIELD(SHFILEINFOA, CHAR[80], szTypeName, 272, 80, 1);
 727 }
 728
 729 static void test_pack_SHFILEINFOW(void)
 730 {
 731     /* SHFILEINFOW (pack 1) */
 732     TEST_TYPE(SHFILEINFOW, 692, 1);
 733     TEST_FIELD(SHFILEINFOW, HICON, hIcon, 0, 4, 1);
 734     TEST_FIELD(SHFILEINFOW, int, iIcon, 4, 4, 1);
 735     TEST_FIELD(SHFILEINFOW, DWORD, dwAttributes, 8, 4, 1);
 736     TEST_FIELD(SHFILEINFOW, WCHAR[MAX_PATH], szDisplayName, 12, 520, 1);
 737     TEST_FIELD(SHFILEINFOW, WCHAR[80], szTypeName, 532, 160, 1);
 738 }
 739
 740 static void test_pack_SHFILEOPSTRUCTA(void)
 741 {
 742     /* SHFILEOPSTRUCTA (pack 1) */
 743     TEST_TYPE(SHFILEOPSTRUCTA, 30, 1);
 744     TEST_FIELD(SHFILEOPSTRUCTA, HWND, hwnd, 0, 4, 1);
 745     TEST_FIELD(SHFILEOPSTRUCTA, UINT, wFunc, 4, 4, 1);
 746     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pFrom, 8, 4, 1);
 747     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pTo, 12, 4, 1);
 748     TEST_FIELD(SHFILEOPSTRUCTA, FILEOP_FLAGS, fFlags, 16, 2, 1);
 749     TEST_FIELD(SHFILEOPSTRUCTA, BOOL, fAnyOperationsAborted, 18, 4, 1);
 750     TEST_FIELD(SHFILEOPSTRUCTA, LPVOID, hNameMappings, 22, 4, 1);
 751     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, lpszProgressTitle, 26, 4, 1);
 752 }
 753
 754 static void test_pack_SHFILEOPSTRUCTW(void)
 755 {
 756     /* SHFILEOPSTRUCTW (pack 1) */
 757     TEST_TYPE(SHFILEOPSTRUCTW, 30, 1);
 758     TEST_FIELD(SHFILEOPSTRUCTW, HWND, hwnd, 0, 4, 1);
 759     TEST_FIELD(SHFILEOPSTRUCTW, UINT, wFunc, 4, 4, 1);
 760     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pFrom, 8, 4, 1);
 761     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pTo, 12, 4, 1);
 762     TEST_FIELD(SHFILEOPSTRUCTW, FILEOP_FLAGS, fFlags, 16, 2, 1);
 763     TEST_FIELD(SHFILEOPSTRUCTW, BOOL, fAnyOperationsAborted, 18, 4, 1);
 764     TEST_FIELD(SHFILEOPSTRUCTW, LPVOID, hNameMappings, 22, 4, 1);
 765     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, lpszProgressTitle, 26, 4, 1);
 766 }
 767
 768 static void test_pack_SHNAMEMAPPINGA(void)
 769 {
 770     /* SHNAMEMAPPINGA (pack 1) */
 771     TEST_TYPE(SHNAMEMAPPINGA, 16, 1);
 772     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszOldPath, 0, 4, 1);
 773     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszNewPath, 4, 4, 1);
 774     TEST_FIELD(SHNAMEMAPPINGA, int, cchOldPath, 8, 4, 1);
 775     TEST_FIELD(SHNAMEMAPPINGA, int, cchNewPath, 12, 4, 1);
 776 }
 777
 778 static void test_pack_SHNAMEMAPPINGW(void)
 779 {
 780     /* SHNAMEMAPPINGW (pack 1) */
 781     TEST_TYPE(SHNAMEMAPPINGW, 16, 1);
 782     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszOldPath, 0, 4, 1);
 783     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszNewPath, 4, 4, 1);
 784     TEST_FIELD(SHNAMEMAPPINGW, int, cchOldPath, 8, 4, 1);
 785     TEST_FIELD(SHNAMEMAPPINGW, int, cchNewPath, 12, 4, 1);
 786 }
 787
 788 static void test_pack_ITEMIDLIST(void)
 789 {
 790     /* ITEMIDLIST (pack 1) */
 791     TEST_TYPE(ITEMIDLIST, 3, 1);
 792     TEST_FIELD(ITEMIDLIST, SHITEMID, mkid, 0, 3, 1);
 793 }
 794
 795 static void test_pack_LPCITEMIDLIST(void)
 796 {
 797     /* LPCITEMIDLIST */
 798     TEST_TYPE(LPCITEMIDLIST, 4, 4);
 799     TEST_TYPE_POINTER(LPCITEMIDLIST, 3, 1);
 800 }
 801
 802 static void test_pack_LPCSHITEMID(void)
 803 {
 804     /* LPCSHITEMID */
 805     TEST_TYPE(LPCSHITEMID, 4, 4);
 806     TEST_TYPE_POINTER(LPCSHITEMID, 3, 1);
 807 }
 808
 809 static void test_pack_LPITEMIDLIST(void)
 810 {
 811     /* LPITEMIDLIST */
 812     TEST_TYPE(LPITEMIDLIST, 4, 4);
 813 }
 814
 815 static void test_pack_LPSHELLDETAILS(void)
 816 {
 817     /* LPSHELLDETAILS */
 818     TEST_TYPE(LPSHELLDETAILS, 4, 4);
 819 }
 820
 821 static void test_pack_LPSHITEMID(void)
 822 {
 823     /* LPSHITEMID */
 824     TEST_TYPE(LPSHITEMID, 4, 4);
 825 }
 826
 827 static void test_pack_LPSTRRET(void)
 828 {
 829     /* LPSTRRET */
 830     TEST_TYPE(LPSTRRET, 4, 4);
 831 }
 832
 833 static void test_pack_SHELLDETAILS(void)
 834 {
 835     /* SHELLDETAILS (pack 1) */
 836     TEST_FIELD(SHELLDETAILS, int, fmt, 0, 4, 1);
 837     TEST_FIELD(SHELLDETAILS, int, cxChar, 4, 4, 1);
 838 }
 839
 840 static void test_pack_SHITEMID(void)
 841 {
 842     /* SHITEMID (pack 1) */
 843     TEST_TYPE(SHITEMID, 3, 1);
 844     TEST_FIELD(SHITEMID, WORD, cb, 0, 2, 1);
 845     TEST_FIELD(SHITEMID, BYTE[1], abID, 2, 1, 1);
 846 }
 847
 848 static void test_pack_STRRET(void)
 849 {
 850     /* STRRET (pack 4) */
 851     TEST_FIELD(STRRET, UINT, uType, 0, 4, 4);
 852 }
 853
 854 static void test_pack_AUTO_SCROLL_DATA(void)
 855 {
 856     /* AUTO_SCROLL_DATA (pack 1) */
 857     TEST_TYPE(AUTO_SCROLL_DATA, 48, 1);
 858     TEST_FIELD(AUTO_SCROLL_DATA, int, iNextSample, 0, 4, 1);
 859     TEST_FIELD(AUTO_SCROLL_DATA, DWORD, dwLastScroll, 4, 4, 1);
 860     TEST_FIELD(AUTO_SCROLL_DATA, BOOL, bFull, 8, 4, 1);
 861     TEST_FIELD(AUTO_SCROLL_DATA, POINT[NUM_POINTS], pts, 12, 24, 1);
 862     TEST_FIELD(AUTO_SCROLL_DATA, DWORD[NUM_POINTS], dwTimes, 36, 12, 1);
 863 }
 864
 865 static void test_pack_BFFCALLBACK(void)
 866 {
 867     /* BFFCALLBACK */
 868     TEST_TYPE(BFFCALLBACK, 4, 4);
 869 }
 870
 871 static void test_pack_BROWSEINFOA(void)
 872 {
 873     /* BROWSEINFOA (pack 8) */
 874     TEST_TYPE(BROWSEINFOA, 32, 4);
 875     TEST_FIELD(BROWSEINFOA, HWND, hwndOwner, 0, 4, 4);
 876     TEST_FIELD(BROWSEINFOA, LPCITEMIDLIST, pidlRoot, 4, 4, 4);
 877     TEST_FIELD(BROWSEINFOA, LPSTR, pszDisplayName, 8, 4, 4);
 878     TEST_FIELD(BROWSEINFOA, LPCSTR, lpszTitle, 12, 4, 4);
 879     TEST_FIELD(BROWSEINFOA, UINT, ulFlags, 16, 4, 4);
 880     TEST_FIELD(BROWSEINFOA, BFFCALLBACK, lpfn, 20, 4, 4);
 881     TEST_FIELD(BROWSEINFOA, LPARAM, lParam, 24, 4, 4);
 882     TEST_FIELD(BROWSEINFOA, INT, iImage, 28, 4, 4);
 883 }
 884
 885 static void test_pack_BROWSEINFOW(void)
 886 {
 887     /* BROWSEINFOW (pack 8) */
 888     TEST_TYPE(BROWSEINFOW, 32, 4);
 889     TEST_FIELD(BROWSEINFOW, HWND, hwndOwner, 0, 4, 4);
 890     TEST_FIELD(BROWSEINFOW, LPCITEMIDLIST, pidlRoot, 4, 4, 4);
 891     TEST_FIELD(BROWSEINFOW, LPWSTR, pszDisplayName, 8, 4, 4);
 892     TEST_FIELD(BROWSEINFOW, LPCWSTR, lpszTitle, 12, 4, 4);
 893     TEST_FIELD(BROWSEINFOW, UINT, ulFlags, 16, 4, 4);
 894     TEST_FIELD(BROWSEINFOW, BFFCALLBACK, lpfn, 20, 4, 4);
 895     TEST_FIELD(BROWSEINFOW, LPARAM, lParam, 24, 4, 4);
 896     TEST_FIELD(BROWSEINFOW, INT, iImage, 28, 4, 4);
 897 }
 898
 899 static void test_pack_CABINETSTATE(void)
 900 {
 901     /* CABINETSTATE (pack 1) */
 902     TEST_TYPE(CABINETSTATE, 12, 1);
 903     TEST_FIELD(CABINETSTATE, WORD, cLength, 0, 2, 1);
 904     TEST_FIELD(CABINETSTATE, WORD, nVersion, 2, 2, 1);
 905     TEST_FIELD(CABINETSTATE, UINT, fMenuEnumFilter, 8, 4, 1);
 906 }
 907
 908 static void test_pack_CIDA(void)
 909 {
 910     /* CIDA (pack 1) */
 911     TEST_TYPE(CIDA, 8, 1);
 912     TEST_FIELD(CIDA, UINT, cidl, 0, 4, 1);
 913     TEST_FIELD(CIDA, UINT[1], aoffset, 4, 4, 1);
 914 }
 915
 916 static void test_pack_CSFV(void)
 917 {
 918     /* CSFV (pack 1) */
 919     TEST_FIELD(CSFV, UINT, cbSize, 0, 4, 1);
 920     TEST_FIELD(CSFV, IShellFolder*, pshf, 4, 4, 1);
 921     TEST_FIELD(CSFV, IShellView*, psvOuter, 8, 4, 1);
 922     TEST_FIELD(CSFV, LPCITEMIDLIST, pidl, 12, 4, 1);
 923     TEST_FIELD(CSFV, LONG, lEvents, 16, 4, 1);
 924     TEST_FIELD(CSFV, LPFNVIEWCALLBACK, pfnCallback, 20, 4, 1);
 925 }
 926
 927 static void test_pack_DROPFILES(void)
 928 {
 929     /* DROPFILES (pack 1) */
 930     TEST_TYPE(DROPFILES, 20, 1);
 931     TEST_FIELD(DROPFILES, DWORD, pFiles, 0, 4, 1);
 932     TEST_FIELD(DROPFILES, POINT, pt, 4, 8, 1);
 933     TEST_FIELD(DROPFILES, BOOL, fNC, 12, 4, 1);
 934     TEST_FIELD(DROPFILES, BOOL, fWide, 16, 4, 1);
 935 }
 936
 937 static void test_pack_FILEDESCRIPTORA(void)
 938 {
 939     /* FILEDESCRIPTORA (pack 1) */
 940     TEST_TYPE(FILEDESCRIPTORA, 332, 1);
 941     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFlags, 0, 4, 1);
 942     TEST_FIELD(FILEDESCRIPTORA, CLSID, clsid, 4, 16, 1);
 943     TEST_FIELD(FILEDESCRIPTORA, SIZEL, sizel, 20, 8, 1);
 944     TEST_FIELD(FILEDESCRIPTORA, POINTL, pointl, 28, 8, 1);
 945     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFileAttributes, 36, 4, 1);
 946     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftCreationTime, 40, 8, 1);
 947     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastAccessTime, 48, 8, 1);
 948     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastWriteTime, 56, 8, 1);
 949     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeHigh, 64, 4, 1);
 950     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeLow, 68, 4, 1);
 951     TEST_FIELD(FILEDESCRIPTORA, CHAR[MAX_PATH], cFileName, 72, 260, 1);
 952 }
 953
 954 static void test_pack_FILEDESCRIPTORW(void)
 955 {
 956     /* FILEDESCRIPTORW (pack 1) */
 957     TEST_TYPE(FILEDESCRIPTORW, 592, 1);
 958     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFlags, 0, 4, 1);
 959     TEST_FIELD(FILEDESCRIPTORW, CLSID, clsid, 4, 16, 1);
 960     TEST_FIELD(FILEDESCRIPTORW, SIZEL, sizel, 20, 8, 1);
 961     TEST_FIELD(FILEDESCRIPTORW, POINTL, pointl, 28, 8, 1);
 962     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFileAttributes, 36, 4, 1);
 963     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftCreationTime, 40, 8, 1);
 964     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastAccessTime, 48, 8, 1);
 965     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastWriteTime, 56, 8, 1);
 966     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeHigh, 64, 4, 1);
 967     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeLow, 68, 4, 1);
 968     TEST_FIELD(FILEDESCRIPTORW, WCHAR[MAX_PATH], cFileName, 72, 520, 1);
 969 }
 970
 971 static void test_pack_FILEGROUPDESCRIPTORA(void)
 972 {
 973     /* FILEGROUPDESCRIPTORA (pack 1) */
 974     TEST_TYPE(FILEGROUPDESCRIPTORA, 336, 1);
 975     TEST_FIELD(FILEGROUPDESCRIPTORA, UINT, cItems, 0, 4, 1);
 976     TEST_FIELD(FILEGROUPDESCRIPTORA, FILEDESCRIPTORA[1], fgd, 4, 332, 1);
 977 }
 978
 979 static void test_pack_FILEGROUPDESCRIPTORW(void)
 980 {
 981     /* FILEGROUPDESCRIPTORW (pack 1) */
 982     TEST_TYPE(FILEGROUPDESCRIPTORW, 596, 1);
 983     TEST_FIELD(FILEGROUPDESCRIPTORW, UINT, cItems, 0, 4, 1);
 984     TEST_FIELD(FILEGROUPDESCRIPTORW, FILEDESCRIPTORW[1], fgd, 4, 592, 1);
 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_LPCSFV(void)
1009 {
1010     /* LPCSFV */
1011     TEST_TYPE(LPCSFV, 4, 4);
1012 }
1013
1014 static void test_pack_LPDROPFILES(void)
1015 {
1016     /* LPDROPFILES */
1017     TEST_TYPE(LPDROPFILES, 4, 4);
1018     TEST_TYPE_POINTER(LPDROPFILES, 20, 1);
1019 }
1020
1021 static void test_pack_LPFILEDESCRIPTORA(void)
1022 {
1023     /* LPFILEDESCRIPTORA */
1024     TEST_TYPE(LPFILEDESCRIPTORA, 4, 4);
1025     TEST_TYPE_POINTER(LPFILEDESCRIPTORA, 332, 1);
1026 }
1027
1028 static void test_pack_LPFILEDESCRIPTORW(void)
1029 {
1030     /* LPFILEDESCRIPTORW */
1031     TEST_TYPE(LPFILEDESCRIPTORW, 4, 4);
1032     TEST_TYPE_POINTER(LPFILEDESCRIPTORW, 592, 1);
1033 }
1034
1035 static void test_pack_LPFILEGROUPDESCRIPTORA(void)
1036 {
1037     /* LPFILEGROUPDESCRIPTORA */
1038     TEST_TYPE(LPFILEGROUPDESCRIPTORA, 4, 4);
1039     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORA, 336, 1);
1040 }
1041
1042 static void test_pack_LPFILEGROUPDESCRIPTORW(void)
1043 {
1044     /* LPFILEGROUPDESCRIPTORW */
1045     TEST_TYPE(LPFILEGROUPDESCRIPTORW, 4, 4);
1046     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORW, 596, 1);
1047 }
1048
1049 static void test_pack_LPFNVIEWCALLBACK(void)
1050 {
1051     /* LPFNVIEWCALLBACK */
1052     TEST_TYPE(LPFNVIEWCALLBACK, 4, 4);
1053 }
1054
1055 static void test_pack_LPIDA(void)
1056 {
1057     /* LPIDA */
1058     TEST_TYPE(LPIDA, 4, 4);
1059     TEST_TYPE_POINTER(LPIDA, 8, 1);
1060 }
1061
1062 static void test_pack_LPQCMINFO(void)
1063 {
1064     /* LPQCMINFO */
1065     TEST_TYPE(LPQCMINFO, 4, 4);
1066     TEST_TYPE_POINTER(LPQCMINFO, 20, 4);
1067 }
1068
1069 static void test_pack_LPSHChangeDWORDAsIDList(void)
1070 {
1071     /* LPSHChangeDWORDAsIDList */
1072     TEST_TYPE(LPSHChangeDWORDAsIDList, 4, 4);
1073     TEST_TYPE_POINTER(LPSHChangeDWORDAsIDList, 12, 1);
1074 }
1075
1076 static void test_pack_LPSHChangeProductKeyAsIDList(void)
1077 {
1078     /* LPSHChangeProductKeyAsIDList */
1079     TEST_TYPE(LPSHChangeProductKeyAsIDList, 4, 4);
1080     TEST_TYPE_POINTER(LPSHChangeProductKeyAsIDList, 82, 1);
1081 }
1082
1083 static void test_pack_LPSHDESCRIPTIONID(void)
1084 {
1085     /* LPSHDESCRIPTIONID */
1086     TEST_TYPE(LPSHDESCRIPTIONID, 4, 4);
1087     TEST_TYPE_POINTER(LPSHDESCRIPTIONID, 20, 4);
1088 }
1089
1090 static void test_pack_LPSHELLFLAGSTATE(void)
1091 {
1092     /* LPSHELLFLAGSTATE */
1093     TEST_TYPE(LPSHELLFLAGSTATE, 4, 4);
1094     TEST_TYPE_POINTER(LPSHELLFLAGSTATE, 4, 1);
1095 }
1096
1097 static void test_pack_LPSHELLSTATE(void)
1098 {
1099     /* LPSHELLSTATE */
1100     TEST_TYPE(LPSHELLSTATE, 4, 4);
1101     TEST_TYPE_POINTER(LPSHELLSTATE, 32, 1);
1102 }
1103
1104 static void test_pack_LPTBINFO(void)
1105 {
1106     /* LPTBINFO */
1107     TEST_TYPE(LPTBINFO, 4, 4);
1108     TEST_TYPE_POINTER(LPTBINFO, 8, 4);
1109 }
1110
1111 static void test_pack_PBROWSEINFOA(void)
1112 {
1113     /* PBROWSEINFOA */
1114     TEST_TYPE(PBROWSEINFOA, 4, 4);
1115     TEST_TYPE_POINTER(PBROWSEINFOA, 32, 4);
1116 }
1117
1118 static void test_pack_PBROWSEINFOW(void)
1119 {
1120     /* PBROWSEINFOW */
1121     TEST_TYPE(PBROWSEINFOW, 4, 4);
1122     TEST_TYPE_POINTER(PBROWSEINFOW, 32, 4);
1123 }
1124
1125 static void test_pack_QCMINFO(void)
1126 {
1127     /* QCMINFO (pack 8) */
1128     TEST_TYPE(QCMINFO, 20, 4);
1129     TEST_FIELD(QCMINFO, HMENU, hmenu, 0, 4, 4);
1130     TEST_FIELD(QCMINFO, UINT, indexMenu, 4, 4, 4);
1131     TEST_FIELD(QCMINFO, UINT, idCmdFirst, 8, 4, 4);
1132     TEST_FIELD(QCMINFO, UINT, idCmdLast, 12, 4, 4);
1133     TEST_FIELD(QCMINFO, QCMINFO_IDMAP const*, pIdMap, 16, 4, 4);
1134 }
1135
1136 static void test_pack_QCMINFO_IDMAP(void)
1137 {
1138     /* QCMINFO_IDMAP (pack 8) */
1139     TEST_TYPE(QCMINFO_IDMAP, 12, 4);
1140     TEST_FIELD(QCMINFO_IDMAP, UINT, nMaxIds, 0, 4, 4);
1141     TEST_FIELD(QCMINFO_IDMAP, QCMINFO_IDMAP_PLACEMENT[1], pIdList, 4, 8, 4);
1142 }
1143
1144 static void test_pack_QCMINFO_IDMAP_PLACEMENT(void)
1145 {
1146     /* QCMINFO_IDMAP_PLACEMENT (pack 8) */
1147     TEST_TYPE(QCMINFO_IDMAP_PLACEMENT, 8, 4);
1148     TEST_FIELD(QCMINFO_IDMAP_PLACEMENT, UINT, id, 0, 4, 4);
1149     TEST_FIELD(QCMINFO_IDMAP_PLACEMENT, UINT, fFlags, 4, 4, 4);
1150 }
1151
1152 static void test_pack_SHChangeDWORDAsIDList(void)
1153 {
1154     /* SHChangeDWORDAsIDList (pack 1) */
1155     TEST_TYPE(SHChangeDWORDAsIDList, 12, 1);
1156     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cb, 0, 2, 1);
1157     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem1, 2, 4, 1);
1158     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem2, 6, 4, 1);
1159     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cbZero, 10, 2, 1);
1160 }
1161
1162 static void test_pack_SHChangeNotifyEntry(void)
1163 {
1164     /* SHChangeNotifyEntry (pack 1) */
1165     TEST_TYPE(SHChangeNotifyEntry, 8, 1);
1166     TEST_FIELD(SHChangeNotifyEntry, LPCITEMIDLIST, pidl, 0, 4, 1);
1167     TEST_FIELD(SHChangeNotifyEntry, BOOL, fRecursive, 4, 4, 1);
1168 }
1169
1170 static void test_pack_SHChangeProductKeyAsIDList(void)
1171 {
1172     /* SHChangeProductKeyAsIDList (pack 1) */
1173     TEST_TYPE(SHChangeProductKeyAsIDList, 82, 1);
1174     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cb, 0, 2, 1);
1175     TEST_FIELD(SHChangeProductKeyAsIDList, WCHAR[39], wszProductKey, 2, 78, 1);
1176     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cbZero, 80, 2, 1);
1177 }
1178
1179 static void test_pack_SHDESCRIPTIONID(void)
1180 {
1181     /* SHDESCRIPTIONID (pack 8) */
1182     TEST_TYPE(SHDESCRIPTIONID, 20, 4);
1183     TEST_FIELD(SHDESCRIPTIONID, DWORD, dwDescriptionId, 0, 4, 4);
1184     TEST_FIELD(SHDESCRIPTIONID, CLSID, clsid, 4, 16, 4);
1185 }
1186
1187 static void test_pack_SHELLFLAGSTATE(void)
1188 {
1189     /* SHELLFLAGSTATE (pack 1) */
1190     TEST_TYPE(SHELLFLAGSTATE, 4, 1);
1191 }
1192
1193 static void test_pack_SHELLSTATE(void)
1194 {
1195     /* SHELLSTATE (pack 1) */
1196     TEST_TYPE(SHELLSTATE, 32, 1);
1197     TEST_FIELD(SHELLSTATE, DWORD, dwWin95Unused, 4, 4, 1);
1198     TEST_FIELD(SHELLSTATE, UINT, uWin95Unused, 8, 4, 1);
1199     TEST_FIELD(SHELLSTATE, LONG, lParamSort, 12, 4, 1);
1200     TEST_FIELD(SHELLSTATE, int, iSortDirection, 16, 4, 1);
1201     TEST_FIELD(SHELLSTATE, UINT, version, 20, 4, 1);
1202     TEST_FIELD(SHELLSTATE, UINT, uNotUsed, 24, 4, 1);
1203 }
1204
1205 static void test_pack_TBINFO(void)
1206 {
1207     /* TBINFO (pack 8) */
1208     TEST_TYPE(TBINFO, 8, 4);
1209     TEST_FIELD(TBINFO, UINT, cbuttons, 0, 4, 4);
1210     TEST_FIELD(TBINFO, UINT, uFlags, 4, 4, 4);
1211 }
1212
1213 static void test_pack(void)
1214 {
1215     test_pack_APPBARDATA();
1216     test_pack_AUTO_SCROLL_DATA();
1217     test_pack_BFFCALLBACK();
1218     test_pack_BLOB();
1219     test_pack_BROWSEINFOA();
1220     test_pack_BROWSEINFOW();
1221     test_pack_BSTR();
1222     test_pack_BSTRBLOB();
1223     test_pack_BYTE_BLOB();
1224     test_pack_BYTE_SIZEDARR();
1225     test_pack_CABINETSTATE();
1226     test_pack_CIDA();
1227     test_pack_CLIPDATA();
1228     test_pack_CLIPFORMAT();
1229     test_pack_CLSID();
1230     test_pack_COAUTHIDENTITY();
1231     test_pack_COAUTHINFO();
1232     test_pack_CSFV();
1233     test_pack_DATE();
1234     test_pack_DOUBLE();
1235     test_pack_DRAGINFOA();
1236     test_pack_DRAGINFOW();
1237     test_pack_DROPFILES();
1238     test_pack_DWORD_SIZEDARR();
1239     test_pack_FILEDESCRIPTORA();
1240     test_pack_FILEDESCRIPTORW();
1241     test_pack_FILEGROUPDESCRIPTORA();
1242     test_pack_FILEGROUPDESCRIPTORW();
1243     test_pack_FILEOP_FLAGS();
1244     test_pack_FLAGGED_BYTE_BLOB();
1245     test_pack_FLAGGED_WORD_BLOB();
1246     test_pack_FMTID();
1247     test_pack_HMETAFILEPICT();
1248     test_pack_HYPER_SIZEDARR();
1249     test_pack_IID();
1250     test_pack_ITEMIDLIST();
1251     test_pack_LPBLOB();
1252     test_pack_LPBROWSEINFOA();
1253     test_pack_LPBROWSEINFOW();
1254     test_pack_LPBSTR();
1255     test_pack_LPBSTRBLOB();
1256     test_pack_LPCABINETSTATE();
1257     test_pack_LPCITEMIDLIST();
1258     test_pack_LPCOLESTR();
1259     test_pack_LPCSFV();
1260     test_pack_LPCSHITEMID();
1261     test_pack_LPCY();
1262     test_pack_LPDECIMAL();
1263     test_pack_LPDRAGINFOA();
1264     test_pack_LPDRAGINFOW();
1265     test_pack_LPDROPFILES();
1266     test_pack_LPFILEDESCRIPTORA();
1267     test_pack_LPFILEDESCRIPTORW();
1268     test_pack_LPFILEGROUPDESCRIPTORA();
1269     test_pack_LPFILEGROUPDESCRIPTORW();
1270     test_pack_LPFNVIEWCALLBACK();
1271     test_pack_LPIDA();
1272     test_pack_LPITEMIDLIST();
1273     test_pack_LPOLESTR();
1274     test_pack_LPQCMINFO();
1275     test_pack_LPSHChangeDWORDAsIDList();
1276     test_pack_LPSHChangeProductKeyAsIDList();
1277     test_pack_LPSHDESCRIPTIONID();
1278     test_pack_LPSHELLDETAILS();
1279     test_pack_LPSHELLEXECUTEINFOA();
1280     test_pack_LPSHELLEXECUTEINFOW();
1281     test_pack_LPSHELLFLAGSTATE();
1282     test_pack_LPSHELLSTATE();
1283     test_pack_LPSHFILEOPSTRUCTA();
1284     test_pack_LPSHFILEOPSTRUCTW();
1285     test_pack_LPSHITEMID();
1286     test_pack_LPSHNAMEMAPPINGA();
1287     test_pack_LPSHNAMEMAPPINGW();
1288     test_pack_LPSTRRET();
1289     test_pack_LPTBINFO();
1290     test_pack_NOTIFYICONDATAA();
1291     test_pack_NOTIFYICONDATAW();
1292     test_pack_OLECHAR();
1293     test_pack_PAPPBARDATA();
1294     test_pack_PBROWSEINFOA();
1295     test_pack_PBROWSEINFOW();
1296     test_pack_PNOTIFYICONDATAA();
1297     test_pack_PNOTIFYICONDATAW();
1298     test_pack_PRINTEROP_FLAGS();
1299     test_pack_PROPID();
1300     test_pack_QCMINFO();
1301     test_pack_QCMINFO_IDMAP();
1302     test_pack_QCMINFO_IDMAP_PLACEMENT();
1303     test_pack_RemHBITMAP();
1304     test_pack_RemHENHMETAFILE();
1305     test_pack_RemHGLOBAL();
1306     test_pack_RemHMETAFILEPICT();
1307     test_pack_RemHPALETTE();
1308     test_pack_SCODE();
1309     test_pack_SHChangeDWORDAsIDList();
1310     test_pack_SHChangeNotifyEntry();
1311     test_pack_SHChangeProductKeyAsIDList();
1312     test_pack_SHDESCRIPTIONID();
1313     test_pack_SHELLDETAILS();
1314     test_pack_SHELLEXECUTEINFOA();
1315     test_pack_SHELLEXECUTEINFOW();
1316     test_pack_SHELLFLAGSTATE();
1317     test_pack_SHELLSTATE();
1318     test_pack_SHFILEINFOA();
1319     test_pack_SHFILEINFOW();
1320     test_pack_SHFILEOPSTRUCTA();
1321     test_pack_SHFILEOPSTRUCTW();
1322     test_pack_SHITEMID();
1323     test_pack_SHNAMEMAPPINGA();
1324     test_pack_SHNAMEMAPPINGW();
1325     test_pack_STRRET();
1326     test_pack_TBINFO();
1327     test_pack_UP_BYTE_BLOB();
1328     test_pack_UP_FLAGGED_BYTE_BLOB();
1329     test_pack_UP_FLAGGED_WORD_BLOB();
1330     test_pack_VARIANT_BOOL();
1331     test_pack_VARTYPE();
1332     test_pack_WORD_SIZEDARR();
1333     test_pack_remoteMETAFILEPICT();
1334     test_pack_userBITMAP();
1335     test_pack_userCLIPFORMAT();
1336     test_pack_userHBITMAP();
1337     test_pack_userHENHMETAFILE();
1338     test_pack_userHGLOBAL();
1339     test_pack_userHMETAFILE();
1340     test_pack_userHMETAFILEPICT();
1341     test_pack_userHPALETTE();
1342     test_pack_wireBSTR();
1343     test_pack_wireCLIPFORMAT();
1344     test_pack_wireHBITMAP();
1345     test_pack_wireHENHMETAFILE();
1346     test_pack_wireHGLOBAL();
1347     test_pack_wireHMETAFILE();
1348     test_pack_wireHMETAFILEPICT();
1349     test_pack_wireHPALETTE();
1350 }
1351
1352 START_TEST(generated)
1353 {
1354     test_pack();
1355 }