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