dlls/ntdll/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 "ntdll_test.h"
  15
  16 #include "wine/test.h"
  17
  18 /***********************************************************************
  19  * Compability macros
  20  */
  21
  22 #define DWORD_PTR UINT_PTR
  23 #define LONG_PTR INT_PTR
  24 #define ULONG_PTR UINT_PTR
  25
  26 /***********************************************************************
  27  * Windows API extension
  28  */
  29
  30 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
  31 # define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
  32 #elif defined(__GNUC__)
  33 # define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
  34 #else
  35 /* FIXME: Not sure if is possible to do without compiler extension */
  36 #endif
  37
  38 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
  39 # define _TYPE_ALIGNMENT(type) __alignof(type)
  40 #elif defined(__GNUC__)
  41 # define _TYPE_ALIGNMENT(type) __alignof__(type)
  42 #else
  43 /*
  44  * FIXME: Not sure if is possible to do without compiler extension
  45  *        (if type is not just a name that is, if so the normal)
  46  *         TYPE_ALIGNMENT can be used)
  47  */
  48 #endif
  49
  50 #if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)
  51 #pragma warning(disable:4116)
  52 #endif
  53
  54 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
  55 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
  56 #endif
  57
  58 /***********************************************************************
  59  * Test helper macros
  60  */
  61
  62 #ifdef FIELD_ALIGNMENT
  63 # define TEST_FIELD_ALIGNMENT(type, field, align) \
  64    ok(FIELD_ALIGNMENT(type, field) == align, \
  65        "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")\n", \
  66            (int)FIELD_ALIGNMENT(type, field))
  67 #else
  68 # define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
  69 #endif
  70
  71 #define TEST_FIELD_OFFSET(type, field, offset) \
  72     ok(FIELD_OFFSET(type, field) == offset, \
  73         "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")\n", \
  74              (long int)FIELD_OFFSET(type, field))
  75
  76 #ifdef _TYPE_ALIGNMENT
  77 #define TEST__TYPE_ALIGNMENT(type, align) \
  78     ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)_TYPE_ALIGNMENT(type))
  79 #else
  80 # define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
  81 #endif
  82
  83 #ifdef TYPE_ALIGNMENT
  84 #define TEST_TYPE_ALIGNMENT(type, align) \
  85     ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)TYPE_ALIGNMENT(type))
  86 #else
  87 # define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
  88 #endif
  89
  90 #define TEST_TYPE_SIZE(type, size) \
  91     ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")\n", ((int) sizeof(type)))
  92
  93 /***********************************************************************
  94  * Test macros
  95  */
  96
  97 #define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
  98   TEST_TYPE_SIZE(field_type, field_size); \
  99   TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
 100   TEST_FIELD_OFFSET(type, field_name, field_offset); \
 101
 102 #define TEST_TYPE(type, size, align) \
 103   TEST_TYPE_ALIGNMENT(type, align); \
 104   TEST_TYPE_SIZE(type, size)
 105
 106 #define TEST_TYPE_POINTER(type, size, align) \
 107     TEST__TYPE_ALIGNMENT(*(type)0, align); \
 108     TEST_TYPE_SIZE(*(type)0, size)
 109
 110 #define TEST_TYPE_SIGNED(type) \
 111     ok((type) -1 < 0, "(" #type ") -1 < 0\n");
 112
 113 #define TEST_TYPE_UNSIGNED(type) \
 114      ok((type) -1 > 0, "(" #type ") -1 > 0\n");
 115
 116 static void test_pack_DWORD32(void)
 117 {
 118     /* DWORD32 */
 119     TEST_TYPE(DWORD32, 4, 4);
 120     TEST_TYPE_UNSIGNED(DWORD32);
 121 }
 122
 123 static void test_pack_DWORD64(void)
 124 {
 125     /* DWORD64 */
 126     TEST_TYPE(DWORD64, 8, 8);
 127     TEST_TYPE_UNSIGNED(DWORD64);
 128 }
 129
 130 static void test_pack_DWORD_PTR(void)
 131 {
 132     /* DWORD_PTR */
 133     TEST_TYPE(DWORD_PTR, 4, 4);
 134 }
 135
 136 static void test_pack_HALF_PTR(void)
 137 {
 138     /* HALF_PTR */
 139     TEST_TYPE(HALF_PTR, 2, 2);
 140     TEST_TYPE_SIGNED(HALF_PTR);
 141 }
 142
 143 static void test_pack_INT16(void)
 144 {
 145     /* INT16 */
 146     TEST_TYPE(INT16, 2, 2);
 147     TEST_TYPE_SIGNED(INT16);
 148 }
 149
 150 static void test_pack_INT32(void)
 151 {
 152     /* INT32 */
 153     TEST_TYPE(INT32, 4, 4);
 154     TEST_TYPE_SIGNED(INT32);
 155 }
 156
 157 static void test_pack_INT64(void)
 158 {
 159     /* INT64 */
 160     TEST_TYPE(INT64, 8, 8);
 161     TEST_TYPE_SIGNED(INT64);
 162 }
 163
 164 static void test_pack_INT8(void)
 165 {
 166     /* INT8 */
 167     TEST_TYPE(INT8, 1, 1);
 168     TEST_TYPE_SIGNED(INT8);
 169 }
 170
 171 static void test_pack_INT_PTR(void)
 172 {
 173     /* INT_PTR */
 174     TEST_TYPE(INT_PTR, 4, 4);
 175     TEST_TYPE_SIGNED(INT_PTR);
 176 }
 177
 178 static void test_pack_LONG32(void)
 179 {
 180     /* LONG32 */
 181     TEST_TYPE(LONG32, 4, 4);
 182     TEST_TYPE_SIGNED(LONG32);
 183 }
 184
 185 static void test_pack_LONG64(void)
 186 {
 187     /* LONG64 */
 188     TEST_TYPE(LONG64, 8, 8);
 189     TEST_TYPE_SIGNED(LONG64);
 190 }
 191
 192 static void test_pack_LONG_PTR(void)
 193 {
 194     /* LONG_PTR */
 195     TEST_TYPE(LONG_PTR, 4, 4);
 196     TEST_TYPE_SIGNED(LONG_PTR);
 197 }
 198
 199 static void test_pack_SIZE_T(void)
 200 {
 201     /* SIZE_T */
 202     TEST_TYPE(SIZE_T, 4, 4);
 203 }
 204
 205 static void test_pack_SSIZE_T(void)
 206 {
 207     /* SSIZE_T */
 208     TEST_TYPE(SSIZE_T, 4, 4);
 209 }
 210
 211 static void test_pack_UHALF_PTR(void)
 212 {
 213     /* UHALF_PTR */
 214     TEST_TYPE(UHALF_PTR, 2, 2);
 215     TEST_TYPE_UNSIGNED(UHALF_PTR);
 216 }
 217
 218 static void test_pack_UINT16(void)
 219 {
 220     /* UINT16 */
 221     TEST_TYPE(UINT16, 2, 2);
 222     TEST_TYPE_UNSIGNED(UINT16);
 223 }
 224
 225 static void test_pack_UINT32(void)
 226 {
 227     /* UINT32 */
 228     TEST_TYPE(UINT32, 4, 4);
 229     TEST_TYPE_UNSIGNED(UINT32);
 230 }
 231
 232 static void test_pack_UINT64(void)
 233 {
 234     /* UINT64 */
 235     TEST_TYPE(UINT64, 8, 8);
 236     TEST_TYPE_UNSIGNED(UINT64);
 237 }
 238
 239 static void test_pack_UINT8(void)
 240 {
 241     /* UINT8 */
 242     TEST_TYPE(UINT8, 1, 1);
 243     TEST_TYPE_UNSIGNED(UINT8);
 244 }
 245
 246 static void test_pack_UINT_PTR(void)
 247 {
 248     /* UINT_PTR */
 249     TEST_TYPE(UINT_PTR, 4, 4);
 250     TEST_TYPE_UNSIGNED(UINT_PTR);
 251 }
 252
 253 static void test_pack_ULONG32(void)
 254 {
 255     /* ULONG32 */
 256     TEST_TYPE(ULONG32, 4, 4);
 257     TEST_TYPE_UNSIGNED(ULONG32);
 258 }
 259
 260 static void test_pack_ULONG64(void)
 261 {
 262     /* ULONG64 */
 263     TEST_TYPE(ULONG64, 8, 8);
 264     TEST_TYPE_UNSIGNED(ULONG64);
 265 }
 266
 267 static void test_pack_ULONG_PTR(void)
 268 {
 269     /* ULONG_PTR */
 270     TEST_TYPE(ULONG_PTR, 4, 4);
 271     TEST_TYPE_UNSIGNED(ULONG_PTR);
 272 }
 273
 274 static void test_pack_ACCESS_ALLOWED_ACE(void)
 275 {
 276     /* ACCESS_ALLOWED_ACE (pack 4) */
 277     TEST_TYPE(ACCESS_ALLOWED_ACE, 12, 4);
 278     TEST_FIELD(ACCESS_ALLOWED_ACE, ACE_HEADER, Header, 0, 4, 2);
 279     TEST_FIELD(ACCESS_ALLOWED_ACE, DWORD, Mask, 4, 4, 4);
 280     TEST_FIELD(ACCESS_ALLOWED_ACE, DWORD, SidStart, 8, 4, 4);
 281 }
 282
 283 static void test_pack_ACCESS_DENIED_ACE(void)
 284 {
 285     /* ACCESS_DENIED_ACE (pack 4) */
 286     TEST_TYPE(ACCESS_DENIED_ACE, 12, 4);
 287     TEST_FIELD(ACCESS_DENIED_ACE, ACE_HEADER, Header, 0, 4, 2);
 288     TEST_FIELD(ACCESS_DENIED_ACE, DWORD, Mask, 4, 4, 4);
 289     TEST_FIELD(ACCESS_DENIED_ACE, DWORD, SidStart, 8, 4, 4);
 290 }
 291
 292 static void test_pack_ACCESS_MASK(void)
 293 {
 294     /* ACCESS_MASK */
 295     TEST_TYPE(ACCESS_MASK, 4, 4);
 296     TEST_TYPE_UNSIGNED(ACCESS_MASK);
 297 }
 298
 299 static void test_pack_ACE_HEADER(void)
 300 {
 301     /* ACE_HEADER (pack 4) */
 302     TEST_TYPE(ACE_HEADER, 4, 2);
 303     TEST_FIELD(ACE_HEADER, BYTE, AceType, 0, 1, 1);
 304     TEST_FIELD(ACE_HEADER, BYTE, AceFlags, 1, 1, 1);
 305     TEST_FIELD(ACE_HEADER, WORD, AceSize, 2, 2, 2);
 306 }
 307
 308 static void test_pack_ACL(void)
 309 {
 310     /* ACL (pack 4) */
 311     TEST_TYPE(ACL, 8, 2);
 312     TEST_FIELD(ACL, BYTE, AclRevision, 0, 1, 1);
 313     TEST_FIELD(ACL, BYTE, Sbz1, 1, 1, 1);
 314     TEST_FIELD(ACL, WORD, AclSize, 2, 2, 2);
 315     TEST_FIELD(ACL, WORD, AceCount, 4, 2, 2);
 316     TEST_FIELD(ACL, WORD, Sbz2, 6, 2, 2);
 317 }
 318
 319 static void test_pack_ACL_REVISION_INFORMATION(void)
 320 {
 321     /* ACL_REVISION_INFORMATION (pack 4) */
 322     TEST_TYPE(ACL_REVISION_INFORMATION, 4, 4);
 323     TEST_FIELD(ACL_REVISION_INFORMATION, DWORD, AclRevision, 0, 4, 4);
 324 }
 325
 326 static void test_pack_ACL_SIZE_INFORMATION(void)
 327 {
 328     /* ACL_SIZE_INFORMATION (pack 4) */
 329     TEST_TYPE(ACL_SIZE_INFORMATION, 12, 4);
 330     TEST_FIELD(ACL_SIZE_INFORMATION, DWORD, AceCount, 0, 4, 4);
 331     TEST_FIELD(ACL_SIZE_INFORMATION, DWORD, AclBytesInUse, 4, 4, 4);
 332     TEST_FIELD(ACL_SIZE_INFORMATION, DWORD, AclBytesFree, 8, 4, 4);
 333 }
 334
 335 static void test_pack_BOOLEAN(void)
 336 {
 337     /* BOOLEAN */
 338     TEST_TYPE(BOOLEAN, 1, 1);
 339     TEST_TYPE_UNSIGNED(BOOLEAN);
 340 }
 341
 342 static void test_pack_CCHAR(void)
 343 {
 344     /* CCHAR */
 345     TEST_TYPE(CCHAR, 1, 1);
 346     TEST_TYPE_SIGNED(CCHAR);
 347 }
 348
 349 static void test_pack_CHAR(void)
 350 {
 351     /* CHAR */
 352     TEST_TYPE(CHAR, 1, 1);
 353     TEST_TYPE_SIGNED(CHAR);
 354 }
 355
 356 static void test_pack_DWORDLONG(void)
 357 {
 358     /* DWORDLONG */
 359     TEST_TYPE(DWORDLONG, 8, 8);
 360     TEST_TYPE_UNSIGNED(DWORDLONG);
 361 }
 362
 363 static void test_pack_EXCEPTION_POINTERS(void)
 364 {
 365     /* EXCEPTION_POINTERS (pack 4) */
 366     TEST_TYPE(EXCEPTION_POINTERS, 8, 4);
 367     TEST_FIELD(EXCEPTION_POINTERS, PEXCEPTION_RECORD, ExceptionRecord, 0, 4, 4);
 368     TEST_FIELD(EXCEPTION_POINTERS, PCONTEXT, ContextRecord, 4, 4, 4);
 369 }
 370
 371 static void test_pack_EXCEPTION_RECORD(void)
 372 {
 373     /* EXCEPTION_RECORD (pack 4) */
 374     TEST_TYPE(EXCEPTION_RECORD, 80, 4);
 375     TEST_FIELD(EXCEPTION_RECORD, DWORD, ExceptionCode, 0, 4, 4);
 376     TEST_FIELD(EXCEPTION_RECORD, DWORD, ExceptionFlags, 4, 4, 4);
 377     TEST_FIELD(EXCEPTION_RECORD, struct _EXCEPTION_RECORD *, ExceptionRecord, 8, 4, 4);
 378     TEST_FIELD(EXCEPTION_RECORD, PVOID, ExceptionAddress, 12, 4, 4);
 379     TEST_FIELD(EXCEPTION_RECORD, DWORD, NumberParameters, 16, 4, 4);
 380     TEST_FIELD(EXCEPTION_RECORD, ULONG_PTR[EXCEPTION_MAXIMUM_PARAMETERS], ExceptionInformation, 20, 60, 4);
 381 }
 382
 383 static void test_pack_EXECUTION_STATE(void)
 384 {
 385     /* EXECUTION_STATE */
 386     TEST_TYPE(EXECUTION_STATE, 4, 4);
 387     TEST_TYPE_UNSIGNED(EXECUTION_STATE);
 388 }
 389
 390 static void test_pack_FLOATING_SAVE_AREA(void)
 391 {
 392     /* FLOATING_SAVE_AREA (pack 4) */
 393     TEST_TYPE(FLOATING_SAVE_AREA, 112, 4);
 394     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, ControlWord, 0, 4, 4);
 395     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, StatusWord, 4, 4, 4);
 396     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, TagWord, 8, 4, 4);
 397     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, ErrorOffset, 12, 4, 4);
 398     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, ErrorSelector, 16, 4, 4);
 399     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, DataOffset, 20, 4, 4);
 400     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, DataSelector, 24, 4, 4);
 401     TEST_FIELD(FLOATING_SAVE_AREA, BYTE[SIZE_OF_80387_REGISTERS], RegisterArea, 28, 80, 1);
 402     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, Cr0NpxState, 108, 4, 4);
 403 }
 404
 405 static void test_pack_FPO_DATA(void)
 406 {
 407     /* FPO_DATA (pack 4) */
 408     TEST_TYPE(FPO_DATA, 16, 4);
 409     TEST_FIELD(FPO_DATA, DWORD, ulOffStart, 0, 4, 4);
 410     TEST_FIELD(FPO_DATA, DWORD, cbProcSize, 4, 4, 4);
 411     TEST_FIELD(FPO_DATA, DWORD, cdwLocals, 8, 4, 4);
 412     TEST_FIELD(FPO_DATA, WORD, cdwParams, 12, 2, 2);
 413 }
 414
 415 static void test_pack_GENERIC_MAPPING(void)
 416 {
 417     /* GENERIC_MAPPING (pack 4) */
 418     TEST_TYPE(GENERIC_MAPPING, 16, 4);
 419     TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericRead, 0, 4, 4);
 420     TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericWrite, 4, 4, 4);
 421     TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericExecute, 8, 4, 4);
 422     TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericAll, 12, 4, 4);
 423 }
 424
 425 static void test_pack_HANDLE(void)
 426 {
 427     /* HANDLE */
 428     TEST_TYPE(HANDLE, 4, 4);
 429 }
 430
 431 static void test_pack_HRESULT(void)
 432 {
 433     /* HRESULT */
 434     TEST_TYPE(HRESULT, 4, 4);
 435 }
 436
 437 static void test_pack_IMAGE_ARCHIVE_MEMBER_HEADER(void)
 438 {
 439     /* IMAGE_ARCHIVE_MEMBER_HEADER (pack 4) */
 440     TEST_TYPE(IMAGE_ARCHIVE_MEMBER_HEADER, 60, 1);
 441     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[16], Name, 0, 16, 1);
 442     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[12], Date, 16, 12, 1);
 443     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[6], UserID, 28, 6, 1);
 444     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[6], GroupID, 34, 6, 1);
 445     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[8], Mode, 40, 8, 1);
 446     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[10], Size, 48, 10, 1);
 447     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[2], EndHeader, 58, 2, 1);
 448 }
 449
 450 static void test_pack_IMAGE_AUX_SYMBOL(void)
 451 {
 452     /* IMAGE_AUX_SYMBOL (pack 2) */
 453 }
 454
 455 static void test_pack_IMAGE_BASE_RELOCATION(void)
 456 {
 457     /* IMAGE_BASE_RELOCATION (pack 4) */
 458     TEST_TYPE(IMAGE_BASE_RELOCATION, 8, 4);
 459     TEST_FIELD(IMAGE_BASE_RELOCATION, DWORD, VirtualAddress, 0, 4, 4);
 460     TEST_FIELD(IMAGE_BASE_RELOCATION, DWORD, SizeOfBlock, 4, 4, 4);
 461 }
 462
 463 static void test_pack_IMAGE_BOUND_FORWARDER_REF(void)
 464 {
 465     /* IMAGE_BOUND_FORWARDER_REF (pack 4) */
 466     TEST_TYPE(IMAGE_BOUND_FORWARDER_REF, 8, 4);
 467     TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, DWORD, TimeDateStamp, 0, 4, 4);
 468     TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, WORD, OffsetModuleName, 4, 2, 2);
 469     TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, WORD, Reserved, 6, 2, 2);
 470 }
 471
 472 static void test_pack_IMAGE_BOUND_IMPORT_DESCRIPTOR(void)
 473 {
 474     /* IMAGE_BOUND_IMPORT_DESCRIPTOR (pack 4) */
 475     TEST_TYPE(IMAGE_BOUND_IMPORT_DESCRIPTOR, 8, 4);
 476     TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, DWORD, TimeDateStamp, 0, 4, 4);
 477     TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, WORD, OffsetModuleName, 4, 2, 2);
 478     TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, WORD, NumberOfModuleForwarderRefs, 6, 2, 2);
 479 }
 480
 481 static void test_pack_IMAGE_COFF_SYMBOLS_HEADER(void)
 482 {
 483     /* IMAGE_COFF_SYMBOLS_HEADER (pack 4) */
 484     TEST_TYPE(IMAGE_COFF_SYMBOLS_HEADER, 32, 4);
 485     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, NumberOfSymbols, 0, 4, 4);
 486     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, LvaToFirstSymbol, 4, 4, 4);
 487     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, NumberOfLinenumbers, 8, 4, 4);
 488     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, LvaToFirstLinenumber, 12, 4, 4);
 489     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToFirstByteOfCode, 16, 4, 4);
 490     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToLastByteOfCode, 20, 4, 4);
 491     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToFirstByteOfData, 24, 4, 4);
 492     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToLastByteOfData, 28, 4, 4);
 493 }
 494
 495 static void test_pack_IMAGE_DATA_DIRECTORY(void)
 496 {
 497     /* IMAGE_DATA_DIRECTORY (pack 4) */
 498     TEST_TYPE(IMAGE_DATA_DIRECTORY, 8, 4);
 499     TEST_FIELD(IMAGE_DATA_DIRECTORY, DWORD, VirtualAddress, 0, 4, 4);
 500     TEST_FIELD(IMAGE_DATA_DIRECTORY, DWORD, Size, 4, 4, 4);
 501 }
 502
 503 static void test_pack_IMAGE_DEBUG_DIRECTORY(void)
 504 {
 505     /* IMAGE_DEBUG_DIRECTORY (pack 4) */
 506     TEST_TYPE(IMAGE_DEBUG_DIRECTORY, 28, 4);
 507     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
 508     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
 509     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
 510     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
 511     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, Type, 12, 4, 4);
 512     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, SizeOfData, 16, 4, 4);
 513     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, AddressOfRawData, 20, 4, 4);
 514     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, PointerToRawData, 24, 4, 4);
 515 }
 516
 517 static void test_pack_IMAGE_DEBUG_MISC(void)
 518 {
 519     /* IMAGE_DEBUG_MISC (pack 4) */
 520     TEST_TYPE(IMAGE_DEBUG_MISC, 16, 4);
 521     TEST_FIELD(IMAGE_DEBUG_MISC, DWORD, DataType, 0, 4, 4);
 522     TEST_FIELD(IMAGE_DEBUG_MISC, DWORD, Length, 4, 4, 4);
 523     TEST_FIELD(IMAGE_DEBUG_MISC, BYTE, Unicode, 8, 1, 1);
 524     TEST_FIELD(IMAGE_DEBUG_MISC, BYTE[ 3 ], Reserved, 9, 3, 1);
 525     TEST_FIELD(IMAGE_DEBUG_MISC, BYTE[ 1 ], Data, 12, 1, 1);
 526 }
 527
 528 static void test_pack_IMAGE_DOS_HEADER(void)
 529 {
 530     /* IMAGE_DOS_HEADER (pack 2) */
 531     TEST_TYPE(IMAGE_DOS_HEADER, 64, 2);
 532     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_magic, 0, 2, 2);
 533     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cblp, 2, 2, 2);
 534     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cp, 4, 2, 2);
 535     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_crlc, 6, 2, 2);
 536     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cparhdr, 8, 2, 2);
 537     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_minalloc, 10, 2, 2);
 538     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_maxalloc, 12, 2, 2);
 539     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_ss, 14, 2, 2);
 540     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_sp, 16, 2, 2);
 541     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_csum, 18, 2, 2);
 542     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_ip, 20, 2, 2);
 543     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cs, 22, 2, 2);
 544     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_lfarlc, 24, 2, 2);
 545     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_ovno, 26, 2, 2);
 546     TEST_FIELD(IMAGE_DOS_HEADER, WORD[4], e_res, 28, 8, 2);
 547     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_oemid, 36, 2, 2);
 548     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_oeminfo, 38, 2, 2);
 549     TEST_FIELD(IMAGE_DOS_HEADER, WORD[10], e_res2, 40, 20, 2);
 550     TEST_FIELD(IMAGE_DOS_HEADER, DWORD, e_lfanew, 60, 4, 2);
 551 }
 552
 553 static void test_pack_IMAGE_EXPORT_DIRECTORY(void)
 554 {
 555     /* IMAGE_EXPORT_DIRECTORY (pack 4) */
 556     TEST_TYPE(IMAGE_EXPORT_DIRECTORY, 40, 4);
 557     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
 558     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
 559     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
 560     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
 561     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, Name, 12, 4, 4);
 562     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, Base, 16, 4, 4);
 563     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, NumberOfFunctions, 20, 4, 4);
 564     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, NumberOfNames, 24, 4, 4);
 565     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, AddressOfFunctions, 28, 4, 4);
 566     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, AddressOfNames, 32, 4, 4);
 567     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, AddressOfNameOrdinals, 36, 4, 4);
 568 }
 569
 570 static void test_pack_IMAGE_FILE_HEADER(void)
 571 {
 572     /* IMAGE_FILE_HEADER (pack 4) */
 573     TEST_TYPE(IMAGE_FILE_HEADER, 20, 4);
 574     TEST_FIELD(IMAGE_FILE_HEADER, WORD, Machine, 0, 2, 2);
 575     TEST_FIELD(IMAGE_FILE_HEADER, WORD, NumberOfSections, 2, 2, 2);
 576     TEST_FIELD(IMAGE_FILE_HEADER, DWORD, TimeDateStamp, 4, 4, 4);
 577     TEST_FIELD(IMAGE_FILE_HEADER, DWORD, PointerToSymbolTable, 8, 4, 4);
 578     TEST_FIELD(IMAGE_FILE_HEADER, DWORD, NumberOfSymbols, 12, 4, 4);
 579     TEST_FIELD(IMAGE_FILE_HEADER, WORD, SizeOfOptionalHeader, 16, 2, 2);
 580     TEST_FIELD(IMAGE_FILE_HEADER, WORD, Characteristics, 18, 2, 2);
 581 }
 582
 583 static void test_pack_IMAGE_FUNCTION_ENTRY(void)
 584 {
 585     /* IMAGE_FUNCTION_ENTRY (pack 4) */
 586     TEST_TYPE(IMAGE_FUNCTION_ENTRY, 12, 4);
 587     TEST_FIELD(IMAGE_FUNCTION_ENTRY, DWORD, StartingAddress, 0, 4, 4);
 588     TEST_FIELD(IMAGE_FUNCTION_ENTRY, DWORD, EndingAddress, 4, 4, 4);
 589     TEST_FIELD(IMAGE_FUNCTION_ENTRY, DWORD, EndOfPrologue, 8, 4, 4);
 590 }
 591
 592 static void test_pack_IMAGE_IMPORT_BY_NAME(void)
 593 {
 594     /* IMAGE_IMPORT_BY_NAME (pack 4) */
 595     TEST_TYPE(IMAGE_IMPORT_BY_NAME, 4, 2);
 596     TEST_FIELD(IMAGE_IMPORT_BY_NAME, WORD, Hint, 0, 2, 2);
 597     TEST_FIELD(IMAGE_IMPORT_BY_NAME, BYTE[1], Name, 2, 1, 1);
 598 }
 599
 600 static void test_pack_IMAGE_IMPORT_DESCRIPTOR(void)
 601 {
 602     /* IMAGE_IMPORT_DESCRIPTOR (pack 4) */
 603 }
 604
 605 static void test_pack_IMAGE_LINENUMBER(void)
 606 {
 607     /* IMAGE_LINENUMBER (pack 2) */
 608 }
 609
 610 static void test_pack_IMAGE_LOAD_CONFIG_DIRECTORY(void)
 611 {
 612     /* IMAGE_LOAD_CONFIG_DIRECTORY (pack 4) */
 613     TEST_TYPE(IMAGE_LOAD_CONFIG_DIRECTORY, 72, 4);
 614     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, Size, 0, 4, 4);
 615     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
 616     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
 617     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
 618     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, GlobalFlagsClear, 12, 4, 4);
 619     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, GlobalFlagsSet, 16, 4, 4);
 620     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, CriticalSectionDefaultTimeout, 20, 4, 4);
 621     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, DeCommitFreeBlockThreshold, 24, 4, 4);
 622     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, DeCommitTotalFreeThreshold, 28, 4, 4);
 623     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, PVOID, LockPrefixTable, 32, 4, 4);
 624     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, MaximumAllocationSize, 36, 4, 4);
 625     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, VirtualMemoryThreshold, 40, 4, 4);
 626     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, ProcessHeapFlags, 44, 4, 4);
 627     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, ProcessAffinityMask, 48, 4, 4);
 628     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, CSDVersion, 52, 2, 2);
 629     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, Reserved1, 54, 2, 2);
 630     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, PVOID, EditList, 56, 4, 4);
 631     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, SecurityCookie, 60, 4, 4);
 632     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, SEHandlerTable, 64, 4, 4);
 633     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, SEHandlerCount, 68, 4, 4);
 634 }
 635
 636 static void test_pack_IMAGE_NT_HEADERS(void)
 637 {
 638     /* IMAGE_NT_HEADERS (pack 4) */
 639     TEST_TYPE(IMAGE_NT_HEADERS, 248, 4);
 640     TEST_FIELD(IMAGE_NT_HEADERS, DWORD, Signature, 0, 4, 4);
 641     TEST_FIELD(IMAGE_NT_HEADERS, IMAGE_FILE_HEADER, FileHeader, 4, 20, 4);
 642     TEST_FIELD(IMAGE_NT_HEADERS, IMAGE_OPTIONAL_HEADER, OptionalHeader, 24, 224, 4);
 643 }
 644
 645 static void test_pack_IMAGE_OPTIONAL_HEADER(void)
 646 {
 647     /* IMAGE_OPTIONAL_HEADER (pack 4) */
 648     TEST_TYPE(IMAGE_OPTIONAL_HEADER, 224, 4);
 649     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, Magic, 0, 2, 2);
 650     TEST_FIELD(IMAGE_OPTIONAL_HEADER, BYTE, MajorLinkerVersion, 2, 1, 1);
 651     TEST_FIELD(IMAGE_OPTIONAL_HEADER, BYTE, MinorLinkerVersion, 3, 1, 1);
 652     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfCode, 4, 4, 4);
 653     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfInitializedData, 8, 4, 4);
 654     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfUninitializedData, 12, 4, 4);
 655     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, AddressOfEntryPoint, 16, 4, 4);
 656     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, BaseOfCode, 20, 4, 4);
 657     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, BaseOfData, 24, 4, 4);
 658     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, ImageBase, 28, 4, 4);
 659     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SectionAlignment, 32, 4, 4);
 660     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, FileAlignment, 36, 4, 4);
 661     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MajorOperatingSystemVersion, 40, 2, 2);
 662     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MinorOperatingSystemVersion, 42, 2, 2);
 663     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MajorImageVersion, 44, 2, 2);
 664     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MinorImageVersion, 46, 2, 2);
 665     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MajorSubsystemVersion, 48, 2, 2);
 666     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MinorSubsystemVersion, 50, 2, 2);
 667     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, Win32VersionValue, 52, 4, 4);
 668     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfImage, 56, 4, 4);
 669     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfHeaders, 60, 4, 4);
 670     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, CheckSum, 64, 4, 4);
 671     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, Subsystem, 68, 2, 2);
 672     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, DllCharacteristics, 70, 2, 2);
 673     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfStackReserve, 72, 4, 4);
 674     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfStackCommit, 76, 4, 4);
 675     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfHeapReserve, 80, 4, 4);
 676     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfHeapCommit, 84, 4, 4);
 677     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, LoaderFlags, 88, 4, 4);
 678     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, NumberOfRvaAndSizes, 92, 4, 4);
 679     TEST_FIELD(IMAGE_OPTIONAL_HEADER, IMAGE_DATA_DIRECTORY[IMAGE_NUMBEROF_DIRECTORY_ENTRIES], DataDirectory, 96, 128, 4);
 680 }
 681
 682 static void test_pack_IMAGE_OS2_HEADER(void)
 683 {
 684     /* IMAGE_OS2_HEADER (pack 2) */
 685     TEST_TYPE(IMAGE_OS2_HEADER, 64, 2);
 686     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_magic, 0, 2, 2);
 687     TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_ver, 2, 1, 1);
 688     TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_rev, 3, 1, 1);
 689     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_enttab, 4, 2, 2);
 690     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cbenttab, 6, 2, 2);
 691     TEST_FIELD(IMAGE_OS2_HEADER, LONG, ne_crc, 8, 4, 2);
 692     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_flags, 12, 2, 2);
 693     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_autodata, 14, 2, 2);
 694     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_heap, 16, 2, 2);
 695     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_stack, 18, 2, 2);
 696     TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_csip, 20, 4, 2);
 697     TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_sssp, 24, 4, 2);
 698     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cseg, 28, 2, 2);
 699     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cmod, 30, 2, 2);
 700     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cbnrestab, 32, 2, 2);
 701     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_segtab, 34, 2, 2);
 702     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_rsrctab, 36, 2, 2);
 703     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_restab, 38, 2, 2);
 704     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_modtab, 40, 2, 2);
 705     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_imptab, 42, 2, 2);
 706     TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_nrestab, 44, 4, 2);
 707     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cmovent, 48, 2, 2);
 708     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_align, 50, 2, 2);
 709     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cres, 52, 2, 2);
 710     TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_exetyp, 54, 1, 1);
 711     TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_flagsothers, 55, 1, 1);
 712     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_pretthunks, 56, 2, 2);
 713     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_psegrefbytes, 58, 2, 2);
 714     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_swaparea, 60, 2, 2);
 715     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_expver, 62, 2, 2);
 716 }
 717
 718 static void test_pack_IMAGE_RELOCATION(void)
 719 {
 720     /* IMAGE_RELOCATION (pack 2) */
 721 }
 722
 723 static void test_pack_IMAGE_RESOURCE_DATA_ENTRY(void)
 724 {
 725     /* IMAGE_RESOURCE_DATA_ENTRY (pack 4) */
 726     TEST_TYPE(IMAGE_RESOURCE_DATA_ENTRY, 16, 4);
 727     TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, OffsetToData, 0, 4, 4);
 728     TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, Size, 4, 4, 4);
 729     TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, CodePage, 8, 4, 4);
 730     TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, Reserved, 12, 4, 4);
 731 }
 732
 733 static void test_pack_IMAGE_RESOURCE_DIRECTORY(void)
 734 {
 735     /* IMAGE_RESOURCE_DIRECTORY (pack 4) */
 736     TEST_TYPE(IMAGE_RESOURCE_DIRECTORY, 16, 4);
 737     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
 738     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
 739     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
 740     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
 741     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, NumberOfNamedEntries, 12, 2, 2);
 742     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, NumberOfIdEntries, 14, 2, 2);
 743 }
 744
 745 static void test_pack_IMAGE_RESOURCE_DIRECTORY_ENTRY(void)
 746 {
 747     /* IMAGE_RESOURCE_DIRECTORY_ENTRY (pack 4) */
 748 }
 749
 750 static void test_pack_IMAGE_RESOURCE_DIRECTORY_STRING(void)
 751 {
 752     /* IMAGE_RESOURCE_DIRECTORY_STRING (pack 4) */
 753     TEST_TYPE(IMAGE_RESOURCE_DIRECTORY_STRING, 4, 2);
 754     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY_STRING, WORD, Length, 0, 2, 2);
 755     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY_STRING, CHAR[ 1 ], NameString, 2, 1, 1);
 756 }
 757
 758 static void test_pack_IMAGE_RESOURCE_DIR_STRING_U(void)
 759 {
 760     /* IMAGE_RESOURCE_DIR_STRING_U (pack 4) */
 761     TEST_TYPE(IMAGE_RESOURCE_DIR_STRING_U, 4, 2);
 762     TEST_FIELD(IMAGE_RESOURCE_DIR_STRING_U, WORD, Length, 0, 2, 2);
 763     TEST_FIELD(IMAGE_RESOURCE_DIR_STRING_U, WCHAR[ 1 ], NameString, 2, 2, 2);
 764 }
 765
 766 static void test_pack_IMAGE_SECTION_HEADER(void)
 767 {
 768     /* IMAGE_SECTION_HEADER (pack 4) */
 769     TEST_FIELD(IMAGE_SECTION_HEADER, BYTE[IMAGE_SIZEOF_SHORT_NAME], Name, 0, 8, 1);
 770 }
 771
 772 static void test_pack_IMAGE_SEPARATE_DEBUG_HEADER(void)
 773 {
 774     /* IMAGE_SEPARATE_DEBUG_HEADER (pack 4) */
 775     TEST_TYPE(IMAGE_SEPARATE_DEBUG_HEADER, 48, 4);
 776     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Signature, 0, 2, 2);
 777     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Flags, 2, 2, 2);
 778     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Machine, 4, 2, 2);
 779     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Characteristics, 6, 2, 2);
 780     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, TimeDateStamp, 8, 4, 4);
 781     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, CheckSum, 12, 4, 4);
 782     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, ImageBase, 16, 4, 4);
 783     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, SizeOfImage, 20, 4, 4);
 784     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, NumberOfSections, 24, 4, 4);
 785     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, ExportedNamesSize, 28, 4, 4);
 786     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, DebugDirectorySize, 32, 4, 4);
 787     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, SectionAlignment, 36, 4, 4);
 788     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD[ 2 ], Reserved, 40, 8, 4);
 789 }
 790
 791 static void test_pack_IMAGE_SYMBOL(void)
 792 {
 793     /* IMAGE_SYMBOL (pack 2) */
 794 }
 795
 796 static void test_pack_IMAGE_THUNK_DATA(void)
 797 {
 798     /* IMAGE_THUNK_DATA (pack 4) */
 799 }
 800
 801 static void test_pack_IMAGE_TLS_DIRECTORY(void)
 802 {
 803     /* IMAGE_TLS_DIRECTORY (pack 4) */
 804     TEST_TYPE(IMAGE_TLS_DIRECTORY, 24, 4);
 805     TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, StartAddressOfRawData, 0, 4, 4);
 806     TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, EndAddressOfRawData, 4, 4, 4);
 807     TEST_FIELD(IMAGE_TLS_DIRECTORY, LPDWORD, AddressOfIndex, 8, 4, 4);
 808     TEST_FIELD(IMAGE_TLS_DIRECTORY, PIMAGE_TLS_CALLBACK *, AddressOfCallBacks, 12, 4, 4);
 809     TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, SizeOfZeroFill, 16, 4, 4);
 810     TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, Characteristics, 20, 4, 4);
 811 }
 812
 813 static void test_pack_IMAGE_VXD_HEADER(void)
 814 {
 815     /* IMAGE_VXD_HEADER (pack 2) */
 816     TEST_TYPE(IMAGE_VXD_HEADER, 196, 2);
 817     TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_magic, 0, 2, 2);
 818     TEST_FIELD(IMAGE_VXD_HEADER, BYTE, e32_border, 2, 1, 1);
 819     TEST_FIELD(IMAGE_VXD_HEADER, BYTE, e32_worder, 3, 1, 1);
 820     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_level, 4, 4, 2);
 821     TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_cpu, 8, 2, 2);
 822     TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_os, 10, 2, 2);
 823     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ver, 12, 4, 2);
 824     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_mflags, 16, 4, 2);
 825     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_mpages, 20, 4, 2);
 826     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_startobj, 24, 4, 2);
 827     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_eip, 28, 4, 2);
 828     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_stackobj, 32, 4, 2);
 829     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_esp, 36, 4, 2);
 830     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_pagesize, 40, 4, 2);
 831     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_lastpagesize, 44, 4, 2);
 832     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fixupsize, 48, 4, 2);
 833     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fixupsum, 52, 4, 2);
 834     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ldrsize, 56, 4, 2);
 835     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ldrsum, 60, 4, 2);
 836     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objtab, 64, 4, 2);
 837     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objcnt, 68, 4, 2);
 838     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objmap, 72, 4, 2);
 839     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_itermap, 76, 4, 2);
 840     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_rsrctab, 80, 4, 2);
 841     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_rsrccnt, 84, 4, 2);
 842     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_restab, 88, 4, 2);
 843     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_enttab, 92, 4, 2);
 844     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_dirtab, 96, 4, 2);
 845     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_dircnt, 100, 4, 2);
 846     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fpagetab, 104, 4, 2);
 847     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_frectab, 108, 4, 2);
 848     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impmod, 112, 4, 2);
 849     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impmodcnt, 116, 4, 2);
 850     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impproc, 120, 4, 2);
 851     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_pagesum, 124, 4, 2);
 852     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_datapage, 128, 4, 2);
 853     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_preload, 132, 4, 2);
 854     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_nrestab, 136, 4, 2);
 855     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_cbnrestab, 140, 4, 2);
 856     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_nressum, 144, 4, 2);
 857     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_autodata, 148, 4, 2);
 858     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_debuginfo, 152, 4, 2);
 859     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_debuglen, 156, 4, 2);
 860     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_instpreload, 160, 4, 2);
 861     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_instdemand, 164, 4, 2);
 862     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_heapsize, 168, 4, 2);
 863     TEST_FIELD(IMAGE_VXD_HEADER, BYTE[12], e32_res3, 172, 12, 1);
 864     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_winresoff, 184, 4, 2);
 865     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_winreslen, 188, 4, 2);
 866     TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_devid, 192, 2, 2);
 867     TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_ddkver, 194, 2, 2);
 868 }
 869
 870 static void test_pack_IO_COUNTERS(void)
 871 {
 872     /* IO_COUNTERS (pack 8) */
 873     TEST_TYPE(IO_COUNTERS, 48, 8);
 874     TEST_FIELD(IO_COUNTERS, ULONGLONG, ReadOperationCount, 0, 8, 8);
 875     TEST_FIELD(IO_COUNTERS, ULONGLONG, WriteOperationCount, 8, 8, 8);
 876     TEST_FIELD(IO_COUNTERS, ULONGLONG, OtherOperationCount, 16, 8, 8);
 877     TEST_FIELD(IO_COUNTERS, ULONGLONG, ReadTransferCount, 24, 8, 8);
 878     TEST_FIELD(IO_COUNTERS, ULONGLONG, WriteTransferCount, 32, 8, 8);
 879     TEST_FIELD(IO_COUNTERS, ULONGLONG, OtherTransferCount, 40, 8, 8);
 880 }
 881
 882 static void test_pack_LANGID(void)
 883 {
 884     /* LANGID */
 885     TEST_TYPE(LANGID, 2, 2);
 886     TEST_TYPE_UNSIGNED(LANGID);
 887 }
 888
 889 static void test_pack_LARGE_INTEGER(void)
 890 {
 891     /* LARGE_INTEGER (pack 4) */
 892 }
 893
 894 static void test_pack_LCID(void)
 895 {
 896     /* LCID */
 897     TEST_TYPE(LCID, 4, 4);
 898     TEST_TYPE_UNSIGNED(LCID);
 899 }
 900
 901 static void test_pack_LIST_ENTRY(void)
 902 {
 903     /* LIST_ENTRY (pack 4) */
 904     TEST_TYPE(LIST_ENTRY, 8, 4);
 905     TEST_FIELD(LIST_ENTRY, struct _LIST_ENTRY *, Flink, 0, 4, 4);
 906     TEST_FIELD(LIST_ENTRY, struct _LIST_ENTRY *, Blink, 4, 4, 4);
 907 }
 908
 909 static void test_pack_LONG(void)
 910 {
 911     /* LONG */
 912     TEST_TYPE(LONG, 4, 4);
 913     TEST_TYPE_SIGNED(LONG);
 914 }
 915
 916 static void test_pack_LONGLONG(void)
 917 {
 918     /* LONGLONG */
 919     TEST_TYPE(LONGLONG, 8, 8);
 920     TEST_TYPE_SIGNED(LONGLONG);
 921 }
 922
 923 static void test_pack_LPTOP_LEVEL_EXCEPTION_FILTER(void)
 924 {
 925     /* LPTOP_LEVEL_EXCEPTION_FILTER */
 926     TEST_TYPE(LPTOP_LEVEL_EXCEPTION_FILTER, 4, 4);
 927 }
 928
 929 static void test_pack_LUID(void)
 930 {
 931     /* LUID (pack 4) */
 932     TEST_TYPE(LUID, 8, 4);
 933     TEST_FIELD(LUID, DWORD, LowPart, 0, 4, 4);
 934     TEST_FIELD(LUID, LONG, HighPart, 4, 4, 4);
 935 }
 936
 937 static void test_pack_LUID_AND_ATTRIBUTES(void)
 938 {
 939     /* LUID_AND_ATTRIBUTES (pack 4) */
 940     TEST_TYPE(LUID_AND_ATTRIBUTES, 12, 4);
 941     TEST_FIELD(LUID_AND_ATTRIBUTES, LUID, Luid, 0, 8, 4);
 942     TEST_FIELD(LUID_AND_ATTRIBUTES, DWORD, Attributes, 8, 4, 4);
 943 }
 944
 945 static void test_pack_MEMORY_BASIC_INFORMATION(void)
 946 {
 947     /* MEMORY_BASIC_INFORMATION (pack 4) */
 948     TEST_TYPE(MEMORY_BASIC_INFORMATION, 28, 4);
 949     TEST_FIELD(MEMORY_BASIC_INFORMATION, LPVOID, BaseAddress, 0, 4, 4);
 950     TEST_FIELD(MEMORY_BASIC_INFORMATION, LPVOID, AllocationBase, 4, 4, 4);
 951     TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, AllocationProtect, 8, 4, 4);
 952     TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, RegionSize, 12, 4, 4);
 953     TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, State, 16, 4, 4);
 954     TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, Protect, 20, 4, 4);
 955     TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, Type, 24, 4, 4);
 956 }
 957
 958 static void test_pack_MESSAGE_RESOURCE_BLOCK(void)
 959 {
 960     /* MESSAGE_RESOURCE_BLOCK (pack 4) */
 961     TEST_TYPE(MESSAGE_RESOURCE_BLOCK, 12, 4);
 962     TEST_FIELD(MESSAGE_RESOURCE_BLOCK, DWORD, LowId, 0, 4, 4);
 963     TEST_FIELD(MESSAGE_RESOURCE_BLOCK, DWORD, HighId, 4, 4, 4);
 964     TEST_FIELD(MESSAGE_RESOURCE_BLOCK, DWORD, OffsetToEntries, 8, 4, 4);
 965 }
 966
 967 static void test_pack_MESSAGE_RESOURCE_DATA(void)
 968 {
 969     /* MESSAGE_RESOURCE_DATA (pack 4) */
 970     TEST_TYPE(MESSAGE_RESOURCE_DATA, 16, 4);
 971     TEST_FIELD(MESSAGE_RESOURCE_DATA, DWORD, NumberOfBlocks, 0, 4, 4);
 972     TEST_FIELD(MESSAGE_RESOURCE_DATA, MESSAGE_RESOURCE_BLOCK[ 1 ], Blocks, 4, 12, 4);
 973 }
 974
 975 static void test_pack_MESSAGE_RESOURCE_ENTRY(void)
 976 {
 977     /* MESSAGE_RESOURCE_ENTRY (pack 4) */
 978     TEST_TYPE(MESSAGE_RESOURCE_ENTRY, 6, 2);
 979     TEST_FIELD(MESSAGE_RESOURCE_ENTRY, WORD, Length, 0, 2, 2);
 980     TEST_FIELD(MESSAGE_RESOURCE_ENTRY, WORD, Flags, 2, 2, 2);
 981     TEST_FIELD(MESSAGE_RESOURCE_ENTRY, BYTE[1], Text, 4, 1, 1);
 982 }
 983
 984 static void test_pack_NT_TIB(void)
 985 {
 986     /* NT_TIB (pack 4) */
 987     TEST_FIELD(NT_TIB, struct _EXCEPTION_REGISTRATION_RECORD *, ExceptionList, 0, 4, 4);
 988     TEST_FIELD(NT_TIB, PVOID, StackBase, 4, 4, 4);
 989     TEST_FIELD(NT_TIB, PVOID, StackLimit, 8, 4, 4);
 990     TEST_FIELD(NT_TIB, PVOID, SubSystemTib, 12, 4, 4);
 991 }
 992
 993 static void test_pack_OBJECT_TYPE_LIST(void)
 994 {
 995     /* OBJECT_TYPE_LIST (pack 4) */
 996     TEST_TYPE(OBJECT_TYPE_LIST, 8, 4);
 997     TEST_FIELD(OBJECT_TYPE_LIST, WORD, Level, 0, 2, 2);
 998     TEST_FIELD(OBJECT_TYPE_LIST, WORD, Sbz, 2, 2, 2);
 999     TEST_FIELD(OBJECT_TYPE_LIST, GUID *, ObjectType, 4, 4, 4);
1000 }
1001
1002 static void test_pack_PACCESS_ALLOWED_ACE(void)
1003 {
1004     /* PACCESS_ALLOWED_ACE */
1005     TEST_TYPE(PACCESS_ALLOWED_ACE, 4, 4);
1006     TEST_TYPE_POINTER(PACCESS_ALLOWED_ACE, 12, 4);
1007 }
1008
1009 static void test_pack_PACCESS_DENIED_ACE(void)
1010 {
1011     /* PACCESS_DENIED_ACE */
1012     TEST_TYPE(PACCESS_DENIED_ACE, 4, 4);
1013     TEST_TYPE_POINTER(PACCESS_DENIED_ACE, 12, 4);
1014 }
1015
1016 static void test_pack_PACCESS_TOKEN(void)
1017 {
1018     /* PACCESS_TOKEN */
1019     TEST_TYPE(PACCESS_TOKEN, 4, 4);
1020 }
1021
1022 static void test_pack_PACE_HEADER(void)
1023 {
1024     /* PACE_HEADER */
1025     TEST_TYPE(PACE_HEADER, 4, 4);
1026     TEST_TYPE_POINTER(PACE_HEADER, 4, 2);
1027 }
1028
1029 static void test_pack_PACL(void)
1030 {
1031     /* PACL */
1032     TEST_TYPE(PACL, 4, 4);
1033     TEST_TYPE_POINTER(PACL, 8, 2);
1034 }
1035
1036 static void test_pack_PACL_REVISION_INFORMATION(void)
1037 {
1038     /* PACL_REVISION_INFORMATION */
1039     TEST_TYPE(PACL_REVISION_INFORMATION, 4, 4);
1040     TEST_TYPE_POINTER(PACL_REVISION_INFORMATION, 4, 4);
1041 }
1042
1043 static void test_pack_PACL_SIZE_INFORMATION(void)
1044 {
1045     /* PACL_SIZE_INFORMATION */
1046     TEST_TYPE(PACL_SIZE_INFORMATION, 4, 4);
1047     TEST_TYPE_POINTER(PACL_SIZE_INFORMATION, 12, 4);
1048 }
1049
1050 static void test_pack_PCCH(void)
1051 {
1052     /* PCCH */
1053     TEST_TYPE(PCCH, 4, 4);
1054     TEST_TYPE_POINTER(PCCH, 1, 1);
1055 }
1056
1057 static void test_pack_PCH(void)
1058 {
1059     /* PCH */
1060     TEST_TYPE(PCH, 4, 4);
1061     TEST_TYPE_POINTER(PCH, 1, 1);
1062 }
1063
1064 static void test_pack_PCSTR(void)
1065 {
1066     /* PCSTR */
1067     TEST_TYPE(PCSTR, 4, 4);
1068     TEST_TYPE_POINTER(PCSTR, 1, 1);
1069 }
1070
1071 static void test_pack_PCTSTR(void)
1072 {
1073     /* PCTSTR */
1074     TEST_TYPE(PCTSTR, 4, 4);
1075 }
1076
1077 static void test_pack_PCWCH(void)
1078 {
1079     /* PCWCH */
1080     TEST_TYPE(PCWCH, 4, 4);
1081     TEST_TYPE_POINTER(PCWCH, 2, 2);
1082 }
1083
1084 static void test_pack_PCWSTR(void)
1085 {
1086     /* PCWSTR */
1087     TEST_TYPE(PCWSTR, 4, 4);
1088     TEST_TYPE_POINTER(PCWSTR, 2, 2);
1089 }
1090
1091 static void test_pack_PEXCEPTION_POINTERS(void)
1092 {
1093     /* PEXCEPTION_POINTERS */
1094     TEST_TYPE(PEXCEPTION_POINTERS, 4, 4);
1095     TEST_TYPE_POINTER(PEXCEPTION_POINTERS, 8, 4);
1096 }
1097
1098 static void test_pack_PEXCEPTION_RECORD(void)
1099 {
1100     /* PEXCEPTION_RECORD */
1101     TEST_TYPE(PEXCEPTION_RECORD, 4, 4);
1102     TEST_TYPE_POINTER(PEXCEPTION_RECORD, 80, 4);
1103 }
1104
1105 static void test_pack_PFLOATING_SAVE_AREA(void)
1106 {
1107     /* PFLOATING_SAVE_AREA */
1108     TEST_TYPE(PFLOATING_SAVE_AREA, 4, 4);
1109     TEST_TYPE_POINTER(PFLOATING_SAVE_AREA, 112, 4);
1110 }
1111
1112 static void test_pack_PFPO_DATA(void)
1113 {
1114     /* PFPO_DATA */
1115     TEST_TYPE(PFPO_DATA, 4, 4);
1116     TEST_TYPE_POINTER(PFPO_DATA, 16, 4);
1117 }
1118
1119 static void test_pack_PGENERIC_MAPPING(void)
1120 {
1121     /* PGENERIC_MAPPING */
1122     TEST_TYPE(PGENERIC_MAPPING, 4, 4);
1123     TEST_TYPE_POINTER(PGENERIC_MAPPING, 16, 4);
1124 }
1125
1126 static void test_pack_PHANDLE(void)
1127 {
1128     /* PHANDLE */
1129     TEST_TYPE(PHANDLE, 4, 4);
1130     TEST_TYPE_POINTER(PHANDLE, 4, 4);
1131 }
1132
1133 static void test_pack_PIMAGE_ARCHIVE_MEMBER_HEADER(void)
1134 {
1135     /* PIMAGE_ARCHIVE_MEMBER_HEADER */
1136     TEST_TYPE(PIMAGE_ARCHIVE_MEMBER_HEADER, 4, 4);
1137     TEST_TYPE_POINTER(PIMAGE_ARCHIVE_MEMBER_HEADER, 60, 1);
1138 }
1139
1140 static void test_pack_PIMAGE_AUX_SYMBOL(void)
1141 {
1142     /* PIMAGE_AUX_SYMBOL */
1143     TEST_TYPE(PIMAGE_AUX_SYMBOL, 4, 4);
1144 }
1145
1146 static void test_pack_PIMAGE_BASE_RELOCATION(void)
1147 {
1148     /* PIMAGE_BASE_RELOCATION */
1149     TEST_TYPE(PIMAGE_BASE_RELOCATION, 4, 4);
1150     TEST_TYPE_POINTER(PIMAGE_BASE_RELOCATION, 8, 4);
1151 }
1152
1153 static void test_pack_PIMAGE_BOUND_FORWARDER_REF(void)
1154 {
1155     /* PIMAGE_BOUND_FORWARDER_REF */
1156     TEST_TYPE(PIMAGE_BOUND_FORWARDER_REF, 4, 4);
1157     TEST_TYPE_POINTER(PIMAGE_BOUND_FORWARDER_REF, 8, 4);
1158 }
1159
1160 static void test_pack_PIMAGE_BOUND_IMPORT_DESCRIPTOR(void)
1161 {
1162     /* PIMAGE_BOUND_IMPORT_DESCRIPTOR */
1163     TEST_TYPE(PIMAGE_BOUND_IMPORT_DESCRIPTOR, 4, 4);
1164     TEST_TYPE_POINTER(PIMAGE_BOUND_IMPORT_DESCRIPTOR, 8, 4);
1165 }
1166
1167 static void test_pack_PIMAGE_COFF_SYMBOLS_HEADER(void)
1168 {
1169     /* PIMAGE_COFF_SYMBOLS_HEADER */
1170     TEST_TYPE(PIMAGE_COFF_SYMBOLS_HEADER, 4, 4);
1171     TEST_TYPE_POINTER(PIMAGE_COFF_SYMBOLS_HEADER, 32, 4);
1172 }
1173
1174 static void test_pack_PIMAGE_DATA_DIRECTORY(void)
1175 {
1176     /* PIMAGE_DATA_DIRECTORY */
1177     TEST_TYPE(PIMAGE_DATA_DIRECTORY, 4, 4);
1178     TEST_TYPE_POINTER(PIMAGE_DATA_DIRECTORY, 8, 4);
1179 }
1180
1181 static void test_pack_PIMAGE_DEBUG_DIRECTORY(void)
1182 {
1183     /* PIMAGE_DEBUG_DIRECTORY */
1184     TEST_TYPE(PIMAGE_DEBUG_DIRECTORY, 4, 4);
1185     TEST_TYPE_POINTER(PIMAGE_DEBUG_DIRECTORY, 28, 4);
1186 }
1187
1188 static void test_pack_PIMAGE_DEBUG_MISC(void)
1189 {
1190     /* PIMAGE_DEBUG_MISC */
1191     TEST_TYPE(PIMAGE_DEBUG_MISC, 4, 4);
1192     TEST_TYPE_POINTER(PIMAGE_DEBUG_MISC, 16, 4);
1193 }
1194
1195 static void test_pack_PIMAGE_DOS_HEADER(void)
1196 {
1197     /* PIMAGE_DOS_HEADER */
1198     TEST_TYPE(PIMAGE_DOS_HEADER, 4, 4);
1199     TEST_TYPE_POINTER(PIMAGE_DOS_HEADER, 64, 2);
1200 }
1201
1202 static void test_pack_PIMAGE_EXPORT_DIRECTORY(void)
1203 {
1204     /* PIMAGE_EXPORT_DIRECTORY */
1205     TEST_TYPE(PIMAGE_EXPORT_DIRECTORY, 4, 4);
1206     TEST_TYPE_POINTER(PIMAGE_EXPORT_DIRECTORY, 40, 4);
1207 }
1208
1209 static void test_pack_PIMAGE_FILE_HEADER(void)
1210 {
1211     /* PIMAGE_FILE_HEADER */
1212     TEST_TYPE(PIMAGE_FILE_HEADER, 4, 4);
1213     TEST_TYPE_POINTER(PIMAGE_FILE_HEADER, 20, 4);
1214 }
1215
1216 static void test_pack_PIMAGE_FUNCTION_ENTRY(void)
1217 {
1218     /* PIMAGE_FUNCTION_ENTRY */
1219     TEST_TYPE(PIMAGE_FUNCTION_ENTRY, 4, 4);
1220     TEST_TYPE_POINTER(PIMAGE_FUNCTION_ENTRY, 12, 4);
1221 }
1222
1223 static void test_pack_PIMAGE_IMPORT_BY_NAME(void)
1224 {
1225     /* PIMAGE_IMPORT_BY_NAME */
1226     TEST_TYPE(PIMAGE_IMPORT_BY_NAME, 4, 4);
1227     TEST_TYPE_POINTER(PIMAGE_IMPORT_BY_NAME, 4, 2);
1228 }
1229
1230 static void test_pack_PIMAGE_IMPORT_DESCRIPTOR(void)
1231 {
1232     /* PIMAGE_IMPORT_DESCRIPTOR */
1233     TEST_TYPE(PIMAGE_IMPORT_DESCRIPTOR, 4, 4);
1234 }
1235
1236 static void test_pack_PIMAGE_LINENUMBER(void)
1237 {
1238     /* PIMAGE_LINENUMBER */
1239     TEST_TYPE(PIMAGE_LINENUMBER, 4, 4);
1240 }
1241
1242 static void test_pack_PIMAGE_LOAD_CONFIG_DIRECTORY(void)
1243 {
1244     /* PIMAGE_LOAD_CONFIG_DIRECTORY */
1245     TEST_TYPE(PIMAGE_LOAD_CONFIG_DIRECTORY, 4, 4);
1246     TEST_TYPE_POINTER(PIMAGE_LOAD_CONFIG_DIRECTORY, 72, 4);
1247 }
1248
1249 static void test_pack_PIMAGE_NT_HEADERS(void)
1250 {
1251     /* PIMAGE_NT_HEADERS */
1252     TEST_TYPE(PIMAGE_NT_HEADERS, 4, 4);
1253     TEST_TYPE_POINTER(PIMAGE_NT_HEADERS, 248, 4);
1254 }
1255
1256 static void test_pack_PIMAGE_OPTIONAL_HEADER(void)
1257 {
1258     /* PIMAGE_OPTIONAL_HEADER */
1259     TEST_TYPE(PIMAGE_OPTIONAL_HEADER, 4, 4);
1260     TEST_TYPE_POINTER(PIMAGE_OPTIONAL_HEADER, 224, 4);
1261 }
1262
1263 static void test_pack_PIMAGE_OS2_HEADER(void)
1264 {
1265     /* PIMAGE_OS2_HEADER */
1266     TEST_TYPE(PIMAGE_OS2_HEADER, 4, 4);
1267     TEST_TYPE_POINTER(PIMAGE_OS2_HEADER, 64, 2);
1268 }
1269
1270 static void test_pack_PIMAGE_RELOCATION(void)
1271 {
1272     /* PIMAGE_RELOCATION */
1273     TEST_TYPE(PIMAGE_RELOCATION, 4, 4);
1274 }
1275
1276 static void test_pack_PIMAGE_RESOURCE_DATA_ENTRY(void)
1277 {
1278     /* PIMAGE_RESOURCE_DATA_ENTRY */
1279     TEST_TYPE(PIMAGE_RESOURCE_DATA_ENTRY, 4, 4);
1280     TEST_TYPE_POINTER(PIMAGE_RESOURCE_DATA_ENTRY, 16, 4);
1281 }
1282
1283 static void test_pack_PIMAGE_RESOURCE_DIRECTORY(void)
1284 {
1285     /* PIMAGE_RESOURCE_DIRECTORY */
1286     TEST_TYPE(PIMAGE_RESOURCE_DIRECTORY, 4, 4);
1287     TEST_TYPE_POINTER(PIMAGE_RESOURCE_DIRECTORY, 16, 4);
1288 }
1289
1290 static void test_pack_PIMAGE_RESOURCE_DIRECTORY_ENTRY(void)
1291 {
1292     /* PIMAGE_RESOURCE_DIRECTORY_ENTRY */
1293     TEST_TYPE(PIMAGE_RESOURCE_DIRECTORY_ENTRY, 4, 4);
1294 }
1295
1296 static void test_pack_PIMAGE_RESOURCE_DIRECTORY_STRING(void)
1297 {
1298     /* PIMAGE_RESOURCE_DIRECTORY_STRING */
1299     TEST_TYPE(PIMAGE_RESOURCE_DIRECTORY_STRING, 4, 4);
1300     TEST_TYPE_POINTER(PIMAGE_RESOURCE_DIRECTORY_STRING, 4, 2);
1301 }
1302
1303 static void test_pack_PIMAGE_RESOURCE_DIR_STRING_U(void)
1304 {
1305     /* PIMAGE_RESOURCE_DIR_STRING_U */
1306     TEST_TYPE(PIMAGE_RESOURCE_DIR_STRING_U, 4, 4);
1307     TEST_TYPE_POINTER(PIMAGE_RESOURCE_DIR_STRING_U, 4, 2);
1308 }
1309
1310 static void test_pack_PIMAGE_SECTION_HEADER(void)
1311 {
1312     /* PIMAGE_SECTION_HEADER */
1313     TEST_TYPE(PIMAGE_SECTION_HEADER, 4, 4);
1314 }
1315
1316 static void test_pack_PIMAGE_SEPARATE_DEBUG_HEADER(void)
1317 {
1318     /* PIMAGE_SEPARATE_DEBUG_HEADER */
1319     TEST_TYPE(PIMAGE_SEPARATE_DEBUG_HEADER, 4, 4);
1320     TEST_TYPE_POINTER(PIMAGE_SEPARATE_DEBUG_HEADER, 48, 4);
1321 }
1322
1323 static void test_pack_PIMAGE_SYMBOL(void)
1324 {
1325     /* PIMAGE_SYMBOL */
1326     TEST_TYPE(PIMAGE_SYMBOL, 4, 4);
1327 }
1328
1329 static void test_pack_PIMAGE_THUNK_DATA(void)
1330 {
1331     /* PIMAGE_THUNK_DATA */
1332     TEST_TYPE(PIMAGE_THUNK_DATA, 4, 4);
1333 }
1334
1335 static void test_pack_PIMAGE_TLS_CALLBACK(void)
1336 {
1337     /* PIMAGE_TLS_CALLBACK */
1338     TEST_TYPE(PIMAGE_TLS_CALLBACK, 4, 4);
1339 }
1340
1341 static void test_pack_PIMAGE_TLS_DIRECTORY(void)
1342 {
1343     /* PIMAGE_TLS_DIRECTORY */
1344     TEST_TYPE(PIMAGE_TLS_DIRECTORY, 4, 4);
1345     TEST_TYPE_POINTER(PIMAGE_TLS_DIRECTORY, 24, 4);
1346 }
1347
1348 static void test_pack_PIMAGE_VXD_HEADER(void)
1349 {
1350     /* PIMAGE_VXD_HEADER */
1351     TEST_TYPE(PIMAGE_VXD_HEADER, 4, 4);
1352     TEST_TYPE_POINTER(PIMAGE_VXD_HEADER, 196, 2);
1353 }
1354
1355 static void test_pack_PIO_COUNTERS(void)
1356 {
1357     /* PIO_COUNTERS */
1358     TEST_TYPE(PIO_COUNTERS, 4, 4);
1359     TEST_TYPE_POINTER(PIO_COUNTERS, 48, 8);
1360 }
1361
1362 static void test_pack_PISECURITY_DESCRIPTOR(void)
1363 {
1364     /* PISECURITY_DESCRIPTOR */
1365     TEST_TYPE(PISECURITY_DESCRIPTOR, 4, 4);
1366     TEST_TYPE_POINTER(PISECURITY_DESCRIPTOR, 20, 4);
1367 }
1368
1369 static void test_pack_PISECURITY_DESCRIPTOR_RELATIVE(void)
1370 {
1371     /* PISECURITY_DESCRIPTOR_RELATIVE */
1372     TEST_TYPE(PISECURITY_DESCRIPTOR_RELATIVE, 4, 4);
1373     TEST_TYPE_POINTER(PISECURITY_DESCRIPTOR_RELATIVE, 20, 4);
1374 }
1375
1376 static void test_pack_PISID(void)
1377 {
1378     /* PISID */
1379     TEST_TYPE(PISID, 4, 4);
1380     TEST_TYPE_POINTER(PISID, 12, 4);
1381 }
1382
1383 static void test_pack_PLARGE_INTEGER(void)
1384 {
1385     /* PLARGE_INTEGER */
1386     TEST_TYPE(PLARGE_INTEGER, 4, 4);
1387 }
1388
1389 static void test_pack_PLIST_ENTRY(void)
1390 {
1391     /* PLIST_ENTRY */
1392     TEST_TYPE(PLIST_ENTRY, 4, 4);
1393     TEST_TYPE_POINTER(PLIST_ENTRY, 8, 4);
1394 }
1395
1396 static void test_pack_PLUID(void)
1397 {
1398     /* PLUID */
1399     TEST_TYPE(PLUID, 4, 4);
1400     TEST_TYPE_POINTER(PLUID, 8, 4);
1401 }
1402
1403 static void test_pack_PLUID_AND_ATTRIBUTES(void)
1404 {
1405     /* PLUID_AND_ATTRIBUTES */
1406     TEST_TYPE(PLUID_AND_ATTRIBUTES, 4, 4);
1407     TEST_TYPE_POINTER(PLUID_AND_ATTRIBUTES, 12, 4);
1408 }
1409
1410 static void test_pack_PMEMORY_BASIC_INFORMATION(void)
1411 {
1412     /* PMEMORY_BASIC_INFORMATION */
1413     TEST_TYPE(PMEMORY_BASIC_INFORMATION, 4, 4);
1414     TEST_TYPE_POINTER(PMEMORY_BASIC_INFORMATION, 28, 4);
1415 }
1416
1417 static void test_pack_PMESSAGE_RESOURCE_BLOCK(void)
1418 {
1419     /* PMESSAGE_RESOURCE_BLOCK */
1420     TEST_TYPE(PMESSAGE_RESOURCE_BLOCK, 4, 4);
1421     TEST_TYPE_POINTER(PMESSAGE_RESOURCE_BLOCK, 12, 4);
1422 }
1423
1424 static void test_pack_PMESSAGE_RESOURCE_DATA(void)
1425 {
1426     /* PMESSAGE_RESOURCE_DATA */
1427     TEST_TYPE(PMESSAGE_RESOURCE_DATA, 4, 4);
1428     TEST_TYPE_POINTER(PMESSAGE_RESOURCE_DATA, 16, 4);
1429 }
1430
1431 static void test_pack_PMESSAGE_RESOURCE_ENTRY(void)
1432 {
1433     /* PMESSAGE_RESOURCE_ENTRY */
1434     TEST_TYPE(PMESSAGE_RESOURCE_ENTRY, 4, 4);
1435     TEST_TYPE_POINTER(PMESSAGE_RESOURCE_ENTRY, 6, 2);
1436 }
1437
1438 static void test_pack_PNT_TIB(void)
1439 {
1440     /* PNT_TIB */
1441     TEST_TYPE(PNT_TIB, 4, 4);
1442 }
1443
1444 static void test_pack_POBJECT_TYPE_LIST(void)
1445 {
1446     /* POBJECT_TYPE_LIST */
1447     TEST_TYPE(POBJECT_TYPE_LIST, 4, 4);
1448     TEST_TYPE_POINTER(POBJECT_TYPE_LIST, 8, 4);
1449 }
1450
1451 static void test_pack_PPRIVILEGE_SET(void)
1452 {
1453     /* PPRIVILEGE_SET */
1454     TEST_TYPE(PPRIVILEGE_SET, 4, 4);
1455     TEST_TYPE_POINTER(PPRIVILEGE_SET, 20, 4);
1456 }
1457
1458 static void test_pack_PRIVILEGE_SET(void)
1459 {
1460     /* PRIVILEGE_SET (pack 4) */
1461     TEST_TYPE(PRIVILEGE_SET, 20, 4);
1462     TEST_FIELD(PRIVILEGE_SET, DWORD, PrivilegeCount, 0, 4, 4);
1463     TEST_FIELD(PRIVILEGE_SET, DWORD, Control, 4, 4, 4);
1464     TEST_FIELD(PRIVILEGE_SET, LUID_AND_ATTRIBUTES[ANYSIZE_ARRAY], Privilege, 8, 12, 4);
1465 }
1466
1467 static void test_pack_PRLIST_ENTRY(void)
1468 {
1469     /* PRLIST_ENTRY */
1470     TEST_TYPE(PRLIST_ENTRY, 4, 4);
1471     TEST_TYPE_POINTER(PRLIST_ENTRY, 8, 4);
1472 }
1473
1474 static void test_pack_PRTL_CRITICAL_SECTION(void)
1475 {
1476     /* PRTL_CRITICAL_SECTION */
1477     TEST_TYPE(PRTL_CRITICAL_SECTION, 4, 4);
1478     TEST_TYPE_POINTER(PRTL_CRITICAL_SECTION, 24, 4);
1479 }
1480
1481 static void test_pack_PRTL_CRITICAL_SECTION_DEBUG(void)
1482 {
1483     /* PRTL_CRITICAL_SECTION_DEBUG */
1484     TEST_TYPE(PRTL_CRITICAL_SECTION_DEBUG, 4, 4);
1485     TEST_TYPE_POINTER(PRTL_CRITICAL_SECTION_DEBUG, 32, 4);
1486 }
1487
1488 static void test_pack_PRTL_OSVERSIONINFOEXW(void)
1489 {
1490     /* PRTL_OSVERSIONINFOEXW */
1491     TEST_TYPE(PRTL_OSVERSIONINFOEXW, 4, 4);
1492     TEST_TYPE_POINTER(PRTL_OSVERSIONINFOEXW, 284, 4);
1493 }
1494
1495 static void test_pack_PRTL_OSVERSIONINFOW(void)
1496 {
1497     /* PRTL_OSVERSIONINFOW */
1498     TEST_TYPE(PRTL_OSVERSIONINFOW, 4, 4);
1499     TEST_TYPE_POINTER(PRTL_OSVERSIONINFOW, 276, 4);
1500 }
1501
1502 static void test_pack_PRTL_RESOURCE_DEBUG(void)
1503 {
1504     /* PRTL_RESOURCE_DEBUG */
1505     TEST_TYPE(PRTL_RESOURCE_DEBUG, 4, 4);
1506     TEST_TYPE_POINTER(PRTL_RESOURCE_DEBUG, 32, 4);
1507 }
1508
1509 static void test_pack_PSECURITY_DESCRIPTOR(void)
1510 {
1511     /* PSECURITY_DESCRIPTOR */
1512     TEST_TYPE(PSECURITY_DESCRIPTOR, 4, 4);
1513 }
1514
1515 static void test_pack_PSECURITY_QUALITY_OF_SERVICE(void)
1516 {
1517     /* PSECURITY_QUALITY_OF_SERVICE */
1518     TEST_TYPE(PSECURITY_QUALITY_OF_SERVICE, 4, 4);
1519 }
1520
1521 static void test_pack_PSID(void)
1522 {
1523     /* PSID */
1524     TEST_TYPE(PSID, 4, 4);
1525 }
1526
1527 static void test_pack_PSID_IDENTIFIER_AUTHORITY(void)
1528 {
1529     /* PSID_IDENTIFIER_AUTHORITY */
1530     TEST_TYPE(PSID_IDENTIFIER_AUTHORITY, 4, 4);
1531     TEST_TYPE_POINTER(PSID_IDENTIFIER_AUTHORITY, 6, 1);
1532 }
1533
1534 static void test_pack_PSINGLE_LIST_ENTRY(void)
1535 {
1536     /* PSINGLE_LIST_ENTRY */
1537     TEST_TYPE(PSINGLE_LIST_ENTRY, 4, 4);
1538     TEST_TYPE_POINTER(PSINGLE_LIST_ENTRY, 4, 4);
1539 }
1540
1541 static void test_pack_PSTR(void)
1542 {
1543     /* PSTR */
1544     TEST_TYPE(PSTR, 4, 4);
1545     TEST_TYPE_POINTER(PSTR, 1, 1);
1546 }
1547
1548 static void test_pack_PSYSTEM_ALARM_ACE(void)
1549 {
1550     /* PSYSTEM_ALARM_ACE */
1551     TEST_TYPE(PSYSTEM_ALARM_ACE, 4, 4);
1552     TEST_TYPE_POINTER(PSYSTEM_ALARM_ACE, 12, 4);
1553 }
1554
1555 static void test_pack_PSYSTEM_AUDIT_ACE(void)
1556 {
1557     /* PSYSTEM_AUDIT_ACE */
1558     TEST_TYPE(PSYSTEM_AUDIT_ACE, 4, 4);
1559     TEST_TYPE_POINTER(PSYSTEM_AUDIT_ACE, 12, 4);
1560 }
1561
1562 static void test_pack_PTOKEN_GROUPS(void)
1563 {
1564     /* PTOKEN_GROUPS */
1565     TEST_TYPE(PTOKEN_GROUPS, 4, 4);
1566     TEST_TYPE_POINTER(PTOKEN_GROUPS, 12, 4);
1567 }
1568
1569 static void test_pack_PTOKEN_PRIVILEGES(void)
1570 {
1571     /* PTOKEN_PRIVILEGES */
1572     TEST_TYPE(PTOKEN_PRIVILEGES, 4, 4);
1573     TEST_TYPE_POINTER(PTOKEN_PRIVILEGES, 16, 4);
1574 }
1575
1576 static void test_pack_PTOKEN_USER(void)
1577 {
1578     /* PTOKEN_USER */
1579     TEST_TYPE(PTOKEN_USER, 4, 4);
1580     TEST_TYPE_POINTER(PTOKEN_USER, 8, 4);
1581 }
1582
1583 static void test_pack_PTOP_LEVEL_EXCEPTION_FILTER(void)
1584 {
1585     /* PTOP_LEVEL_EXCEPTION_FILTER */
1586     TEST_TYPE(PTOP_LEVEL_EXCEPTION_FILTER, 4, 4);
1587 }
1588
1589 static void test_pack_PTSTR(void)
1590 {
1591     /* PTSTR */
1592     TEST_TYPE(PTSTR, 4, 4);
1593 }
1594
1595 static void test_pack_PULARGE_INTEGER(void)
1596 {
1597     /* PULARGE_INTEGER */
1598     TEST_TYPE(PULARGE_INTEGER, 4, 4);
1599 }
1600
1601 static void test_pack_PVECTORED_EXCEPTION_HANDLER(void)
1602 {
1603     /* PVECTORED_EXCEPTION_HANDLER */
1604     TEST_TYPE(PVECTORED_EXCEPTION_HANDLER, 4, 4);
1605 }
1606
1607 static void test_pack_PVOID(void)
1608 {
1609     /* PVOID */
1610     TEST_TYPE(PVOID, 4, 4);
1611 }
1612
1613 static void test_pack_PWCH(void)
1614 {
1615     /* PWCH */
1616     TEST_TYPE(PWCH, 4, 4);
1617     TEST_TYPE_POINTER(PWCH, 2, 2);
1618 }
1619
1620 static void test_pack_PWSTR(void)
1621 {
1622     /* PWSTR */
1623     TEST_TYPE(PWSTR, 4, 4);
1624     TEST_TYPE_POINTER(PWSTR, 2, 2);
1625 }
1626
1627 static void test_pack_RTL_CRITICAL_SECTION(void)
1628 {
1629     /* RTL_CRITICAL_SECTION (pack 4) */
1630     TEST_TYPE(RTL_CRITICAL_SECTION, 24, 4);
1631     TEST_FIELD(RTL_CRITICAL_SECTION, PRTL_CRITICAL_SECTION_DEBUG, DebugInfo, 0, 4, 4);
1632     TEST_FIELD(RTL_CRITICAL_SECTION, LONG, LockCount, 4, 4, 4);
1633     TEST_FIELD(RTL_CRITICAL_SECTION, LONG, RecursionCount, 8, 4, 4);
1634     TEST_FIELD(RTL_CRITICAL_SECTION, HANDLE, OwningThread, 12, 4, 4);
1635     TEST_FIELD(RTL_CRITICAL_SECTION, HANDLE, LockSemaphore, 16, 4, 4);
1636     TEST_FIELD(RTL_CRITICAL_SECTION, ULONG_PTR, SpinCount, 20, 4, 4);
1637 }
1638
1639 static void test_pack_RTL_CRITICAL_SECTION_DEBUG(void)
1640 {
1641     /* RTL_CRITICAL_SECTION_DEBUG (pack 4) */
1642     TEST_TYPE(RTL_CRITICAL_SECTION_DEBUG, 32, 4);
1643     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, WORD, Type, 0, 2, 2);
1644     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, WORD, CreatorBackTraceIndex, 2, 2, 2);
1645     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, struct _RTL_CRITICAL_SECTION *, CriticalSection, 4, 4, 4);
1646     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, LIST_ENTRY, ProcessLocksList, 8, 8, 4);
1647     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, DWORD, EntryCount, 16, 4, 4);
1648     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, DWORD, ContentionCount, 20, 4, 4);
1649     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, DWORD[ 2 ], Spare, 24, 8, 4);
1650 }
1651
1652 static void test_pack_RTL_OSVERSIONINFOEXW(void)
1653 {
1654     /* RTL_OSVERSIONINFOEXW (pack 4) */
1655     TEST_TYPE(RTL_OSVERSIONINFOEXW, 284, 4);
1656     TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
1657     TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwMajorVersion, 4, 4, 4);
1658     TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwMinorVersion, 8, 4, 4);
1659     TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwBuildNumber, 12, 4, 4);
1660     TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwPlatformId, 16, 4, 4);
1661     TEST_FIELD(RTL_OSVERSIONINFOEXW, WCHAR[128], szCSDVersion, 20, 256, 2);
1662     TEST_FIELD(RTL_OSVERSIONINFOEXW, WORD, wServicePackMajor, 276, 2, 2);
1663     TEST_FIELD(RTL_OSVERSIONINFOEXW, WORD, wServicePackMinor, 278, 2, 2);
1664     TEST_FIELD(RTL_OSVERSIONINFOEXW, WORD, wSuiteMask, 280, 2, 2);
1665     TEST_FIELD(RTL_OSVERSIONINFOEXW, BYTE, wProductType, 282, 1, 1);
1666     TEST_FIELD(RTL_OSVERSIONINFOEXW, BYTE, wReserved, 283, 1, 1);
1667 }
1668
1669 static void test_pack_RTL_OSVERSIONINFOW(void)
1670 {
1671     /* RTL_OSVERSIONINFOW (pack 4) */
1672     TEST_TYPE(RTL_OSVERSIONINFOW, 276, 4);
1673     TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
1674     TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwMajorVersion, 4, 4, 4);
1675     TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwMinorVersion, 8, 4, 4);
1676     TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwBuildNumber, 12, 4, 4);
1677     TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwPlatformId, 16, 4, 4);
1678     TEST_FIELD(RTL_OSVERSIONINFOW, WCHAR[128], szCSDVersion, 20, 256, 2);
1679 }
1680
1681 static void test_pack_RTL_RESOURCE_DEBUG(void)
1682 {
1683     /* RTL_RESOURCE_DEBUG (pack 4) */
1684     TEST_TYPE(RTL_RESOURCE_DEBUG, 32, 4);
1685     TEST_FIELD(RTL_RESOURCE_DEBUG, WORD, Type, 0, 2, 2);
1686     TEST_FIELD(RTL_RESOURCE_DEBUG, WORD, CreatorBackTraceIndex, 2, 2, 2);
1687     TEST_FIELD(RTL_RESOURCE_DEBUG, struct _RTL_CRITICAL_SECTION *, CriticalSection, 4, 4, 4);
1688     TEST_FIELD(RTL_RESOURCE_DEBUG, LIST_ENTRY, ProcessLocksList, 8, 8, 4);
1689     TEST_FIELD(RTL_RESOURCE_DEBUG, DWORD, EntryCount, 16, 4, 4);
1690     TEST_FIELD(RTL_RESOURCE_DEBUG, DWORD, ContentionCount, 20, 4, 4);
1691     TEST_FIELD(RTL_RESOURCE_DEBUG, DWORD[ 2 ], Spare, 24, 8, 4);
1692 }
1693
1694 static void test_pack_SECURITY_CONTEXT_TRACKING_MODE(void)
1695 {
1696     /* SECURITY_CONTEXT_TRACKING_MODE */
1697     TEST_TYPE(SECURITY_CONTEXT_TRACKING_MODE, 1, 1);
1698 }
1699
1700 static void test_pack_SECURITY_DESCRIPTOR(void)
1701 {
1702     /* SECURITY_DESCRIPTOR (pack 4) */
1703     TEST_TYPE(SECURITY_DESCRIPTOR, 20, 4);
1704     TEST_FIELD(SECURITY_DESCRIPTOR, BYTE, Revision, 0, 1, 1);
1705     TEST_FIELD(SECURITY_DESCRIPTOR, BYTE, Sbz1, 1, 1, 1);
1706     TEST_FIELD(SECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, Control, 2, 2, 2);
1707     TEST_FIELD(SECURITY_DESCRIPTOR, PSID, Owner, 4, 4, 4);
1708     TEST_FIELD(SECURITY_DESCRIPTOR, PSID, Group, 8, 4, 4);
1709     TEST_FIELD(SECURITY_DESCRIPTOR, PACL, Sacl, 12, 4, 4);
1710     TEST_FIELD(SECURITY_DESCRIPTOR, PACL, Dacl, 16, 4, 4);
1711 }
1712
1713 static void test_pack_SECURITY_DESCRIPTOR_CONTROL(void)
1714 {
1715     /* SECURITY_DESCRIPTOR_CONTROL */
1716     TEST_TYPE(SECURITY_DESCRIPTOR_CONTROL, 2, 2);
1717     TEST_TYPE_UNSIGNED(SECURITY_DESCRIPTOR_CONTROL);
1718 }
1719
1720 static void test_pack_SECURITY_DESCRIPTOR_RELATIVE(void)
1721 {
1722     /* SECURITY_DESCRIPTOR_RELATIVE (pack 4) */
1723     TEST_TYPE(SECURITY_DESCRIPTOR_RELATIVE, 20, 4);
1724     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, BYTE, Revision, 0, 1, 1);
1725     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, BYTE, Sbz1, 1, 1, 1);
1726     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, SECURITY_DESCRIPTOR_CONTROL, Control, 2, 2, 2);
1727     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Owner, 4, 4, 4);
1728     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Group, 8, 4, 4);
1729     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Sacl, 12, 4, 4);
1730     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Dacl, 16, 4, 4);
1731 }
1732
1733 static void test_pack_SECURITY_INFORMATION(void)
1734 {
1735     /* SECURITY_INFORMATION */
1736     TEST_TYPE(SECURITY_INFORMATION, 4, 4);
1737     TEST_TYPE_UNSIGNED(SECURITY_INFORMATION);
1738 }
1739
1740 static void test_pack_SECURITY_QUALITY_OF_SERVICE(void)
1741 {
1742     /* SECURITY_QUALITY_OF_SERVICE (pack 4) */
1743     TEST_FIELD(SECURITY_QUALITY_OF_SERVICE, DWORD, Length, 0, 4, 4);
1744 }
1745
1746 static void test_pack_SHORT(void)
1747 {
1748     /* SHORT */
1749     TEST_TYPE(SHORT, 2, 2);
1750     TEST_TYPE_SIGNED(SHORT);
1751 }
1752
1753 static void test_pack_SID(void)
1754 {
1755     /* SID (pack 4) */
1756     TEST_TYPE(SID, 12, 4);
1757     TEST_FIELD(SID, BYTE, Revision, 0, 1, 1);
1758     TEST_FIELD(SID, BYTE, SubAuthorityCount, 1, 1, 1);
1759     TEST_FIELD(SID, SID_IDENTIFIER_AUTHORITY, IdentifierAuthority, 2, 6, 1);
1760     TEST_FIELD(SID, DWORD[1], SubAuthority, 8, 4, 4);
1761 }
1762
1763 static void test_pack_SID_AND_ATTRIBUTES(void)
1764 {
1765     /* SID_AND_ATTRIBUTES (pack 4) */
1766     TEST_TYPE(SID_AND_ATTRIBUTES, 8, 4);
1767     TEST_FIELD(SID_AND_ATTRIBUTES, PSID, Sid, 0, 4, 4);
1768     TEST_FIELD(SID_AND_ATTRIBUTES, DWORD, Attributes, 4, 4, 4);
1769 }
1770
1771 static void test_pack_SID_IDENTIFIER_AUTHORITY(void)
1772 {
1773     /* SID_IDENTIFIER_AUTHORITY (pack 4) */
1774     TEST_TYPE(SID_IDENTIFIER_AUTHORITY, 6, 1);
1775     TEST_FIELD(SID_IDENTIFIER_AUTHORITY, BYTE[6], Value, 0, 6, 1);
1776 }
1777
1778 static void test_pack_SINGLE_LIST_ENTRY(void)
1779 {
1780     /* SINGLE_LIST_ENTRY (pack 4) */
1781     TEST_TYPE(SINGLE_LIST_ENTRY, 4, 4);
1782     TEST_FIELD(SINGLE_LIST_ENTRY, struct _SINGLE_LIST_ENTRY *, Next, 0, 4, 4);
1783 }
1784
1785 static void test_pack_SYSTEM_ALARM_ACE(void)
1786 {
1787     /* SYSTEM_ALARM_ACE (pack 4) */
1788     TEST_TYPE(SYSTEM_ALARM_ACE, 12, 4);
1789     TEST_FIELD(SYSTEM_ALARM_ACE, ACE_HEADER, Header, 0, 4, 2);
1790     TEST_FIELD(SYSTEM_ALARM_ACE, DWORD, Mask, 4, 4, 4);
1791     TEST_FIELD(SYSTEM_ALARM_ACE, DWORD, SidStart, 8, 4, 4);
1792 }
1793
1794 static void test_pack_SYSTEM_AUDIT_ACE(void)
1795 {
1796     /* SYSTEM_AUDIT_ACE (pack 4) */
1797     TEST_TYPE(SYSTEM_AUDIT_ACE, 12, 4);
1798     TEST_FIELD(SYSTEM_AUDIT_ACE, ACE_HEADER, Header, 0, 4, 2);
1799     TEST_FIELD(SYSTEM_AUDIT_ACE, DWORD, Mask, 4, 4, 4);
1800     TEST_FIELD(SYSTEM_AUDIT_ACE, DWORD, SidStart, 8, 4, 4);
1801 }
1802
1803 static void test_pack_TCHAR(void)
1804 {
1805     /* TCHAR */
1806     TEST_TYPE(TCHAR, 1, 1);
1807 }
1808
1809 static void test_pack_TOKEN_DEFAULT_DACL(void)
1810 {
1811     /* TOKEN_DEFAULT_DACL (pack 4) */
1812     TEST_TYPE(TOKEN_DEFAULT_DACL, 4, 4);
1813     TEST_FIELD(TOKEN_DEFAULT_DACL, PACL, DefaultDacl, 0, 4, 4);
1814 }
1815
1816 static void test_pack_TOKEN_GROUPS(void)
1817 {
1818     /* TOKEN_GROUPS (pack 4) */
1819     TEST_TYPE(TOKEN_GROUPS, 12, 4);
1820     TEST_FIELD(TOKEN_GROUPS, DWORD, GroupCount, 0, 4, 4);
1821     TEST_FIELD(TOKEN_GROUPS, SID_AND_ATTRIBUTES[ANYSIZE_ARRAY], Groups, 4, 8, 4);
1822 }
1823
1824 static void test_pack_TOKEN_OWNER(void)
1825 {
1826     /* TOKEN_OWNER (pack 4) */
1827     TEST_TYPE(TOKEN_OWNER, 4, 4);
1828     TEST_FIELD(TOKEN_OWNER, PSID, Owner, 0, 4, 4);
1829 }
1830
1831 static void test_pack_TOKEN_PRIMARY_GROUP(void)
1832 {
1833     /* TOKEN_PRIMARY_GROUP (pack 4) */
1834     TEST_TYPE(TOKEN_PRIMARY_GROUP, 4, 4);
1835     TEST_FIELD(TOKEN_PRIMARY_GROUP, PSID, PrimaryGroup, 0, 4, 4);
1836 }
1837
1838 static void test_pack_TOKEN_PRIVILEGES(void)
1839 {
1840     /* TOKEN_PRIVILEGES (pack 4) */
1841     TEST_TYPE(TOKEN_PRIVILEGES, 16, 4);
1842     TEST_FIELD(TOKEN_PRIVILEGES, DWORD, PrivilegeCount, 0, 4, 4);
1843     TEST_FIELD(TOKEN_PRIVILEGES, LUID_AND_ATTRIBUTES[ANYSIZE_ARRAY], Privileges, 4, 12, 4);
1844 }
1845
1846 static void test_pack_TOKEN_SOURCE(void)
1847 {
1848     /* TOKEN_SOURCE (pack 4) */
1849     TEST_TYPE(TOKEN_SOURCE, 16, 4);
1850     TEST_FIELD(TOKEN_SOURCE, char[TOKEN_SOURCE_LENGTH], SourceName, 0, 8, 1);
1851     TEST_FIELD(TOKEN_SOURCE, LUID, SourceIdentifier, 8, 8, 4);
1852 }
1853
1854 static void test_pack_TOKEN_STATISTICS(void)
1855 {
1856     /* TOKEN_STATISTICS (pack 4) */
1857     TEST_FIELD(TOKEN_STATISTICS, LUID, TokenId, 0, 8, 4);
1858     TEST_FIELD(TOKEN_STATISTICS, LUID, AuthenticationId, 8, 8, 4);
1859     TEST_FIELD(TOKEN_STATISTICS, LARGE_INTEGER, ExpirationTime, 16, 8, 4);
1860 }
1861
1862 static void test_pack_TOKEN_USER(void)
1863 {
1864     /* TOKEN_USER (pack 4) */
1865     TEST_TYPE(TOKEN_USER, 8, 4);
1866     TEST_FIELD(TOKEN_USER, SID_AND_ATTRIBUTES, User, 0, 8, 4);
1867 }
1868
1869 static void test_pack_ULARGE_INTEGER(void)
1870 {
1871     /* ULARGE_INTEGER (pack 4) */
1872 }
1873
1874 static void test_pack_ULONGLONG(void)
1875 {
1876     /* ULONGLONG */
1877     TEST_TYPE(ULONGLONG, 8, 8);
1878     TEST_TYPE_UNSIGNED(ULONGLONG);
1879 }
1880
1881 static void test_pack_WAITORTIMERCALLBACKFUNC(void)
1882 {
1883     /* WAITORTIMERCALLBACKFUNC */
1884     TEST_TYPE(WAITORTIMERCALLBACKFUNC, 4, 4);
1885 }
1886
1887 static void test_pack_WCHAR(void)
1888 {
1889     /* WCHAR */
1890     TEST_TYPE(WCHAR, 2, 2);
1891     TEST_TYPE_UNSIGNED(WCHAR);
1892 }
1893
1894 static void test_pack_ATOM(void)
1895 {
1896     /* ATOM */
1897     TEST_TYPE(ATOM, 2, 2);
1898     TEST_TYPE_UNSIGNED(ATOM);
1899 }
1900
1901 static void test_pack_BOOL(void)
1902 {
1903     /* BOOL */
1904     TEST_TYPE(BOOL, 4, 4);
1905     TEST_TYPE_SIGNED(BOOL);
1906 }
1907
1908 static void test_pack_BYTE(void)
1909 {
1910     /* BYTE */
1911     TEST_TYPE(BYTE, 1, 1);
1912     TEST_TYPE_UNSIGNED(BYTE);
1913 }
1914
1915 static void test_pack_COLORREF(void)
1916 {
1917     /* COLORREF */
1918     TEST_TYPE(COLORREF, 4, 4);
1919     TEST_TYPE_UNSIGNED(COLORREF);
1920 }
1921
1922 static void test_pack_DWORD(void)
1923 {
1924     /* DWORD */
1925     TEST_TYPE(DWORD, 4, 4);
1926     TEST_TYPE_UNSIGNED(DWORD);
1927 }
1928
1929 static void test_pack_FARPROC(void)
1930 {
1931     /* FARPROC */
1932     TEST_TYPE(FARPROC, 4, 4);
1933 }
1934
1935 static void test_pack_FLOAT(void)
1936 {
1937     /* FLOAT */
1938     TEST_TYPE(FLOAT, 4, 4);
1939 }
1940
1941 static void test_pack_GLOBALHANDLE(void)
1942 {
1943     /* GLOBALHANDLE */
1944     TEST_TYPE(GLOBALHANDLE, 4, 4);
1945 }
1946
1947 static void test_pack_HCURSOR(void)
1948 {
1949     /* HCURSOR */
1950     TEST_TYPE(HCURSOR, 4, 4);
1951     TEST_TYPE_UNSIGNED(HCURSOR);
1952 }
1953
1954 static void test_pack_HFILE(void)
1955 {
1956     /* HFILE */
1957     TEST_TYPE(HFILE, 4, 4);
1958     TEST_TYPE_SIGNED(HFILE);
1959 }
1960
1961 static void test_pack_HGDIOBJ(void)
1962 {
1963     /* HGDIOBJ */
1964     TEST_TYPE(HGDIOBJ, 4, 4);
1965 }
1966
1967 static void test_pack_HGLOBAL(void)
1968 {
1969     /* HGLOBAL */
1970     TEST_TYPE(HGLOBAL, 4, 4);
1971 }
1972
1973 static void test_pack_HLOCAL(void)
1974 {
1975     /* HLOCAL */
1976     TEST_TYPE(HLOCAL, 4, 4);
1977 }
1978
1979 static void test_pack_HMODULE(void)
1980 {
1981     /* HMODULE */
1982     TEST_TYPE(HMODULE, 4, 4);
1983     TEST_TYPE_UNSIGNED(HMODULE);
1984 }
1985
1986 static void test_pack_INT(void)
1987 {
1988     /* INT */
1989     TEST_TYPE(INT, 4, 4);
1990     TEST_TYPE_SIGNED(INT);
1991 }
1992
1993 static void test_pack_LOCALHANDLE(void)
1994 {
1995     /* LOCALHANDLE */
1996     TEST_TYPE(LOCALHANDLE, 4, 4);
1997 }
1998
1999 static void test_pack_LPARAM(void)
2000 {
2001     /* LPARAM */
2002     TEST_TYPE(LPARAM, 4, 4);
2003 }
2004
2005 static void test_pack_LPCRECT(void)
2006 {
2007     /* LPCRECT */
2008     TEST_TYPE(LPCRECT, 4, 4);
2009     TEST_TYPE_POINTER(LPCRECT, 16, 4);
2010 }
2011
2012 static void test_pack_LPCRECTL(void)
2013 {
2014     /* LPCRECTL */
2015     TEST_TYPE(LPCRECTL, 4, 4);
2016     TEST_TYPE_POINTER(LPCRECTL, 16, 4);
2017 }
2018
2019 static void test_pack_LPCVOID(void)
2020 {
2021     /* LPCVOID */
2022     TEST_TYPE(LPCVOID, 4, 4);
2023 }
2024
2025 static void test_pack_LPPOINT(void)
2026 {
2027     /* LPPOINT */
2028     TEST_TYPE(LPPOINT, 4, 4);
2029     TEST_TYPE_POINTER(LPPOINT, 8, 4);
2030 }
2031
2032 static void test_pack_LPPOINTS(void)
2033 {
2034     /* LPPOINTS */
2035     TEST_TYPE(LPPOINTS, 4, 4);
2036     TEST_TYPE_POINTER(LPPOINTS, 4, 2);
2037 }
2038
2039 static void test_pack_LPRECT(void)
2040 {
2041     /* LPRECT */
2042     TEST_TYPE(LPRECT, 4, 4);
2043     TEST_TYPE_POINTER(LPRECT, 16, 4);
2044 }
2045
2046 static void test_pack_LPRECTL(void)
2047 {
2048     /* LPRECTL */
2049     TEST_TYPE(LPRECTL, 4, 4);
2050     TEST_TYPE_POINTER(LPRECTL, 16, 4);
2051 }
2052
2053 static void test_pack_LPSIZE(void)
2054 {
2055     /* LPSIZE */
2056     TEST_TYPE(LPSIZE, 4, 4);
2057     TEST_TYPE_POINTER(LPSIZE, 8, 4);
2058 }
2059
2060 static void test_pack_LRESULT(void)
2061 {
2062     /* LRESULT */
2063     TEST_TYPE(LRESULT, 4, 4);
2064 }
2065
2066 static void test_pack_POINT(void)
2067 {
2068     /* POINT (pack 4) */
2069     TEST_TYPE(POINT, 8, 4);
2070     TEST_FIELD(POINT, LONG, x, 0, 4, 4);
2071     TEST_FIELD(POINT, LONG, y, 4, 4, 4);
2072 }
2073
2074 static void test_pack_POINTL(void)
2075 {
2076     /* POINTL (pack 4) */
2077     TEST_TYPE(POINTL, 8, 4);
2078     TEST_FIELD(POINTL, LONG, x, 0, 4, 4);
2079     TEST_FIELD(POINTL, LONG, y, 4, 4, 4);
2080 }
2081
2082 static void test_pack_POINTS(void)
2083 {
2084     /* POINTS (pack 4) */
2085     TEST_TYPE(POINTS, 4, 2);
2086     TEST_FIELD(POINTS, SHORT, x, 0, 2, 2);
2087     TEST_FIELD(POINTS, SHORT, y, 2, 2, 2);
2088 }
2089
2090 static void test_pack_PPOINT(void)
2091 {
2092     /* PPOINT */
2093     TEST_TYPE(PPOINT, 4, 4);
2094     TEST_TYPE_POINTER(PPOINT, 8, 4);
2095 }
2096
2097 static void test_pack_PPOINTL(void)
2098 {
2099     /* PPOINTL */
2100     TEST_TYPE(PPOINTL, 4, 4);
2101     TEST_TYPE_POINTER(PPOINTL, 8, 4);
2102 }
2103
2104 static void test_pack_PPOINTS(void)
2105 {
2106     /* PPOINTS */
2107     TEST_TYPE(PPOINTS, 4, 4);
2108     TEST_TYPE_POINTER(PPOINTS, 4, 2);
2109 }
2110
2111 static void test_pack_PRECT(void)
2112 {
2113     /* PRECT */
2114     TEST_TYPE(PRECT, 4, 4);
2115     TEST_TYPE_POINTER(PRECT, 16, 4);
2116 }
2117
2118 static void test_pack_PRECTL(void)
2119 {
2120     /* PRECTL */
2121     TEST_TYPE(PRECTL, 4, 4);
2122     TEST_TYPE_POINTER(PRECTL, 16, 4);
2123 }
2124
2125 static void test_pack_PROC(void)
2126 {
2127     /* PROC */
2128     TEST_TYPE(PROC, 4, 4);
2129 }
2130
2131 static void test_pack_PSIZE(void)
2132 {
2133     /* PSIZE */
2134     TEST_TYPE(PSIZE, 4, 4);
2135     TEST_TYPE_POINTER(PSIZE, 8, 4);
2136 }
2137
2138 static void test_pack_PSZ(void)
2139 {
2140     /* PSZ */
2141     TEST_TYPE(PSZ, 4, 4);
2142 }
2143
2144 static void test_pack_RECT(void)
2145 {
2146     /* RECT (pack 4) */
2147     TEST_TYPE(RECT, 16, 4);
2148     TEST_FIELD(RECT, LONG, left, 0, 4, 4);
2149     TEST_FIELD(RECT, LONG, top, 4, 4, 4);
2150     TEST_FIELD(RECT, LONG, right, 8, 4, 4);
2151     TEST_FIELD(RECT, LONG, bottom, 12, 4, 4);
2152 }
2153
2154 static void test_pack_RECTL(void)
2155 {
2156     /* RECTL (pack 4) */
2157     TEST_TYPE(RECTL, 16, 4);
2158     TEST_FIELD(RECTL, LONG, left, 0, 4, 4);
2159     TEST_FIELD(RECTL, LONG, top, 4, 4, 4);
2160     TEST_FIELD(RECTL, LONG, right, 8, 4, 4);
2161     TEST_FIELD(RECTL, LONG, bottom, 12, 4, 4);
2162 }
2163
2164 static void test_pack_SIZE(void)
2165 {
2166     /* SIZE (pack 4) */
2167     TEST_TYPE(SIZE, 8, 4);
2168     TEST_FIELD(SIZE, LONG, cx, 0, 4, 4);
2169     TEST_FIELD(SIZE, LONG, cy, 4, 4, 4);
2170 }
2171
2172 static void test_pack_SIZEL(void)
2173 {
2174     /* SIZEL */
2175     TEST_TYPE(SIZEL, 8, 4);
2176 }
2177
2178 static void test_pack_UCHAR(void)
2179 {
2180     /* UCHAR */
2181     TEST_TYPE(UCHAR, 1, 1);
2182     TEST_TYPE_UNSIGNED(UCHAR);
2183 }
2184
2185 static void test_pack_UINT(void)
2186 {
2187     /* UINT */
2188     TEST_TYPE(UINT, 4, 4);
2189     TEST_TYPE_UNSIGNED(UINT);
2190 }
2191
2192 static void test_pack_ULONG(void)
2193 {
2194     /* ULONG */
2195     TEST_TYPE(ULONG, 4, 4);
2196     TEST_TYPE_UNSIGNED(ULONG);
2197 }
2198
2199 static void test_pack_USHORT(void)
2200 {
2201     /* USHORT */
2202     TEST_TYPE(USHORT, 2, 2);
2203     TEST_TYPE_UNSIGNED(USHORT);
2204 }
2205
2206 static void test_pack_WORD(void)
2207 {
2208     /* WORD */
2209     TEST_TYPE(WORD, 2, 2);
2210     TEST_TYPE_UNSIGNED(WORD);
2211 }
2212
2213 static void test_pack_WPARAM(void)
2214 {
2215     /* WPARAM */
2216     TEST_TYPE(WPARAM, 4, 4);
2217 }
2218
2219 static void test_pack(void)
2220 {
2221     test_pack_ACCESS_ALLOWED_ACE();
2222     test_pack_ACCESS_DENIED_ACE();
2223     test_pack_ACCESS_MASK();
2224     test_pack_ACE_HEADER();
2225     test_pack_ACL();
2226     test_pack_ACL_REVISION_INFORMATION();
2227     test_pack_ACL_SIZE_INFORMATION();
2228     test_pack_ATOM();
2229     test_pack_BOOL();
2230     test_pack_BOOLEAN();
2231     test_pack_BYTE();
2232     test_pack_CCHAR();
2233     test_pack_CHAR();
2234     test_pack_COLORREF();
2235     test_pack_DWORD();
2236     test_pack_DWORD32();
2237     test_pack_DWORD64();
2238     test_pack_DWORDLONG();
2239     test_pack_DWORD_PTR();
2240     test_pack_EXCEPTION_POINTERS();
2241     test_pack_EXCEPTION_RECORD();
2242     test_pack_EXECUTION_STATE();
2243     test_pack_FARPROC();
2244     test_pack_FLOAT();
2245     test_pack_FLOATING_SAVE_AREA();
2246     test_pack_FPO_DATA();
2247     test_pack_GENERIC_MAPPING();
2248     test_pack_GLOBALHANDLE();
2249     test_pack_HALF_PTR();
2250     test_pack_HANDLE();
2251     test_pack_HCURSOR();
2252     test_pack_HFILE();
2253     test_pack_HGDIOBJ();
2254     test_pack_HGLOBAL();
2255     test_pack_HLOCAL();
2256     test_pack_HMODULE();
2257     test_pack_HRESULT();
2258     test_pack_IMAGE_ARCHIVE_MEMBER_HEADER();
2259     test_pack_IMAGE_AUX_SYMBOL();
2260     test_pack_IMAGE_BASE_RELOCATION();
2261     test_pack_IMAGE_BOUND_FORWARDER_REF();
2262     test_pack_IMAGE_BOUND_IMPORT_DESCRIPTOR();
2263     test_pack_IMAGE_COFF_SYMBOLS_HEADER();
2264     test_pack_IMAGE_DATA_DIRECTORY();
2265     test_pack_IMAGE_DEBUG_DIRECTORY();
2266     test_pack_IMAGE_DEBUG_MISC();
2267     test_pack_IMAGE_DOS_HEADER();
2268     test_pack_IMAGE_EXPORT_DIRECTORY();
2269     test_pack_IMAGE_FILE_HEADER();
2270     test_pack_IMAGE_FUNCTION_ENTRY();
2271     test_pack_IMAGE_IMPORT_BY_NAME();
2272     test_pack_IMAGE_IMPORT_DESCRIPTOR();
2273     test_pack_IMAGE_LINENUMBER();
2274     test_pack_IMAGE_LOAD_CONFIG_DIRECTORY();
2275     test_pack_IMAGE_NT_HEADERS();
2276     test_pack_IMAGE_OPTIONAL_HEADER();
2277     test_pack_IMAGE_OS2_HEADER();
2278     test_pack_IMAGE_RELOCATION();
2279     test_pack_IMAGE_RESOURCE_DATA_ENTRY();
2280     test_pack_IMAGE_RESOURCE_DIRECTORY();
2281     test_pack_IMAGE_RESOURCE_DIRECTORY_ENTRY();
2282     test_pack_IMAGE_RESOURCE_DIRECTORY_STRING();
2283     test_pack_IMAGE_RESOURCE_DIR_STRING_U();
2284     test_pack_IMAGE_SECTION_HEADER();
2285     test_pack_IMAGE_SEPARATE_DEBUG_HEADER();
2286     test_pack_IMAGE_SYMBOL();
2287     test_pack_IMAGE_THUNK_DATA();
2288     test_pack_IMAGE_TLS_DIRECTORY();
2289     test_pack_IMAGE_VXD_HEADER();
2290     test_pack_INT();
2291     test_pack_INT16();
2292     test_pack_INT32();
2293     test_pack_INT64();
2294     test_pack_INT8();
2295     test_pack_INT_PTR();
2296     test_pack_IO_COUNTERS();
2297     test_pack_LANGID();
2298     test_pack_LARGE_INTEGER();
2299     test_pack_LCID();
2300     test_pack_LIST_ENTRY();
2301     test_pack_LOCALHANDLE();
2302     test_pack_LONG();
2303     test_pack_LONG32();
2304     test_pack_LONG64();
2305     test_pack_LONGLONG();
2306     test_pack_LONG_PTR();
2307     test_pack_LPARAM();
2308     test_pack_LPCRECT();
2309     test_pack_LPCRECTL();
2310     test_pack_LPCVOID();
2311     test_pack_LPPOINT();
2312     test_pack_LPPOINTS();
2313     test_pack_LPRECT();
2314     test_pack_LPRECTL();
2315     test_pack_LPSIZE();
2316     test_pack_LPTOP_LEVEL_EXCEPTION_FILTER();
2317     test_pack_LRESULT();
2318     test_pack_LUID();
2319     test_pack_LUID_AND_ATTRIBUTES();
2320     test_pack_MEMORY_BASIC_INFORMATION();
2321     test_pack_MESSAGE_RESOURCE_BLOCK();
2322     test_pack_MESSAGE_RESOURCE_DATA();
2323     test_pack_MESSAGE_RESOURCE_ENTRY();
2324     test_pack_NT_TIB();
2325     test_pack_OBJECT_TYPE_LIST();
2326     test_pack_PACCESS_ALLOWED_ACE();
2327     test_pack_PACCESS_DENIED_ACE();
2328     test_pack_PACCESS_TOKEN();
2329     test_pack_PACE_HEADER();
2330     test_pack_PACL();
2331     test_pack_PACL_REVISION_INFORMATION();
2332     test_pack_PACL_SIZE_INFORMATION();
2333     test_pack_PCCH();
2334     test_pack_PCH();
2335     test_pack_PCSTR();
2336     test_pack_PCTSTR();
2337     test_pack_PCWCH();
2338     test_pack_PCWSTR();
2339     test_pack_PEXCEPTION_POINTERS();
2340     test_pack_PEXCEPTION_RECORD();
2341     test_pack_PFLOATING_SAVE_AREA();
2342     test_pack_PFPO_DATA();
2343     test_pack_PGENERIC_MAPPING();
2344     test_pack_PHANDLE();
2345     test_pack_PIMAGE_ARCHIVE_MEMBER_HEADER();
2346     test_pack_PIMAGE_AUX_SYMBOL();
2347     test_pack_PIMAGE_BASE_RELOCATION();
2348     test_pack_PIMAGE_BOUND_FORWARDER_REF();
2349     test_pack_PIMAGE_BOUND_IMPORT_DESCRIPTOR();
2350     test_pack_PIMAGE_COFF_SYMBOLS_HEADER();
2351     test_pack_PIMAGE_DATA_DIRECTORY();
2352     test_pack_PIMAGE_DEBUG_DIRECTORY();
2353     test_pack_PIMAGE_DEBUG_MISC();
2354     test_pack_PIMAGE_DOS_HEADER();
2355     test_pack_PIMAGE_EXPORT_DIRECTORY();
2356     test_pack_PIMAGE_FILE_HEADER();
2357     test_pack_PIMAGE_FUNCTION_ENTRY();
2358     test_pack_PIMAGE_IMPORT_BY_NAME();
2359     test_pack_PIMAGE_IMPORT_DESCRIPTOR();
2360     test_pack_PIMAGE_LINENUMBER();
2361     test_pack_PIMAGE_LOAD_CONFIG_DIRECTORY();
2362     test_pack_PIMAGE_NT_HEADERS();
2363     test_pack_PIMAGE_OPTIONAL_HEADER();
2364     test_pack_PIMAGE_OS2_HEADER();
2365     test_pack_PIMAGE_RELOCATION();
2366     test_pack_PIMAGE_RESOURCE_DATA_ENTRY();
2367     test_pack_PIMAGE_RESOURCE_DIRECTORY();
2368     test_pack_PIMAGE_RESOURCE_DIRECTORY_ENTRY();
2369     test_pack_PIMAGE_RESOURCE_DIRECTORY_STRING();
2370     test_pack_PIMAGE_RESOURCE_DIR_STRING_U();
2371     test_pack_PIMAGE_SECTION_HEADER();
2372     test_pack_PIMAGE_SEPARATE_DEBUG_HEADER();
2373     test_pack_PIMAGE_SYMBOL();
2374     test_pack_PIMAGE_THUNK_DATA();
2375     test_pack_PIMAGE_TLS_CALLBACK();
2376     test_pack_PIMAGE_TLS_DIRECTORY();
2377     test_pack_PIMAGE_VXD_HEADER();
2378     test_pack_PIO_COUNTERS();
2379     test_pack_PISECURITY_DESCRIPTOR();
2380     test_pack_PISECURITY_DESCRIPTOR_RELATIVE();
2381     test_pack_PISID();
2382     test_pack_PLARGE_INTEGER();
2383     test_pack_PLIST_ENTRY();
2384     test_pack_PLUID();
2385     test_pack_PLUID_AND_ATTRIBUTES();
2386     test_pack_PMEMORY_BASIC_INFORMATION();
2387     test_pack_PMESSAGE_RESOURCE_BLOCK();
2388     test_pack_PMESSAGE_RESOURCE_DATA();
2389     test_pack_PMESSAGE_RESOURCE_ENTRY();
2390     test_pack_PNT_TIB();
2391     test_pack_POBJECT_TYPE_LIST();
2392     test_pack_POINT();
2393     test_pack_POINTL();
2394     test_pack_POINTS();
2395     test_pack_PPOINT();
2396     test_pack_PPOINTL();
2397     test_pack_PPOINTS();
2398     test_pack_PPRIVILEGE_SET();
2399     test_pack_PRECT();
2400     test_pack_PRECTL();
2401     test_pack_PRIVILEGE_SET();
2402     test_pack_PRLIST_ENTRY();
2403     test_pack_PROC();
2404     test_pack_PRTL_CRITICAL_SECTION();
2405     test_pack_PRTL_CRITICAL_SECTION_DEBUG();
2406     test_pack_PRTL_OSVERSIONINFOEXW();
2407     test_pack_PRTL_OSVERSIONINFOW();
2408     test_pack_PRTL_RESOURCE_DEBUG();
2409     test_pack_PSECURITY_DESCRIPTOR();
2410     test_pack_PSECURITY_QUALITY_OF_SERVICE();
2411     test_pack_PSID();
2412     test_pack_PSID_IDENTIFIER_AUTHORITY();
2413     test_pack_PSINGLE_LIST_ENTRY();
2414     test_pack_PSIZE();
2415     test_pack_PSTR();
2416     test_pack_PSYSTEM_ALARM_ACE();
2417     test_pack_PSYSTEM_AUDIT_ACE();
2418     test_pack_PSZ();
2419     test_pack_PTOKEN_GROUPS();
2420     test_pack_PTOKEN_PRIVILEGES();
2421     test_pack_PTOKEN_USER();
2422     test_pack_PTOP_LEVEL_EXCEPTION_FILTER();
2423     test_pack_PTSTR();
2424     test_pack_PULARGE_INTEGER();
2425     test_pack_PVECTORED_EXCEPTION_HANDLER();
2426     test_pack_PVOID();
2427     test_pack_PWCH();
2428     test_pack_PWSTR();
2429     test_pack_RECT();
2430     test_pack_RECTL();
2431     test_pack_RTL_CRITICAL_SECTION();
2432     test_pack_RTL_CRITICAL_SECTION_DEBUG();
2433     test_pack_RTL_OSVERSIONINFOEXW();
2434     test_pack_RTL_OSVERSIONINFOW();
2435     test_pack_RTL_RESOURCE_DEBUG();
2436     test_pack_SECURITY_CONTEXT_TRACKING_MODE();
2437     test_pack_SECURITY_DESCRIPTOR();
2438     test_pack_SECURITY_DESCRIPTOR_CONTROL();
2439     test_pack_SECURITY_DESCRIPTOR_RELATIVE();
2440     test_pack_SECURITY_INFORMATION();
2441     test_pack_SECURITY_QUALITY_OF_SERVICE();
2442     test_pack_SHORT();
2443     test_pack_SID();
2444     test_pack_SID_AND_ATTRIBUTES();
2445     test_pack_SID_IDENTIFIER_AUTHORITY();
2446     test_pack_SINGLE_LIST_ENTRY();
2447     test_pack_SIZE();
2448     test_pack_SIZEL();
2449     test_pack_SIZE_T();
2450     test_pack_SSIZE_T();
2451     test_pack_SYSTEM_ALARM_ACE();
2452     test_pack_SYSTEM_AUDIT_ACE();
2453     test_pack_TCHAR();
2454     test_pack_TOKEN_DEFAULT_DACL();
2455     test_pack_TOKEN_GROUPS();
2456     test_pack_TOKEN_OWNER();
2457     test_pack_TOKEN_PRIMARY_GROUP();
2458     test_pack_TOKEN_PRIVILEGES();
2459     test_pack_TOKEN_SOURCE();
2460     test_pack_TOKEN_STATISTICS();
2461     test_pack_TOKEN_USER();
2462     test_pack_UCHAR();
2463     test_pack_UHALF_PTR();
2464     test_pack_UINT();
2465     test_pack_UINT16();
2466     test_pack_UINT32();
2467     test_pack_UINT64();
2468     test_pack_UINT8();
2469     test_pack_UINT_PTR();
2470     test_pack_ULARGE_INTEGER();
2471     test_pack_ULONG();
2472     test_pack_ULONG32();
2473     test_pack_ULONG64();
2474     test_pack_ULONGLONG();
2475     test_pack_ULONG_PTR();
2476     test_pack_USHORT();
2477     test_pack_WAITORTIMERCALLBACKFUNC();
2478     test_pack_WCHAR();
2479     test_pack_WORD();
2480     test_pack_WPARAM();
2481 }
2482
2483 START_TEST(generated)
2484 {
2485     test_pack();
2486 }