dlls/kernel/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 defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
  31 # define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
  32 #elif defined(__GNUC__)
  33 # define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
  34 #else
  35 /* FIXME: Not sure if is possible to do without compiler extension */
  36 #endif
  37
  38 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
  39 # define _TYPE_ALIGNMENT(type) __alignof(type)
  40 #elif defined(__GNUC__)
  41 # define _TYPE_ALIGNMENT(type) __alignof__(type)
  42 #else
  43 /*
  44  * FIXME: Not sure if is possible to do without compiler extension
  45  *        (if type is not just a name that is, if so the normal)
  46  *         TYPE_ALIGNMENT can be used)
  47  */
  48 #endif
  49
  50 #if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)
  51 #pragma warning(disable:4116)
  52 #endif
  53
  54 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
  55 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
  56 #endif
  57
  58 /***********************************************************************
  59  * Test helper macros
  60  */
  61
  62 #ifdef FIELD_ALIGNMENT
  63 # define TEST_FIELD_ALIGNMENT(type, field, align) \
  64    ok(FIELD_ALIGNMENT(type, field) == align, \
  65        "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")\n", \
  66            (int)FIELD_ALIGNMENT(type, field))
  67 #else
  68 # define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
  69 #endif
  70
  71 #define TEST_FIELD_OFFSET(type, field, offset) \
  72     ok(FIELD_OFFSET(type, field) == offset, \
  73         "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")\n", \
  74              (long int)FIELD_OFFSET(type, field))
  75
  76 #ifdef _TYPE_ALIGNMENT
  77 #define TEST__TYPE_ALIGNMENT(type, align) \
  78     ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)_TYPE_ALIGNMENT(type))
  79 #else
  80 # define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
  81 #endif
  82
  83 #ifdef TYPE_ALIGNMENT
  84 #define TEST_TYPE_ALIGNMENT(type, align) \
  85     ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)TYPE_ALIGNMENT(type))
  86 #else
  87 # define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
  88 #endif
  89
  90 #define TEST_TYPE_SIZE(type, size) \
  91     ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")\n", ((int) sizeof(type)))
  92
  93 /***********************************************************************
  94  * Test macros
  95  */
  96
  97 #define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
  98   TEST_TYPE_SIZE(field_type, field_size); \
  99   TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
 100   TEST_FIELD_OFFSET(type, field_name, field_offset); \
 101
 102 #define TEST_TYPE(type, size, align) \
 103   TEST_TYPE_ALIGNMENT(type, align); \
 104   TEST_TYPE_SIZE(type, size)
 105
 106 #define TEST_TYPE_POINTER(type, size, align) \
 107     TEST__TYPE_ALIGNMENT(*(type)0, align); \
 108     TEST_TYPE_SIZE(*(type)0, size)
 109
 110 #define TEST_TYPE_SIGNED(type) \
 111     ok((type) -1 < 0, "(" #type ") -1 < 0\n");
 112
 113 #define TEST_TYPE_UNSIGNED(type) \
 114      ok((type) -1 > 0, "(" #type ") -1 > 0\n");
 115
 116 static void test_pack_LPOSVERSIONINFOA(void)
 117 {
 118     /* LPOSVERSIONINFOA */
 119     TEST_TYPE(LPOSVERSIONINFOA, 4, 4);
 120     TEST_TYPE_POINTER(LPOSVERSIONINFOA, 148, 4);
 121 }
 122
 123 static void test_pack_LPOSVERSIONINFOEXA(void)
 124 {
 125     /* LPOSVERSIONINFOEXA */
 126     TEST_TYPE(LPOSVERSIONINFOEXA, 4, 4);
 127     TEST_TYPE_POINTER(LPOSVERSIONINFOEXA, 156, 4);
 128 }
 129
 130 static void test_pack_LPOSVERSIONINFOEXW(void)
 131 {
 132     /* LPOSVERSIONINFOEXW */
 133     TEST_TYPE(LPOSVERSIONINFOEXW, 4, 4);
 134     TEST_TYPE_POINTER(LPOSVERSIONINFOEXW, 284, 4);
 135 }
 136
 137 static void test_pack_LPOSVERSIONINFOW(void)
 138 {
 139     /* LPOSVERSIONINFOW */
 140     TEST_TYPE(LPOSVERSIONINFOW, 4, 4);
 141     TEST_TYPE_POINTER(LPOSVERSIONINFOW, 276, 4);
 142 }
 143
 144 static void test_pack_OSVERSIONINFOA(void)
 145 {
 146     /* OSVERSIONINFOA (pack 4) */
 147     TEST_TYPE(OSVERSIONINFOA, 148, 4);
 148     TEST_FIELD(OSVERSIONINFOA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
 149     TEST_FIELD(OSVERSIONINFOA, DWORD, dwMajorVersion, 4, 4, 4);
 150     TEST_FIELD(OSVERSIONINFOA, DWORD, dwMinorVersion, 8, 4, 4);
 151     TEST_FIELD(OSVERSIONINFOA, DWORD, dwBuildNumber, 12, 4, 4);
 152     TEST_FIELD(OSVERSIONINFOA, DWORD, dwPlatformId, 16, 4, 4);
 153     TEST_FIELD(OSVERSIONINFOA, CHAR[128], szCSDVersion, 20, 128, 1);
 154 }
 155
 156 static void test_pack_OSVERSIONINFOEXA(void)
 157 {
 158     /* OSVERSIONINFOEXA (pack 4) */
 159     TEST_TYPE(OSVERSIONINFOEXA, 156, 4);
 160     TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
 161     TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwMajorVersion, 4, 4, 4);
 162     TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwMinorVersion, 8, 4, 4);
 163     TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwBuildNumber, 12, 4, 4);
 164     TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwPlatformId, 16, 4, 4);
 165     TEST_FIELD(OSVERSIONINFOEXA, CHAR[128], szCSDVersion, 20, 128, 1);
 166     TEST_FIELD(OSVERSIONINFOEXA, WORD, wServicePackMajor, 148, 2, 2);
 167     TEST_FIELD(OSVERSIONINFOEXA, WORD, wServicePackMinor, 150, 2, 2);
 168     TEST_FIELD(OSVERSIONINFOEXA, WORD, wSuiteMask, 152, 2, 2);
 169     TEST_FIELD(OSVERSIONINFOEXA, BYTE, wProductType, 154, 1, 1);
 170     TEST_FIELD(OSVERSIONINFOEXA, BYTE, wReserved, 155, 1, 1);
 171 }
 172
 173 static void test_pack_OSVERSIONINFOEXW(void)
 174 {
 175     /* OSVERSIONINFOEXW (pack 4) */
 176     TEST_TYPE(OSVERSIONINFOEXW, 284, 4);
 177     TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
 178     TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwMajorVersion, 4, 4, 4);
 179     TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwMinorVersion, 8, 4, 4);
 180     TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwBuildNumber, 12, 4, 4);
 181     TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwPlatformId, 16, 4, 4);
 182     TEST_FIELD(OSVERSIONINFOEXW, WCHAR[128], szCSDVersion, 20, 256, 2);
 183     TEST_FIELD(OSVERSIONINFOEXW, WORD, wServicePackMajor, 276, 2, 2);
 184     TEST_FIELD(OSVERSIONINFOEXW, WORD, wServicePackMinor, 278, 2, 2);
 185     TEST_FIELD(OSVERSIONINFOEXW, WORD, wSuiteMask, 280, 2, 2);
 186     TEST_FIELD(OSVERSIONINFOEXW, BYTE, wProductType, 282, 1, 1);
 187     TEST_FIELD(OSVERSIONINFOEXW, BYTE, wReserved, 283, 1, 1);
 188 }
 189
 190 static void test_pack_OSVERSIONINFOW(void)
 191 {
 192     /* OSVERSIONINFOW (pack 4) */
 193     TEST_TYPE(OSVERSIONINFOW, 276, 4);
 194     TEST_FIELD(OSVERSIONINFOW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
 195     TEST_FIELD(OSVERSIONINFOW, DWORD, dwMajorVersion, 4, 4, 4);
 196     TEST_FIELD(OSVERSIONINFOW, DWORD, dwMinorVersion, 8, 4, 4);
 197     TEST_FIELD(OSVERSIONINFOW, DWORD, dwBuildNumber, 12, 4, 4);
 198     TEST_FIELD(OSVERSIONINFOW, DWORD, dwPlatformId, 16, 4, 4);
 199     TEST_FIELD(OSVERSIONINFOW, WCHAR[128], szCSDVersion, 20, 256, 2);
 200 }
 201
 202 static void test_pack_POSVERSIONINFOA(void)
 203 {
 204     /* POSVERSIONINFOA */
 205     TEST_TYPE(POSVERSIONINFOA, 4, 4);
 206     TEST_TYPE_POINTER(POSVERSIONINFOA, 148, 4);
 207 }
 208
 209 static void test_pack_POSVERSIONINFOEXA(void)
 210 {
 211     /* POSVERSIONINFOEXA */
 212     TEST_TYPE(POSVERSIONINFOEXA, 4, 4);
 213     TEST_TYPE_POINTER(POSVERSIONINFOEXA, 156, 4);
 214 }
 215
 216 static void test_pack_POSVERSIONINFOEXW(void)
 217 {
 218     /* POSVERSIONINFOEXW */
 219     TEST_TYPE(POSVERSIONINFOEXW, 4, 4);
 220     TEST_TYPE_POINTER(POSVERSIONINFOEXW, 284, 4);
 221 }
 222
 223 static void test_pack_POSVERSIONINFOW(void)
 224 {
 225     /* POSVERSIONINFOW */
 226     TEST_TYPE(POSVERSIONINFOW, 4, 4);
 227     TEST_TYPE_POINTER(POSVERSIONINFOW, 276, 4);
 228 }
 229
 230 static void test_pack_LPLONG(void)
 231 {
 232     /* LPLONG */
 233     TEST_TYPE(LPLONG, 4, 4);
 234 }
 235
 236 static void test_pack_LPVOID(void)
 237 {
 238     /* LPVOID */
 239     TEST_TYPE(LPVOID, 4, 4);
 240 }
 241
 242 static void test_pack_PHKEY(void)
 243 {
 244     /* PHKEY */
 245     TEST_TYPE(PHKEY, 4, 4);
 246 }
 247
 248 static void test_pack_ACTCTXA(void)
 249 {
 250     /* ACTCTXA (pack 4) */
 251     TEST_TYPE(ACTCTXA, 32, 4);
 252     TEST_FIELD(ACTCTXA, ULONG, cbSize, 0, 4, 4);
 253     TEST_FIELD(ACTCTXA, DWORD, dwFlags, 4, 4, 4);
 254     TEST_FIELD(ACTCTXA, LPCSTR, lpSource, 8, 4, 4);
 255     TEST_FIELD(ACTCTXA, USHORT, wProcessorArchitecture, 12, 2, 2);
 256     TEST_FIELD(ACTCTXA, LANGID, wLangId, 14, 2, 2);
 257     TEST_FIELD(ACTCTXA, LPCSTR, lpAssemblyDirectory, 16, 4, 4);
 258     TEST_FIELD(ACTCTXA, LPCSTR, lpResourceName, 20, 4, 4);
 259     TEST_FIELD(ACTCTXA, LPCSTR, lpApplicationName, 24, 4, 4);
 260     TEST_FIELD(ACTCTXA, HMODULE, hModule, 28, 4, 4);
 261 }
 262
 263 static void test_pack_ACTCTXW(void)
 264 {
 265     /* ACTCTXW (pack 4) */
 266     TEST_TYPE(ACTCTXW, 32, 4);
 267     TEST_FIELD(ACTCTXW, ULONG, cbSize, 0, 4, 4);
 268     TEST_FIELD(ACTCTXW, DWORD, dwFlags, 4, 4, 4);
 269     TEST_FIELD(ACTCTXW, LPCWSTR, lpSource, 8, 4, 4);
 270     TEST_FIELD(ACTCTXW, USHORT, wProcessorArchitecture, 12, 2, 2);
 271     TEST_FIELD(ACTCTXW, LANGID, wLangId, 14, 2, 2);
 272     TEST_FIELD(ACTCTXW, LPCWSTR, lpAssemblyDirectory, 16, 4, 4);
 273     TEST_FIELD(ACTCTXW, LPCWSTR, lpResourceName, 20, 4, 4);
 274     TEST_FIELD(ACTCTXW, LPCWSTR, lpApplicationName, 24, 4, 4);
 275     TEST_FIELD(ACTCTXW, HMODULE, hModule, 28, 4, 4);
 276 }
 277
 278 static void test_pack_ACTCTX_SECTION_KEYED_DATA(void)
 279 {
 280     /* ACTCTX_SECTION_KEYED_DATA (pack 4) */
 281     TEST_TYPE(ACTCTX_SECTION_KEYED_DATA, 64, 4);
 282     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, cbSize, 0, 4, 4);
 283     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulDataFormatVersion, 4, 4, 4);
 284     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, PVOID, lpData, 8, 4, 4);
 285     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulLength, 12, 4, 4);
 286     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, PVOID, lpSectionGlobalData, 16, 4, 4);
 287     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulSectionGlobalDataLength, 20, 4, 4);
 288     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, PVOID, lpSectionBase, 24, 4, 4);
 289     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulSectionTotalLength, 28, 4, 4);
 290     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, HANDLE, hActCtx, 32, 4, 4);
 291     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulAssemblyRosterIndex, 36, 4, 4);
 292     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulFlags, 40, 4, 4);
 293     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, AssemblyMetadata, 44, 20, 4);
 294 }
 295
 296 static void test_pack_ACTCTX_SECTION_KEYED_DATA_2600(void)
 297 {
 298     /* ACTCTX_SECTION_KEYED_DATA_2600 (pack 4) */
 299     TEST_TYPE(ACTCTX_SECTION_KEYED_DATA_2600, 40, 4);
 300     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, cbSize, 0, 4, 4);
 301     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulDataFormatVersion, 4, 4, 4);
 302     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, PVOID, lpData, 8, 4, 4);
 303     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulLength, 12, 4, 4);
 304     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, PVOID, lpSectionGlobalData, 16, 4, 4);
 305     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulSectionGlobalDataLength, 20, 4, 4);
 306     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, PVOID, lpSectionBase, 24, 4, 4);
 307     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulSectionTotalLength, 28, 4, 4);
 308     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, HANDLE, hActCtx, 32, 4, 4);
 309     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulAssemblyRosterIndex, 36, 4, 4);
 310 }
 311
 312 static void test_pack_ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA(void)
 313 {
 314     /* ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA (pack 4) */
 315     TEST_TYPE(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 20, 4);
 316     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, PVOID, lpInformation, 0, 4, 4);
 317     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, PVOID, lpSectionBase, 4, 4, 4);
 318     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, ULONG, ulSectionLength, 8, 4, 4);
 319     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, PVOID, lpSectionGlobalDataBase, 12, 4, 4);
 320     TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, ULONG, ulSectionGlobalDataLength, 16, 4, 4);
 321 }
 322
 323 static void test_pack_ACTIVATION_CONTEXT_BASIC_INFORMATION(void)
 324 {
 325     /* ACTIVATION_CONTEXT_BASIC_INFORMATION (pack 4) */
 326     TEST_TYPE(ACTIVATION_CONTEXT_BASIC_INFORMATION, 8, 4);
 327     TEST_FIELD(ACTIVATION_CONTEXT_BASIC_INFORMATION, HANDLE, hActCtx, 0, 4, 4);
 328     TEST_FIELD(ACTIVATION_CONTEXT_BASIC_INFORMATION, DWORD, dwFlags, 4, 4, 4);
 329 }
 330
 331 static void test_pack_BY_HANDLE_FILE_INFORMATION(void)
 332 {
 333     /* BY_HANDLE_FILE_INFORMATION (pack 4) */
 334     TEST_TYPE(BY_HANDLE_FILE_INFORMATION, 52, 4);
 335     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, dwFileAttributes, 0, 4, 4);
 336     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, FILETIME, ftCreationTime, 4, 8, 4);
 337     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, FILETIME, ftLastAccessTime, 12, 8, 4);
 338     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, FILETIME, ftLastWriteTime, 20, 8, 4);
 339     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, dwVolumeSerialNumber, 28, 4, 4);
 340     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileSizeHigh, 32, 4, 4);
 341     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileSizeLow, 36, 4, 4);
 342     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nNumberOfLinks, 40, 4, 4);
 343     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileIndexHigh, 44, 4, 4);
 344     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileIndexLow, 48, 4, 4);
 345 }
 346
 347 static void test_pack_COMMCONFIG(void)
 348 {
 349     /* COMMCONFIG (pack 4) */
 350     TEST_TYPE(COMMCONFIG, 52, 4);
 351     TEST_FIELD(COMMCONFIG, DWORD, dwSize, 0, 4, 4);
 352     TEST_FIELD(COMMCONFIG, WORD, wVersion, 4, 2, 2);
 353     TEST_FIELD(COMMCONFIG, WORD, wReserved, 6, 2, 2);
 354     TEST_FIELD(COMMCONFIG, DCB, dcb, 8, 28, 4);
 355     TEST_FIELD(COMMCONFIG, DWORD, dwProviderSubType, 36, 4, 4);
 356     TEST_FIELD(COMMCONFIG, DWORD, dwProviderOffset, 40, 4, 4);
 357     TEST_FIELD(COMMCONFIG, DWORD, dwProviderSize, 44, 4, 4);
 358     TEST_FIELD(COMMCONFIG, DWORD[1], wcProviderData, 48, 4, 4);
 359 }
 360
 361 static void test_pack_COMMPROP(void)
 362 {
 363     /* COMMPROP (pack 4) */
 364     TEST_TYPE(COMMPROP, 64, 4);
 365     TEST_FIELD(COMMPROP, WORD, wPacketLength, 0, 2, 2);
 366     TEST_FIELD(COMMPROP, WORD, wPacketVersion, 2, 2, 2);
 367     TEST_FIELD(COMMPROP, DWORD, dwServiceMask, 4, 4, 4);
 368     TEST_FIELD(COMMPROP, DWORD, dwReserved1, 8, 4, 4);
 369     TEST_FIELD(COMMPROP, DWORD, dwMaxTxQueue, 12, 4, 4);
 370     TEST_FIELD(COMMPROP, DWORD, dwMaxRxQueue, 16, 4, 4);
 371     TEST_FIELD(COMMPROP, DWORD, dwMaxBaud, 20, 4, 4);
 372     TEST_FIELD(COMMPROP, DWORD, dwProvSubType, 24, 4, 4);
 373     TEST_FIELD(COMMPROP, DWORD, dwProvCapabilities, 28, 4, 4);
 374     TEST_FIELD(COMMPROP, DWORD, dwSettableParams, 32, 4, 4);
 375     TEST_FIELD(COMMPROP, DWORD, dwSettableBaud, 36, 4, 4);
 376     TEST_FIELD(COMMPROP, WORD, wSettableData, 40, 2, 2);
 377     TEST_FIELD(COMMPROP, WORD, wSettableStopParity, 42, 2, 2);
 378     TEST_FIELD(COMMPROP, DWORD, dwCurrentTxQueue, 44, 4, 4);
 379     TEST_FIELD(COMMPROP, DWORD, dwCurrentRxQueue, 48, 4, 4);
 380     TEST_FIELD(COMMPROP, DWORD, dwProvSpec1, 52, 4, 4);
 381     TEST_FIELD(COMMPROP, DWORD, dwProvSpec2, 56, 4, 4);
 382     TEST_FIELD(COMMPROP, WCHAR[1], wcProvChar, 60, 2, 2);
 383 }
 384
 385 static void test_pack_COMMTIMEOUTS(void)
 386 {
 387     /* COMMTIMEOUTS (pack 4) */
 388     TEST_TYPE(COMMTIMEOUTS, 20, 4);
 389     TEST_FIELD(COMMTIMEOUTS, DWORD, ReadIntervalTimeout, 0, 4, 4);
 390     TEST_FIELD(COMMTIMEOUTS, DWORD, ReadTotalTimeoutMultiplier, 4, 4, 4);
 391     TEST_FIELD(COMMTIMEOUTS, DWORD, ReadTotalTimeoutConstant, 8, 4, 4);
 392     TEST_FIELD(COMMTIMEOUTS, DWORD, WriteTotalTimeoutMultiplier, 12, 4, 4);
 393     TEST_FIELD(COMMTIMEOUTS, DWORD, WriteTotalTimeoutConstant, 16, 4, 4);
 394 }
 395
 396 static void test_pack_COMSTAT(void)
 397 {
 398     /* COMSTAT (pack 4) */
 399     TEST_TYPE(COMSTAT, 12, 4);
 400     TEST_FIELD(COMSTAT, DWORD, cbInQue, 4, 4, 4);
 401     TEST_FIELD(COMSTAT, DWORD, cbOutQue, 8, 4, 4);
 402 }
 403
 404 static void test_pack_CREATE_PROCESS_DEBUG_INFO(void)
 405 {
 406     /* CREATE_PROCESS_DEBUG_INFO (pack 4) */
 407     TEST_TYPE(CREATE_PROCESS_DEBUG_INFO, 40, 4);
 408     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, HANDLE, hFile, 0, 4, 4);
 409     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, HANDLE, hProcess, 4, 4, 4);
 410     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, HANDLE, hThread, 8, 4, 4);
 411     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, LPVOID, lpBaseOfImage, 12, 4, 4);
 412     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, DWORD, dwDebugInfoFileOffset, 16, 4, 4);
 413     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, DWORD, nDebugInfoSize, 20, 4, 4);
 414     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, LPVOID, lpThreadLocalBase, 24, 4, 4);
 415     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, LPTHREAD_START_ROUTINE, lpStartAddress, 28, 4, 4);
 416     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, LPVOID, lpImageName, 32, 4, 4);
 417     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, WORD, fUnicode, 36, 2, 2);
 418 }
 419
 420 static void test_pack_CREATE_THREAD_DEBUG_INFO(void)
 421 {
 422     /* CREATE_THREAD_DEBUG_INFO (pack 4) */
 423     TEST_TYPE(CREATE_THREAD_DEBUG_INFO, 12, 4);
 424     TEST_FIELD(CREATE_THREAD_DEBUG_INFO, HANDLE, hThread, 0, 4, 4);
 425     TEST_FIELD(CREATE_THREAD_DEBUG_INFO, LPVOID, lpThreadLocalBase, 4, 4, 4);
 426     TEST_FIELD(CREATE_THREAD_DEBUG_INFO, LPTHREAD_START_ROUTINE, lpStartAddress, 8, 4, 4);
 427 }
 428
 429 static void test_pack_CRITICAL_SECTION(void)
 430 {
 431     /* CRITICAL_SECTION */
 432     TEST_TYPE(CRITICAL_SECTION, 24, 4);
 433 }
 434
 435 static void test_pack_CRITICAL_SECTION_DEBUG(void)
 436 {
 437     /* CRITICAL_SECTION_DEBUG */
 438     TEST_TYPE(CRITICAL_SECTION_DEBUG, 32, 4);
 439 }
 440
 441 static void test_pack_DCB(void)
 442 {
 443     /* DCB (pack 4) */
 444     TEST_TYPE(DCB, 28, 4);
 445     TEST_FIELD(DCB, DWORD, DCBlength, 0, 4, 4);
 446     TEST_FIELD(DCB, DWORD, BaudRate, 4, 4, 4);
 447     TEST_FIELD(DCB, WORD, wReserved, 12, 2, 2);
 448     TEST_FIELD(DCB, WORD, XonLim, 14, 2, 2);
 449     TEST_FIELD(DCB, WORD, XoffLim, 16, 2, 2);
 450     TEST_FIELD(DCB, BYTE, ByteSize, 18, 1, 1);
 451     TEST_FIELD(DCB, BYTE, Parity, 19, 1, 1);
 452     TEST_FIELD(DCB, BYTE, StopBits, 20, 1, 1);
 453     TEST_FIELD(DCB, char, XonChar, 21, 1, 1);
 454     TEST_FIELD(DCB, char, XoffChar, 22, 1, 1);
 455     TEST_FIELD(DCB, char, ErrorChar, 23, 1, 1);
 456     TEST_FIELD(DCB, char, EofChar, 24, 1, 1);
 457     TEST_FIELD(DCB, char, EvtChar, 25, 1, 1);
 458     TEST_FIELD(DCB, WORD, wReserved1, 26, 2, 2);
 459 }
 460
 461 static void test_pack_DEBUG_EVENT(void)
 462 {
 463     /* DEBUG_EVENT (pack 4) */
 464     TEST_FIELD(DEBUG_EVENT, DWORD, dwDebugEventCode, 0, 4, 4);
 465     TEST_FIELD(DEBUG_EVENT, DWORD, dwProcessId, 4, 4, 4);
 466     TEST_FIELD(DEBUG_EVENT, DWORD, dwThreadId, 8, 4, 4);
 467 }
 468
 469 static void test_pack_ENUMRESLANGPROCA(void)
 470 {
 471     /* ENUMRESLANGPROCA */
 472     TEST_TYPE(ENUMRESLANGPROCA, 4, 4);
 473 }
 474
 475 static void test_pack_ENUMRESLANGPROCW(void)
 476 {
 477     /* ENUMRESLANGPROCW */
 478     TEST_TYPE(ENUMRESLANGPROCW, 4, 4);
 479 }
 480
 481 static void test_pack_ENUMRESNAMEPROCA(void)
 482 {
 483     /* ENUMRESNAMEPROCA */
 484     TEST_TYPE(ENUMRESNAMEPROCA, 4, 4);
 485 }
 486
 487 static void test_pack_ENUMRESNAMEPROCW(void)
 488 {
 489     /* ENUMRESNAMEPROCW */
 490     TEST_TYPE(ENUMRESNAMEPROCW, 4, 4);
 491 }
 492
 493 static void test_pack_ENUMRESTYPEPROCA(void)
 494 {
 495     /* ENUMRESTYPEPROCA */
 496     TEST_TYPE(ENUMRESTYPEPROCA, 4, 4);
 497 }
 498
 499 static void test_pack_ENUMRESTYPEPROCW(void)
 500 {
 501     /* ENUMRESTYPEPROCW */
 502     TEST_TYPE(ENUMRESTYPEPROCW, 4, 4);
 503 }
 504
 505 static void test_pack_EXCEPTION_DEBUG_INFO(void)
 506 {
 507     /* EXCEPTION_DEBUG_INFO (pack 4) */
 508     TEST_TYPE(EXCEPTION_DEBUG_INFO, 84, 4);
 509     TEST_FIELD(EXCEPTION_DEBUG_INFO, EXCEPTION_RECORD, ExceptionRecord, 0, 80, 4);
 510     TEST_FIELD(EXCEPTION_DEBUG_INFO, DWORD, dwFirstChance, 80, 4, 4);
 511 }
 512
 513 static void test_pack_EXIT_PROCESS_DEBUG_INFO(void)
 514 {
 515     /* EXIT_PROCESS_DEBUG_INFO (pack 4) */
 516     TEST_TYPE(EXIT_PROCESS_DEBUG_INFO, 4, 4);
 517     TEST_FIELD(EXIT_PROCESS_DEBUG_INFO, DWORD, dwExitCode, 0, 4, 4);
 518 }
 519
 520 static void test_pack_EXIT_THREAD_DEBUG_INFO(void)
 521 {
 522     /* EXIT_THREAD_DEBUG_INFO (pack 4) */
 523     TEST_TYPE(EXIT_THREAD_DEBUG_INFO, 4, 4);
 524     TEST_FIELD(EXIT_THREAD_DEBUG_INFO, DWORD, dwExitCode, 0, 4, 4);
 525 }
 526
 527 static void test_pack_HW_PROFILE_INFOA(void)
 528 {
 529     /* HW_PROFILE_INFOA (pack 4) */
 530     TEST_TYPE(HW_PROFILE_INFOA, 124, 4);
 531     TEST_FIELD(HW_PROFILE_INFOA, DWORD, dwDockInfo, 0, 4, 4);
 532     TEST_FIELD(HW_PROFILE_INFOA, CHAR[HW_PROFILE_GUIDLEN], szHwProfileGuid, 4, 39, 1);
 533     TEST_FIELD(HW_PROFILE_INFOA, CHAR[MAX_PROFILE_LEN], szHwProfileName, 43, 80, 1);
 534 }
 535
 536 static void test_pack_HW_PROFILE_INFOW(void)
 537 {
 538     /* HW_PROFILE_INFOW (pack 4) */
 539     TEST_TYPE(HW_PROFILE_INFOW, 244, 4);
 540     TEST_FIELD(HW_PROFILE_INFOW, DWORD, dwDockInfo, 0, 4, 4);
 541     TEST_FIELD(HW_PROFILE_INFOW, WCHAR[HW_PROFILE_GUIDLEN], szHwProfileGuid, 4, 78, 2);
 542     TEST_FIELD(HW_PROFILE_INFOW, WCHAR[MAX_PROFILE_LEN], szHwProfileName, 82, 160, 2);
 543 }
 544
 545 static void test_pack_LOAD_DLL_DEBUG_INFO(void)
 546 {
 547     /* LOAD_DLL_DEBUG_INFO (pack 4) */
 548     TEST_TYPE(LOAD_DLL_DEBUG_INFO, 24, 4);
 549     TEST_FIELD(LOAD_DLL_DEBUG_INFO, HANDLE, hFile, 0, 4, 4);
 550     TEST_FIELD(LOAD_DLL_DEBUG_INFO, LPVOID, lpBaseOfDll, 4, 4, 4);
 551     TEST_FIELD(LOAD_DLL_DEBUG_INFO, DWORD, dwDebugInfoFileOffset, 8, 4, 4);
 552     TEST_FIELD(LOAD_DLL_DEBUG_INFO, DWORD, nDebugInfoSize, 12, 4, 4);
 553     TEST_FIELD(LOAD_DLL_DEBUG_INFO, LPVOID, lpImageName, 16, 4, 4);
 554     TEST_FIELD(LOAD_DLL_DEBUG_INFO, WORD, fUnicode, 20, 2, 2);
 555 }
 556
 557 static void test_pack_LPBY_HANDLE_FILE_INFORMATION(void)
 558 {
 559     /* LPBY_HANDLE_FILE_INFORMATION */
 560     TEST_TYPE(LPBY_HANDLE_FILE_INFORMATION, 4, 4);
 561     TEST_TYPE_POINTER(LPBY_HANDLE_FILE_INFORMATION, 52, 4);
 562 }
 563
 564 static void test_pack_LPCOMMCONFIG(void)
 565 {
 566     /* LPCOMMCONFIG */
 567     TEST_TYPE(LPCOMMCONFIG, 4, 4);
 568     TEST_TYPE_POINTER(LPCOMMCONFIG, 52, 4);
 569 }
 570
 571 static void test_pack_LPCOMMPROP(void)
 572 {
 573     /* LPCOMMPROP */
 574     TEST_TYPE(LPCOMMPROP, 4, 4);
 575     TEST_TYPE_POINTER(LPCOMMPROP, 64, 4);
 576 }
 577
 578 static void test_pack_LPCOMMTIMEOUTS(void)
 579 {
 580     /* LPCOMMTIMEOUTS */
 581     TEST_TYPE(LPCOMMTIMEOUTS, 4, 4);
 582     TEST_TYPE_POINTER(LPCOMMTIMEOUTS, 20, 4);
 583 }
 584
 585 static void test_pack_LPCOMSTAT(void)
 586 {
 587     /* LPCOMSTAT */
 588     TEST_TYPE(LPCOMSTAT, 4, 4);
 589     TEST_TYPE_POINTER(LPCOMSTAT, 12, 4);
 590 }
 591
 592 static void test_pack_LPCRITICAL_SECTION(void)
 593 {
 594     /* LPCRITICAL_SECTION */
 595     TEST_TYPE(LPCRITICAL_SECTION, 4, 4);
 596 }
 597
 598 static void test_pack_LPCRITICAL_SECTION_DEBUG(void)
 599 {
 600     /* LPCRITICAL_SECTION_DEBUG */
 601     TEST_TYPE(LPCRITICAL_SECTION_DEBUG, 4, 4);
 602 }
 603
 604 static void test_pack_LPDCB(void)
 605 {
 606     /* LPDCB */
 607     TEST_TYPE(LPDCB, 4, 4);
 608     TEST_TYPE_POINTER(LPDCB, 28, 4);
 609 }
 610
 611 static void test_pack_LPDEBUG_EVENT(void)
 612 {
 613     /* LPDEBUG_EVENT */
 614     TEST_TYPE(LPDEBUG_EVENT, 4, 4);
 615 }
 616
 617 static void test_pack_LPEXCEPTION_POINTERS(void)
 618 {
 619     /* LPEXCEPTION_POINTERS */
 620     TEST_TYPE(LPEXCEPTION_POINTERS, 4, 4);
 621 }
 622
 623 static void test_pack_LPEXCEPTION_RECORD(void)
 624 {
 625     /* LPEXCEPTION_RECORD */
 626     TEST_TYPE(LPEXCEPTION_RECORD, 4, 4);
 627 }
 628
 629 static void test_pack_LPFIBER_START_ROUTINE(void)
 630 {
 631     /* LPFIBER_START_ROUTINE */
 632     TEST_TYPE(LPFIBER_START_ROUTINE, 4, 4);
 633 }
 634
 635 static void test_pack_LPHW_PROFILE_INFOA(void)
 636 {
 637     /* LPHW_PROFILE_INFOA */
 638     TEST_TYPE(LPHW_PROFILE_INFOA, 4, 4);
 639     TEST_TYPE_POINTER(LPHW_PROFILE_INFOA, 124, 4);
 640 }
 641
 642 static void test_pack_LPHW_PROFILE_INFOW(void)
 643 {
 644     /* LPHW_PROFILE_INFOW */
 645     TEST_TYPE(LPHW_PROFILE_INFOW, 4, 4);
 646     TEST_TYPE_POINTER(LPHW_PROFILE_INFOW, 244, 4);
 647 }
 648
 649 static void test_pack_LPMEMORYSTATUS(void)
 650 {
 651     /* LPMEMORYSTATUS */
 652     TEST_TYPE(LPMEMORYSTATUS, 4, 4);
 653     TEST_TYPE_POINTER(LPMEMORYSTATUS, 32, 4);
 654 }
 655
 656 static void test_pack_LPMEMORYSTATUSEX(void)
 657 {
 658     /* LPMEMORYSTATUSEX */
 659     TEST_TYPE(LPMEMORYSTATUSEX, 4, 4);
 660     TEST_TYPE_POINTER(LPMEMORYSTATUSEX, 64, 8);
 661 }
 662
 663 static void test_pack_LPOFSTRUCT(void)
 664 {
 665     /* LPOFSTRUCT */
 666     TEST_TYPE(LPOFSTRUCT, 4, 4);
 667     TEST_TYPE_POINTER(LPOFSTRUCT, 136, 2);
 668 }
 669
 670 static void test_pack_LPOVERLAPPED(void)
 671 {
 672     /* LPOVERLAPPED */
 673     TEST_TYPE(LPOVERLAPPED, 4, 4);
 674     TEST_TYPE_POINTER(LPOVERLAPPED, 20, 4);
 675 }
 676
 677 static void test_pack_LPOVERLAPPED_COMPLETION_ROUTINE(void)
 678 {
 679     /* LPOVERLAPPED_COMPLETION_ROUTINE */
 680     TEST_TYPE(LPOVERLAPPED_COMPLETION_ROUTINE, 4, 4);
 681 }
 682
 683 static void test_pack_LPPROCESS_HEAP_ENTRY(void)
 684 {
 685     /* LPPROCESS_HEAP_ENTRY */
 686     TEST_TYPE(LPPROCESS_HEAP_ENTRY, 4, 4);
 687 }
 688
 689 static void test_pack_LPPROCESS_INFORMATION(void)
 690 {
 691     /* LPPROCESS_INFORMATION */
 692     TEST_TYPE(LPPROCESS_INFORMATION, 4, 4);
 693     TEST_TYPE_POINTER(LPPROCESS_INFORMATION, 16, 4);
 694 }
 695
 696 static void test_pack_LPPROGRESS_ROUTINE(void)
 697 {
 698     /* LPPROGRESS_ROUTINE */
 699     TEST_TYPE(LPPROGRESS_ROUTINE, 4, 4);
 700 }
 701
 702 static void test_pack_LPSECURITY_ATTRIBUTES(void)
 703 {
 704     /* LPSECURITY_ATTRIBUTES */
 705     TEST_TYPE(LPSECURITY_ATTRIBUTES, 4, 4);
 706     TEST_TYPE_POINTER(LPSECURITY_ATTRIBUTES, 12, 4);
 707 }
 708
 709 static void test_pack_LPSTARTUPINFOA(void)
 710 {
 711     /* LPSTARTUPINFOA */
 712     TEST_TYPE(LPSTARTUPINFOA, 4, 4);
 713     TEST_TYPE_POINTER(LPSTARTUPINFOA, 68, 4);
 714 }
 715
 716 static void test_pack_LPSTARTUPINFOW(void)
 717 {
 718     /* LPSTARTUPINFOW */
 719     TEST_TYPE(LPSTARTUPINFOW, 4, 4);
 720     TEST_TYPE_POINTER(LPSTARTUPINFOW, 68, 4);
 721 }
 722
 723 static void test_pack_LPSYSTEMTIME(void)
 724 {
 725     /* LPSYSTEMTIME */
 726     TEST_TYPE(LPSYSTEMTIME, 4, 4);
 727     TEST_TYPE_POINTER(LPSYSTEMTIME, 16, 2);
 728 }
 729
 730 static void test_pack_LPSYSTEM_INFO(void)
 731 {
 732     /* LPSYSTEM_INFO */
 733     TEST_TYPE(LPSYSTEM_INFO, 4, 4);
 734 }
 735
 736 static void test_pack_LPSYSTEM_POWER_STATUS(void)
 737 {
 738     /* LPSYSTEM_POWER_STATUS */
 739     TEST_TYPE(LPSYSTEM_POWER_STATUS, 4, 4);
 740     TEST_TYPE_POINTER(LPSYSTEM_POWER_STATUS, 12, 4);
 741 }
 742
 743 static void test_pack_LPTHREAD_START_ROUTINE(void)
 744 {
 745     /* LPTHREAD_START_ROUTINE */
 746     TEST_TYPE(LPTHREAD_START_ROUTINE, 4, 4);
 747 }
 748
 749 static void test_pack_LPTIME_ZONE_INFORMATION(void)
 750 {
 751     /* LPTIME_ZONE_INFORMATION */
 752     TEST_TYPE(LPTIME_ZONE_INFORMATION, 4, 4);
 753     TEST_TYPE_POINTER(LPTIME_ZONE_INFORMATION, 172, 4);
 754 }
 755
 756 static void test_pack_LPWIN32_FILE_ATTRIBUTE_DATA(void)
 757 {
 758     /* LPWIN32_FILE_ATTRIBUTE_DATA */
 759     TEST_TYPE(LPWIN32_FILE_ATTRIBUTE_DATA, 4, 4);
 760     TEST_TYPE_POINTER(LPWIN32_FILE_ATTRIBUTE_DATA, 36, 4);
 761 }
 762
 763 static void test_pack_LPWIN32_FIND_DATAA(void)
 764 {
 765     /* LPWIN32_FIND_DATAA */
 766     TEST_TYPE(LPWIN32_FIND_DATAA, 4, 4);
 767     TEST_TYPE_POINTER(LPWIN32_FIND_DATAA, 320, 4);
 768 }
 769
 770 static void test_pack_LPWIN32_FIND_DATAW(void)
 771 {
 772     /* LPWIN32_FIND_DATAW */
 773     TEST_TYPE(LPWIN32_FIND_DATAW, 4, 4);
 774     TEST_TYPE_POINTER(LPWIN32_FIND_DATAW, 592, 4);
 775 }
 776
 777 static void test_pack_LPWIN32_STREAM_ID(void)
 778 {
 779     /* LPWIN32_STREAM_ID */
 780     TEST_TYPE(LPWIN32_STREAM_ID, 4, 4);
 781     TEST_TYPE_POINTER(LPWIN32_STREAM_ID, 24, 8);
 782 }
 783
 784 static void test_pack_MEMORYSTATUS(void)
 785 {
 786     /* MEMORYSTATUS (pack 4) */
 787     TEST_TYPE(MEMORYSTATUS, 32, 4);
 788     TEST_FIELD(MEMORYSTATUS, DWORD, dwLength, 0, 4, 4);
 789     TEST_FIELD(MEMORYSTATUS, DWORD, dwMemoryLoad, 4, 4, 4);
 790     TEST_FIELD(MEMORYSTATUS, SIZE_T, dwTotalPhys, 8, 4, 4);
 791     TEST_FIELD(MEMORYSTATUS, SIZE_T, dwAvailPhys, 12, 4, 4);
 792     TEST_FIELD(MEMORYSTATUS, SIZE_T, dwTotalPageFile, 16, 4, 4);
 793     TEST_FIELD(MEMORYSTATUS, SIZE_T, dwAvailPageFile, 20, 4, 4);
 794     TEST_FIELD(MEMORYSTATUS, SIZE_T, dwTotalVirtual, 24, 4, 4);
 795     TEST_FIELD(MEMORYSTATUS, SIZE_T, dwAvailVirtual, 28, 4, 4);
 796 }
 797
 798 static void test_pack_MEMORYSTATUSEX(void)
 799 {
 800     /* MEMORYSTATUSEX (pack 8) */
 801     TEST_TYPE(MEMORYSTATUSEX, 64, 8);
 802     TEST_FIELD(MEMORYSTATUSEX, DWORD, dwLength, 0, 4, 4);
 803     TEST_FIELD(MEMORYSTATUSEX, DWORD, dwMemoryLoad, 4, 4, 4);
 804     TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullTotalPhys, 8, 8, 8);
 805     TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullAvailPhys, 16, 8, 8);
 806     TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullTotalPageFile, 24, 8, 8);
 807     TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullAvailPageFile, 32, 8, 8);
 808     TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullTotalVirtual, 40, 8, 8);
 809     TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullAvailVirtual, 48, 8, 8);
 810     TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullAvailExtendedVirtual, 56, 8, 8);
 811 }
 812
 813 static void test_pack_OFSTRUCT(void)
 814 {
 815     /* OFSTRUCT (pack 4) */
 816     TEST_TYPE(OFSTRUCT, 136, 2);
 817     TEST_FIELD(OFSTRUCT, BYTE, cBytes, 0, 1, 1);
 818     TEST_FIELD(OFSTRUCT, BYTE, fFixedDisk, 1, 1, 1);
 819     TEST_FIELD(OFSTRUCT, WORD, nErrCode, 2, 2, 2);
 820     TEST_FIELD(OFSTRUCT, WORD, Reserved1, 4, 2, 2);
 821     TEST_FIELD(OFSTRUCT, WORD, Reserved2, 6, 2, 2);
 822     TEST_FIELD(OFSTRUCT, BYTE[OFS_MAXPATHNAME], szPathName, 8, 128, 1);
 823 }
 824
 825 static void test_pack_OUTPUT_DEBUG_STRING_INFO(void)
 826 {
 827     /* OUTPUT_DEBUG_STRING_INFO (pack 4) */
 828     TEST_TYPE(OUTPUT_DEBUG_STRING_INFO, 8, 4);
 829     TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, LPSTR, lpDebugStringData, 0, 4, 4);
 830     TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, WORD, fUnicode, 4, 2, 2);
 831     TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, WORD, nDebugStringLength, 6, 2, 2);
 832 }
 833
 834 static void test_pack_OVERLAPPED(void)
 835 {
 836     /* OVERLAPPED (pack 4) */
 837     TEST_TYPE(OVERLAPPED, 20, 4);
 838     TEST_FIELD(OVERLAPPED, ULONG_PTR, Internal, 0, 4, 4);
 839     TEST_FIELD(OVERLAPPED, ULONG_PTR, InternalHigh, 4, 4, 4);
 840     /*TEST_FIELD(OVERLAPPED, DWORD, Offset, 8, 4, 4);*/
 841     /*TEST_FIELD(OVERLAPPED, DWORD, OffsetHigh, 12, 4, 4);*/
 842     TEST_FIELD(OVERLAPPED, HANDLE, hEvent, 16, 4, 4);
 843 }
 844
 845 static void test_pack_PACTCTXA(void)
 846 {
 847     /* PACTCTXA */
 848     TEST_TYPE(PACTCTXA, 4, 4);
 849     TEST_TYPE_POINTER(PACTCTXA, 32, 4);
 850 }
 851
 852 static void test_pack_PACTCTXW(void)
 853 {
 854     /* PACTCTXW */
 855     TEST_TYPE(PACTCTXW, 4, 4);
 856     TEST_TYPE_POINTER(PACTCTXW, 32, 4);
 857 }
 858
 859 static void test_pack_PACTCTX_SECTION_KEYED_DATA(void)
 860 {
 861     /* PACTCTX_SECTION_KEYED_DATA */
 862     TEST_TYPE(PACTCTX_SECTION_KEYED_DATA, 4, 4);
 863     TEST_TYPE_POINTER(PACTCTX_SECTION_KEYED_DATA, 64, 4);
 864 }
 865
 866 static void test_pack_PACTCTX_SECTION_KEYED_DATA_2600(void)
 867 {
 868     /* PACTCTX_SECTION_KEYED_DATA_2600 */
 869     TEST_TYPE(PACTCTX_SECTION_KEYED_DATA_2600, 4, 4);
 870     TEST_TYPE_POINTER(PACTCTX_SECTION_KEYED_DATA_2600, 40, 4);
 871 }
 872
 873 static void test_pack_PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA(void)
 874 {
 875     /* PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA */
 876     TEST_TYPE(PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 4, 4);
 877     TEST_TYPE_POINTER(PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 20, 4);
 878 }
 879
 880 static void test_pack_PACTIVATION_CONTEXT_BASIC_INFORMATION(void)
 881 {
 882     /* PACTIVATION_CONTEXT_BASIC_INFORMATION */
 883     TEST_TYPE(PACTIVATION_CONTEXT_BASIC_INFORMATION, 4, 4);
 884     TEST_TYPE_POINTER(PACTIVATION_CONTEXT_BASIC_INFORMATION, 8, 4);
 885 }
 886
 887 static void test_pack_PAPCFUNC(void)
 888 {
 889     /* PAPCFUNC */
 890     TEST_TYPE(PAPCFUNC, 4, 4);
 891 }
 892
 893 static void test_pack_PBY_HANDLE_FILE_INFORMATION(void)
 894 {
 895     /* PBY_HANDLE_FILE_INFORMATION */
 896     TEST_TYPE(PBY_HANDLE_FILE_INFORMATION, 4, 4);
 897     TEST_TYPE_POINTER(PBY_HANDLE_FILE_INFORMATION, 52, 4);
 898 }
 899
 900 static void test_pack_PCACTCTXA(void)
 901 {
 902     /* PCACTCTXA */
 903     TEST_TYPE(PCACTCTXA, 4, 4);
 904     TEST_TYPE_POINTER(PCACTCTXA, 32, 4);
 905 }
 906
 907 static void test_pack_PCACTCTXW(void)
 908 {
 909     /* PCACTCTXW */
 910     TEST_TYPE(PCACTCTXW, 4, 4);
 911     TEST_TYPE_POINTER(PCACTCTXW, 32, 4);
 912 }
 913
 914 static void test_pack_PCACTCTX_SECTION_KEYED_DATA(void)
 915 {
 916     /* PCACTCTX_SECTION_KEYED_DATA */
 917     TEST_TYPE(PCACTCTX_SECTION_KEYED_DATA, 4, 4);
 918     TEST_TYPE_POINTER(PCACTCTX_SECTION_KEYED_DATA, 64, 4);
 919 }
 920
 921 static void test_pack_PCACTCTX_SECTION_KEYED_DATA_2600(void)
 922 {
 923     /* PCACTCTX_SECTION_KEYED_DATA_2600 */
 924     TEST_TYPE(PCACTCTX_SECTION_KEYED_DATA_2600, 4, 4);
 925     TEST_TYPE_POINTER(PCACTCTX_SECTION_KEYED_DATA_2600, 40, 4);
 926 }
 927
 928 static void test_pack_PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA(void)
 929 {
 930     /* PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA */
 931     TEST_TYPE(PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 4, 4);
 932     TEST_TYPE_POINTER(PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 20, 4);
 933 }
 934
 935 static void test_pack_PCRITICAL_SECTION(void)
 936 {
 937     /* PCRITICAL_SECTION */
 938     TEST_TYPE(PCRITICAL_SECTION, 4, 4);
 939 }
 940
 941 static void test_pack_PCRITICAL_SECTION_DEBUG(void)
 942 {
 943     /* PCRITICAL_SECTION_DEBUG */
 944     TEST_TYPE(PCRITICAL_SECTION_DEBUG, 4, 4);
 945 }
 946
 947 static void test_pack_PFIBER_START_ROUTINE(void)
 948 {
 949     /* PFIBER_START_ROUTINE */
 950     TEST_TYPE(PFIBER_START_ROUTINE, 4, 4);
 951 }
 952
 953 static void test_pack_POFSTRUCT(void)
 954 {
 955     /* POFSTRUCT */
 956     TEST_TYPE(POFSTRUCT, 4, 4);
 957     TEST_TYPE_POINTER(POFSTRUCT, 136, 2);
 958 }
 959
 960 static void test_pack_PPROCESS_HEAP_ENTRY(void)
 961 {
 962     /* PPROCESS_HEAP_ENTRY */
 963     TEST_TYPE(PPROCESS_HEAP_ENTRY, 4, 4);
 964 }
 965
 966 static void test_pack_PPROCESS_INFORMATION(void)
 967 {
 968     /* PPROCESS_INFORMATION */
 969     TEST_TYPE(PPROCESS_INFORMATION, 4, 4);
 970     TEST_TYPE_POINTER(PPROCESS_INFORMATION, 16, 4);
 971 }
 972
 973 static void test_pack_PQUERYACTCTXW_FUNC(void)
 974 {
 975     /* PQUERYACTCTXW_FUNC */
 976     TEST_TYPE(PQUERYACTCTXW_FUNC, 4, 4);
 977 }
 978
 979 static void test_pack_PROCESS_HEAP_ENTRY(void)
 980 {
 981     /* PROCESS_HEAP_ENTRY (pack 4) */
 982     TEST_FIELD(PROCESS_HEAP_ENTRY, LPVOID, lpData, 0, 4, 4);
 983     TEST_FIELD(PROCESS_HEAP_ENTRY, DWORD, cbData, 4, 4, 4);
 984     TEST_FIELD(PROCESS_HEAP_ENTRY, BYTE, cbOverhead, 8, 1, 1);
 985     TEST_FIELD(PROCESS_HEAP_ENTRY, BYTE, iRegionIndex, 9, 1, 1);
 986     TEST_FIELD(PROCESS_HEAP_ENTRY, WORD, wFlags, 10, 2, 2);
 987 }
 988
 989 static void test_pack_PROCESS_INFORMATION(void)
 990 {
 991     /* PROCESS_INFORMATION (pack 4) */
 992     TEST_TYPE(PROCESS_INFORMATION, 16, 4);
 993     TEST_FIELD(PROCESS_INFORMATION, HANDLE, hProcess, 0, 4, 4);
 994     TEST_FIELD(PROCESS_INFORMATION, HANDLE, hThread, 4, 4, 4);
 995     TEST_FIELD(PROCESS_INFORMATION, DWORD, dwProcessId, 8, 4, 4);
 996     TEST_FIELD(PROCESS_INFORMATION, DWORD, dwThreadId, 12, 4, 4);
 997 }
 998
 999 static void test_pack_PSECURITY_ATTRIBUTES(void)
