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