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