1000 {
1001     /* PSECURITY_ATTRIBUTES */
1002     TEST_TYPE(PSECURITY_ATTRIBUTES, 4, 4);
1003     TEST_TYPE_POINTER(PSECURITY_ATTRIBUTES, 12, 4);
1004 }
1005
1006 static void test_pack_PSYSTEMTIME(void)
1007 {
1008     /* PSYSTEMTIME */
1009     TEST_TYPE(PSYSTEMTIME, 4, 4);
1010     TEST_TYPE_POINTER(PSYSTEMTIME, 16, 2);
1011 }
1012
1013 static void test_pack_PTIMERAPCROUTINE(void)
1014 {
1015     /* PTIMERAPCROUTINE */
1016     TEST_TYPE(PTIMERAPCROUTINE, 4, 4);
1017 }
1018
1019 static void test_pack_PTIME_ZONE_INFORMATION(void)
1020 {
1021     /* PTIME_ZONE_INFORMATION */
1022     TEST_TYPE(PTIME_ZONE_INFORMATION, 4, 4);
1023     TEST_TYPE_POINTER(PTIME_ZONE_INFORMATION, 172, 4);
1024 }
1025
1026 static void test_pack_PWIN32_FIND_DATAA(void)
1027 {
1028     /* PWIN32_FIND_DATAA */
1029     TEST_TYPE(PWIN32_FIND_DATAA, 4, 4);
1030     TEST_TYPE_POINTER(PWIN32_FIND_DATAA, 320, 4);
1031 }
1032
1033 static void test_pack_PWIN32_FIND_DATAW(void)
1034 {
1035     /* PWIN32_FIND_DATAW */
1036     TEST_TYPE(PWIN32_FIND_DATAW, 4, 4);
1037     TEST_TYPE_POINTER(PWIN32_FIND_DATAW, 592, 4);
1038 }
1039
1040 static void test_pack_RIP_INFO(void)
1041 {
1042     /* RIP_INFO (pack 4) */
1043     TEST_TYPE(RIP_INFO, 8, 4);
1044     TEST_FIELD(RIP_INFO, DWORD, dwError, 0, 4, 4);
1045     TEST_FIELD(RIP_INFO, DWORD, dwType, 4, 4, 4);
1046 }
1047
1048 static void test_pack_SECURITY_ATTRIBUTES(void)
1049 {
1050     /* SECURITY_ATTRIBUTES (pack 4) */
1051     TEST_TYPE(SECURITY_ATTRIBUTES, 12, 4);
1052     TEST_FIELD(SECURITY_ATTRIBUTES, DWORD, nLength, 0, 4, 4);
1053     TEST_FIELD(SECURITY_ATTRIBUTES, LPVOID, lpSecurityDescriptor, 4, 4, 4);
1054     TEST_FIELD(SECURITY_ATTRIBUTES, BOOL, bInheritHandle, 8, 4, 4);
1055 }
1056
1057 static void test_pack_STARTUPINFOA(void)
1058 {
1059     /* STARTUPINFOA (pack 4) */
1060     TEST_TYPE(STARTUPINFOA, 68, 4);
1061     TEST_FIELD(STARTUPINFOA, DWORD, cb, 0, 4, 4);
1062     TEST_FIELD(STARTUPINFOA, LPSTR, lpReserved, 4, 4, 4);
1063     TEST_FIELD(STARTUPINFOA, LPSTR, lpDesktop, 8, 4, 4);
1064     TEST_FIELD(STARTUPINFOA, LPSTR, lpTitle, 12, 4, 4);
1065     TEST_FIELD(STARTUPINFOA, DWORD, dwX, 16, 4, 4);
1066     TEST_FIELD(STARTUPINFOA, DWORD, dwY, 20, 4, 4);
1067     TEST_FIELD(STARTUPINFOA, DWORD, dwXSize, 24, 4, 4);
1068     TEST_FIELD(STARTUPINFOA, DWORD, dwYSize, 28, 4, 4);
1069     TEST_FIELD(STARTUPINFOA, DWORD, dwXCountChars, 32, 4, 4);
1070     TEST_FIELD(STARTUPINFOA, DWORD, dwYCountChars, 36, 4, 4);
1071     TEST_FIELD(STARTUPINFOA, DWORD, dwFillAttribute, 40, 4, 4);
1072     TEST_FIELD(STARTUPINFOA, DWORD, dwFlags, 44, 4, 4);
1073     TEST_FIELD(STARTUPINFOA, WORD, wShowWindow, 48, 2, 2);
1074     TEST_FIELD(STARTUPINFOA, WORD, cbReserved2, 50, 2, 2);
1075     TEST_FIELD(STARTUPINFOA, BYTE *, lpReserved2, 52, 4, 4);
1076     TEST_FIELD(STARTUPINFOA, HANDLE, hStdInput, 56, 4, 4);
1077     TEST_FIELD(STARTUPINFOA, HANDLE, hStdOutput, 60, 4, 4);
1078     TEST_FIELD(STARTUPINFOA, HANDLE, hStdError, 64, 4, 4);
1079 }
1080
1081 static void test_pack_STARTUPINFOW(void)
1082 {
1083     /* STARTUPINFOW (pack 4) */
1084     TEST_TYPE(STARTUPINFOW, 68, 4);
1085     TEST_FIELD(STARTUPINFOW, DWORD, cb, 0, 4, 4);
1086     TEST_FIELD(STARTUPINFOW, LPWSTR, lpReserved, 4, 4, 4);
1087     TEST_FIELD(STARTUPINFOW, LPWSTR, lpDesktop, 8, 4, 4);
1088     TEST_FIELD(STARTUPINFOW, LPWSTR, lpTitle, 12, 4, 4);
1089     TEST_FIELD(STARTUPINFOW, DWORD, dwX, 16, 4, 4);
1090     TEST_FIELD(STARTUPINFOW, DWORD, dwY, 20, 4, 4);
1091     TEST_FIELD(STARTUPINFOW, DWORD, dwXSize, 24, 4, 4);
1092     TEST_FIELD(STARTUPINFOW, DWORD, dwYSize, 28, 4, 4);
1093     TEST_FIELD(STARTUPINFOW, DWORD, dwXCountChars, 32, 4, 4);
1094     TEST_FIELD(STARTUPINFOW, DWORD, dwYCountChars, 36, 4, 4);
1095     TEST_FIELD(STARTUPINFOW, DWORD, dwFillAttribute, 40, 4, 4);
1096     TEST_FIELD(STARTUPINFOW, DWORD, dwFlags, 44, 4, 4);
1097     TEST_FIELD(STARTUPINFOW, WORD, wShowWindow, 48, 2, 2);
1098     TEST_FIELD(STARTUPINFOW, WORD, cbReserved2, 50, 2, 2);
1099     TEST_FIELD(STARTUPINFOW, BYTE *, lpReserved2, 52, 4, 4);
1100     TEST_FIELD(STARTUPINFOW, HANDLE, hStdInput, 56, 4, 4);
1101     TEST_FIELD(STARTUPINFOW, HANDLE, hStdOutput, 60, 4, 4);
1102     TEST_FIELD(STARTUPINFOW, HANDLE, hStdError, 64, 4, 4);
1103 }
1104
1105 static void test_pack_SYSTEMTIME(void)
1106 {
1107     /* SYSTEMTIME (pack 4) */
1108     TEST_TYPE(SYSTEMTIME, 16, 2);
1109     TEST_FIELD(SYSTEMTIME, WORD, wYear, 0, 2, 2);
1110     TEST_FIELD(SYSTEMTIME, WORD, wMonth, 2, 2, 2);
1111     TEST_FIELD(SYSTEMTIME, WORD, wDayOfWeek, 4, 2, 2);
1112     TEST_FIELD(SYSTEMTIME, WORD, wDay, 6, 2, 2);
1113     TEST_FIELD(SYSTEMTIME, WORD, wHour, 8, 2, 2);
1114     TEST_FIELD(SYSTEMTIME, WORD, wMinute, 10, 2, 2);
1115     TEST_FIELD(SYSTEMTIME, WORD, wSecond, 12, 2, 2);
1116     TEST_FIELD(SYSTEMTIME, WORD, wMilliseconds, 14, 2, 2);
1117 }
1118
1119 static void test_pack_SYSTEM_INFO(void)
1120 {
1121     /* SYSTEM_INFO (pack 4) */
1122 }
1123
1124 static void test_pack_SYSTEM_POWER_STATUS(void)
1125 {
1126     /* SYSTEM_POWER_STATUS (pack 4) */
1127     TEST_TYPE(SYSTEM_POWER_STATUS, 12, 4);
1128     TEST_FIELD(SYSTEM_POWER_STATUS, BYTE, ACLineStatus, 0, 1, 1);
1129     TEST_FIELD(SYSTEM_POWER_STATUS, BYTE, BatteryFlag, 1, 1, 1);
1130     TEST_FIELD(SYSTEM_POWER_STATUS, BYTE, BatteryLifePercent, 2, 1, 1);
1131     TEST_FIELD(SYSTEM_POWER_STATUS, BYTE, Reserved1, 3, 1, 1);
1132     TEST_FIELD(SYSTEM_POWER_STATUS, DWORD, BatteryLifeTime, 4, 4, 4);
1133     TEST_FIELD(SYSTEM_POWER_STATUS, DWORD, BatteryFullLifeTime, 8, 4, 4);
1134 }
1135
1136 static void test_pack_TIME_ZONE_INFORMATION(void)
1137 {
1138     /* TIME_ZONE_INFORMATION (pack 4) */
1139     TEST_TYPE(TIME_ZONE_INFORMATION, 172, 4);
1140     TEST_FIELD(TIME_ZONE_INFORMATION, LONG, Bias, 0, 4, 4);
1141     TEST_FIELD(TIME_ZONE_INFORMATION, WCHAR[32], StandardName, 4, 64, 2);
1142     TEST_FIELD(TIME_ZONE_INFORMATION, SYSTEMTIME, StandardDate, 68, 16, 2);
1143     TEST_FIELD(TIME_ZONE_INFORMATION, LONG, StandardBias, 84, 4, 4);
1144     TEST_FIELD(TIME_ZONE_INFORMATION, WCHAR[32], DaylightName, 88, 64, 2);
1145     TEST_FIELD(TIME_ZONE_INFORMATION, SYSTEMTIME, DaylightDate, 152, 16, 2);
1146     TEST_FIELD(TIME_ZONE_INFORMATION, LONG, DaylightBias, 168, 4, 4);
1147 }
1148
1149 static void test_pack_UNLOAD_DLL_DEBUG_INFO(void)
1150 {
1151     /* UNLOAD_DLL_DEBUG_INFO (pack 4) */
1152     TEST_TYPE(UNLOAD_DLL_DEBUG_INFO, 4, 4);
1153     TEST_FIELD(UNLOAD_DLL_DEBUG_INFO, LPVOID, lpBaseOfDll, 0, 4, 4);
1154 }
1155
1156 static void test_pack_WAITORTIMERCALLBACK(void)
1157 {
1158     /* WAITORTIMERCALLBACK */
1159     TEST_TYPE(WAITORTIMERCALLBACK, 4, 4);
1160 }
1161
1162 static void test_pack_WIN32_FILE_ATTRIBUTE_DATA(void)
1163 {
1164     /* WIN32_FILE_ATTRIBUTE_DATA (pack 4) */
1165     TEST_TYPE(WIN32_FILE_ATTRIBUTE_DATA, 36, 4);
1166     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, DWORD, dwFileAttributes, 0, 4, 4);
1167     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, FILETIME, ftCreationTime, 4, 8, 4);
1168     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, FILETIME, ftLastAccessTime, 12, 8, 4);
1169     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, FILETIME, ftLastWriteTime, 20, 8, 4);
1170     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, DWORD, nFileSizeHigh, 28, 4, 4);
1171     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, DWORD, nFileSizeLow, 32, 4, 4);
1172 }
1173
1174 static void test_pack_WIN32_FIND_DATAA(void)
1175 {
1176     /* WIN32_FIND_DATAA (pack 4) */
1177     TEST_TYPE(WIN32_FIND_DATAA, 320, 4);
1178     TEST_FIELD(WIN32_FIND_DATAA, DWORD, dwFileAttributes, 0, 4, 4);
1179     TEST_FIELD(WIN32_FIND_DATAA, FILETIME, ftCreationTime, 4, 8, 4);
1180     TEST_FIELD(WIN32_FIND_DATAA, FILETIME, ftLastAccessTime, 12, 8, 4);
1181     TEST_FIELD(WIN32_FIND_DATAA, FILETIME, ftLastWriteTime, 20, 8, 4);
1182     TEST_FIELD(WIN32_FIND_DATAA, DWORD, nFileSizeHigh, 28, 4, 4);
1183     TEST_FIELD(WIN32_FIND_DATAA, DWORD, nFileSizeLow, 32, 4, 4);
1184     TEST_FIELD(WIN32_FIND_DATAA, DWORD, dwReserved0, 36, 4, 4);
1185     TEST_FIELD(WIN32_FIND_DATAA, DWORD, dwReserved1, 40, 4, 4);
1186     TEST_FIELD(WIN32_FIND_DATAA, CHAR[260], cFileName, 44, 260, 1);
1187     TEST_FIELD(WIN32_FIND_DATAA, CHAR[14], cAlternateFileName, 304, 14, 1);
1188 }
1189
1190 static void test_pack_WIN32_FIND_DATAW(void)
1191 {
1192     /* WIN32_FIND_DATAW (pack 4) */
1193     TEST_TYPE(WIN32_FIND_DATAW, 592, 4);
1194     TEST_FIELD(WIN32_FIND_DATAW, DWORD, dwFileAttributes, 0, 4, 4);
1195     TEST_FIELD(WIN32_FIND_DATAW, FILETIME, ftCreationTime, 4, 8, 4);
1196     TEST_FIELD(WIN32_FIND_DATAW, FILETIME, ftLastAccessTime, 12, 8, 4);
1197     TEST_FIELD(WIN32_FIND_DATAW, FILETIME, ftLastWriteTime, 20, 8, 4);
1198     TEST_FIELD(WIN32_FIND_DATAW, DWORD, nFileSizeHigh, 28, 4, 4);
1199     TEST_FIELD(WIN32_FIND_DATAW, DWORD, nFileSizeLow, 32, 4, 4);
1200     TEST_FIELD(WIN32_FIND_DATAW, DWORD, dwReserved0, 36, 4, 4);
1201     TEST_FIELD(WIN32_FIND_DATAW, DWORD, dwReserved1, 40, 4, 4);
1202     TEST_FIELD(WIN32_FIND_DATAW, WCHAR[260], cFileName, 44, 520, 2);
1203     TEST_FIELD(WIN32_FIND_DATAW, WCHAR[14], cAlternateFileName, 564, 28, 2);
1204 }
1205
1206 static void test_pack_WIN32_STREAM_ID(void)
1207 {
1208     /* WIN32_STREAM_ID (pack 8) */
1209     TEST_TYPE(WIN32_STREAM_ID, 24, 8);
1210     TEST_FIELD(WIN32_STREAM_ID, DWORD, dwStreamId, 0, 4, 4);
1211     TEST_FIELD(WIN32_STREAM_ID, DWORD, dwStreamAttributes, 4, 4, 4);
1212     TEST_FIELD(WIN32_STREAM_ID, LARGE_INTEGER, Size, 8, 8, 8);
1213     TEST_FIELD(WIN32_STREAM_ID, DWORD, dwStreamNameSize, 16, 4, 4);
1214     TEST_FIELD(WIN32_STREAM_ID, WCHAR[ANYSIZE_ARRAY], cStreamName, 20, 2, 2);
1215 }
1216
1217 static void test_pack(void)
1218 {
1219     test_pack_ACTCTXA();
1220     test_pack_ACTCTXW();
1221     test_pack_ACTCTX_SECTION_KEYED_DATA();
1222     test_pack_ACTCTX_SECTION_KEYED_DATA_2600();
1223     test_pack_ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA();
1224     test_pack_ACTIVATION_CONTEXT_BASIC_INFORMATION();
1225     test_pack_BY_HANDLE_FILE_INFORMATION();
1226     test_pack_COMMCONFIG();
1227     test_pack_COMMPROP();
1228     test_pack_COMMTIMEOUTS();
1229     test_pack_COMSTAT();
1230     test_pack_CREATE_PROCESS_DEBUG_INFO();
1231     test_pack_CREATE_THREAD_DEBUG_INFO();
1232     test_pack_CRITICAL_SECTION();
1233     test_pack_CRITICAL_SECTION_DEBUG();
1234     test_pack_DCB();
1235     test_pack_DEBUG_EVENT();
1236     test_pack_ENUMRESLANGPROCA();
1237     test_pack_ENUMRESLANGPROCW();
1238     test_pack_ENUMRESNAMEPROCA();
1239     test_pack_ENUMRESNAMEPROCW();
1240     test_pack_ENUMRESTYPEPROCA();
1241     test_pack_ENUMRESTYPEPROCW();
1242     test_pack_EXCEPTION_DEBUG_INFO();
1243     test_pack_EXIT_PROCESS_DEBUG_INFO();
1244     test_pack_EXIT_THREAD_DEBUG_INFO();
1245     test_pack_HW_PROFILE_INFOA();
1246     test_pack_HW_PROFILE_INFOW();
1247     test_pack_LOAD_DLL_DEBUG_INFO();
1248     test_pack_LPBY_HANDLE_FILE_INFORMATION();
1249     test_pack_LPCOMMCONFIG();
1250     test_pack_LPCOMMPROP();
1251     test_pack_LPCOMMTIMEOUTS();
1252     test_pack_LPCOMSTAT();
1253     test_pack_LPCRITICAL_SECTION();
1254     test_pack_LPCRITICAL_SECTION_DEBUG();
1255     test_pack_LPDCB();
1256     test_pack_LPDEBUG_EVENT();
1257     test_pack_LPEXCEPTION_POINTERS();
1258     test_pack_LPEXCEPTION_RECORD();
1259     test_pack_LPFIBER_START_ROUTINE();
1260     test_pack_LPHW_PROFILE_INFOA();
1261     test_pack_LPHW_PROFILE_INFOW();
1262     test_pack_LPLONG();
1263     test_pack_LPMEMORYSTATUS();
1264     test_pack_LPMEMORYSTATUSEX();
1265     test_pack_LPOFSTRUCT();
1266     test_pack_LPOSVERSIONINFOA();
1267     test_pack_LPOSVERSIONINFOEXA();
1268     test_pack_LPOSVERSIONINFOEXW();
1269     test_pack_LPOSVERSIONINFOW();
1270     test_pack_LPOVERLAPPED();
1271     test_pack_LPOVERLAPPED_COMPLETION_ROUTINE();
1272     test_pack_LPPROCESS_HEAP_ENTRY();
1273     test_pack_LPPROCESS_INFORMATION();
1274     test_pack_LPPROGRESS_ROUTINE();
1275     test_pack_LPSECURITY_ATTRIBUTES();
1276     test_pack_LPSTARTUPINFOA();
1277     test_pack_LPSTARTUPINFOW();
1278     test_pack_LPSYSTEMTIME();
1279     test_pack_LPSYSTEM_INFO();
1280     test_pack_LPSYSTEM_POWER_STATUS();
1281     test_pack_LPTHREAD_START_ROUTINE();
1282     test_pack_LPTIME_ZONE_INFORMATION();
1283     test_pack_LPVOID();
1284     test_pack_LPWIN32_FILE_ATTRIBUTE_DATA();
1285     test_pack_LPWIN32_FIND_DATAA();
1286     test_pack_LPWIN32_FIND_DATAW();
1287     test_pack_LPWIN32_STREAM_ID();
1288     test_pack_MEMORYSTATUS();
1289     test_pack_MEMORYSTATUSEX();
1290     test_pack_OFSTRUCT();
1291     test_pack_OSVERSIONINFOA();
1292     test_pack_OSVERSIONINFOEXA();
1293     test_pack_OSVERSIONINFOEXW();
1294     test_pack_OSVERSIONINFOW();
1295     test_pack_OUTPUT_DEBUG_STRING_INFO();
1296     test_pack_OVERLAPPED();
1297     test_pack_PACTCTXA();
1298     test_pack_PACTCTXW();
1299     test_pack_PACTCTX_SECTION_KEYED_DATA();
1300     test_pack_PACTCTX_SECTION_KEYED_DATA_2600();
1301     test_pack_PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA();
1302     test_pack_PACTIVATION_CONTEXT_BASIC_INFORMATION();
1303     test_pack_PAPCFUNC();
1304     test_pack_PBY_HANDLE_FILE_INFORMATION();
1305     test_pack_PCACTCTXA();
1306     test_pack_PCACTCTXW();
1307     test_pack_PCACTCTX_SECTION_KEYED_DATA();
1308     test_pack_PCACTCTX_SECTION_KEYED_DATA_2600();
1309     test_pack_PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA();
1310     test_pack_PCRITICAL_SECTION();
1311     test_pack_PCRITICAL_SECTION_DEBUG();
1312     test_pack_PFIBER_START_ROUTINE();
1313     test_pack_PHKEY();
1314     test_pack_POFSTRUCT();
1315     test_pack_POSVERSIONINFOA();
1316     test_pack_POSVERSIONINFOEXA();
1317     test_pack_POSVERSIONINFOEXW();
1318     test_pack_POSVERSIONINFOW();
1319     test_pack_PPROCESS_HEAP_ENTRY();
1320     test_pack_PPROCESS_INFORMATION();
1321     test_pack_PQUERYACTCTXW_FUNC();
1322     test_pack_PROCESS_HEAP_ENTRY();
1323     test_pack_PROCESS_INFORMATION();
1324     test_pack_PSECURITY_ATTRIBUTES();
1325     test_pack_PSYSTEMTIME();
1326     test_pack_PTIMERAPCROUTINE();
1327     test_pack_PTIME_ZONE_INFORMATION();
1328     test_pack_PWIN32_FIND_DATAA();
1329     test_pack_PWIN32_FIND_DATAW();
1330     test_pack_RIP_INFO();
1331     test_pack_SECURITY_ATTRIBUTES();
1332     test_pack_STARTUPINFOA();
1333     test_pack_STARTUPINFOW();
1334     test_pack_SYSTEMTIME();
1335     test_pack_SYSTEM_INFO();
1336     test_pack_SYSTEM_POWER_STATUS();
1337     test_pack_TIME_ZONE_INFORMATION();
1338     test_pack_UNLOAD_DLL_DEBUG_INFO();
1339     test_pack_WAITORTIMERCALLBACK();
1340     test_pack_WIN32_FILE_ATTRIBUTE_DATA();
1341     test_pack_WIN32_FIND_DATAA();
1342     test_pack_WIN32_FIND_DATAW();
1343     test_pack_WIN32_STREAM_ID();
1344 }
1345
1346 START_TEST(generated)
1347 {
1348     test_pack();
1349 }