git.oblomov.eu Git - wine/blob - dlls/gdi/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(_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 ")\n", \
  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 ")\n", \
  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 ")\n", _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 ")\n", 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 ")\n", 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\n");
 108
 109 #define TEST_TYPE_UNSIGNED(type) \
 110      ok((type) -1 > 0, "(" #type ") -1 > 0\n");
 111
 112 static void test_pack_ABC(void)
 113 {
 114     /* ABC (pack 4) */
 115     TEST_TYPE(ABC, 12, 4);
 116     TEST_FIELD(ABC, INT, abcA, 0, 4, 4);
 117     TEST_FIELD(ABC, UINT, abcB, 4, 4, 4);
 118     TEST_FIELD(ABC, INT, abcC, 8, 4, 4);
 119 }
 120
 121 static void test_pack_ABCFLOAT(void)
 122 {
 123     /* ABCFLOAT (pack 4) */
 124     TEST_TYPE(ABCFLOAT, 12, 4);
 125     TEST_FIELD(ABCFLOAT, FLOAT, abcfA, 0, 4, 4);
 126     TEST_FIELD(ABCFLOAT, FLOAT, abcfB, 4, 4, 4);
 127     TEST_FIELD(ABCFLOAT, FLOAT, abcfC, 8, 4, 4);
 128 }
 129
 130 static void test_pack_ABORTPROC(void)
 131 {
 132     /* ABORTPROC */
 133     TEST_TYPE(ABORTPROC, 4, 4);
 134 }
 135
 136 static void test_pack_BITMAP(void)
 137 {
 138     /* BITMAP (pack 4) */
 139     TEST_TYPE(BITMAP, 24, 4);
 140     TEST_FIELD(BITMAP, INT, bmType, 0, 4, 4);
 141     TEST_FIELD(BITMAP, INT, bmWidth, 4, 4, 4);
 142     TEST_FIELD(BITMAP, INT, bmHeight, 8, 4, 4);
 143     TEST_FIELD(BITMAP, INT, bmWidthBytes, 12, 4, 4);
 144     TEST_FIELD(BITMAP, WORD, bmPlanes, 16, 2, 2);
 145     TEST_FIELD(BITMAP, WORD, bmBitsPixel, 18, 2, 2);
 146     TEST_FIELD(BITMAP, LPVOID, bmBits, 20, 4, 4);
 147 }
 148
 149 static void test_pack_BITMAPCOREHEADER(void)
 150 {
 151     /* BITMAPCOREHEADER (pack 4) */
 152     TEST_TYPE(BITMAPCOREHEADER, 12, 4);
 153     TEST_FIELD(BITMAPCOREHEADER, DWORD, bcSize, 0, 4, 4);
 154     TEST_FIELD(BITMAPCOREHEADER, WORD, bcWidth, 4, 2, 2);
 155     TEST_FIELD(BITMAPCOREHEADER, WORD, bcHeight, 6, 2, 2);
 156     TEST_FIELD(BITMAPCOREHEADER, WORD, bcPlanes, 8, 2, 2);
 157     TEST_FIELD(BITMAPCOREHEADER, WORD, bcBitCount, 10, 2, 2);
 158 }
 159
 160 static void test_pack_BITMAPCOREINFO(void)
 161 {
 162     /* BITMAPCOREINFO (pack 4) */
 163     TEST_TYPE(BITMAPCOREINFO, 16, 4);
 164     TEST_FIELD(BITMAPCOREINFO, BITMAPCOREHEADER, bmciHeader, 0, 12, 4);
 165     TEST_FIELD(BITMAPCOREINFO, RGBTRIPLE[1], bmciColors, 12, 3, 1);
 166 }
 167
 168 static void test_pack_BITMAPFILEHEADER(void)
 169 {
 170     /* BITMAPFILEHEADER (pack 2) */
 171     TEST_TYPE(BITMAPFILEHEADER, 14, 2);
 172     TEST_FIELD(BITMAPFILEHEADER, WORD, bfType, 0, 2, 2);
 173     TEST_FIELD(BITMAPFILEHEADER, DWORD, bfSize, 2, 4, 2);
 174     TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved1, 6, 2, 2);
 175     TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved2, 8, 2, 2);
 176     TEST_FIELD(BITMAPFILEHEADER, DWORD, bfOffBits, 10, 4, 2);
 177 }
 178
 179 static void test_pack_BITMAPINFO(void)
 180 {
 181     /* BITMAPINFO (pack 4) */
 182     TEST_TYPE(BITMAPINFO, 44, 4);
 183     TEST_FIELD(BITMAPINFO, BITMAPINFOHEADER, bmiHeader, 0, 40, 4);
 184     TEST_FIELD(BITMAPINFO, RGBQUAD[1], bmiColors, 40, 4, 1);
 185 }
 186
 187 static void test_pack_BITMAPINFOHEADER(void)
 188 {
 189     /* BITMAPINFOHEADER (pack 4) */
 190     TEST_TYPE(BITMAPINFOHEADER, 40, 4);
 191     TEST_FIELD(BITMAPINFOHEADER, DWORD, biSize, 0, 4, 4);
 192     TEST_FIELD(BITMAPINFOHEADER, LONG, biWidth, 4, 4, 4);
 193     TEST_FIELD(BITMAPINFOHEADER, LONG, biHeight, 8, 4, 4);
 194     TEST_FIELD(BITMAPINFOHEADER, WORD, biPlanes, 12, 2, 2);
 195     TEST_FIELD(BITMAPINFOHEADER, WORD, biBitCount, 14, 2, 2);
 196     TEST_FIELD(BITMAPINFOHEADER, DWORD, biCompression, 16, 4, 4);
 197     TEST_FIELD(BITMAPINFOHEADER, DWORD, biSizeImage, 20, 4, 4);
 198     TEST_FIELD(BITMAPINFOHEADER, LONG, biXPelsPerMeter, 24, 4, 4);
 199     TEST_FIELD(BITMAPINFOHEADER, LONG, biYPelsPerMeter, 28, 4, 4);
 200     TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrUsed, 32, 4, 4);
 201     TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrImportant, 36, 4, 4);
 202 }
 203
 204 static void test_pack_BITMAPV4HEADER(void)
 205 {
 206     /* BITMAPV4HEADER (pack 4) */
 207     TEST_TYPE(BITMAPV4HEADER, 108, 4);
 208     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4Size, 0, 4, 4);
 209     TEST_FIELD(BITMAPV4HEADER, LONG, bV4Width, 4, 4, 4);
 210     TEST_FIELD(BITMAPV4HEADER, LONG, bV4Height, 8, 4, 4);
 211     TEST_FIELD(BITMAPV4HEADER, WORD, bV4Planes, 12, 2, 2);
 212     TEST_FIELD(BITMAPV4HEADER, WORD, bV4BitCount, 14, 2, 2);
 213     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4V4Compression, 16, 4, 4);
 214     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4SizeImage, 20, 4, 4);
 215     TEST_FIELD(BITMAPV4HEADER, LONG, bV4XPelsPerMeter, 24, 4, 4);
 216     TEST_FIELD(BITMAPV4HEADER, LONG, bV4YPelsPerMeter, 28, 4, 4);
 217     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrUsed, 32, 4, 4);
 218     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrImportant, 36, 4, 4);
 219     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4RedMask, 40, 4, 4);
 220     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GreenMask, 44, 4, 4);
 221     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4BlueMask, 48, 4, 4);
 222     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4AlphaMask, 52, 4, 4);
 223     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4CSType, 56, 4, 4);
 224     TEST_FIELD(BITMAPV4HEADER, CIEXYZTRIPLE, bV4Endpoints, 60, 36, 4);
 225     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaRed, 96, 4, 4);
 226     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaGreen, 100, 4, 4);
 227     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaBlue, 104, 4, 4);
 228 }
 229
 230 static void test_pack_BITMAPV5HEADER(void)
 231 {
 232     /* BITMAPV5HEADER (pack 4) */
 233     TEST_TYPE(BITMAPV5HEADER, 124, 4);
 234     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Size, 0, 4, 4);
 235     TEST_FIELD(BITMAPV5HEADER, LONG, bV5Width, 4, 4, 4);
 236     TEST_FIELD(BITMAPV5HEADER, LONG, bV5Height, 8, 4, 4);
 237     TEST_FIELD(BITMAPV5HEADER, WORD, bV5Planes, 12, 2, 2);
 238     TEST_FIELD(BITMAPV5HEADER, WORD, bV5BitCount, 14, 2, 2);
 239     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Compression, 16, 4, 4);
 240     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5SizeImage, 20, 4, 4);
 241     TEST_FIELD(BITMAPV5HEADER, LONG, bV5XPelsPerMeter, 24, 4, 4);
 242     TEST_FIELD(BITMAPV5HEADER, LONG, bV5YPelsPerMeter, 28, 4, 4);
 243     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrUsed, 32, 4, 4);
 244     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrImportant, 36, 4, 4);
 245     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5RedMask, 40, 4, 4);
 246     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GreenMask, 44, 4, 4);
 247     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5BlueMask, 48, 4, 4);
 248     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5AlphaMask, 52, 4, 4);
 249     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5CSType, 56, 4, 4);
 250     TEST_FIELD(BITMAPV5HEADER, CIEXYZTRIPLE, bV5Endpoints, 60, 36, 4);
 251     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaRed, 96, 4, 4);
 252     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaGreen, 100, 4, 4);
 253     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaBlue, 104, 4, 4);
 254     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Intent, 108, 4, 4);
 255     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileData, 112, 4, 4);
 256     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileSize, 116, 4, 4);
 257     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Reserved, 120, 4, 4);
 258 }
 259
 260 static void test_pack_BLENDFUNCTION(void)
 261 {
 262     /* BLENDFUNCTION (pack 4) */
 263     TEST_TYPE(BLENDFUNCTION, 4, 1);
 264     TEST_FIELD(BLENDFUNCTION, BYTE, BlendOp, 0, 1, 1);
 265     TEST_FIELD(BLENDFUNCTION, BYTE, BlendFlags, 1, 1, 1);
 266     TEST_FIELD(BLENDFUNCTION, BYTE, SourceConstantAlpha, 2, 1, 1);
 267     TEST_FIELD(BLENDFUNCTION, BYTE, AlphaFormat, 3, 1, 1);
 268 }
 269
 270 static void test_pack_CHARSETINFO(void)
 271 {
 272     /* CHARSETINFO (pack 4) */
 273     TEST_TYPE(CHARSETINFO, 32, 4);
 274     TEST_FIELD(CHARSETINFO, UINT, ciCharset, 0, 4, 4);
 275     TEST_FIELD(CHARSETINFO, UINT, ciACP, 4, 4, 4);
 276     TEST_FIELD(CHARSETINFO, FONTSIGNATURE, fs, 8, 24, 4);
 277 }
 278
 279 static void test_pack_CIEXYZ(void)
 280 {
 281     /* CIEXYZ (pack 4) */
 282     TEST_TYPE(CIEXYZ, 12, 4);
 283     TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzX, 0, 4, 4);
 284     TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzY, 4, 4, 4);
 285     TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzZ, 8, 4, 4);
 286 }
 287
 288 static void test_pack_CIEXYZTRIPLE(void)
 289 {
 290     /* CIEXYZTRIPLE (pack 4) */
 291     TEST_TYPE(CIEXYZTRIPLE, 36, 4);
 292     TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzRed, 0, 12, 4);
 293     TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzGreen, 12, 12, 4);
 294     TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzBlue, 24, 12, 4);
 295 }
 296
 297 static void test_pack_COLOR16(void)
 298 {
 299     /* COLOR16 */
 300     TEST_TYPE(COLOR16, 2, 2);
 301 }
 302
 303 static void test_pack_COLORADJUSTMENT(void)
 304 {
 305     /* COLORADJUSTMENT (pack 4) */
 306     TEST_TYPE(COLORADJUSTMENT, 24, 2);
 307     TEST_FIELD(COLORADJUSTMENT, WORD, caSize, 0, 2, 2);
 308     TEST_FIELD(COLORADJUSTMENT, WORD, caFlags, 2, 2, 2);
 309     TEST_FIELD(COLORADJUSTMENT, WORD, caIlluminantIndex, 4, 2, 2);
 310     TEST_FIELD(COLORADJUSTMENT, WORD, caRedGamma, 6, 2, 2);
 311     TEST_FIELD(COLORADJUSTMENT, WORD, caGreenGamma, 8, 2, 2);
 312     TEST_FIELD(COLORADJUSTMENT, WORD, caBlueGamma, 10, 2, 2);
 313     TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceBlack, 12, 2, 2);
 314     TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceWhite, 14, 2, 2);
 315     TEST_FIELD(COLORADJUSTMENT, SHORT, caContrast, 16, 2, 2);
 316     TEST_FIELD(COLORADJUSTMENT, SHORT, caBrightness, 18, 2, 2);
 317     TEST_FIELD(COLORADJUSTMENT, SHORT, caColorfulness, 20, 2, 2);
 318     TEST_FIELD(COLORADJUSTMENT, SHORT, caRedGreenTint, 22, 2, 2);
 319 }
 320
 321 static void test_pack_DEVMODEA(void)
 322 {
 323     /* DEVMODEA (pack 4) */
 324     TEST_FIELD(DEVMODEA, BYTE[CCHDEVICENAME], dmDeviceName, 0, 32, 1);
 325     TEST_FIELD(DEVMODEA, WORD, dmSpecVersion, 32, 2, 2);
 326     TEST_FIELD(DEVMODEA, WORD, dmDriverVersion, 34, 2, 2);
 327     TEST_FIELD(DEVMODEA, WORD, dmSize, 36, 2, 2);
 328     TEST_FIELD(DEVMODEA, WORD, dmDriverExtra, 38, 2, 2);
 329     TEST_FIELD(DEVMODEA, DWORD, dmFields, 40, 4, 4);
 330 }
 331
 332 static void test_pack_DEVMODEW(void)
 333 {
 334     /* DEVMODEW (pack 4) */
 335     TEST_FIELD(DEVMODEW, WCHAR[CCHDEVICENAME], dmDeviceName, 0, 64, 2);
 336     TEST_FIELD(DEVMODEW, WORD, dmSpecVersion, 64, 2, 2);
 337     TEST_FIELD(DEVMODEW, WORD, dmDriverVersion, 66, 2, 2);
 338     TEST_FIELD(DEVMODEW, WORD, dmSize, 68, 2, 2);
 339     TEST_FIELD(DEVMODEW, WORD, dmDriverExtra, 70, 2, 2);
 340     TEST_FIELD(DEVMODEW, DWORD, dmFields, 72, 4, 4);
 341 }
 342
 343 static void test_pack_DIBSECTION(void)
 344 {
 345     /* DIBSECTION (pack 4) */
 346     TEST_TYPE(DIBSECTION, 84, 4);
 347     TEST_FIELD(DIBSECTION, BITMAP, dsBm, 0, 24, 4);
 348     TEST_FIELD(DIBSECTION, BITMAPINFOHEADER, dsBmih, 24, 40, 4);
 349     TEST_FIELD(DIBSECTION, DWORD[3], dsBitfields, 64, 12, 4);
 350     TEST_FIELD(DIBSECTION, HANDLE, dshSection, 76, 4, 4);
 351     TEST_FIELD(DIBSECTION, DWORD, dsOffset, 80, 4, 4);
 352 }
 353
 354 static void test_pack_DISPLAY_DEVICEA(void)
 355 {
 356     /* DISPLAY_DEVICEA (pack 4) */
 357     TEST_TYPE(DISPLAY_DEVICEA, 424, 4);
 358     TEST_FIELD(DISPLAY_DEVICEA, DWORD, cb, 0, 4, 4);
 359     TEST_FIELD(DISPLAY_DEVICEA, CHAR[32], DeviceName, 4, 32, 1);
 360     TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceString, 36, 128, 1);
 361     TEST_FIELD(DISPLAY_DEVICEA, DWORD, StateFlags, 164, 4, 4);
 362     TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceID, 168, 128, 1);
 363     TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceKey, 296, 128, 1);
 364 }
 365
 366 static void test_pack_DISPLAY_DEVICEW(void)
 367 {
 368     /* DISPLAY_DEVICEW (pack 4) */
 369     TEST_TYPE(DISPLAY_DEVICEW, 840, 4);
 370     TEST_FIELD(DISPLAY_DEVICEW, DWORD, cb, 0, 4, 4);
 371     TEST_FIELD(DISPLAY_DEVICEW, WCHAR[32], DeviceName, 4, 64, 2);
 372     TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceString, 68, 256, 2);
 373     TEST_FIELD(DISPLAY_DEVICEW, DWORD, StateFlags, 324, 4, 4);
 374     TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceID, 328, 256, 2);
 375     TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceKey, 584, 256, 2);
 376 }
 377
 378 static void test_pack_DOCINFOA(void)
 379 {
 380     /* DOCINFOA (pack 4) */
 381     TEST_TYPE(DOCINFOA, 20, 4);
 382     TEST_FIELD(DOCINFOA, INT, cbSize, 0, 4, 4);
 383     TEST_FIELD(DOCINFOA, LPCSTR, lpszDocName, 4, 4, 4);
 384     TEST_FIELD(DOCINFOA, LPCSTR, lpszOutput, 8, 4, 4);
 385     TEST_FIELD(DOCINFOA, LPCSTR, lpszDatatype, 12, 4, 4);
 386     TEST_FIELD(DOCINFOA, DWORD, fwType, 16, 4, 4);
 387 }
 388
 389 static void test_pack_DOCINFOW(void)
 390 {
 391     /* DOCINFOW (pack 4) */
 392     TEST_TYPE(DOCINFOW, 20, 4);
 393     TEST_FIELD(DOCINFOW, INT, cbSize, 0, 4, 4);
 394     TEST_FIELD(DOCINFOW, LPCWSTR, lpszDocName, 4, 4, 4);
 395     TEST_FIELD(DOCINFOW, LPCWSTR, lpszOutput, 8, 4, 4);
 396     TEST_FIELD(DOCINFOW, LPCWSTR, lpszDatatype, 12, 4, 4);
 397     TEST_FIELD(DOCINFOW, DWORD, fwType, 16, 4, 4);
 398 }
 399
 400 static void test_pack_EMR(void)
 401 {
 402     /* EMR (pack 4) */
 403     TEST_TYPE(EMR, 8, 4);
 404     TEST_FIELD(EMR, DWORD, iType, 0, 4, 4);
 405     TEST_FIELD(EMR, DWORD, nSize, 4, 4, 4);
 406 }
 407
 408 static void test_pack_EMRABORTPATH(void)
 409 {
 410     /* EMRABORTPATH (pack 4) */
 411     TEST_TYPE(EMRABORTPATH, 8, 4);
 412     TEST_FIELD(EMRABORTPATH, EMR, emr, 0, 8, 4);
 413 }
 414
 415 static void test_pack_EMRANGLEARC(void)
 416 {
 417     /* EMRANGLEARC (pack 4) */
 418     TEST_TYPE(EMRANGLEARC, 28, 4);
 419     TEST_FIELD(EMRANGLEARC, EMR, emr, 0, 8, 4);
 420     TEST_FIELD(EMRANGLEARC, POINTL, ptlCenter, 8, 8, 4);
 421     TEST_FIELD(EMRANGLEARC, DWORD, nRadius, 16, 4, 4);
 422     TEST_FIELD(EMRANGLEARC, FLOAT, eStartAngle, 20, 4, 4);
 423     TEST_FIELD(EMRANGLEARC, FLOAT, eSweepAngle, 24, 4, 4);
 424 }
 425
 426 static void test_pack_EMRARC(void)
 427 {
 428     /* EMRARC (pack 4) */
 429     TEST_TYPE(EMRARC, 40, 4);
 430     TEST_FIELD(EMRARC, EMR, emr, 0, 8, 4);
 431     TEST_FIELD(EMRARC, RECTL, rclBox, 8, 16, 4);
 432     TEST_FIELD(EMRARC, POINTL, ptlStart, 24, 8, 4);
 433     TEST_FIELD(EMRARC, POINTL, ptlEnd, 32, 8, 4);
 434 }
 435
 436 static void test_pack_EMRARCTO(void)
 437 {
 438     /* EMRARCTO (pack 4) */
 439     TEST_TYPE(EMRARCTO, 40, 4);
 440     TEST_FIELD(EMRARCTO, EMR, emr, 0, 8, 4);
 441     TEST_FIELD(EMRARCTO, RECTL, rclBox, 8, 16, 4);
 442     TEST_FIELD(EMRARCTO, POINTL, ptlStart, 24, 8, 4);
 443     TEST_FIELD(EMRARCTO, POINTL, ptlEnd, 32, 8, 4);
 444 }
 445
 446 static void test_pack_EMRBEGINPATH(void)
 447 {
 448     /* EMRBEGINPATH (pack 4) */
 449     TEST_TYPE(EMRBEGINPATH, 8, 4);
 450     TEST_FIELD(EMRBEGINPATH, EMR, emr, 0, 8, 4);
 451 }
 452
 453 static void test_pack_EMRBITBLT(void)
 454 {
 455     /* EMRBITBLT (pack 4) */
 456     TEST_TYPE(EMRBITBLT, 100, 4);
 457     TEST_FIELD(EMRBITBLT, EMR, emr, 0, 8, 4);
 458     TEST_FIELD(EMRBITBLT, RECTL, rclBounds, 8, 16, 4);
 459     TEST_FIELD(EMRBITBLT, LONG, xDest, 24, 4, 4);
 460     TEST_FIELD(EMRBITBLT, LONG, yDest, 28, 4, 4);
 461     TEST_FIELD(EMRBITBLT, LONG, cxDest, 32, 4, 4);
 462     TEST_FIELD(EMRBITBLT, LONG, cyDest, 36, 4, 4);
 463     TEST_FIELD(EMRBITBLT, DWORD, dwRop, 40, 4, 4);
 464     TEST_FIELD(EMRBITBLT, LONG, xSrc, 44, 4, 4);
 465     TEST_FIELD(EMRBITBLT, LONG, ySrc, 48, 4, 4);
 466     TEST_FIELD(EMRBITBLT, XFORM, xformSrc, 52, 24, 4);
 467     TEST_FIELD(EMRBITBLT, COLORREF, crBkColorSrc, 76, 4, 4);
 468     TEST_FIELD(EMRBITBLT, DWORD, iUsageSrc, 80, 4, 4);
 469     TEST_FIELD(EMRBITBLT, DWORD, offBmiSrc, 84, 4, 4);
 470     TEST_FIELD(EMRBITBLT, DWORD, cbBmiSrc, 88, 4, 4);
 471     TEST_FIELD(EMRBITBLT, DWORD, offBitsSrc, 92, 4, 4);
 472     TEST_FIELD(EMRBITBLT, DWORD, cbBitsSrc, 96, 4, 4);
 473 }
 474
 475 static void test_pack_EMRCHORD(void)
 476 {
 477     /* EMRCHORD (pack 4) */
 478     TEST_TYPE(EMRCHORD, 40, 4);
 479     TEST_FIELD(EMRCHORD, EMR, emr, 0, 8, 4);
 480     TEST_FIELD(EMRCHORD, RECTL, rclBox, 8, 16, 4);
 481     TEST_FIELD(EMRCHORD, POINTL, ptlStart, 24, 8, 4);
 482     TEST_FIELD(EMRCHORD, POINTL, ptlEnd, 32, 8, 4);
 483 }
 484
 485 static void test_pack_EMRCLOSEFIGURE(void)
 486 {
 487     /* EMRCLOSEFIGURE (pack 4) */
 488     TEST_TYPE(EMRCLOSEFIGURE, 8, 4);
 489     TEST_FIELD(EMRCLOSEFIGURE, EMR, emr, 0, 8, 4);
 490 }
 491
 492 static void test_pack_EMRCREATEBRUSHINDIRECT(void)
 493 {
 494     /* EMRCREATEBRUSHINDIRECT (pack 4) */
 495     TEST_TYPE(EMRCREATEBRUSHINDIRECT, 24, 4);
 496     TEST_FIELD(EMRCREATEBRUSHINDIRECT, EMR, emr, 0, 8, 4);
 497     TEST_FIELD(EMRCREATEBRUSHINDIRECT, DWORD, ihBrush, 8, 4, 4);
 498     TEST_FIELD(EMRCREATEBRUSHINDIRECT, LOGBRUSH, lb, 12, 12, 4);
 499 }
 500
 501 static void test_pack_EMRCREATECOLORSPACE(void)
 502 {
 503     /* EMRCREATECOLORSPACE (pack 4) */
 504     TEST_TYPE(EMRCREATECOLORSPACE, 340, 4);
 505     TEST_FIELD(EMRCREATECOLORSPACE, EMR, emr, 0, 8, 4);
 506     TEST_FIELD(EMRCREATECOLORSPACE, DWORD, ihCS, 8, 4, 4);
 507     TEST_FIELD(EMRCREATECOLORSPACE, LOGCOLORSPACEA, lcs, 12, 328, 4);
 508 }
 509
 510 static void test_pack_EMRCREATECOLORSPACEW(void)
 511 {
 512     /* EMRCREATECOLORSPACEW (pack 4) */
 513     TEST_TYPE(EMRCREATECOLORSPACEW, 612, 4);
 514     TEST_FIELD(EMRCREATECOLORSPACEW, EMR, emr, 0, 8, 4);
 515     TEST_FIELD(EMRCREATECOLORSPACEW, DWORD, ihCS, 8, 4, 4);
 516     TEST_FIELD(EMRCREATECOLORSPACEW, LOGCOLORSPACEW, lcs, 12, 588, 4);
 517     TEST_FIELD(EMRCREATECOLORSPACEW, DWORD, dwFlags, 600, 4, 4);
 518     TEST_FIELD(EMRCREATECOLORSPACEW, DWORD, cbData, 604, 4, 4);
 519     TEST_FIELD(EMRCREATECOLORSPACEW, BYTE[1], Data, 608, 1, 1);
 520 }
 521
 522 static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void)
 523 {
 524     /* EMRCREATEDIBPATTERNBRUSHPT (pack 4) */
 525     TEST_TYPE(EMRCREATEDIBPATTERNBRUSHPT, 32, 4);
 526     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, EMR, emr, 0, 8, 4);
 527     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, ihBrush, 8, 4, 4);
 528     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, iUsage, 12, 4, 4);
 529     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBmi, 16, 4, 4);
 530     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBmi, 20, 4, 4);
 531     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBits, 24, 4, 4);
 532     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBits, 28, 4, 4);
 533 }
 534
 535 static void test_pack_EMRCREATEMONOBRUSH(void)
 536 {
 537     /* EMRCREATEMONOBRUSH (pack 4) */
 538     TEST_TYPE(EMRCREATEMONOBRUSH, 32, 4);
 539     TEST_FIELD(EMRCREATEMONOBRUSH, EMR, emr, 0, 8, 4);
 540     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, ihBrush, 8, 4, 4);
 541     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, iUsage, 12, 4, 4);
 542     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBmi, 16, 4, 4);
 543     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBmi, 20, 4, 4);
 544     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBits, 24, 4, 4);
 545     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBits, 28, 4, 4);
 546 }
 547
 548 static void test_pack_EMRCREATEPEN(void)
 549 {
 550     /* EMRCREATEPEN (pack 4) */
 551     TEST_TYPE(EMRCREATEPEN, 28, 4);
 552     TEST_FIELD(EMRCREATEPEN, EMR, emr, 0, 8, 4);
 553     TEST_FIELD(EMRCREATEPEN, DWORD, ihPen, 8, 4, 4);
 554     TEST_FIELD(EMRCREATEPEN, LOGPEN, lopn, 12, 16, 4);
 555 }
 556
 557 static void test_pack_EMRDELETECOLORSPACE(void)
 558 {
 559     /* EMRDELETECOLORSPACE (pack 4) */
 560     TEST_TYPE(EMRDELETECOLORSPACE, 12, 4);
 561     TEST_FIELD(EMRDELETECOLORSPACE, EMR, emr, 0, 8, 4);
 562     TEST_FIELD(EMRDELETECOLORSPACE, DWORD, ihCS, 8, 4, 4);
 563 }
 564
 565 static void test_pack_EMRDELETEOBJECT(void)
 566 {
 567     /* EMRDELETEOBJECT (pack 4) */
 568     TEST_TYPE(EMRDELETEOBJECT, 12, 4);
 569     TEST_FIELD(EMRDELETEOBJECT, EMR, emr, 0, 8, 4);
 570     TEST_FIELD(EMRDELETEOBJECT, DWORD, ihObject, 8, 4, 4);
 571 }
 572
 573 static void test_pack_EMRELLIPSE(void)
 574 {
 575     /* EMRELLIPSE (pack 4) */
 576     TEST_TYPE(EMRELLIPSE, 24, 4);
 577     TEST_FIELD(EMRELLIPSE, EMR, emr, 0, 8, 4);
 578     TEST_FIELD(EMRELLIPSE, RECTL, rclBox, 8, 16, 4);
 579 }
 580
 581 static void test_pack_EMRENDPATH(void)
 582 {
 583     /* EMRENDPATH (pack 4) */
 584     TEST_TYPE(EMRENDPATH, 8, 4);
 585     TEST_FIELD(EMRENDPATH, EMR, emr, 0, 8, 4);
 586 }
 587
 588 static void test_pack_EMREOF(void)
 589 {
 590     /* EMREOF (pack 4) */
 591     TEST_TYPE(EMREOF, 20, 4);
 592     TEST_FIELD(EMREOF, EMR, emr, 0, 8, 4);
 593     TEST_FIELD(EMREOF, DWORD, nPalEntries, 8, 4, 4);
 594     TEST_FIELD(EMREOF, DWORD, offPalEntries, 12, 4, 4);
 595     TEST_FIELD(EMREOF, DWORD, nSizeLast, 16, 4, 4);
 596 }
 597
 598 static void test_pack_EMREXCLUDECLIPRECT(void)
 599 {
 600     /* EMREXCLUDECLIPRECT (pack 4) */
 601     TEST_TYPE(EMREXCLUDECLIPRECT, 24, 4);
 602     TEST_FIELD(EMREXCLUDECLIPRECT, EMR, emr, 0, 8, 4);
 603     TEST_FIELD(EMREXCLUDECLIPRECT, RECTL, rclClip, 8, 16, 4);
 604 }
 605
 606 static void test_pack_EMREXTCREATEFONTINDIRECTW(void)
 607 {
 608     /* EMREXTCREATEFONTINDIRECTW (pack 4) */
 609     TEST_TYPE(EMREXTCREATEFONTINDIRECTW, 332, 4);
 610     TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EMR, emr, 0, 8, 4);
 611     TEST_FIELD(EMREXTCREATEFONTINDIRECTW, DWORD, ihFont, 8, 4, 4);
 612     TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EXTLOGFONTW, elfw, 12, 320, 4);
 613 }
 614
 615 static void test_pack_EMREXTCREATEPEN(void)
 616 {
 617     /* EMREXTCREATEPEN (pack 4) */
 618     TEST_TYPE(EMREXTCREATEPEN, 56, 4);
 619     TEST_FIELD(EMREXTCREATEPEN, EMR, emr, 0, 8, 4);
 620     TEST_FIELD(EMREXTCREATEPEN, DWORD, ihPen, 8, 4, 4);
 621     TEST_FIELD(EMREXTCREATEPEN, DWORD, offBmi, 12, 4, 4);
 622     TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBmi, 16, 4, 4);
 623     TEST_FIELD(EMREXTCREATEPEN, DWORD, offBits, 20, 4, 4);
 624     TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBits, 24, 4, 4);
 625     TEST_FIELD(EMREXTCREATEPEN, EXTLOGPEN, elp, 28, 28, 4);
 626 }
 627
 628 static void test_pack_EMREXTFLOODFILL(void)
 629 {
 630     /* EMREXTFLOODFILL (pack 4) */
 631     TEST_TYPE(EMREXTFLOODFILL, 24, 4);
 632     TEST_FIELD(EMREXTFLOODFILL, EMR, emr, 0, 8, 4);
 633     TEST_FIELD(EMREXTFLOODFILL, POINTL, ptlStart, 8, 8, 4);
 634     TEST_FIELD(EMREXTFLOODFILL, COLORREF, crColor, 16, 4, 4);
 635     TEST_FIELD(EMREXTFLOODFILL, DWORD, iMode, 20, 4, 4);
 636 }
 637
 638 static void test_pack_EMREXTSELECTCLIPRGN(void)
 639 {
 640     /* EMREXTSELECTCLIPRGN (pack 4) */
 641     TEST_TYPE(EMREXTSELECTCLIPRGN, 20, 4);
 642     TEST_FIELD(EMREXTSELECTCLIPRGN, EMR, emr, 0, 8, 4);
 643     TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, cbRgnData, 8, 4, 4);
 644     TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, iMode, 12, 4, 4);
 645     TEST_FIELD(EMREXTSELECTCLIPRGN, BYTE[1], RgnData, 16, 1, 1);
 646 }
 647
 648 static void test_pack_EMREXTTEXTOUTA(void)
 649 {
 650     /* EMREXTTEXTOUTA (pack 4) */
 651     TEST_TYPE(EMREXTTEXTOUTA, 76, 4);
 652     TEST_FIELD(EMREXTTEXTOUTA, EMR, emr, 0, 8, 4);
 653     TEST_FIELD(EMREXTTEXTOUTA, RECTL, rclBounds, 8, 16, 4);
 654     TEST_FIELD(EMREXTTEXTOUTA, DWORD, iGraphicsMode, 24, 4, 4);
 655     TEST_FIELD(EMREXTTEXTOUTA, FLOAT, exScale, 28, 4, 4);
 656     TEST_FIELD(EMREXTTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
 657     TEST_FIELD(EMREXTTEXTOUTA, EMRTEXT, emrtext, 36, 40, 4);
 658 }
 659
 660 static void test_pack_EMREXTTEXTOUTW(void)
 661 {
 662     /* EMREXTTEXTOUTW (pack 4) */
 663     TEST_TYPE(EMREXTTEXTOUTW, 76, 4);
 664     TEST_FIELD(EMREXTTEXTOUTW, EMR, emr, 0, 8, 4);
 665     TEST_FIELD(EMREXTTEXTOUTW, RECTL, rclBounds, 8, 16, 4);
 666     TEST_FIELD(EMREXTTEXTOUTW, DWORD, iGraphicsMode, 24, 4, 4);
 667     TEST_FIELD(EMREXTTEXTOUTW, FLOAT, exScale, 28, 4, 4);
 668     TEST_FIELD(EMREXTTEXTOUTW, FLOAT, eyScale, 32, 4, 4);
 669     TEST_FIELD(EMREXTTEXTOUTW, EMRTEXT, emrtext, 36, 40, 4);
 670 }
 671
 672 static void test_pack_EMRFILLPATH(void)
 673 {
 674     /* EMRFILLPATH (pack 4) */
 675     TEST_TYPE(EMRFILLPATH, 24, 4);
 676     TEST_FIELD(EMRFILLPATH, EMR, emr, 0, 8, 4);
 677     TEST_FIELD(EMRFILLPATH, RECTL, rclBounds, 8, 16, 4);
 678 }
 679
 680 static void test_pack_EMRFILLRGN(void)
 681 {
 682     /* EMRFILLRGN (pack 4) */
 683     TEST_TYPE(EMRFILLRGN, 36, 4);
 684     TEST_FIELD(EMRFILLRGN, EMR, emr, 0, 8, 4);
 685     TEST_FIELD(EMRFILLRGN, RECTL, rclBounds, 8, 16, 4);
 686     TEST_FIELD(EMRFILLRGN, DWORD, cbRgnData, 24, 4, 4);
 687     TEST_FIELD(EMRFILLRGN, DWORD, ihBrush, 28, 4, 4);
 688     TEST_FIELD(EMRFILLRGN, BYTE[1], RgnData, 32, 1, 1);
 689 }
 690
 691 static void test_pack_EMRFLATTENPATH(void)
 692 {
 693     /* EMRFLATTENPATH (pack 4) */
 694     TEST_TYPE(EMRFLATTENPATH, 8, 4);
 695     TEST_FIELD(EMRFLATTENPATH, EMR, emr, 0, 8, 4);
 696 }
 697
 698 static void test_pack_EMRFORMAT(void)
 699 {
 700     /* EMRFORMAT (pack 4) */
 701     TEST_TYPE(EMRFORMAT, 16, 4);
 702     TEST_FIELD(EMRFORMAT, DWORD, dSignature, 0, 4, 4);
 703     TEST_FIELD(EMRFORMAT, DWORD, nVersion, 4, 4, 4);
 704     TEST_FIELD(EMRFORMAT, DWORD, cbData, 8, 4, 4);
 705     TEST_FIELD(EMRFORMAT, DWORD, offData, 12, 4, 4);
 706 }
 707
 708 static void test_pack_EMRFRAMERGN(void)
 709 {
 710     /* EMRFRAMERGN (pack 4) */
 711     TEST_TYPE(EMRFRAMERGN, 44, 4);
 712     TEST_FIELD(EMRFRAMERGN, EMR, emr, 0, 8, 4);
 713     TEST_FIELD(EMRFRAMERGN, RECTL, rclBounds, 8, 16, 4);
 714     TEST_FIELD(EMRFRAMERGN, DWORD, cbRgnData, 24, 4, 4);
 715     TEST_FIELD(EMRFRAMERGN, DWORD, ihBrush, 28, 4, 4);
 716     TEST_FIELD(EMRFRAMERGN, SIZEL, szlStroke, 32, 8, 4);
 717     TEST_FIELD(EMRFRAMERGN, BYTE[1], RgnData, 40, 1, 1);
 718 }
 719
 720 static void test_pack_EMRGDICOMMENT(void)
 721 {
 722     /* EMRGDICOMMENT (pack 4) */
 723     TEST_TYPE(EMRGDICOMMENT, 16, 4);
 724     TEST_FIELD(EMRGDICOMMENT, EMR, emr, 0, 8, 4);
 725     TEST_FIELD(EMRGDICOMMENT, DWORD, cbData, 8, 4, 4);
 726     TEST_FIELD(EMRGDICOMMENT, BYTE[1], Data, 12, 1, 1);
 727 }
 728
 729 static void test_pack_EMRGLSBOUNDEDRECORD(void)
 730 {
 731     /* EMRGLSBOUNDEDRECORD (pack 4) */
 732     TEST_TYPE(EMRGLSBOUNDEDRECORD, 32, 4);
 733     TEST_FIELD(EMRGLSBOUNDEDRECORD, EMR, emr, 0, 8, 4);
 734     TEST_FIELD(EMRGLSBOUNDEDRECORD, RECTL, rclBounds, 8, 16, 4);
 735     TEST_FIELD(EMRGLSBOUNDEDRECORD, DWORD, cbData, 24, 4, 4);
 736     TEST_FIELD(EMRGLSBOUNDEDRECORD, BYTE[1], Data, 28, 1, 1);
 737 }
 738
 739 static void test_pack_EMRGLSRECORD(void)
 740 {
 741     /* EMRGLSRECORD (pack 4) */
 742     TEST_TYPE(EMRGLSRECORD, 16, 4);
 743     TEST_FIELD(EMRGLSRECORD, EMR, emr, 0, 8, 4);
 744     TEST_FIELD(EMRGLSRECORD, DWORD, cbData, 8, 4, 4);
 745     TEST_FIELD(EMRGLSRECORD, BYTE[1], Data, 12, 1, 1);
 746 }
 747
 748 static void test_pack_EMRINTERSECTCLIPRECT(void)
 749 {
 750     /* EMRINTERSECTCLIPRECT (pack 4) */
 751     TEST_TYPE(EMRINTERSECTCLIPRECT, 24, 4);
 752     TEST_FIELD(EMRINTERSECTCLIPRECT, EMR, emr, 0, 8, 4);
 753     TEST_FIELD(EMRINTERSECTCLIPRECT, RECTL, rclClip, 8, 16, 4);
 754 }
 755
 756 static void test_pack_EMRINVERTRGN(void)
 757 {
 758     /* EMRINVERTRGN (pack 4) */
 759     TEST_TYPE(EMRINVERTRGN, 32, 4);
 760     TEST_FIELD(EMRINVERTRGN, EMR, emr, 0, 8, 4);
 761     TEST_FIELD(EMRINVERTRGN, RECTL, rclBounds, 8, 16, 4);
 762     TEST_FIELD(EMRINVERTRGN, DWORD, cbRgnData, 24, 4, 4);
 763     TEST_FIELD(EMRINVERTRGN, BYTE[1], RgnData, 28, 1, 1);
 764 }
 765
 766 static void test_pack_EMRLINETO(void)
 767 {
 768     /* EMRLINETO (pack 4) */
 769     TEST_TYPE(EMRLINETO, 16, 4);
 770     TEST_FIELD(EMRLINETO, EMR, emr, 0, 8, 4);
 771     TEST_FIELD(EMRLINETO, POINTL, ptl, 8, 8, 4);
 772 }
 773
 774 static void test_pack_EMRMASKBLT(void)
 775 {
 776     /* EMRMASKBLT (pack 4) */
 777     TEST_TYPE(EMRMASKBLT, 128, 4);
 778     TEST_FIELD(EMRMASKBLT, EMR, emr, 0, 8, 4);
 779     TEST_FIELD(EMRMASKBLT, RECTL, rclBounds, 8, 16, 4);
 780     TEST_FIELD(EMRMASKBLT, LONG, xDest, 24, 4, 4);
 781     TEST_FIELD(EMRMASKBLT, LONG, yDest, 28, 4, 4);
 782     TEST_FIELD(EMRMASKBLT, LONG, cxDest, 32, 4, 4);
 783     TEST_FIELD(EMRMASKBLT, LONG, cyDest, 36, 4, 4);
 784     TEST_FIELD(EMRMASKBLT, DWORD, dwRop, 40, 4, 4);
 785     TEST_FIELD(EMRMASKBLT, LONG, xSrc, 44, 4, 4);
 786     TEST_FIELD(EMRMASKBLT, LONG, ySrc, 48, 4, 4);
 787     TEST_FIELD(EMRMASKBLT, XFORM, xformSrc, 52, 24, 4);
 788     TEST_FIELD(EMRMASKBLT, COLORREF, crBkColorSrc, 76, 4, 4);
 789     TEST_FIELD(EMRMASKBLT, DWORD, iUsageSrc, 80, 4, 4);
 790     TEST_FIELD(EMRMASKBLT, DWORD, offBmiSrc, 84, 4, 4);
 791     TEST_FIELD(EMRMASKBLT, DWORD, cbBmiSrc, 88, 4, 4);
 792     TEST_FIELD(EMRMASKBLT, DWORD, offBitsSrc, 92, 4, 4);
 793     TEST_FIELD(EMRMASKBLT, DWORD, cbBitsSrc, 96, 4, 4);
 794     TEST_FIELD(EMRMASKBLT, LONG, xMask, 100, 4, 4);
 795     TEST_FIELD(EMRMASKBLT, LONG, yMask, 104, 4, 4);
 796     TEST_FIELD(EMRMASKBLT, DWORD, iUsageMask, 108, 4, 4);
 797     TEST_FIELD(EMRMASKBLT, DWORD, offBmiMask, 112, 4, 4);
 798     TEST_FIELD(EMRMASKBLT, DWORD, cbBmiMask, 116, 4, 4);
 799     TEST_FIELD(EMRMASKBLT, DWORD, offBitsMask, 120, 4, 4);
 800     TEST_FIELD(EMRMASKBLT, DWORD, cbBitsMask, 124, 4, 4);
 801 }
 802
 803 static void test_pack_EMRMODIFYWORLDTRANSFORM(void)
 804 {
 805     /* EMRMODIFYWORLDTRANSFORM (pack 4) */
 806     TEST_TYPE(EMRMODIFYWORLDTRANSFORM, 36, 4);
 807     TEST_FIELD(EMRMODIFYWORLDTRANSFORM, EMR, emr, 0, 8, 4);
 808     TEST_FIELD(EMRMODIFYWORLDTRANSFORM, XFORM, xform, 8, 24, 4);
 809     TEST_FIELD(EMRMODIFYWORLDTRANSFORM, DWORD, iMode, 32, 4, 4);
 810 }
 811
 812 static void test_pack_EMRMOVETOEX(void)
 813 {
 814     /* EMRMOVETOEX (pack 4) */
 815     TEST_TYPE(EMRMOVETOEX, 16, 4);
 816     TEST_FIELD(EMRMOVETOEX, EMR, emr, 0, 8, 4);
 817     TEST_FIELD(EMRMOVETOEX, POINTL, ptl, 8, 8, 4);
 818 }
 819
 820 static void test_pack_EMROFFSETCLIPRGN(void)
 821 {
 822     /* EMROFFSETCLIPRGN (pack 4) */
 823     TEST_TYPE(EMROFFSETCLIPRGN, 16, 4);
 824     TEST_FIELD(EMROFFSETCLIPRGN, EMR, emr, 0, 8, 4);
 825     TEST_FIELD(EMROFFSETCLIPRGN, POINTL, ptlOffset, 8, 8, 4);
 826 }
 827
 828 static void test_pack_EMRPAINTRGN(void)
 829 {
 830     /* EMRPAINTRGN (pack 4) */
 831     TEST_TYPE(EMRPAINTRGN, 32, 4);
 832     TEST_FIELD(EMRPAINTRGN, EMR, emr, 0, 8, 4);
 833     TEST_FIELD(EMRPAINTRGN, RECTL, rclBounds, 8, 16, 4);
 834     TEST_FIELD(EMRPAINTRGN, DWORD, cbRgnData, 24, 4, 4);
 835     TEST_FIELD(EMRPAINTRGN, BYTE[1], RgnData, 28, 1, 1);
 836 }
 837
 838 static void test_pack_EMRPIE(void)
 839 {
 840     /* EMRPIE (pack 4) */
 841     TEST_TYPE(EMRPIE, 40, 4);
 842     TEST_FIELD(EMRPIE, EMR, emr, 0, 8, 4);
 843     TEST_FIELD(EMRPIE, RECTL, rclBox, 8, 16, 4);
 844     TEST_FIELD(EMRPIE, POINTL, ptlStart, 24, 8, 4);
 845     TEST_FIELD(EMRPIE, POINTL, ptlEnd, 32, 8, 4);
 846 }
 847
 848 static void test_pack_EMRPIXELFORMAT(void)
 849 {
 850     /* EMRPIXELFORMAT (pack 4) */
 851     TEST_TYPE(EMRPIXELFORMAT, 48, 4);
 852     TEST_FIELD(EMRPIXELFORMAT, EMR, emr, 0, 8, 4);
 853     TEST_FIELD(EMRPIXELFORMAT, PIXELFORMATDESCRIPTOR, pfd, 8, 40, 4);
 854 }
 855
 856 static void test_pack_EMRPLGBLT(void)
 857 {
 858     /* EMRPLGBLT (pack 4) */
 859     TEST_TYPE(EMRPLGBLT, 140, 4);
 860     TEST_FIELD(EMRPLGBLT, EMR, emr, 0, 8, 4);
 861     TEST_FIELD(EMRPLGBLT, RECTL, rclBounds, 8, 16, 4);
 862     TEST_FIELD(EMRPLGBLT, POINTL[3], aptlDest, 24, 24, 4);
 863     TEST_FIELD(EMRPLGBLT, LONG, xSrc, 48, 4, 4);
 864     TEST_FIELD(EMRPLGBLT, LONG, ySrc, 52, 4, 4);
 865     TEST_FIELD(EMRPLGBLT, LONG, cxSrc, 56, 4, 4);
 866     TEST_FIELD(EMRPLGBLT, LONG, cySrc, 60, 4, 4);
 867     TEST_FIELD(EMRPLGBLT, XFORM, xformSrc, 64, 24, 4);
 868     TEST_FIELD(EMRPLGBLT, COLORREF, crBkColorSrc, 88, 4, 4);
 869     TEST_FIELD(EMRPLGBLT, DWORD, iUsageSrc, 92, 4, 4);
 870     TEST_FIELD(EMRPLGBLT, DWORD, offBmiSrc, 96, 4, 4);
 871     TEST_FIELD(EMRPLGBLT, DWORD, cbBmiSrc, 100, 4, 4);
 872     TEST_FIELD(EMRPLGBLT, DWORD, offBitsSrc, 104, 4, 4);
 873     TEST_FIELD(EMRPLGBLT, DWORD, cbBitsSrc, 108, 4, 4);
 874     TEST_FIELD(EMRPLGBLT, LONG, xMask, 112, 4, 4);
 875     TEST_FIELD(EMRPLGBLT, LONG, yMask, 116, 4, 4);
 876     TEST_FIELD(EMRPLGBLT, DWORD, iUsageMask, 120, 4, 4);
 877     TEST_FIELD(EMRPLGBLT, DWORD, offBmiMask, 124, 4, 4);
 878     TEST_FIELD(EMRPLGBLT, DWORD, cbBmiMask, 128, 4, 4);
 879     TEST_FIELD(EMRPLGBLT, DWORD, offBitsMask, 132, 4, 4);
 880     TEST_FIELD(EMRPLGBLT, DWORD, cbBitsMask, 136, 4, 4);
 881 }
 882
 883 static void test_pack_EMRPOLYBEZIER(void)
 884 {
 885     /* EMRPOLYBEZIER (pack 4) */
 886     TEST_TYPE(EMRPOLYBEZIER, 36, 4);
 887     TEST_FIELD(EMRPOLYBEZIER, EMR, emr, 0, 8, 4);
 888     TEST_FIELD(EMRPOLYBEZIER, RECTL, rclBounds, 8, 16, 4);
 889     TEST_FIELD(EMRPOLYBEZIER, DWORD, cptl, 24, 4, 4);
 890     TEST_FIELD(EMRPOLYBEZIER, POINTL[1], aptl, 28, 8, 4);
 891 }
 892
 893 static void test_pack_EMRPOLYBEZIER16(void)
 894 {
 895     /* EMRPOLYBEZIER16 (pack 4) */
 896     TEST_TYPE(EMRPOLYBEZIER16, 32, 4);
 897     TEST_FIELD(EMRPOLYBEZIER16, EMR, emr, 0, 8, 4);
 898     TEST_FIELD(EMRPOLYBEZIER16, RECTL, rclBounds, 8, 16, 4);
 899     TEST_FIELD(EMRPOLYBEZIER16, DWORD, cpts, 24, 4, 4);
 900     TEST_FIELD(EMRPOLYBEZIER16, POINTS[1], apts, 28, 4, 2);
 901 }
 902
 903 static void test_pack_EMRPOLYBEZIERTO(void)
 904 {
 905     /* EMRPOLYBEZIERTO (pack 4) */
 906     TEST_TYPE(EMRPOLYBEZIERTO, 36, 4);
 907     TEST_FIELD(EMRPOLYBEZIERTO, EMR, emr, 0, 8, 4);
 908     TEST_FIELD(EMRPOLYBEZIERTO, RECTL, rclBounds, 8, 16, 4);
 909     TEST_FIELD(EMRPOLYBEZIERTO, DWORD, cptl, 24, 4, 4);
 910     TEST_FIELD(EMRPOLYBEZIERTO, POINTL[1], aptl, 28, 8, 4);
 911 }
 912
 913 static void test_pack_EMRPOLYBEZIERTO16(void)
 914 {
 915     /* EMRPOLYBEZIERTO16 (pack 4) */
 916     TEST_TYPE(EMRPOLYBEZIERTO16, 32, 4);
 917     TEST_FIELD(EMRPOLYBEZIERTO16, EMR, emr, 0, 8, 4);
 918     TEST_FIELD(EMRPOLYBEZIERTO16, RECTL, rclBounds, 8, 16, 4);
 919     TEST_FIELD(EMRPOLYBEZIERTO16, DWORD, cpts, 24, 4, 4);
 920     TEST_FIELD(EMRPOLYBEZIERTO16, POINTS[1], apts, 28, 4, 2);
 921 }
 922
 923 static void test_pack_EMRPOLYDRAW(void)
 924 {
 925     /* EMRPOLYDRAW (pack 4) */
 926     TEST_TYPE(EMRPOLYDRAW, 40, 4);
 927     TEST_FIELD(EMRPOLYDRAW, EMR, emr, 0, 8, 4);
 928     TEST_FIELD(EMRPOLYDRAW, RECTL, rclBounds, 8, 16, 4);
 929     TEST_FIELD(EMRPOLYDRAW, DWORD, cptl, 24, 4, 4);
 930     TEST_FIELD(EMRPOLYDRAW, POINTL[1], aptl, 28, 8, 4);
 931     TEST_FIELD(EMRPOLYDRAW, BYTE[1], abTypes, 36, 1, 1);
 932 }
 933
 934 static void test_pack_EMRPOLYDRAW16(void)
 935 {
 936     /* EMRPOLYDRAW16 (pack 4) */
 937     TEST_TYPE(EMRPOLYDRAW16, 36, 4);
 938     TEST_FIELD(EMRPOLYDRAW16, EMR, emr, 0, 8, 4);
 939     TEST_FIELD(EMRPOLYDRAW16, RECTL, rclBounds, 8, 16, 4);
 940     TEST_FIELD(EMRPOLYDRAW16, DWORD, cpts, 24, 4, 4);
 941     TEST_FIELD(EMRPOLYDRAW16, POINTS[1], apts, 28, 4, 2);
 942     TEST_FIELD(EMRPOLYDRAW16, BYTE[1], abTypes, 32, 1, 1);
 943 }
 944
 945 static void test_pack_EMRPOLYGON(void)
 946 {
 947     /* EMRPOLYGON (pack 4) */
 948     TEST_TYPE(EMRPOLYGON, 36, 4);
 949     TEST_FIELD(EMRPOLYGON, EMR, emr, 0, 8, 4);
 950     TEST_FIELD(EMRPOLYGON, RECTL, rclBounds, 8, 16, 4);
 951     TEST_FIELD(EMRPOLYGON, DWORD, cptl, 24, 4, 4);
 952     TEST_FIELD(EMRPOLYGON, POINTL[1], aptl, 28, 8, 4);
 953 }
 954
 955 static void test_pack_EMRPOLYGON16(void)
 956 {
 957     /* EMRPOLYGON16 (pack 4) */
 958     TEST_TYPE(EMRPOLYGON16, 32, 4);
 959     TEST_FIELD(EMRPOLYGON16, EMR, emr, 0, 8, 4);
 960     TEST_FIELD(EMRPOLYGON16, RECTL, rclBounds, 8, 16, 4);
 961     TEST_FIELD(EMRPOLYGON16, DWORD, cpts, 24, 4, 4);
 962     TEST_FIELD(EMRPOLYGON16, POINTS[1], apts, 28, 4, 2);
 963 }
 964
 965 static void test_pack_EMRPOLYLINE(void)
 966 {
 967     /* EMRPOLYLINE (pack 4) */
 968     TEST_TYPE(EMRPOLYLINE, 36, 4);
 969     TEST_FIELD(EMRPOLYLINE, EMR, emr, 0, 8, 4);
 970     TEST_FIELD(EMRPOLYLINE, RECTL, rclBounds, 8, 16, 4);
 971     TEST_FIELD(EMRPOLYLINE, DWORD, cptl, 24, 4, 4);
 972     TEST_FIELD(EMRPOLYLINE, POINTL[1], aptl, 28, 8, 4);
 973 }
 974
 975 static void test_pack_EMRPOLYLINE16(void)
 976 {
 977     /* EMRPOLYLINE16 (pack 4) */
 978     TEST_TYPE(EMRPOLYLINE16, 32, 4);
 979     TEST_FIELD(EMRPOLYLINE16, EMR, emr, 0, 8, 4);
 980     TEST_FIELD(EMRPOLYLINE16, RECTL, rclBounds, 8, 16, 4);
 981     TEST_FIELD(EMRPOLYLINE16, DWORD, cpts, 24, 4, 4);
 982     TEST_FIELD(EMRPOLYLINE16, POINTS[1], apts, 28, 4, 2);
 983 }
 984
 985 static void test_pack_EMRPOLYLINETO(void)
 986 {
 987     /* EMRPOLYLINETO (pack 4) */
 988     TEST_TYPE(EMRPOLYLINETO, 36, 4);
 989     TEST_FIELD(EMRPOLYLINETO, EMR, emr, 0, 8, 4);
 990     TEST_FIELD(EMRPOLYLINETO, RECTL, rclBounds, 8, 16, 4);
 991     TEST_FIELD(EMRPOLYLINETO, DWORD, cptl, 24, 4, 4);
 992     TEST_FIELD(EMRPOLYLINETO, POINTL[1], aptl, 28, 8, 4);
 993 }
 994
 995 static void test_pack_EMRPOLYLINETO16(void)
 996 {
 997     /* EMRPOLYLINETO16 (pack 4) */
 998     TEST_TYPE(EMRPOLYLINETO16, 32, 4);
 999     TEST_FIELD(EMRPOLYLINETO16, EMR, emr, 0, 8, 4);
1000     TEST_FIELD(EMRPOLYLINETO16, RECTL, rclBounds, 8, 16, 4);
1001     TEST_FIELD(EMRPOLYLINETO16, DWORD, cpts, 24, 4, 4);
1002     TEST_FIELD(EMRPOLYLINETO16, POINTS[1], apts, 28, 4, 2);
1003 }
1004
1005 static void test_pack_EMRPOLYPOLYGON(void)
1006 {
1007     /* EMRPOLYPOLYGON (pack 4) */
1008     TEST_TYPE(EMRPOLYPOLYGON, 44, 4);
1009     TEST_FIELD(EMRPOLYPOLYGON, EMR, emr, 0, 8, 4);
1010     TEST_FIELD(EMRPOLYPOLYGON, RECTL, rclBounds, 8, 16, 4);
1011     TEST_FIELD(EMRPOLYPOLYGON, DWORD, nPolys, 24, 4, 4);
1012     TEST_FIELD(EMRPOLYPOLYGON, DWORD, cptl, 28, 4, 4);
1013     TEST_FIELD(EMRPOLYPOLYGON, DWORD[1], aPolyCounts, 32, 4, 4);
1014     TEST_FIELD(EMRPOLYPOLYGON, POINTL[1], aptl, 36, 8, 4);
1015 }
1016
1017 static void test_pack_EMRPOLYPOLYGON16(void)
1018 {
1019     /* EMRPOLYPOLYGON16 (pack 4) */
1020     TEST_TYPE(EMRPOLYPOLYGON16, 40, 4);
1021     TEST_FIELD(EMRPOLYPOLYGON16, EMR, emr, 0, 8, 4);
1022     TEST_FIELD(EMRPOLYPOLYGON16, RECTL, rclBounds, 8, 16, 4);
1023     TEST_FIELD(EMRPOLYPOLYGON16, DWORD, nPolys, 24, 4, 4);
1024     TEST_FIELD(EMRPOLYPOLYGON16, DWORD, cpts, 28, 4, 4);
1025     TEST_FIELD(EMRPOLYPOLYGON16, DWORD[1], aPolyCounts, 32, 4, 4);
1026     TEST_FIELD(EMRPOLYPOLYGON16, POINTS[1], apts, 36, 4, 2);
1027 }
1028
1029 static void test_pack_EMRPOLYPOLYLINE(void)
1030 {
1031     /* EMRPOLYPOLYLINE (pack 4) */
1032     TEST_TYPE(EMRPOLYPOLYLINE, 44, 4);
1033     TEST_FIELD(EMRPOLYPOLYLINE, EMR, emr, 0, 8, 4);
1034     TEST_FIELD(EMRPOLYPOLYLINE, RECTL, rclBounds, 8, 16, 4);
1035     TEST_FIELD(EMRPOLYPOLYLINE, DWORD, nPolys, 24, 4, 4);
1036     TEST_FIELD(EMRPOLYPOLYLINE, DWORD, cptl, 28, 4, 4);
1037     TEST_FIELD(EMRPOLYPOLYLINE, DWORD[1], aPolyCounts, 32, 4, 4);
1038     TEST_FIELD(EMRPOLYPOLYLINE, POINTL[1], aptl, 36, 8, 4);
1039 }
1040
1041 static void test_pack_EMRPOLYPOLYLINE16(void)
1042 {
1043     /* EMRPOLYPOLYLINE16 (pack 4) */
1044     TEST_TYPE(EMRPOLYPOLYLINE16, 40, 4);
1045     TEST_FIELD(EMRPOLYPOLYLINE16, EMR, emr, 0, 8, 4);
1046     TEST_FIELD(EMRPOLYPOLYLINE16, RECTL, rclBounds, 8, 16, 4);
1047     TEST_FIELD(EMRPOLYPOLYLINE16, DWORD, nPolys, 24, 4, 4);
1048     TEST_FIELD(EMRPOLYPOLYLINE16, DWORD, cpts, 28, 4, 4);
1049     TEST_FIELD(EMRPOLYPOLYLINE16, DWORD[1], aPolyCounts, 32, 4, 4);
1050     TEST_FIELD(EMRPOLYPOLYLINE16, POINTS[1], apts, 36, 4, 2);
1051 }
1052
1053 static void test_pack_EMRPOLYTEXTOUTA(void)
1054 {
1055     /* EMRPOLYTEXTOUTA (pack 4) */
1056     TEST_TYPE(EMRPOLYTEXTOUTA, 80, 4);
1057     TEST_FIELD(EMRPOLYTEXTOUTA, EMR, emr, 0, 8, 4);
1058     TEST_FIELD(EMRPOLYTEXTOUTA, RECTL, rclBounds, 8, 16, 4);
1059     TEST_FIELD(EMRPOLYTEXTOUTA, DWORD, iGraphicsMode, 24, 4, 4);
1060     TEST_FIELD(EMRPOLYTEXTOUTA, FLOAT, exScale, 28, 4, 4);
1061     TEST_FIELD(EMRPOLYTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
1062     TEST_FIELD(EMRPOLYTEXTOUTA, LONG, cStrings, 36, 4, 4);
1063     TEST_FIELD(EMRPOLYTEXTOUTA, EMRTEXT[1], aemrtext, 40, 40, 4);
1064 }
1065
1066 static void test_pack_EMRPOLYTEXTOUTW(void)
1067 {
1068     /* EMRPOLYTEXTOUTW (pack 4) */
1069     TEST_TYPE(EMRPOLYTEXTOUTW, 80, 4);
1070     TEST_FIELD(EMRPOLYTEXTOUTW, EMR, emr, 0, 8, 4);
1071     TEST_FIELD(EMRPOLYTEXTOUTW, RECTL, rclBounds, 8, 16, 4);
1072     TEST_FIELD(EMRPOLYTEXTOUTW, DWORD, iGraphicsMode, 24, 4, 4);
1073     TEST_FIELD(EMRPOLYTEXTOUTW, FLOAT, exScale, 28, 4, 4);
1074     TEST_FIELD(EMRPOLYTEXTOUTW, FLOAT, eyScale, 32, 4, 4);
1075     TEST_FIELD(EMRPOLYTEXTOUTW, LONG, cStrings, 36, 4, 4);
1076     TEST_FIELD(EMRPOLYTEXTOUTW, EMRTEXT[1], aemrtext, 40, 40, 4);
1077 }
1078
1079 static void test_pack_EMRREALIZEPALETTE(void)
1080 {
1081     /* EMRREALIZEPALETTE (pack 4) */
1082     TEST_TYPE(EMRREALIZEPALETTE, 8, 4);
1083     TEST_FIELD(EMRREALIZEPALETTE, EMR, emr, 0, 8, 4);
1084 }
1085
1086 static void test_pack_EMRRECTANGLE(void)
1087 {
1088     /* EMRRECTANGLE (pack 4) */
1089     TEST_TYPE(EMRRECTANGLE, 24, 4);
1090     TEST_FIELD(EMRRECTANGLE, EMR, emr, 0, 8, 4);
1091     TEST_FIELD(EMRRECTANGLE, RECTL, rclBox, 8, 16, 4);
1092 }
1093
1094 static void test_pack_EMRRESIZEPALETTE(void)
1095 {
1096     /* EMRRESIZEPALETTE (pack 4) */
1097     TEST_TYPE(EMRRESIZEPALETTE, 16, 4);
1098     TEST_FIELD(EMRRESIZEPALETTE, EMR, emr, 0, 8, 4);
1099     TEST_FIELD(EMRRESIZEPALETTE, DWORD, ihPal, 8, 4, 4);
1100     TEST_FIELD(EMRRESIZEPALETTE, DWORD, cEntries, 12, 4, 4);
1101 }
1102
1103 static void test_pack_EMRRESTOREDC(void)
1104 {
1105     /* EMRRESTOREDC (pack 4) */
1106     TEST_TYPE(EMRRESTOREDC, 12, 4);
1107     TEST_FIELD(EMRRESTOREDC, EMR, emr, 0, 8, 4);
1108     TEST_FIELD(EMRRESTOREDC, LONG, iRelative, 8, 4, 4);
1109 }
1110
1111 static void test_pack_EMRROUNDRECT(void)
1112 {
1113     /* EMRROUNDRECT (pack 4) */
1114     TEST_TYPE(EMRROUNDRECT, 32, 4);
1115     TEST_FIELD(EMRROUNDRECT, EMR, emr, 0, 8, 4);
1116     TEST_FIELD(EMRROUNDRECT, RECTL, rclBox, 8, 16, 4);
1117     TEST_FIELD(EMRROUNDRECT, SIZEL, szlCorner, 24, 8, 4);
1118 }
1119
1120 static void test_pack_EMRSAVEDC(void)
1121 {
1122     /* EMRSAVEDC (pack 4) */
1123     TEST_TYPE(EMRSAVEDC, 8, 4);
1124     TEST_FIELD(EMRSAVEDC, EMR, emr, 0, 8, 4);
1125 }
1126
1127 static void test_pack_EMRSCALEVIEWPORTEXTEX(void)
1128 {
1129     /* EMRSCALEVIEWPORTEXTEX (pack 4) */
1130     TEST_TYPE(EMRSCALEVIEWPORTEXTEX, 24, 4);
1131     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, EMR, emr, 0, 8, 4);
1132     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, xNum, 8, 4, 4);
1133     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, xDenom, 12, 4, 4);
1134     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yNum, 16, 4, 4);
1135     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yDenom, 20, 4, 4);
1136 }
1137
1138 static void test_pack_EMRSCALEWINDOWEXTEX(void)
1139 {
1140     /* EMRSCALEWINDOWEXTEX (pack 4) */
1141     TEST_TYPE(EMRSCALEWINDOWEXTEX, 24, 4);
1142     TEST_FIELD(EMRSCALEWINDOWEXTEX, EMR, emr, 0, 8, 4);
1143     TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, xNum, 8, 4, 4);
1144     TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, xDenom, 12, 4, 4);
1145     TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, yNum, 16, 4, 4);
1146     TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, yDenom, 20, 4, 4);
1147 }
1148
1149 static void test_pack_EMRSELECTCLIPPATH(void)
1150 {
1151     /* EMRSELECTCLIPPATH (pack 4) */
1152     TEST_TYPE(EMRSELECTCLIPPATH, 12, 4);
1153     TEST_FIELD(EMRSELECTCLIPPATH, EMR, emr, 0, 8, 4);
1154     TEST_FIELD(EMRSELECTCLIPPATH, DWORD, iMode, 8, 4, 4);
1155 }
1156
1157 static void test_pack_EMRSELECTCOLORSPACE(void)
1158 {
1159     /* EMRSELECTCOLORSPACE (pack 4) */
1160     TEST_TYPE(EMRSELECTCOLORSPACE, 12, 4);
1161     TEST_FIELD(EMRSELECTCOLORSPACE, EMR, emr, 0, 8, 4);
1162     TEST_FIELD(EMRSELECTCOLORSPACE, DWORD, ihCS, 8, 4, 4);
1163 }
1164
1165 static void test_pack_EMRSELECTOBJECT(void)
1166 {
1167     /* EMRSELECTOBJECT (pack 4) */
1168     TEST_TYPE(EMRSELECTOBJECT, 12, 4);
1169     TEST_FIELD(EMRSELECTOBJECT, EMR, emr, 0, 8, 4);
1170     TEST_FIELD(EMRSELECTOBJECT, DWORD, ihObject, 8, 4, 4);
1171 }
1172
1173 static void test_pack_EMRSELECTPALETTE(void)
1174 {
1175     /* EMRSELECTPALETTE (pack 4) */
1176     TEST_TYPE(EMRSELECTPALETTE, 12, 4);
1177     TEST_FIELD(EMRSELECTPALETTE, EMR, emr, 0, 8, 4);
1178     TEST_FIELD(EMRSELECTPALETTE, DWORD, ihPal, 8, 4, 4);
1179 }
1180
1181 static void test_pack_EMRSETARCDIRECTION(void)
1182 {
1183     /* EMRSETARCDIRECTION (pack 4) */
1184     TEST_TYPE(EMRSETARCDIRECTION, 12, 4);
1185     TEST_FIELD(EMRSETARCDIRECTION, EMR, emr, 0, 8, 4);
1186     TEST_FIELD(EMRSETARCDIRECTION, DWORD, iArcDirection, 8, 4, 4);
1187 }
1188
1189 static void test_pack_EMRSETBKCOLOR(void)
1190 {
1191     /* EMRSETBKCOLOR (pack 4) */
1192     TEST_TYPE(EMRSETBKCOLOR, 12, 4);
1193     TEST_FIELD(EMRSETBKCOLOR, EMR, emr, 0, 8, 4);
1194     TEST_FIELD(EMRSETBKCOLOR, COLORREF, crColor, 8, 4, 4);
1195 }
1196
1197 static void test_pack_EMRSETBKMODE(void)
1198 {
1199     /* EMRSETBKMODE (pack 4) */
1200     TEST_TYPE(EMRSETBKMODE, 12, 4);
1201     TEST_FIELD(EMRSETBKMODE, EMR, emr, 0, 8, 4);
1202     TEST_FIELD(EMRSETBKMODE, DWORD, iMode, 8, 4, 4);
1203 }
1204
1205 static void test_pack_EMRSETBRUSHORGEX(void)
1206 {
1207     /* EMRSETBRUSHORGEX (pack 4) */
1208     TEST_TYPE(EMRSETBRUSHORGEX, 16, 4);
1209     TEST_FIELD(EMRSETBRUSHORGEX, EMR, emr, 0, 8, 4);
1210     TEST_FIELD(EMRSETBRUSHORGEX, POINTL, ptlOrigin, 8, 8, 4);
1211 }
1212
1213 static void test_pack_EMRSETCOLORADJUSTMENT(void)
1214 {
1215     /* EMRSETCOLORADJUSTMENT (pack 4) */
1216     TEST_TYPE(EMRSETCOLORADJUSTMENT, 32, 4);
1217     TEST_FIELD(EMRSETCOLORADJUSTMENT, EMR, emr, 0, 8, 4);
1218     TEST_FIELD(EMRSETCOLORADJUSTMENT, COLORADJUSTMENT, ColorAdjustment, 8, 24, 2);
1219 }
1220
1221 static void test_pack_EMRSETCOLORSPACE(void)
1222 {
1223     /* EMRSETCOLORSPACE (pack 4) */
1224     TEST_TYPE(EMRSETCOLORSPACE, 12, 4);
1225     TEST_FIELD(EMRSETCOLORSPACE, EMR, emr, 0, 8, 4);
1226     TEST_FIELD(EMRSETCOLORSPACE, DWORD, ihCS, 8, 4, 4);
1227 }
1228
1229 static void test_pack_EMRSETDIBITSTODEVICE(void)
1230 {
1231     /* EMRSETDIBITSTODEVICE (pack 4) */
1232     TEST_TYPE(EMRSETDIBITSTODEVICE, 76, 4);
1233     TEST_FIELD(EMRSETDIBITSTODEVICE, EMR, emr, 0, 8, 4);
1234     TEST_FIELD(EMRSETDIBITSTODEVICE, RECTL, rclBounds, 8, 16, 4);
1235     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, xDest, 24, 4, 4);
1236     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, yDest, 28, 4, 4);
1237     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, xSrc, 32, 4, 4);
1238     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, ySrc, 36, 4, 4);
1239     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, cxSrc, 40, 4, 4);
1240     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, cySrc, 44, 4, 4);
1241     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, offBmiSrc, 48, 4, 4);
1242     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cbBmiSrc, 52, 4, 4);
1243     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, offBitsSrc, 56, 4, 4);
1244     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cbBitsSrc, 60, 4, 4);
1245     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iUsageSrc, 64, 4, 4);
1246     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iStartScan, 68, 4, 4);
1247     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cScans, 72, 4, 4);
1248 }
1249
1250 static void test_pack_EMRSETICMMODE(void)
1251 {
1252     /* EMRSETICMMODE (pack 4) */
1253     TEST_TYPE(EMRSETICMMODE, 12, 4);
1254     TEST_FIELD(EMRSETICMMODE, EMR, emr, 0, 8, 4);
1255     TEST_FIELD(EMRSETICMMODE, DWORD, iMode, 8, 4, 4);
1256 }
1257
1258 static void test_pack_EMRSETLAYOUT(void)
1259 {
1260     /* EMRSETLAYOUT (pack 4) */
1261     TEST_TYPE(EMRSETLAYOUT, 12, 4);
1262     TEST_FIELD(EMRSETLAYOUT, EMR, emr, 0, 8, 4);
1263     TEST_FIELD(EMRSETLAYOUT, DWORD, iMode, 8, 4, 4);
1264 }
1265
1266 static void test_pack_EMRSETMAPMODE(void)
1267 {
1268     /* EMRSETMAPMODE (pack 4) */
1269     TEST_TYPE(EMRSETMAPMODE, 12, 4);
1270     TEST_FIELD(EMRSETMAPMODE, EMR, emr, 0, 8, 4);
1271     TEST_FIELD(EMRSETMAPMODE, DWORD, iMode, 8, 4, 4);
1272 }
1273
1274 static void test_pack_EMRSETMAPPERFLAGS(void)
1275 {
1276     /* EMRSETMAPPERFLAGS (pack 4) */
1277     TEST_TYPE(EMRSETMAPPERFLAGS, 12, 4);
1278     TEST_FIELD(EMRSETMAPPERFLAGS, EMR, emr, 0, 8, 4);
1279     TEST_FIELD(EMRSETMAPPERFLAGS, DWORD, dwFlags, 8, 4, 4);
1280 }
1281
1282 static void test_pack_EMRSETMETARGN(void)
1283 {
1284     /* EMRSETMETARGN (pack 4) */
1285     TEST_TYPE(EMRSETMETARGN, 8, 4);
1286     TEST_FIELD(EMRSETMETARGN, EMR, emr, 0, 8, 4);
1287 }
1288
1289 static void test_pack_EMRSETMITERLIMIT(void)
1290 {
1291     /* EMRSETMITERLIMIT (pack 4) */
1292     TEST_TYPE(EMRSETMITERLIMIT, 12, 4);
1293     TEST_FIELD(EMRSETMITERLIMIT, EMR, emr, 0, 8, 4);
1294     TEST_FIELD(EMRSETMITERLIMIT, FLOAT, eMiterLimit, 8, 4, 4);
1295 }
1296
1297 static void test_pack_EMRSETPIXELV(void)
1298 {
1299     /* EMRSETPIXELV (pack 4) */
1300     TEST_TYPE(EMRSETPIXELV, 20, 4);
1301     TEST_FIELD(EMRSETPIXELV, EMR, emr, 0, 8, 4);
1302     TEST_FIELD(EMRSETPIXELV, POINTL, ptlPixel, 8, 8, 4);
1303     TEST_FIELD(EMRSETPIXELV, COLORREF, crColor, 16, 4, 4);
1304 }
1305
1306 static void test_pack_EMRSETPOLYFILLMODE(void)
1307 {
1308     /* EMRSETPOLYFILLMODE (pack 4) */
1309     TEST_TYPE(EMRSETPOLYFILLMODE, 12, 4);
1310     TEST_FIELD(EMRSETPOLYFILLMODE, EMR, emr, 0, 8, 4);
1311     TEST_FIELD(EMRSETPOLYFILLMODE, DWORD, iMode, 8, 4, 4);
1312 }
1313
1314 static void test_pack_EMRSETROP2(void)
1315 {
1316     /* EMRSETROP2 (pack 4) */
1317     TEST_TYPE(EMRSETROP2, 12, 4);
1318     TEST_FIELD(EMRSETROP2, EMR, emr, 0, 8, 4);
1319     TEST_FIELD(EMRSETROP2, DWORD, iMode, 8, 4, 4);
1320 }
1321
1322 static void test_pack_EMRSETSTRETCHBLTMODE(void)
1323 {
1324     /* EMRSETSTRETCHBLTMODE (pack 4) */
1325     TEST_TYPE(EMRSETSTRETCHBLTMODE, 12, 4);
1326     TEST_FIELD(EMRSETSTRETCHBLTMODE, EMR, emr, 0, 8, 4);
1327     TEST_FIELD(EMRSETSTRETCHBLTMODE, DWORD, iMode, 8, 4, 4);
1328 }
1329
1330 static void test_pack_EMRSETTEXTALIGN(void)
1331 {
1332     /* EMRSETTEXTALIGN (pack 4) */
1333     TEST_TYPE(EMRSETTEXTALIGN, 12, 4);
1334     TEST_FIELD(EMRSETTEXTALIGN, EMR, emr, 0, 8, 4);
1335     TEST_FIELD(EMRSETTEXTALIGN, DWORD, iMode, 8, 4, 4);
1336 }
1337
1338 static void test_pack_EMRSETTEXTCOLOR(void)
1339 {
1340     /* EMRSETTEXTCOLOR (pack 4) */
1341     TEST_TYPE(EMRSETTEXTCOLOR, 12, 4);
1342     TEST_FIELD(EMRSETTEXTCOLOR, EMR, emr, 0, 8, 4);
1343     TEST_FIELD(EMRSETTEXTCOLOR, COLORREF, crColor, 8, 4, 4);
1344 }
1345
1346 static void test_pack_EMRSETVIEWPORTEXTEX(void)
1347 {
1348     /* EMRSETVIEWPORTEXTEX (pack 4) */
1349     TEST_TYPE(EMRSETVIEWPORTEXTEX, 16, 4);
1350     TEST_FIELD(EMRSETVIEWPORTEXTEX, EMR, emr, 0, 8, 4);
1351     TEST_FIELD(EMRSETVIEWPORTEXTEX, SIZEL, szlExtent, 8, 8, 4);
1352 }
1353
1354 static void test_pack_EMRSETVIEWPORTORGEX(void)
1355 {
1356     /* EMRSETVIEWPORTORGEX (pack 4) */
1357     TEST_TYPE(EMRSETVIEWPORTORGEX, 16, 4);
1358     TEST_FIELD(EMRSETVIEWPORTORGEX, EMR, emr, 0, 8, 4);
1359     TEST_FIELD(EMRSETVIEWPORTORGEX, POINTL, ptlOrigin, 8, 8, 4);
1360 }
1361
1362 static void test_pack_EMRSETWINDOWEXTEX(void)
1363 {
1364     /* EMRSETWINDOWEXTEX (pack 4) */
1365     TEST_TYPE(EMRSETWINDOWEXTEX, 16, 4);
1366     TEST_FIELD(EMRSETWINDOWEXTEX, EMR, emr, 0, 8, 4);
1367     TEST_FIELD(EMRSETWINDOWEXTEX, SIZEL, szlExtent, 8, 8, 4);
1368 }
1369
1370 static void test_pack_EMRSETWINDOWORGEX(void)
1371 {
1372     /* EMRSETWINDOWORGEX (pack 4) */
1373     TEST_TYPE(EMRSETWINDOWORGEX, 16, 4);
1374     TEST_FIELD(EMRSETWINDOWORGEX, EMR, emr, 0, 8, 4);
1375     TEST_FIELD(EMRSETWINDOWORGEX, POINTL, ptlOrigin, 8, 8, 4);
1376 }
1377
1378 static void test_pack_EMRSETWORLDTRANSFORM(void)
1379 {
1380     /* EMRSETWORLDTRANSFORM (pack 4) */
1381     TEST_TYPE(EMRSETWORLDTRANSFORM, 32, 4);
1382     TEST_FIELD(EMRSETWORLDTRANSFORM, EMR, emr, 0, 8, 4);
1383     TEST_FIELD(EMRSETWORLDTRANSFORM, XFORM, xform, 8, 24, 4);
1384 }
1385
1386 static void test_pack_EMRSTRETCHBLT(void)
1387 {
1388     /* EMRSTRETCHBLT (pack 4) */
1389     TEST_TYPE(EMRSTRETCHBLT, 108, 4);
1390     TEST_FIELD(EMRSTRETCHBLT, EMR, emr, 0, 8, 4);
1391     TEST_FIELD(EMRSTRETCHBLT, RECTL, rclBounds, 8, 16, 4);
1392     TEST_FIELD(EMRSTRETCHBLT, LONG, xDest, 24, 4, 4);
1393     TEST_FIELD(EMRSTRETCHBLT, LONG, yDest, 28, 4, 4);
1394     TEST_FIELD(EMRSTRETCHBLT, LONG, cxDest, 32, 4, 4);
1395     TEST_FIELD(EMRSTRETCHBLT, LONG, cyDest, 36, 4, 4);
1396     TEST_FIELD(EMRSTRETCHBLT, DWORD, dwRop, 40, 4, 4);
1397     TEST_FIELD(EMRSTRETCHBLT, LONG, xSrc, 44, 4, 4);
1398     TEST_FIELD(EMRSTRETCHBLT, LONG, ySrc, 48, 4, 4);
1399     TEST_FIELD(EMRSTRETCHBLT, XFORM, xformSrc, 52, 24, 4);
1400     TEST_FIELD(EMRSTRETCHBLT, COLORREF, crBkColorSrc, 76, 4, 4);
1401     TEST_FIELD(EMRSTRETCHBLT, DWORD, iUsageSrc, 80, 4, 4);
1402     TEST_FIELD(EMRSTRETCHBLT, DWORD, offBmiSrc, 84, 4, 4);
1403     TEST_FIELD(EMRSTRETCHBLT, DWORD, cbBmiSrc, 88, 4, 4);
1404     TEST_FIELD(EMRSTRETCHBLT, DWORD, offBitsSrc, 92, 4, 4);
1405     TEST_FIELD(EMRSTRETCHBLT, DWORD, cbBitsSrc, 96, 4, 4);
1406     TEST_FIELD(EMRSTRETCHBLT, LONG, cxSrc, 100, 4, 4);
1407     TEST_FIELD(EMRSTRETCHBLT, LONG, cySrc, 104, 4, 4);
1408 }
1409
1410 static void test_pack_EMRSTRETCHDIBITS(void)
1411 {
1412     /* EMRSTRETCHDIBITS (pack 4) */
1413     TEST_TYPE(EMRSTRETCHDIBITS, 80, 4);
1414     TEST_FIELD(EMRSTRETCHDIBITS, EMR, emr, 0, 8, 4);
1415     TEST_FIELD(EMRSTRETCHDIBITS, RECTL, rclBounds, 8, 16, 4);
1416     TEST_FIELD(EMRSTRETCHDIBITS, LONG, xDest, 24, 4, 4);
1417     TEST_FIELD(EMRSTRETCHDIBITS, LONG, yDest, 28, 4, 4);
1418     TEST_FIELD(EMRSTRETCHDIBITS, LONG, xSrc, 32, 4, 4);
1419     TEST_FIELD(EMRSTRETCHDIBITS, LONG, ySrc, 36, 4, 4);
1420     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cxSrc, 40, 4, 4);
1421     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cySrc, 44, 4, 4);
1422     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, offBmiSrc, 48, 4, 4);
1423     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, cbBmiSrc, 52, 4, 4);
1424     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, offBitsSrc, 56, 4, 4);
1425     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, cbBitsSrc, 60, 4, 4);
1426     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, iUsageSrc, 64, 4, 4);
1427     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, dwRop, 68, 4, 4);
1428     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cxDest, 72, 4, 4);
1429     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cyDest, 76, 4, 4);
1430 }
1431
1432 static void test_pack_EMRSTROKEANDFILLPATH(void)
1433 {
1434     /* EMRSTROKEANDFILLPATH (pack 4) */
1435     TEST_TYPE(EMRSTROKEANDFILLPATH, 24, 4);
1436     TEST_FIELD(EMRSTROKEANDFILLPATH, EMR, emr, 0, 8, 4);
1437     TEST_FIELD(EMRSTROKEANDFILLPATH, RECTL, rclBounds, 8, 16, 4);
1438 }
1439
1440 static void test_pack_EMRSTROKEPATH(void)
1441 {
1442     /* EMRSTROKEPATH (pack 4) */
1443     TEST_TYPE(EMRSTROKEPATH, 24, 4);
1444     TEST_FIELD(EMRSTROKEPATH, EMR, emr, 0, 8, 4);
1445     TEST_FIELD(EMRSTROKEPATH, RECTL, rclBounds, 8, 16, 4);
1446 }
1447
1448 static void test_pack_EMRTEXT(void)
1449 {
1450     /* EMRTEXT (pack 4) */
1451     TEST_TYPE(EMRTEXT, 40, 4);
1452     TEST_FIELD(EMRTEXT, POINTL, ptlReference, 0, 8, 4);
1453     TEST_FIELD(EMRTEXT, DWORD, nChars, 8, 4, 4);
1454     TEST_FIELD(EMRTEXT, DWORD, offString, 12, 4, 4);
1455     TEST_FIELD(EMRTEXT, DWORD, fOptions, 16, 4, 4);
1456     TEST_FIELD(EMRTEXT, RECTL, rcl, 20, 16, 4);
1457     TEST_FIELD(EMRTEXT, DWORD, offDx, 36, 4, 4);
1458 }
1459
1460 static void test_pack_EMRWIDENPATH(void)
1461 {
1462     /* EMRWIDENPATH (pack 4) */
1463     TEST_TYPE(EMRWIDENPATH, 8, 4);
1464     TEST_FIELD(EMRWIDENPATH, EMR, emr, 0, 8, 4);
1465 }
1466
1467 static void test_pack_ENHMETAHEADER(void)
1468 {
1469     /* ENHMETAHEADER (pack 4) */
1470     TEST_TYPE(ENHMETAHEADER, 108, 4);
1471     TEST_FIELD(ENHMETAHEADER, DWORD, iType, 0, 4, 4);
1472     TEST_FIELD(ENHMETAHEADER, DWORD, nSize, 4, 4, 4);
1473     TEST_FIELD(ENHMETAHEADER, RECTL, rclBounds, 8, 16, 4);
1474     TEST_FIELD(ENHMETAHEADER, RECTL, rclFrame, 24, 16, 4);
1475     TEST_FIELD(ENHMETAHEADER, DWORD, dSignature, 40, 4, 4);
1476     TEST_FIELD(ENHMETAHEADER, DWORD, nVersion, 44, 4, 4);
1477     TEST_FIELD(ENHMETAHEADER, DWORD, nBytes, 48, 4, 4);
1478     TEST_FIELD(ENHMETAHEADER, DWORD, nRecords, 52, 4, 4);
1479     TEST_FIELD(ENHMETAHEADER, WORD, nHandles, 56, 2, 2);
1480     TEST_FIELD(ENHMETAHEADER, WORD, sReserved, 58, 2, 2);
1481     TEST_FIELD(ENHMETAHEADER, DWORD, nDescription, 60, 4, 4);
1482     TEST_FIELD(ENHMETAHEADER, DWORD, offDescription, 64, 4, 4);
1483     TEST_FIELD(ENHMETAHEADER, DWORD, nPalEntries, 68, 4, 4);
1484     TEST_FIELD(ENHMETAHEADER, SIZEL, szlDevice, 72, 8, 4);
1485     TEST_FIELD(ENHMETAHEADER, SIZEL, szlMillimeters, 80, 8, 4);
1486     TEST_FIELD(ENHMETAHEADER, DWORD, cbPixelFormat, 88, 4, 4);
1487     TEST_FIELD(ENHMETAHEADER, DWORD, offPixelFormat, 92, 4, 4);
1488     TEST_FIELD(ENHMETAHEADER, DWORD, bOpenGL, 96, 4, 4);
1489     TEST_FIELD(ENHMETAHEADER, SIZEL, szlMicrometers, 100, 8, 4);
1490 }
1491
1492 static void test_pack_ENHMETARECORD(void)
1493 {
1494     /* ENHMETARECORD (pack 4) */
1495     TEST_TYPE(ENHMETARECORD, 12, 4);
1496     TEST_FIELD(ENHMETARECORD, DWORD, iType, 0, 4, 4);
1497     TEST_FIELD(ENHMETARECORD, DWORD, nSize, 4, 4, 4);
1498     TEST_FIELD(ENHMETARECORD, DWORD[1], dParm, 8, 4, 4);
1499 }
1500
1501 static void test_pack_ENHMFENUMPROC(void)
1502 {
1503     /* ENHMFENUMPROC */
1504     TEST_TYPE(ENHMFENUMPROC, 4, 4);
1505 }
1506
1507 static void test_pack_ENUMLOGFONTA(void)
1508 {
1509     /* ENUMLOGFONTA (pack 4) */
1510     TEST_TYPE(ENUMLOGFONTA, 156, 4);
1511     TEST_FIELD(ENUMLOGFONTA, LOGFONTA, elfLogFont, 0, 60, 4);
1512     TEST_FIELD(ENUMLOGFONTA, BYTE[LF_FULLFACESIZE], elfFullName, 60, 64, 1);
1513     TEST_FIELD(ENUMLOGFONTA, BYTE[LF_FACESIZE], elfStyle, 124, 32, 1);
1514 }
1515
1516 static void test_pack_ENUMLOGFONTEXA(void)
1517 {
1518     /* ENUMLOGFONTEXA (pack 4) */
1519     TEST_TYPE(ENUMLOGFONTEXA, 188, 4);
1520     TEST_FIELD(ENUMLOGFONTEXA, LOGFONTA, elfLogFont, 0, 60, 4);
1521     TEST_FIELD(ENUMLOGFONTEXA, BYTE[LF_FULLFACESIZE], elfFullName, 60, 64, 1);
1522     TEST_FIELD(ENUMLOGFONTEXA, BYTE[LF_FACESIZE], elfStyle, 124, 32, 1);
1523     TEST_FIELD(ENUMLOGFONTEXA, BYTE[LF_FACESIZE], elfScript, 156, 32, 1);
1524 }
1525
1526 static void test_pack_ENUMLOGFONTEXW(void)
1527 {
1528     /* ENUMLOGFONTEXW (pack 4) */
1529     TEST_TYPE(ENUMLOGFONTEXW, 348, 4);
1530     TEST_FIELD(ENUMLOGFONTEXW, LOGFONTW, elfLogFont, 0, 92, 4);
1531     TEST_FIELD(ENUMLOGFONTEXW, WCHAR[LF_FULLFACESIZE], elfFullName, 92, 128, 2);
1532     TEST_FIELD(ENUMLOGFONTEXW, WCHAR[LF_FACESIZE], elfStyle, 220, 64, 2);
1533     TEST_FIELD(ENUMLOGFONTEXW, WCHAR[LF_FACESIZE], elfScript, 284, 64, 2);
1534 }
1535
1536 static void test_pack_ENUMLOGFONTW(void)
1537 {
1538     /* ENUMLOGFONTW (pack 4) */
1539     TEST_TYPE(ENUMLOGFONTW, 284, 4);
1540     TEST_FIELD(ENUMLOGFONTW, LOGFONTW, elfLogFont, 0, 92, 4);
1541     TEST_FIELD(ENUMLOGFONTW, WCHAR[LF_FULLFACESIZE], elfFullName, 92, 128, 2);
1542     TEST_FIELD(ENUMLOGFONTW, WCHAR[LF_FACESIZE], elfStyle, 220, 64, 2);
1543 }
1544
1545 static void test_pack_EXTLOGFONTA(void)
1546 {
1547     /* EXTLOGFONTA (pack 4) */
1548     TEST_TYPE(EXTLOGFONTA, 192, 4);
1549     TEST_FIELD(EXTLOGFONTA, LOGFONTA, elfLogFont, 0, 60, 4);
1550     TEST_FIELD(EXTLOGFONTA, BYTE[LF_FULLFACESIZE], elfFullName, 60, 64, 1);
1551     TEST_FIELD(EXTLOGFONTA, BYTE[LF_FACESIZE], elfStyle, 124, 32, 1);
1552     TEST_FIELD(EXTLOGFONTA, DWORD, elfVersion, 156, 4, 4);
1553     TEST_FIELD(EXTLOGFONTA, DWORD, elfStyleSize, 160, 4, 4);
1554     TEST_FIELD(EXTLOGFONTA, DWORD, elfMatch, 164, 4, 4);
1555     TEST_FIELD(EXTLOGFONTA, DWORD, elfReserved, 168, 4, 4);
1556     TEST_FIELD(EXTLOGFONTA, BYTE[ELF_VENDOR_SIZE], elfVendorId, 172, 4, 1);
1557     TEST_FIELD(EXTLOGFONTA, DWORD, elfCulture, 176, 4, 4);
1558     TEST_FIELD(EXTLOGFONTA, PANOSE, elfPanose, 180, 10, 1);
1559 }
1560
1561 static void test_pack_EXTLOGFONTW(void)
1562 {
1563     /* EXTLOGFONTW (pack 4) */
1564     TEST_TYPE(EXTLOGFONTW, 320, 4);
1565     TEST_FIELD(EXTLOGFONTW, LOGFONTW, elfLogFont, 0, 92, 4);
1566     TEST_FIELD(EXTLOGFONTW, WCHAR[LF_FULLFACESIZE], elfFullName, 92, 128, 2);
1567     TEST_FIELD(EXTLOGFONTW, WCHAR[LF_FACESIZE], elfStyle, 220, 64, 2);
1568     TEST_FIELD(EXTLOGFONTW, DWORD, elfVersion, 284, 4, 4);
1569     TEST_FIELD(EXTLOGFONTW, DWORD, elfStyleSize, 288, 4, 4);
1570     TEST_FIELD(EXTLOGFONTW, DWORD, elfMatch, 292, 4, 4);
1571     TEST_FIELD(EXTLOGFONTW, DWORD, elfReserved, 296, 4, 4);
1572     TEST_FIELD(EXTLOGFONTW, BYTE[ELF_VENDOR_SIZE], elfVendorId, 300, 4, 1);
1573     TEST_FIELD(EXTLOGFONTW, DWORD, elfCulture, 304, 4, 4);
1574     TEST_FIELD(EXTLOGFONTW, PANOSE, elfPanose, 308, 10, 1);
1575 }
1576
1577 static void test_pack_EXTLOGPEN(void)
1578 {
1579     /* EXTLOGPEN (pack 4) */
1580     TEST_TYPE(EXTLOGPEN, 28, 4);
1581     TEST_FIELD(EXTLOGPEN, DWORD, elpPenStyle, 0, 4, 4);
1582     TEST_FIELD(EXTLOGPEN, DWORD, elpWidth, 4, 4, 4);
1583     TEST_FIELD(EXTLOGPEN, UINT, elpBrushStyle, 8, 4, 4);
1584     TEST_FIELD(EXTLOGPEN, COLORREF, elpColor, 12, 4, 4);
1585     TEST_FIELD(EXTLOGPEN, LONG, elpHatch, 16, 4, 4);
1586     TEST_FIELD(EXTLOGPEN, DWORD, elpNumEntries, 20, 4, 4);
1587     TEST_FIELD(EXTLOGPEN, DWORD[1], elpStyleEntry, 24, 4, 4);
1588 }
1589
1590 static void test_pack_FIXED(void)
1591 {
1592     /* FIXED (pack 4) */
1593     TEST_TYPE(FIXED, 4, 2);
1594     TEST_FIELD(FIXED, WORD, fract, 0, 2, 2);
1595     TEST_FIELD(FIXED, SHORT, value, 2, 2, 2);
1596 }
1597
1598 static void test_pack_FONTENUMPROCA(void)
1599 {
1600     /* FONTENUMPROCA */
1601     TEST_TYPE(FONTENUMPROCA, 4, 4);
1602 }
1603
1604 static void test_pack_FONTENUMPROCW(void)
1605 {
1606     /* FONTENUMPROCW */
1607     TEST_TYPE(FONTENUMPROCW, 4, 4);
1608 }
1609
1610 static void test_pack_FONTSIGNATURE(void)
1611 {
1612     /* FONTSIGNATURE (pack 4) */
1613     TEST_TYPE(FONTSIGNATURE, 24, 4);
1614     TEST_FIELD(FONTSIGNATURE, DWORD[4], fsUsb, 0, 16, 4);
1615     TEST_FIELD(FONTSIGNATURE, DWORD[2], fsCsb, 16, 8, 4);
1616 }
1617
1618 static void test_pack_FXPT16DOT16(void)
1619 {
1620     /* FXPT16DOT16 */
1621     TEST_TYPE(FXPT16DOT16, 4, 4);
1622 }
1623
1624 static void test_pack_FXPT2DOT30(void)
1625 {
1626     /* FXPT2DOT30 */
1627     TEST_TYPE(FXPT2DOT30, 4, 4);
1628 }
1629
1630 static void test_pack_GCP_RESULTSA(void)
1631 {
1632     /* GCP_RESULTSA (pack 4) */
1633     TEST_TYPE(GCP_RESULTSA, 36, 4);
1634     TEST_FIELD(GCP_RESULTSA, DWORD, lStructSize, 0, 4, 4);
1635     TEST_FIELD(GCP_RESULTSA, LPSTR, lpOutString, 4, 4, 4);
1636     TEST_FIELD(GCP_RESULTSA, UINT *, lpOrder, 8, 4, 4);
1637     TEST_FIELD(GCP_RESULTSA, INT *, lpDx, 12, 4, 4);
1638     TEST_FIELD(GCP_RESULTSA, INT *, lpCaretPos, 16, 4, 4);
1639     TEST_FIELD(GCP_RESULTSA, LPSTR, lpClass, 20, 4, 4);
1640     TEST_FIELD(GCP_RESULTSA, LPWSTR, lpGlyphs, 24, 4, 4);
1641     TEST_FIELD(GCP_RESULTSA, UINT, nGlyphs, 28, 4, 4);
1642     TEST_FIELD(GCP_RESULTSA, UINT, nMaxFit, 32, 4, 4);
1643 }
1644
1645 static void test_pack_GCP_RESULTSW(void)
1646 {
1647     /* GCP_RESULTSW (pack 4) */
1648     TEST_TYPE(GCP_RESULTSW, 36, 4);
1649     TEST_FIELD(GCP_RESULTSW, DWORD, lStructSize, 0, 4, 4);
1650     TEST_FIELD(GCP_RESULTSW, LPWSTR, lpOutString, 4, 4, 4);
1651     TEST_FIELD(GCP_RESULTSW, UINT *, lpOrder, 8, 4, 4);
1652     TEST_FIELD(GCP_RESULTSW, INT *, lpDx, 12, 4, 4);
1653     TEST_FIELD(GCP_RESULTSW, INT *, lpCaretPos, 16, 4, 4);
1654     TEST_FIELD(GCP_RESULTSW, LPSTR, lpClass, 20, 4, 4);
1655     TEST_FIELD(GCP_RESULTSW, LPWSTR, lpGlyphs, 24, 4, 4);
1656     TEST_FIELD(GCP_RESULTSW, UINT, nGlyphs, 28, 4, 4);
1657     TEST_FIELD(GCP_RESULTSW, UINT, nMaxFit, 32, 4, 4);
1658 }
1659
1660 static void test_pack_GLYPHMETRICS(void)
1661 {
1662     /* GLYPHMETRICS (pack 4) */
1663     TEST_TYPE(GLYPHMETRICS, 20, 4);
1664     TEST_FIELD(GLYPHMETRICS, UINT, gmBlackBoxX, 0, 4, 4);
1665     TEST_FIELD(GLYPHMETRICS, UINT, gmBlackBoxY, 4, 4, 4);
1666     TEST_FIELD(GLYPHMETRICS, POINT, gmptGlyphOrigin, 8, 8, 4);
1667     TEST_FIELD(GLYPHMETRICS, SHORT, gmCellIncX, 16, 2, 2);
1668     TEST_FIELD(GLYPHMETRICS, SHORT, gmCellIncY, 18, 2, 2);
1669 }
1670
1671 static void test_pack_GOBJENUMPROC(void)
1672 {
1673     /* GOBJENUMPROC */
1674     TEST_TYPE(GOBJENUMPROC, 4, 4);
1675 }
1676
1677 static void test_pack_GRADIENT_RECT(void)
1678 {
1679     /* GRADIENT_RECT (pack 4) */
1680     TEST_TYPE(GRADIENT_RECT, 8, 4);
1681     TEST_FIELD(GRADIENT_RECT, ULONG, UpperLeft, 0, 4, 4);
1682     TEST_FIELD(GRADIENT_RECT, ULONG, LowerRight, 4, 4, 4);
1683 }
1684
1685 static void test_pack_GRADIENT_TRIANGLE(void)
1686 {
1687     /* GRADIENT_TRIANGLE (pack 4) */
1688     TEST_TYPE(GRADIENT_TRIANGLE, 12, 4);
1689     TEST_FIELD(GRADIENT_TRIANGLE, ULONG, Vertex1, 0, 4, 4);
1690     TEST_FIELD(GRADIENT_TRIANGLE, ULONG, Vertex2, 4, 4, 4);
1691     TEST_FIELD(GRADIENT_TRIANGLE, ULONG, Vertex3, 8, 4, 4);
1692 }
1693
1694 static void test_pack_HANDLETABLE(void)
1695 {
1696     /* HANDLETABLE (pack 4) */
1697     TEST_TYPE(HANDLETABLE, 4, 4);
1698     TEST_FIELD(HANDLETABLE, HGDIOBJ[1], objectHandle, 0, 4, 4);
1699 }
1700
1701 static void test_pack_ICMENUMPROCA(void)
1702 {
1703     /* ICMENUMPROCA */
1704     TEST_TYPE(ICMENUMPROCA, 4, 4);
1705 }
1706
1707 static void test_pack_ICMENUMPROCW(void)
1708 {
1709     /* ICMENUMPROCW */
1710     TEST_TYPE(ICMENUMPROCW, 4, 4);
1711 }
1712
1713 static void test_pack_KERNINGPAIR(void)
1714 {
1715     /* KERNINGPAIR (pack 4) */
1716     TEST_TYPE(KERNINGPAIR, 8, 4);
1717     TEST_FIELD(KERNINGPAIR, WORD, wFirst, 0, 2, 2);
1718     TEST_FIELD(KERNINGPAIR, WORD, wSecond, 2, 2, 2);
1719     TEST_FIELD(KERNINGPAIR, INT, iKernAmount, 4, 4, 4);
1720 }
1721
1722 static void test_pack_LCSCSTYPE(void)
1723 {
1724     /* LCSCSTYPE */
1725     TEST_TYPE(LCSCSTYPE, 4, 4);
1726 }
1727
1728 static void test_pack_LCSGAMUTMATCH(void)
1729 {
1730     /* LCSGAMUTMATCH */
1731     TEST_TYPE(LCSGAMUTMATCH, 4, 4);
1732 }
1733
1734 static void test_pack_LINEDDAPROC(void)
1735 {
1736     /* LINEDDAPROC */
1737     TEST_TYPE(LINEDDAPROC, 4, 4);
1738 }
1739
1740 static void test_pack_LOCALESIGNATURE(void)
1741 {
1742     /* LOCALESIGNATURE (pack 4) */
1743     TEST_TYPE(LOCALESIGNATURE, 32, 4);
1744     TEST_FIELD(LOCALESIGNATURE, DWORD[4], lsUsb, 0, 16, 4);
1745     TEST_FIELD(LOCALESIGNATURE, DWORD[2], lsCsbDefault, 16, 8, 4);
1746     TEST_FIELD(LOCALESIGNATURE, DWORD[2], lsCsbSupported, 24, 8, 4);
1747 }
1748
1749 static void test_pack_LOGBRUSH(void)
1750 {
1751     /* LOGBRUSH (pack 4) */
1752     TEST_TYPE(LOGBRUSH, 12, 4);
1753     TEST_FIELD(LOGBRUSH, UINT, lbStyle, 0, 4, 4);
1754     TEST_FIELD(LOGBRUSH, COLORREF, lbColor, 4, 4, 4);
1755     TEST_FIELD(LOGBRUSH, INT, lbHatch, 8, 4, 4);
1756 }
1757
1758 static void test_pack_LOGCOLORSPACEA(void)
1759 {
1760     /* LOGCOLORSPACEA (pack 4) */
1761     TEST_TYPE(LOGCOLORSPACEA, 328, 4);
1762     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsSignature, 0, 4, 4);
1763     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsVersion, 4, 4, 4);
1764     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsSize, 8, 4, 4);
1765     TEST_FIELD(LOGCOLORSPACEA, LCSCSTYPE, lcsCSType, 12, 4, 4);
1766     TEST_FIELD(LOGCOLORSPACEA, LCSGAMUTMATCH, lcsIntent, 16, 4, 4);
1767     TEST_FIELD(LOGCOLORSPACEA, CIEXYZTRIPLE, lcsEndpoints, 20, 36, 4);
1768     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsGammaRed, 56, 4, 4);
1769     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsGammaGreen, 60, 4, 4);
1770     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsGammaBlue, 64, 4, 4);
1771     TEST_FIELD(LOGCOLORSPACEA, CHAR[MAX_PATH], lcsFilename, 68, 260, 1);
1772 }
1773
1774 static void test_pack_LOGCOLORSPACEW(void)
1775 {
1776     /* LOGCOLORSPACEW (pack 4) */
1777     TEST_TYPE(LOGCOLORSPACEW, 588, 4);
1778     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsSignature, 0, 4, 4);
1779     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsVersion, 4, 4, 4);
1780     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsSize, 8, 4, 4);
1781     TEST_FIELD(LOGCOLORSPACEW, LCSCSTYPE, lcsCSType, 12, 4, 4);
1782     TEST_FIELD(LOGCOLORSPACEW, LCSGAMUTMATCH, lcsIntent, 16, 4, 4);
1783     TEST_FIELD(LOGCOLORSPACEW, CIEXYZTRIPLE, lcsEndpoints, 20, 36, 4);
1784     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsGammaRed, 56, 4, 4);
1785     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsGammaGreen, 60, 4, 4);
1786     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsGammaBlue, 64, 4, 4);
1787     TEST_FIELD(LOGCOLORSPACEW, WCHAR[MAX_PATH], lcsFilename, 68, 520, 2);
1788 }
1789
1790 static void test_pack_LOGFONTA(void)
1791 {
1792     /* LOGFONTA (pack 4) */
1793     TEST_TYPE(LOGFONTA, 60, 4);
1794     TEST_FIELD(LOGFONTA, LONG, lfHeight, 0, 4, 4);
1795     TEST_FIELD(LOGFONTA, LONG, lfWidth, 4, 4, 4);
1796     TEST_FIELD(LOGFONTA, LONG, lfEscapement, 8, 4, 4);
1797     TEST_FIELD(LOGFONTA, LONG, lfOrientation, 12, 4, 4);
1798     TEST_FIELD(LOGFONTA, LONG, lfWeight, 16, 4, 4);
1799     TEST_FIELD(LOGFONTA, BYTE, lfItalic, 20, 1, 1);
1800     TEST_FIELD(LOGFONTA, BYTE, lfUnderline, 21, 1, 1);
1801     TEST_FIELD(LOGFONTA, BYTE, lfStrikeOut, 22, 1, 1);
1802     TEST_FIELD(LOGFONTA, BYTE, lfCharSet, 23, 1, 1);
1803     TEST_FIELD(LOGFONTA, BYTE, lfOutPrecision, 24, 1, 1);
1804     TEST_FIELD(LOGFONTA, BYTE, lfClipPrecision, 25, 1, 1);
1805     TEST_FIELD(LOGFONTA, BYTE, lfQuality, 26, 1, 1);
1806     TEST_FIELD(LOGFONTA, BYTE, lfPitchAndFamily, 27, 1, 1);
1807     TEST_FIELD(LOGFONTA, CHAR[LF_FACESIZE], lfFaceName, 28, 32, 1);
1808 }
1809
1810 static void test_pack_LOGFONTW(void)
1811 {
1812     /* LOGFONTW (pack 4) */
1813     TEST_TYPE(LOGFONTW, 92, 4);
1814     TEST_FIELD(LOGFONTW, LONG, lfHeight, 0, 4, 4);
1815     TEST_FIELD(LOGFONTW, LONG, lfWidth, 4, 4, 4);
1816     TEST_FIELD(LOGFONTW, LONG, lfEscapement, 8, 4, 4);
1817     TEST_FIELD(LOGFONTW, LONG, lfOrientation, 12, 4, 4);
1818     TEST_FIELD(LOGFONTW, LONG, lfWeight, 16, 4, 4);
1819     TEST_FIELD(LOGFONTW, BYTE, lfItalic, 20, 1, 1);
1820     TEST_FIELD(LOGFONTW, BYTE, lfUnderline, 21, 1, 1);
1821     TEST_FIELD(LOGFONTW, BYTE, lfStrikeOut, 22, 1, 1);
1822     TEST_FIELD(LOGFONTW, BYTE, lfCharSet, 23, 1, 1);
1823     TEST_FIELD(LOGFONTW, BYTE, lfOutPrecision, 24, 1, 1);
1824     TEST_FIELD(LOGFONTW, BYTE, lfClipPrecision, 25, 1, 1);
1825     TEST_FIELD(LOGFONTW, BYTE, lfQuality, 26, 1, 1);
1826     TEST_FIELD(LOGFONTW, BYTE, lfPitchAndFamily, 27, 1, 1);
1827     TEST_FIELD(LOGFONTW, WCHAR[LF_FACESIZE], lfFaceName, 28, 64, 2);
1828 }
1829
1830 static void test_pack_LOGPEN(void)
1831 {
1832     /* LOGPEN (pack 4) */
1833     TEST_TYPE(LOGPEN, 16, 4);
1834     TEST_FIELD(LOGPEN, UINT, lopnStyle, 0, 4, 4);
1835     TEST_FIELD(LOGPEN, POINT, lopnWidth, 4, 8, 4);
1836     TEST_FIELD(LOGPEN, COLORREF, lopnColor, 12, 4, 4);
1837 }
1838
1839 static void test_pack_LPABC(void)
1840 {
1841     /* LPABC */
1842     TEST_TYPE(LPABC, 4, 4);
1843     TEST_TYPE_POINTER(LPABC, 12, 4);
1844 }
1845
1846 static void test_pack_LPABCFLOAT(void)
1847 {
1848     /* LPABCFLOAT */
1849     TEST_TYPE(LPABCFLOAT, 4, 4);
1850     TEST_TYPE_POINTER(LPABCFLOAT, 12, 4);
1851 }
1852
1853 static void test_pack_LPBITMAP(void)
1854 {
1855     /* LPBITMAP */
1856     TEST_TYPE(LPBITMAP, 4, 4);
1857     TEST_TYPE_POINTER(LPBITMAP, 24, 4);
1858 }
1859
1860 static void test_pack_LPBITMAPCOREHEADER(void)
1861 {
1862     /* LPBITMAPCOREHEADER */
1863     TEST_TYPE(LPBITMAPCOREHEADER, 4, 4);
1864     TEST_TYPE_POINTER(LPBITMAPCOREHEADER, 12, 4);
1865 }
1866
1867 static void test_pack_LPBITMAPCOREINFO(void)
1868 {
1869     /* LPBITMAPCOREINFO */
1870     TEST_TYPE(LPBITMAPCOREINFO, 4, 4);
1871     TEST_TYPE_POINTER(LPBITMAPCOREINFO, 16, 4);
1872 }
1873
1874 static void test_pack_LPBITMAPFILEHEADER(void)
1875 {
1876     /* LPBITMAPFILEHEADER */
1877     TEST_TYPE(LPBITMAPFILEHEADER, 4, 4);
1878     TEST_TYPE_POINTER(LPBITMAPFILEHEADER, 14, 2);
1879 }
1880
1881 static void test_pack_LPBITMAPINFO(void)
1882 {
1883     /* LPBITMAPINFO */
1884     TEST_TYPE(LPBITMAPINFO, 4, 4);
1885     TEST_TYPE_POINTER(LPBITMAPINFO, 44, 4);
1886 }
1887
1888 static void test_pack_LPBITMAPINFOHEADER(void)
1889 {
1890     /* LPBITMAPINFOHEADER */
1891     TEST_TYPE(LPBITMAPINFOHEADER, 4, 4);
1892     TEST_TYPE_POINTER(LPBITMAPINFOHEADER, 40, 4);
1893 }
1894
1895 static void test_pack_LPBITMAPV5HEADER(void)
1896 {
1897     /* LPBITMAPV5HEADER */
1898     TEST_TYPE(LPBITMAPV5HEADER, 4, 4);
1899     TEST_TYPE_POINTER(LPBITMAPV5HEADER, 124, 4);
1900 }
1901
1902 static void test_pack_LPCHARSETINFO(void)
1903 {
1904     /* LPCHARSETINFO */
1905     TEST_TYPE(LPCHARSETINFO, 4, 4);
1906     TEST_TYPE_POINTER(LPCHARSETINFO, 32, 4);
1907 }
1908
1909 static void test_pack_LPCIEXYZ(void)
1910 {
1911     /* LPCIEXYZ */
1912     TEST_TYPE(LPCIEXYZ, 4, 4);
1913     TEST_TYPE_POINTER(LPCIEXYZ, 12, 4);
1914 }
1915
1916 static void test_pack_LPCIEXYZTRIPLE(void)
1917 {
1918     /* LPCIEXYZTRIPLE */
1919     TEST_TYPE(LPCIEXYZTRIPLE, 4, 4);
1920     TEST_TYPE_POINTER(LPCIEXYZTRIPLE, 36, 4);
1921 }
1922
1923 static void test_pack_LPCOLORADJUSTMENT(void)
1924 {
1925     /* LPCOLORADJUSTMENT */
1926     TEST_TYPE(LPCOLORADJUSTMENT, 4, 4);
1927     TEST_TYPE_POINTER(LPCOLORADJUSTMENT, 24, 2);
1928 }
1929
1930 static void test_pack_LPDEVMODEA(void)
1931 {
1932     /* LPDEVMODEA */
1933     TEST_TYPE(LPDEVMODEA, 4, 4);
1934 }
1935
1936 static void test_pack_LPDEVMODEW(void)
1937 {
1938     /* LPDEVMODEW */
1939     TEST_TYPE(LPDEVMODEW, 4, 4);
1940 }
1941
1942 static void test_pack_LPDIBSECTION(void)
1943 {
1944     /* LPDIBSECTION */
1945     TEST_TYPE(LPDIBSECTION, 4, 4);
1946     TEST_TYPE_POINTER(LPDIBSECTION, 84, 4);
1947 }
1948
1949 static void test_pack_LPDISPLAY_DEVICEA(void)
1950 {
1951     /* LPDISPLAY_DEVICEA */
1952     TEST_TYPE(LPDISPLAY_DEVICEA, 4, 4);
1953     TEST_TYPE_POINTER(LPDISPLAY_DEVICEA, 424, 4);
1954 }
1955
1956 static void test_pack_LPDISPLAY_DEVICEW(void)
1957 {
1958     /* LPDISPLAY_DEVICEW */
1959     TEST_TYPE(LPDISPLAY_DEVICEW, 4, 4);
1960     TEST_TYPE_POINTER(LPDISPLAY_DEVICEW, 840, 4);
1961 }
1962
1963 static void test_pack_LPDOCINFOA(void)
1964 {
1965     /* LPDOCINFOA */
1966     TEST_TYPE(LPDOCINFOA, 4, 4);
1967     TEST_TYPE_POINTER(LPDOCINFOA, 20, 4);
1968 }
1969
1970 static void test_pack_LPDOCINFOW(void)
1971 {
1972     /* LPDOCINFOW */
1973     TEST_TYPE(LPDOCINFOW, 4, 4);
1974     TEST_TYPE_POINTER(LPDOCINFOW, 20, 4);
1975 }
1976
1977 static void test_pack_LPENHMETAHEADER(void)
1978 {
1979     /* LPENHMETAHEADER */
1980     TEST_TYPE(LPENHMETAHEADER, 4, 4);
1981     TEST_TYPE_POINTER(LPENHMETAHEADER, 108, 4);
1982 }
1983
1984 static void test_pack_LPENHMETARECORD(void)
1985 {
1986     /* LPENHMETARECORD */
1987     TEST_TYPE(LPENHMETARECORD, 4, 4);
1988     TEST_TYPE_POINTER(LPENHMETARECORD, 12, 4);
1989 }
1990
1991 static void test_pack_LPENUMLOGFONTA(void)
1992 {
1993     /* LPENUMLOGFONTA */
1994     TEST_TYPE(LPENUMLOGFONTA, 4, 4);
1995     TEST_TYPE_POINTER(LPENUMLOGFONTA, 156, 4);
1996 }
1997
1998 static void test_pack_LPENUMLOGFONTEXA(void)
1999 {
2000     /* LPENUMLOGFONTEXA */
2001     TEST_TYPE(LPENUMLOGFONTEXA, 4, 4);
2002     TEST_TYPE_POINTER(LPENUMLOGFONTEXA, 188, 4);
2003 }
2004
2005 static void test_pack_LPENUMLOGFONTEXW(void)
2006 {
2007     /* LPENUMLOGFONTEXW */
2008     TEST_TYPE(LPENUMLOGFONTEXW, 4, 4);
2009     TEST_TYPE_POINTER(LPENUMLOGFONTEXW, 348, 4);
2010 }
2011
2012 static void test_pack_LPENUMLOGFONTW(void)
2013 {
2014     /* LPENUMLOGFONTW */
2015     TEST_TYPE(LPENUMLOGFONTW, 4, 4);
2016     TEST_TYPE_POINTER(LPENUMLOGFONTW, 284, 4);
2017 }
2018
2019 static void test_pack_LPEXTLOGFONTA(void)
2020 {
2021     /* LPEXTLOGFONTA */
2022     TEST_TYPE(LPEXTLOGFONTA, 4, 4);
2023     TEST_TYPE_POINTER(LPEXTLOGFONTA, 192, 4);
2024 }
2025
2026 static void test_pack_LPEXTLOGFONTW(void)
2027 {
2028     /* LPEXTLOGFONTW */
2029     TEST_TYPE(LPEXTLOGFONTW, 4, 4);
2030     TEST_TYPE_POINTER(LPEXTLOGFONTW, 320, 4);
2031 }
2032
2033 static void test_pack_LPEXTLOGPEN(void)
2034 {
2035     /* LPEXTLOGPEN */
2036     TEST_TYPE(LPEXTLOGPEN, 4, 4);
2037     TEST_TYPE_POINTER(LPEXTLOGPEN, 28, 4);
2038 }
2039
2040 static void test_pack_LPFONTSIGNATURE(void)
2041 {
2042     /* LPFONTSIGNATURE */
2043     TEST_TYPE(LPFONTSIGNATURE, 4, 4);
2044     TEST_TYPE_POINTER(LPFONTSIGNATURE, 24, 4);
2045 }
2046
2047 static void test_pack_LPGCP_RESULTSA(void)
2048 {
2049     /* LPGCP_RESULTSA */
2050     TEST_TYPE(LPGCP_RESULTSA, 4, 4);
2051     TEST_TYPE_POINTER(LPGCP_RESULTSA, 36, 4);
2052 }
2053
2054 static void test_pack_LPGCP_RESULTSW(void)
2055 {
2056     /* LPGCP_RESULTSW */
2057     TEST_TYPE(LPGCP_RESULTSW, 4, 4);
2058     TEST_TYPE_POINTER(LPGCP_RESULTSW, 36, 4);
2059 }
2060
2061 static void test_pack_LPGLYPHMETRICS(void)
2062 {
2063     /* LPGLYPHMETRICS */
2064     TEST_TYPE(LPGLYPHMETRICS, 4, 4);
2065     TEST_TYPE_POINTER(LPGLYPHMETRICS, 20, 4);
2066 }
2067
2068 static void test_pack_LPGRADIENT_RECT(void)
2069 {
2070     /* LPGRADIENT_RECT */
2071     TEST_TYPE(LPGRADIENT_RECT, 4, 4);
2072     TEST_TYPE_POINTER(LPGRADIENT_RECT, 8, 4);
2073 }
2074
2075 static void test_pack_LPGRADIENT_TRIANGLE(void)
2076 {
2077     /* LPGRADIENT_TRIANGLE */
2078     TEST_TYPE(LPGRADIENT_TRIANGLE, 4, 4);
2079     TEST_TYPE_POINTER(LPGRADIENT_TRIANGLE, 12, 4);
2080 }
2081
2082 static void test_pack_LPHANDLETABLE(void)
2083 {
2084     /* LPHANDLETABLE */
2085     TEST_TYPE(LPHANDLETABLE, 4, 4);
2086     TEST_TYPE_POINTER(LPHANDLETABLE, 4, 4);
2087 }
2088
2089 static void test_pack_LPKERNINGPAIR(void)
2090 {
2091     /* LPKERNINGPAIR */
2092     TEST_TYPE(LPKERNINGPAIR, 4, 4);
2093     TEST_TYPE_POINTER(LPKERNINGPAIR, 8, 4);
2094 }
2095
2096 static void test_pack_LPLOCALESIGNATURE(void)
2097 {
2098     /* LPLOCALESIGNATURE */
2099     TEST_TYPE(LPLOCALESIGNATURE, 4, 4);
2100     TEST_TYPE_POINTER(LPLOCALESIGNATURE, 32, 4);
2101 }
2102
2103 static void test_pack_LPLOGBRUSH(void)
2104 {
2105     /* LPLOGBRUSH */
2106     TEST_TYPE(LPLOGBRUSH, 4, 4);
2107     TEST_TYPE_POINTER(LPLOGBRUSH, 12, 4);
2108 }
2109
2110 static void test_pack_LPLOGCOLORSPACEA(void)
2111 {
2112     /* LPLOGCOLORSPACEA */
2113     TEST_TYPE(LPLOGCOLORSPACEA, 4, 4);
2114     TEST_TYPE_POINTER(LPLOGCOLORSPACEA, 328, 4);
2115 }
2116
2117 static void test_pack_LPLOGCOLORSPACEW(void)
2118 {
2119     /* LPLOGCOLORSPACEW */
2120     TEST_TYPE(LPLOGCOLORSPACEW, 4, 4);
2121     TEST_TYPE_POINTER(LPLOGCOLORSPACEW, 588, 4);
2122 }
2123
2124 static void test_pack_LPLOGFONTA(void)
2125 {
2126     /* LPLOGFONTA */
2127     TEST_TYPE(LPLOGFONTA, 4, 4);
2128     TEST_TYPE_POINTER(LPLOGFONTA, 60, 4);
2129 }
2130
2131 static void test_pack_LPLOGFONTW(void)
2132 {
2133     /* LPLOGFONTW */
2134     TEST_TYPE(LPLOGFONTW, 4, 4);
2135     TEST_TYPE_POINTER(LPLOGFONTW, 92, 4);
2136 }
2137
2138 static void test_pack_LPLOGPEN(void)
2139 {
2140     /* LPLOGPEN */
2141     TEST_TYPE(LPLOGPEN, 4, 4);
2142     TEST_TYPE_POINTER(LPLOGPEN, 16, 4);
2143 }
2144
2145 static void test_pack_LPMAT2(void)
2146 {
2147     /* LPMAT2 */
2148     TEST_TYPE(LPMAT2, 4, 4);
2149     TEST_TYPE_POINTER(LPMAT2, 16, 2);
2150 }
2151
2152 static void test_pack_LPMETAFILEPICT(void)
2153 {
2154     /* LPMETAFILEPICT */
2155     TEST_TYPE(LPMETAFILEPICT, 4, 4);
2156     TEST_TYPE_POINTER(LPMETAFILEPICT, 16, 4);
2157 }
2158
2159 static void test_pack_LPMETAHEADER(void)
2160 {
2161     /* LPMETAHEADER */
2162     TEST_TYPE(LPMETAHEADER, 4, 4);
2163     TEST_TYPE_POINTER(LPMETAHEADER, 18, 2);
2164 }
2165
2166 static void test_pack_LPMETARECORD(void)
2167 {
2168     /* LPMETARECORD */
2169     TEST_TYPE(LPMETARECORD, 4, 4);
2170     TEST_TYPE_POINTER(LPMETARECORD, 8, 4);
2171 }
2172
2173 static void test_pack_LPNEWTEXTMETRICA(void)
2174 {
2175     /* LPNEWTEXTMETRICA */
2176     TEST_TYPE(LPNEWTEXTMETRICA, 4, 4);
2177     TEST_TYPE_POINTER(LPNEWTEXTMETRICA, 72, 4);
2178 }
2179
2180 static void test_pack_LPNEWTEXTMETRICW(void)
2181 {
2182     /* LPNEWTEXTMETRICW */
2183     TEST_TYPE(LPNEWTEXTMETRICW, 4, 4);
2184     TEST_TYPE_POINTER(LPNEWTEXTMETRICW, 76, 4);
2185 }
2186
2187 static void test_pack_LPOUTLINETEXTMETRICA(void)
2188 {
2189     /* LPOUTLINETEXTMETRICA */
2190     TEST_TYPE(LPOUTLINETEXTMETRICA, 4, 4);
2191     TEST_TYPE_POINTER(LPOUTLINETEXTMETRICA, 212, 4);
2192 }
2193
2194 static void test_pack_LPOUTLINETEXTMETRICW(void)
2195 {
2196     /* LPOUTLINETEXTMETRICW */
2197     TEST_TYPE(LPOUTLINETEXTMETRICW, 4, 4);
2198     TEST_TYPE_POINTER(LPOUTLINETEXTMETRICW, 216, 4);
2199 }
2200
2201 static void test_pack_LPPANOSE(void)
2202 {
2203     /* LPPANOSE */
2204     TEST_TYPE(LPPANOSE, 4, 4);
2205     TEST_TYPE_POINTER(LPPANOSE, 10, 1);
2206 }
2207
2208 static void test_pack_LPPELARRAY(void)
2209 {
2210     /* LPPELARRAY */
2211     TEST_TYPE(LPPELARRAY, 4, 4);
2212     TEST_TYPE_POINTER(LPPELARRAY, 20, 4);
2213 }
2214
2215 static void test_pack_LPPIXELFORMATDESCRIPTOR(void)
2216 {
2217     /* LPPIXELFORMATDESCRIPTOR */
2218     TEST_TYPE(LPPIXELFORMATDESCRIPTOR, 4, 4);
2219     TEST_TYPE_POINTER(LPPIXELFORMATDESCRIPTOR, 40, 4);
2220 }
2221
2222 static void test_pack_LPPOINTFX(void)
2223 {
2224     /* LPPOINTFX */
2225     TEST_TYPE(LPPOINTFX, 4, 4);
2226     TEST_TYPE_POINTER(LPPOINTFX, 8, 2);
2227 }
2228
2229 static void test_pack_LPPOLYTEXTA(void)
2230 {
2231     /* LPPOLYTEXTA */
2232     TEST_TYPE(LPPOLYTEXTA, 4, 4);
2233     TEST_TYPE_POINTER(LPPOLYTEXTA, 40, 4);
2234 }
2235
2236 static void test_pack_LPPOLYTEXTW(void)
2237 {
2238     /* LPPOLYTEXTW */
2239     TEST_TYPE(LPPOLYTEXTW, 4, 4);
2240     TEST_TYPE_POINTER(LPPOLYTEXTW, 40, 4);
2241 }
2242
2243 static void test_pack_LPRASTERIZER_STATUS(void)
2244 {
2245     /* LPRASTERIZER_STATUS */
2246     TEST_TYPE(LPRASTERIZER_STATUS, 4, 4);
2247     TEST_TYPE_POINTER(LPRASTERIZER_STATUS, 6, 2);
2248 }
2249
2250 static void test_pack_LPRGBQUAD(void)
2251 {
2252     /* LPRGBQUAD */
2253     TEST_TYPE(LPRGBQUAD, 4, 4);
2254     TEST_TYPE_POINTER(LPRGBQUAD, 4, 1);
2255 }
2256
2257 static void test_pack_LPRGNDATA(void)
2258 {
2259     /* LPRGNDATA */
2260     TEST_TYPE(LPRGNDATA, 4, 4);
2261     TEST_TYPE_POINTER(LPRGNDATA, 36, 4);
2262 }
2263
2264 static void test_pack_LPTEXTMETRICA(void)
2265 {
2266     /* LPTEXTMETRICA */
2267     TEST_TYPE(LPTEXTMETRICA, 4, 4);
2268     TEST_TYPE_POINTER(LPTEXTMETRICA, 56, 4);
2269 }
2270
2271 static void test_pack_LPTEXTMETRICW(void)
2272 {
2273     /* LPTEXTMETRICW */
2274     TEST_TYPE(LPTEXTMETRICW, 4, 4);
2275     TEST_TYPE_POINTER(LPTEXTMETRICW, 60, 4);
2276 }
2277
2278 static void test_pack_LPTRIVERTEX(void)
2279 {
2280     /* LPTRIVERTEX */
2281     TEST_TYPE(LPTRIVERTEX, 4, 4);
2282     TEST_TYPE_POINTER(LPTRIVERTEX, 16, 4);
2283 }
2284
2285 static void test_pack_LPTTPOLYCURVE(void)
2286 {
2287     /* LPTTPOLYCURVE */
2288     TEST_TYPE(LPTTPOLYCURVE, 4, 4);
2289     TEST_TYPE_POINTER(LPTTPOLYCURVE, 12, 2);
2290 }
2291
2292 static void test_pack_LPTTPOLYGONHEADER(void)
2293 {
2294     /* LPTTPOLYGONHEADER */
2295     TEST_TYPE(LPTTPOLYGONHEADER, 4, 4);
2296     TEST_TYPE_POINTER(LPTTPOLYGONHEADER, 16, 4);
2297 }
2298
2299 static void test_pack_LPXFORM(void)
2300 {
2301     /* LPXFORM */
2302     TEST_TYPE(LPXFORM, 4, 4);
2303     TEST_TYPE_POINTER(LPXFORM, 24, 4);
2304 }
2305
2306 static void test_pack_MAT2(void)
2307 {
2308     /* MAT2 (pack 4) */
2309     TEST_TYPE(MAT2, 16, 2);
2310     TEST_FIELD(MAT2, FIXED, eM11, 0, 4, 2);
2311     TEST_FIELD(MAT2, FIXED, eM12, 4, 4, 2);
2312     TEST_FIELD(MAT2, FIXED, eM21, 8, 4, 2);
2313     TEST_FIELD(MAT2, FIXED, eM22, 12, 4, 2);
2314 }
2315
2316 static void test_pack_METAFILEPICT(void)
2317 {
2318     /* METAFILEPICT (pack 4) */
2319     TEST_TYPE(METAFILEPICT, 16, 4);
2320     TEST_FIELD(METAFILEPICT, LONG, mm, 0, 4, 4);
2321     TEST_FIELD(METAFILEPICT, LONG, xExt, 4, 4, 4);
2322     TEST_FIELD(METAFILEPICT, LONG, yExt, 8, 4, 4);
2323     TEST_FIELD(METAFILEPICT, HMETAFILE, hMF, 12, 4, 4);
2324 }
2325
2326 static void test_pack_METAHEADER(void)
2327 {
2328     /* METAHEADER (pack 2) */
2329     TEST_TYPE(METAHEADER, 18, 2);
2330     TEST_FIELD(METAHEADER, WORD, mtType, 0, 2, 2);
2331     TEST_FIELD(METAHEADER, WORD, mtHeaderSize, 2, 2, 2);
2332     TEST_FIELD(METAHEADER, WORD, mtVersion, 4, 2, 2);
2333     TEST_FIELD(METAHEADER, DWORD, mtSize, 6, 4, 2);
2334     TEST_FIELD(METAHEADER, WORD, mtNoObjects, 10, 2, 2);
2335     TEST_FIELD(METAHEADER, DWORD, mtMaxRecord, 12, 4, 2);
2336     TEST_FIELD(METAHEADER, WORD, mtNoParameters, 16, 2, 2);
2337 }
2338
2339 static void test_pack_METARECORD(void)
2340 {
2341     /* METARECORD (pack 4) */
2342     TEST_TYPE(METARECORD, 8, 4);
2343     TEST_FIELD(METARECORD, DWORD, rdSize, 0, 4, 4);
2344     TEST_FIELD(METARECORD, WORD, rdFunction, 4, 2, 2);
2345     TEST_FIELD(METARECORD, WORD[1], rdParm, 6, 2, 2);
2346 }
2347
2348 static void test_pack_MFENUMPROC(void)
2349 {
2350     /* MFENUMPROC */
2351     TEST_TYPE(MFENUMPROC, 4, 4);
2352 }
2353
2354 static void test_pack_NEWTEXTMETRICA(void)
2355 {
2356     /* NEWTEXTMETRICA (pack 4) */
2357     TEST_TYPE(NEWTEXTMETRICA, 72, 4);
2358     TEST_FIELD(NEWTEXTMETRICA, LONG, tmHeight, 0, 4, 4);
2359     TEST_FIELD(NEWTEXTMETRICA, LONG, tmAscent, 4, 4, 4);
2360     TEST_FIELD(NEWTEXTMETRICA, LONG, tmDescent, 8, 4, 4);
2361     TEST_FIELD(NEWTEXTMETRICA, LONG, tmInternalLeading, 12, 4, 4);
2362     TEST_FIELD(NEWTEXTMETRICA, LONG, tmExternalLeading, 16, 4, 4);
2363     TEST_FIELD(NEWTEXTMETRICA, LONG, tmAveCharWidth, 20, 4, 4);
2364     TEST_FIELD(NEWTEXTMETRICA, LONG, tmMaxCharWidth, 24, 4, 4);
2365     TEST_FIELD(NEWTEXTMETRICA, LONG, tmWeight, 28, 4, 4);
2366     TEST_FIELD(NEWTEXTMETRICA, LONG, tmOverhang, 32, 4, 4);
2367     TEST_FIELD(NEWTEXTMETRICA, LONG, tmDigitizedAspectX, 36, 4, 4);
2368     TEST_FIELD(NEWTEXTMETRICA, LONG, tmDigitizedAspectY, 40, 4, 4);
2369     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmFirstChar, 44, 1, 1);
2370     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmLastChar, 45, 1, 1);
2371     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmDefaultChar, 46, 1, 1);
2372     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmBreakChar, 47, 1, 1);
2373     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmItalic, 48, 1, 1);
2374     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmUnderlined, 49, 1, 1);
2375     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmStruckOut, 50, 1, 1);
2376     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmPitchAndFamily, 51, 1, 1);
2377     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmCharSet, 52, 1, 1);
2378     TEST_FIELD(NEWTEXTMETRICA, DWORD, ntmFlags, 56, 4, 4);
2379     TEST_FIELD(NEWTEXTMETRICA, UINT, ntmSizeEM, 60, 4, 4);
2380     TEST_FIELD(NEWTEXTMETRICA, UINT, ntmCellHeight, 64, 4, 4);
2381     TEST_FIELD(NEWTEXTMETRICA, UINT, ntmAvgWidth, 68, 4, 4);
2382 }
2383
2384 static void test_pack_NEWTEXTMETRICEXA(void)
2385 {
2386     /* NEWTEXTMETRICEXA (pack 4) */
2387     TEST_TYPE(NEWTEXTMETRICEXA, 96, 4);
2388     TEST_FIELD(NEWTEXTMETRICEXA, NEWTEXTMETRICA, ntmTm, 0, 72, 4);
2389     TEST_FIELD(NEWTEXTMETRICEXA, FONTSIGNATURE, ntmFontSig, 72, 24, 4);
2390 }
2391
2392 static void test_pack_NEWTEXTMETRICEXW(void)
2393 {
2394     /* NEWTEXTMETRICEXW (pack 4) */
2395     TEST_TYPE(NEWTEXTMETRICEXW, 100, 4);
2396     TEST_FIELD(NEWTEXTMETRICEXW, NEWTEXTMETRICW, ntmTm, 0, 76, 4);
2397     TEST_FIELD(NEWTEXTMETRICEXW, FONTSIGNATURE, ntmFontSig, 76, 24, 4);
2398 }
2399
2400 static void test_pack_NEWTEXTMETRICW(void)
2401 {
2402     /* NEWTEXTMETRICW (pack 4) */
2403     TEST_TYPE(NEWTEXTMETRICW, 76, 4);
2404     TEST_FIELD(NEWTEXTMETRICW, LONG, tmHeight, 0, 4, 4);
2405     TEST_FIELD(NEWTEXTMETRICW, LONG, tmAscent, 4, 4, 4);
2406     TEST_FIELD(NEWTEXTMETRICW, LONG, tmDescent, 8, 4, 4);
2407     TEST_FIELD(NEWTEXTMETRICW, LONG, tmInternalLeading, 12, 4, 4);
2408     TEST_FIELD(NEWTEXTMETRICW, LONG, tmExternalLeading, 16, 4, 4);
2409     TEST_FIELD(NEWTEXTMETRICW, LONG, tmAveCharWidth, 20, 4, 4);
2410     TEST_FIELD(NEWTEXTMETRICW, LONG, tmMaxCharWidth, 24, 4, 4);
2411     TEST_FIELD(NEWTEXTMETRICW, LONG, tmWeight, 28, 4, 4);
2412     TEST_FIELD(NEWTEXTMETRICW, LONG, tmOverhang, 32, 4, 4);
2413     TEST_FIELD(NEWTEXTMETRICW, LONG, tmDigitizedAspectX, 36, 4, 4);
2414     TEST_FIELD(NEWTEXTMETRICW, LONG, tmDigitizedAspectY, 40, 4, 4);
2415     TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmFirstChar, 44, 2, 2);
2416     TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmLastChar, 46, 2, 2);
2417     TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmDefaultChar, 48, 2, 2);
2418     TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmBreakChar, 50, 2, 2);
2419     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmItalic, 52, 1, 1);
2420     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmUnderlined, 53, 1, 1);
2421     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmStruckOut, 54, 1, 1);
2422     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmPitchAndFamily, 55, 1, 1);
2423     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmCharSet, 56, 1, 1);
2424     TEST_FIELD(NEWTEXTMETRICW, DWORD, ntmFlags, 60, 4, 4);
2425     TEST_FIELD(NEWTEXTMETRICW, UINT, ntmSizeEM, 64, 4, 4);
2426     TEST_FIELD(NEWTEXTMETRICW, UINT, ntmCellHeight, 68, 4, 4);
2427     TEST_FIELD(NEWTEXTMETRICW, UINT, ntmAvgWidth, 72, 4, 4);
2428 }
2429
2430 static void test_pack_NPEXTLOGPEN(void)
2431 {
2432     /* NPEXTLOGPEN */
2433     TEST_TYPE(NPEXTLOGPEN, 4, 4);
2434     TEST_TYPE_POINTER(NPEXTLOGPEN, 28, 4);
2435 }
2436
2437 static void test_pack_OLDFONTENUMPROC(void)
2438 {
2439     /* OLDFONTENUMPROC */
2440     TEST_TYPE(OLDFONTENUMPROC, 4, 4);
2441 }
2442
2443 static void test_pack_OLDFONTENUMPROCA(void)
2444 {
2445     /* OLDFONTENUMPROCA */
2446     TEST_TYPE(OLDFONTENUMPROCA, 4, 4);
2447 }
2448
2449 static void test_pack_OLDFONTENUMPROCW(void)
2450 {
2451     /* OLDFONTENUMPROCW */
2452     TEST_TYPE(OLDFONTENUMPROCW, 4, 4);
2453 }
2454
2455 static void test_pack_OUTLINETEXTMETRICA(void)
2456 {
2457     /* OUTLINETEXTMETRICA (pack 4) */
2458     TEST_TYPE(OUTLINETEXTMETRICA, 212, 4);
2459     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmSize, 0, 4, 4);
2460     TEST_FIELD(OUTLINETEXTMETRICA, TEXTMETRICA, otmTextMetrics, 4, 56, 4);
2461     TEST_FIELD(OUTLINETEXTMETRICA, BYTE, otmFiller, 60, 1, 1);
2462     TEST_FIELD(OUTLINETEXTMETRICA, PANOSE, otmPanoseNumber, 61, 10, 1);
2463     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmfsSelection, 72, 4, 4);
2464     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmfsType, 76, 4, 4);
2465     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsCharSlopeRise, 80, 4, 4);
2466     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsCharSlopeRun, 84, 4, 4);
2467     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmItalicAngle, 88, 4, 4);
2468     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmEMSquare, 92, 4, 4);
2469     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmAscent, 96, 4, 4);
2470     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmDescent, 100, 4, 4);
2471     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmLineGap, 104, 4, 4);
2472     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmsCapEmHeight, 108, 4, 4);
2473     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmsXHeight, 112, 4, 4);
2474     TEST_FIELD(OUTLINETEXTMETRICA, RECT, otmrcFontBox, 116, 16, 4);
2475     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmMacAscent, 132, 4, 4);
2476     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmMacDescent, 136, 4, 4);
2477     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmMacLineGap, 140, 4, 4);
2478     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmusMinimumPPEM, 144, 4, 4);
2479     TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSubscriptSize, 148, 8, 4);
2480     TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSubscriptOffset, 156, 8, 4);
2481     TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSuperscriptSize, 164, 8, 4);
2482     TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSuperscriptOffset, 172, 8, 4);
2483     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmsStrikeoutSize, 180, 4, 4);
2484     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsStrikeoutPosition, 184, 4, 4);
2485     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsUnderscoreSize, 188, 4, 4);
2486     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsUnderscorePosition, 192, 4, 4);
2487     TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpFamilyName, 196, 4, 4);
2488     TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpFaceName, 200, 4, 4);
2489     TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpStyleName, 204, 4, 4);
2490     TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpFullName, 208, 4, 4);
2491 }
2492
2493 static void test_pack_OUTLINETEXTMETRICW(void)
2494 {
2495     /* OUTLINETEXTMETRICW (pack 4) */
2496     TEST_TYPE(OUTLINETEXTMETRICW, 216, 4);
2497     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmSize, 0, 4, 4);
2498     TEST_FIELD(OUTLINETEXTMETRICW, TEXTMETRICW, otmTextMetrics, 4, 60, 4);
2499     TEST_FIELD(OUTLINETEXTMETRICW, BYTE, otmFiller, 64, 1, 1);
2500     TEST_FIELD(OUTLINETEXTMETRICW, PANOSE, otmPanoseNumber, 65, 10, 1);
2501     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmfsSelection, 76, 4, 4);
2502     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmfsType, 80, 4, 4);
2503     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsCharSlopeRise, 84, 4, 4);
2504     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsCharSlopeRun, 88, 4, 4);
2505     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmItalicAngle, 92, 4, 4);
2506     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmEMSquare, 96, 4, 4);
2507     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmAscent, 100, 4, 4);
2508     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmDescent, 104, 4, 4);
2509     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmLineGap, 108, 4, 4);
2510     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmsCapEmHeight, 112, 4, 4);
2511     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmsXHeight, 116, 4, 4);
2512     TEST_FIELD(OUTLINETEXTMETRICW, RECT, otmrcFontBox, 120, 16, 4);
2513     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmMacAscent, 136, 4, 4);
2514     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmMacDescent, 140, 4, 4);
2515     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmMacLineGap, 144, 4, 4);
2516     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmusMinimumPPEM, 148, 4, 4);
2517     TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSubscriptSize, 152, 8, 4);
2518     TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSubscriptOffset, 160, 8, 4);
2519     TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSuperscriptSize, 168, 8, 4);
2520     TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSuperscriptOffset, 176, 8, 4);
2521     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmsStrikeoutSize, 184, 4, 4);
2522     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsStrikeoutPosition, 188, 4, 4);
2523     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsUnderscoreSize, 192, 4, 4);
2524     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsUnderscorePosition, 196, 4, 4);
2525     TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpFamilyName, 200, 4, 4);
2526     TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpFaceName, 204, 4, 4);
2527     TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpStyleName, 208, 4, 4);
2528     TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpFullName, 212, 4, 4);
2529 }
2530
2531 static void test_pack_PABC(void)
2532 {
2533     /* PABC */
2534     TEST_TYPE(PABC, 4, 4);
2535     TEST_TYPE_POINTER(PABC, 12, 4);
2536 }
2537
2538 static void test_pack_PABCFLOAT(void)
2539 {
2540     /* PABCFLOAT */
2541     TEST_TYPE(PABCFLOAT, 4, 4);
2542     TEST_TYPE_POINTER(PABCFLOAT, 12, 4);
2543 }
2544
2545 static void test_pack_PANOSE(void)
2546 {
2547     /* PANOSE (pack 4) */
2548     TEST_TYPE(PANOSE, 10, 1);
2549     TEST_FIELD(PANOSE, BYTE, bFamilyType, 0, 1, 1);
2550     TEST_FIELD(PANOSE, BYTE, bSerifStyle, 1, 1, 1);
2551     TEST_FIELD(PANOSE, BYTE, bWeight, 2, 1, 1);
2552     TEST_FIELD(PANOSE, BYTE, bProportion, 3, 1, 1);
2553     TEST_FIELD(PANOSE, BYTE, bContrast, 4, 1, 1);
2554     TEST_FIELD(PANOSE, BYTE, bStrokeVariation, 5, 1, 1);
2555     TEST_FIELD(PANOSE, BYTE, bArmStyle, 6, 1, 1);
2556     TEST_FIELD(PANOSE, BYTE, bLetterform, 7, 1, 1);
2557     TEST_FIELD(PANOSE, BYTE, bMidline, 8, 1, 1);
2558     TEST_FIELD(PANOSE, BYTE, bXHeight, 9, 1, 1);
2559 }
2560
2561 static void test_pack_PATTERN(void)
2562 {
2563     /* PATTERN */
2564     TEST_TYPE(PATTERN, 12, 4);
2565 }
2566
2567 static void test_pack_PBITMAP(void)
2568 {
2569     /* PBITMAP */
2570     TEST_TYPE(PBITMAP, 4, 4);
2571     TEST_TYPE_POINTER(PBITMAP, 24, 4);
2572 }
2573
2574 static void test_pack_PBITMAPCOREHEADER(void)
2575 {
2576     /* PBITMAPCOREHEADER */
2577     TEST_TYPE(PBITMAPCOREHEADER, 4, 4);
2578     TEST_TYPE_POINTER(PBITMAPCOREHEADER, 12, 4);
2579 }
2580
2581 static void test_pack_PBITMAPCOREINFO(void)
2582 {
2583     /* PBITMAPCOREINFO */
2584     TEST_TYPE(PBITMAPCOREINFO, 4, 4);
2585     TEST_TYPE_POINTER(PBITMAPCOREINFO, 16, 4);
2586 }
2587
2588 static void test_pack_PBITMAPFILEHEADER(void)
2589 {
2590     /* PBITMAPFILEHEADER */
2591     TEST_TYPE(PBITMAPFILEHEADER, 4, 4);
2592     TEST_TYPE_POINTER(PBITMAPFILEHEADER, 14, 2);
2593 }
2594
2595 static void test_pack_PBITMAPINFO(void)
2596 {
2597     /* PBITMAPINFO */
2598     TEST_TYPE(PBITMAPINFO, 4, 4);
2599     TEST_TYPE_POINTER(PBITMAPINFO, 44, 4);
2600 }
2601
2602 static void test_pack_PBITMAPINFOHEADER(void)
2603 {
2604     /* PBITMAPINFOHEADER */
2605     TEST_TYPE(PBITMAPINFOHEADER, 4, 4);
2606     TEST_TYPE_POINTER(PBITMAPINFOHEADER, 40, 4);
2607 }
2608
2609 static void test_pack_PBITMAPV4HEADER(void)
2610 {
2611     /* PBITMAPV4HEADER */
2612     TEST_TYPE(PBITMAPV4HEADER, 4, 4);
2613     TEST_TYPE_POINTER(PBITMAPV4HEADER, 108, 4);
2614 }
2615
2616 static void test_pack_PBITMAPV5HEADER(void)
2617 {
2618     /* PBITMAPV5HEADER */
2619     TEST_TYPE(PBITMAPV5HEADER, 4, 4);
2620     TEST_TYPE_POINTER(PBITMAPV5HEADER, 124, 4);
2621 }
2622
2623 static void test_pack_PBLENDFUNCTION(void)
2624 {
2625     /* PBLENDFUNCTION */
2626     TEST_TYPE(PBLENDFUNCTION, 4, 4);
2627     TEST_TYPE_POINTER(PBLENDFUNCTION, 4, 1);
2628 }
2629
2630 static void test_pack_PCHARSETINFO(void)
2631 {
2632     /* PCHARSETINFO */
2633     TEST_TYPE(PCHARSETINFO, 4, 4);
2634     TEST_TYPE_POINTER(PCHARSETINFO, 32, 4);
2635 }
2636
2637 static void test_pack_PCOLORADJUSTMENT(void)
2638 {
2639     /* PCOLORADJUSTMENT */
2640     TEST_TYPE(PCOLORADJUSTMENT, 4, 4);
2641     TEST_TYPE_POINTER(PCOLORADJUSTMENT, 24, 2);
2642 }
2643
2644 static void test_pack_PDEVMODEA(void)
2645 {
2646     /* PDEVMODEA */
2647     TEST_TYPE(PDEVMODEA, 4, 4);
2648 }
2649
2650 static void test_pack_PDEVMODEW(void)
2651 {
2652     /* PDEVMODEW */
2653     TEST_TYPE(PDEVMODEW, 4, 4);
2654 }
2655
2656 static void test_pack_PDIBSECTION(void)
2657 {
2658     /* PDIBSECTION */
2659     TEST_TYPE(PDIBSECTION, 4, 4);
2660     TEST_TYPE_POINTER(PDIBSECTION, 84, 4);
2661 }
2662
2663 static void test_pack_PDISPLAY_DEVICEA(void)
2664 {
2665     /* PDISPLAY_DEVICEA */
2666     TEST_TYPE(PDISPLAY_DEVICEA, 4, 4);
2667     TEST_TYPE_POINTER(PDISPLAY_DEVICEA, 424, 4);
2668 }
2669
2670 static void test_pack_PDISPLAY_DEVICEW(void)
2671 {
2672     /* PDISPLAY_DEVICEW */
2673     TEST_TYPE(PDISPLAY_DEVICEW, 4, 4);
2674     TEST_TYPE_POINTER(PDISPLAY_DEVICEW, 840, 4);
2675 }
2676
2677 static void test_pack_PELARRAY(void)
2678 {
2679     /* PELARRAY (pack 4) */
2680     TEST_TYPE(PELARRAY, 20, 4);
2681     TEST_FIELD(PELARRAY, LONG, paXCount, 0, 4, 4);
2682     TEST_FIELD(PELARRAY, LONG, paYCount, 4, 4, 4);
2683     TEST_FIELD(PELARRAY, LONG, paXExt, 8, 4, 4);
2684     TEST_FIELD(PELARRAY, LONG, paYExt, 12, 4, 4);
2685     TEST_FIELD(PELARRAY, BYTE, paRGBs, 16, 1, 1);
2686 }
2687
2688 static void test_pack_PEMR(void)
2689 {
2690     /* PEMR */
2691     TEST_TYPE(PEMR, 4, 4);
2692     TEST_TYPE_POINTER(PEMR, 8, 4);
2693 }
2694
2695 static void test_pack_PEMRABORTPATH(void)
2696 {
2697     /* PEMRABORTPATH */
2698     TEST_TYPE(PEMRABORTPATH, 4, 4);
2699     TEST_TYPE_POINTER(PEMRABORTPATH, 8, 4);
2700 }
2701
2702 static void test_pack_PEMRANGLEARC(void)
2703 {
2704     /* PEMRANGLEARC */
2705     TEST_TYPE(PEMRANGLEARC, 4, 4);
2706     TEST_TYPE_POINTER(PEMRANGLEARC, 28, 4);
2707 }
2708
2709 static void test_pack_PEMRARC(void)
2710 {
2711     /* PEMRARC */
2712     TEST_TYPE(PEMRARC, 4, 4);
2713     TEST_TYPE_POINTER(PEMRARC, 40, 4);
2714 }
2715
2716 static void test_pack_PEMRARCTO(void)
2717 {
2718     /* PEMRARCTO */
2719     TEST_TYPE(PEMRARCTO, 4, 4);
2720     TEST_TYPE_POINTER(PEMRARCTO, 40, 4);
2721 }
2722
2723 static void test_pack_PEMRBEGINPATH(void)
2724 {
2725     /* PEMRBEGINPATH */
2726     TEST_TYPE(PEMRBEGINPATH, 4, 4);
2727     TEST_TYPE_POINTER(PEMRBEGINPATH, 8, 4);
2728 }
2729
2730 static void test_pack_PEMRBITBLT(void)
2731 {
2732     /* PEMRBITBLT */
2733     TEST_TYPE(PEMRBITBLT, 4, 4);
2734     TEST_TYPE_POINTER(PEMRBITBLT, 100, 4);
2735 }
2736
2737 static void test_pack_PEMRCHORD(void)
2738 {
2739     /* PEMRCHORD */
2740     TEST_TYPE(PEMRCHORD, 4, 4);
2741     TEST_TYPE_POINTER(PEMRCHORD, 40, 4);
2742 }
2743
2744 static void test_pack_PEMRCLOSEFIGURE(void)
2745 {
2746     /* PEMRCLOSEFIGURE */
2747     TEST_TYPE(PEMRCLOSEFIGURE, 4, 4);
2748     TEST_TYPE_POINTER(PEMRCLOSEFIGURE, 8, 4);
2749 }
2750
2751 static void test_pack_PEMRCREATEBRUSHINDIRECT(void)
2752 {
2753     /* PEMRCREATEBRUSHINDIRECT */
2754     TEST_TYPE(PEMRCREATEBRUSHINDIRECT, 4, 4);
2755     TEST_TYPE_POINTER(PEMRCREATEBRUSHINDIRECT, 24, 4);
2756 }
2757
2758 static void test_pack_PEMRCREATECOLORSPACE(void)
2759 {
2760     /* PEMRCREATECOLORSPACE */
2761     TEST_TYPE(PEMRCREATECOLORSPACE, 4, 4);
2762     TEST_TYPE_POINTER(PEMRCREATECOLORSPACE, 340, 4);
2763 }
2764
2765 static void test_pack_PEMRCREATECOLORSPACEW(void)
2766 {
2767     /* PEMRCREATECOLORSPACEW */
2768     TEST_TYPE(PEMRCREATECOLORSPACEW, 4, 4);
2769     TEST_TYPE_POINTER(PEMRCREATECOLORSPACEW, 612, 4);
2770 }
2771
2772 static void test_pack_PEMRCREATEDIBPATTERNBRUSHPT(void)
2773 {
2774     /* PEMRCREATEDIBPATTERNBRUSHPT */
2775     TEST_TYPE(PEMRCREATEDIBPATTERNBRUSHPT, 4, 4);
2776     TEST_TYPE_POINTER(PEMRCREATEDIBPATTERNBRUSHPT, 32, 4);
2777 }
2778
2779 static void test_pack_PEMRCREATEMONOBRUSH(void)
2780 {
2781     /* PEMRCREATEMONOBRUSH */
2782     TEST_TYPE(PEMRCREATEMONOBRUSH, 4, 4);
2783     TEST_TYPE_POINTER(PEMRCREATEMONOBRUSH, 32, 4);
2784 }
2785
2786 static void test_pack_PEMRCREATEPALETTE(void)
2787 {
2788     /* PEMRCREATEPALETTE */
2789     TEST_TYPE(PEMRCREATEPALETTE, 4, 4);
2790     TEST_TYPE_POINTER(PEMRCREATEPALETTE, 20, 4);
2791 }
2792
2793 static void test_pack_PEMRCREATEPEN(void)
2794 {
2795     /* PEMRCREATEPEN */
2796     TEST_TYPE(PEMRCREATEPEN, 4, 4);
2797     TEST_TYPE_POINTER(PEMRCREATEPEN, 28, 4);
2798 }
2799
2800 static void test_pack_PEMRDELETECOLORSPACE(void)
2801 {
2802     /* PEMRDELETECOLORSPACE */
2803     TEST_TYPE(PEMRDELETECOLORSPACE, 4, 4);
2804     TEST_TYPE_POINTER(PEMRDELETECOLORSPACE, 12, 4);
2805 }
2806
2807 static void test_pack_PEMRDELETEOBJECT(void)
2808 {
2809     /* PEMRDELETEOBJECT */
2810     TEST_TYPE(PEMRDELETEOBJECT, 4, 4);
2811     TEST_TYPE_POINTER(PEMRDELETEOBJECT, 12, 4);
2812 }
2813
2814 static void test_pack_PEMRELLIPSE(void)
2815 {
2816     /* PEMRELLIPSE */
2817     TEST_TYPE(PEMRELLIPSE, 4, 4);
2818     TEST_TYPE_POINTER(PEMRELLIPSE, 24, 4);
2819 }
2820
2821 static void test_pack_PEMRENDPATH(void)
2822 {
2823     /* PEMRENDPATH */
2824     TEST_TYPE(PEMRENDPATH, 4, 4);
2825     TEST_TYPE_POINTER(PEMRENDPATH, 8, 4);
2826 }
2827
2828 static void test_pack_PEMREOF(void)
2829 {
2830     /* PEMREOF */
2831     TEST_TYPE(PEMREOF, 4, 4);
2832     TEST_TYPE_POINTER(PEMREOF, 20, 4);
2833 }
2834
2835 static void test_pack_PEMREXCLUDECLIPRECT(void)
2836 {
2837     /* PEMREXCLUDECLIPRECT */
2838     TEST_TYPE(PEMREXCLUDECLIPRECT, 4, 4);
2839     TEST_TYPE_POINTER(PEMREXCLUDECLIPRECT, 24, 4);
2840 }
2841
2842 static void test_pack_PEMREXTCREATEFONTINDIRECTW(void)
2843 {
2844     /* PEMREXTCREATEFONTINDIRECTW */
2845     TEST_TYPE(PEMREXTCREATEFONTINDIRECTW, 4, 4);
2846     TEST_TYPE_POINTER(PEMREXTCREATEFONTINDIRECTW, 332, 4);
2847 }
2848
2849 static void test_pack_PEMREXTCREATEPEN(void)
2850 {
2851     /* PEMREXTCREATEPEN */
2852     TEST_TYPE(PEMREXTCREATEPEN, 4, 4);
2853     TEST_TYPE_POINTER(PEMREXTCREATEPEN, 56, 4);
2854 }
2855
2856 static void test_pack_PEMREXTFLOODFILL(void)
2857 {
2858     /* PEMREXTFLOODFILL */
2859     TEST_TYPE(PEMREXTFLOODFILL, 4, 4);
2860     TEST_TYPE_POINTER(PEMREXTFLOODFILL, 24, 4);
2861 }
2862
2863 static void test_pack_PEMREXTSELECTCLIPRGN(void)
2864 {
2865     /* PEMREXTSELECTCLIPRGN */
2866     TEST_TYPE(PEMREXTSELECTCLIPRGN, 4, 4);
2867     TEST_TYPE_POINTER(PEMREXTSELECTCLIPRGN, 20, 4);
2868 }
2869
2870 static void test_pack_PEMREXTTEXTOUTA(void)
2871 {
2872     /* PEMREXTTEXTOUTA */
2873     TEST_TYPE(PEMREXTTEXTOUTA, 4, 4);
2874     TEST_TYPE_POINTER(PEMREXTTEXTOUTA, 76, 4);
2875 }
2876
2877 static void test_pack_PEMREXTTEXTOUTW(void)
2878 {
2879     /* PEMREXTTEXTOUTW */
2880     TEST_TYPE(PEMREXTTEXTOUTW, 4, 4);
2881     TEST_TYPE_POINTER(PEMREXTTEXTOUTW, 76, 4);
2882 }
2883
2884 static void test_pack_PEMRFILLPATH(void)
2885 {
2886     /* PEMRFILLPATH */
2887     TEST_TYPE(PEMRFILLPATH, 4, 4);
2888     TEST_TYPE_POINTER(PEMRFILLPATH, 24, 4);
2889 }
2890
2891 static void test_pack_PEMRFILLRGN(void)
2892 {
2893     /* PEMRFILLRGN */
2894     TEST_TYPE(PEMRFILLRGN, 4, 4);
2895     TEST_TYPE_POINTER(PEMRFILLRGN, 36, 4);
2896 }
2897
2898 static void test_pack_PEMRFLATTENPATH(void)
2899 {
2900     /* PEMRFLATTENPATH */
2901     TEST_TYPE(PEMRFLATTENPATH, 4, 4);
2902     TEST_TYPE_POINTER(PEMRFLATTENPATH, 8, 4);
2903 }
2904
2905 static void test_pack_PEMRFORMAT(void)
2906 {
2907     /* PEMRFORMAT */
2908     TEST_TYPE(PEMRFORMAT, 4, 4);
2909     TEST_TYPE_POINTER(PEMRFORMAT, 16, 4);
2910 }
2911
2912 static void test_pack_PEMRFRAMERGN(void)
2913 {
2914     /* PEMRFRAMERGN */
2915     TEST_TYPE(PEMRFRAMERGN, 4, 4);
2916     TEST_TYPE_POINTER(PEMRFRAMERGN, 44, 4);
2917 }
2918
2919 static void test_pack_PEMRGDICOMMENT(void)
2920 {
2921     /* PEMRGDICOMMENT */
2922     TEST_TYPE(PEMRGDICOMMENT, 4, 4);
2923     TEST_TYPE_POINTER(PEMRGDICOMMENT, 16, 4);
2924 }
2925
2926 static void test_pack_PEMRGLSBOUNDEDRECORD(void)
2927 {
2928     /* PEMRGLSBOUNDEDRECORD */
2929     TEST_TYPE(PEMRGLSBOUNDEDRECORD, 4, 4);
2930     TEST_TYPE_POINTER(PEMRGLSBOUNDEDRECORD, 32, 4);
2931 }
2932
2933 static void test_pack_PEMRGLSRECORD(void)
2934 {
2935     /* PEMRGLSRECORD */
2936     TEST_TYPE(PEMRGLSRECORD, 4, 4);
2937     TEST_TYPE_POINTER(PEMRGLSRECORD, 16, 4);
2938 }
2939
2940 static void test_pack_PEMRINTERSECTCLIPRECT(void)
2941 {
2942     /* PEMRINTERSECTCLIPRECT */
2943     TEST_TYPE(PEMRINTERSECTCLIPRECT, 4, 4);
2944     TEST_TYPE_POINTER(PEMRINTERSECTCLIPRECT, 24, 4);
2945 }
2946
2947 static void test_pack_PEMRINVERTRGN(void)
2948 {
2949     /* PEMRINVERTRGN */
2950     TEST_TYPE(PEMRINVERTRGN, 4, 4);
2951     TEST_TYPE_POINTER(PEMRINVERTRGN, 32, 4);
2952 }
2953
2954 static void test_pack_PEMRLINETO(void)
2955 {
2956     /* PEMRLINETO */
2957     TEST_TYPE(PEMRLINETO, 4, 4);
2958     TEST_TYPE_POINTER(PEMRLINETO, 16, 4);
2959 }
2960
2961 static void test_pack_PEMRMASKBLT(void)
2962 {
2963     /* PEMRMASKBLT */
2964     TEST_TYPE(PEMRMASKBLT, 4, 4);
2965     TEST_TYPE_POINTER(PEMRMASKBLT, 128, 4);
2966 }
2967
2968 static void test_pack_PEMRMODIFYWORLDTRANSFORM(void)
2969 {
2970     /* PEMRMODIFYWORLDTRANSFORM */
2971     TEST_TYPE(PEMRMODIFYWORLDTRANSFORM, 4, 4);
2972     TEST_TYPE_POINTER(PEMRMODIFYWORLDTRANSFORM, 36, 4);
2973 }
2974
2975 static void test_pack_PEMRMOVETOEX(void)
2976 {
2977     /* PEMRMOVETOEX */
2978     TEST_TYPE(PEMRMOVETOEX, 4, 4);
2979     TEST_TYPE_POINTER(PEMRMOVETOEX, 16, 4);
2980 }
2981
2982 static void test_pack_PEMROFFSETCLIPRGN(void)
2983 {
2984     /* PEMROFFSETCLIPRGN */
2985     TEST_TYPE(PEMROFFSETCLIPRGN, 4, 4);
2986     TEST_TYPE_POINTER(PEMROFFSETCLIPRGN, 16, 4);
2987 }
2988
2989 static void test_pack_PEMRPAINTRGN(void)
2990 {
2991     /* PEMRPAINTRGN */
2992     TEST_TYPE(PEMRPAINTRGN, 4, 4);
2993     TEST_TYPE_POINTER(PEMRPAINTRGN, 32, 4);
2994 }
2995
2996 static void test_pack_PEMRPIE(void)
2997 {
2998     /* PEMRPIE */
2999     TEST_TYPE(PEMRPIE, 4, 4);
3000     TEST_TYPE_POINTER(PEMRPIE, 40, 4);
3001 }
3002
3003 static void test_pack_PEMRPIXELFORMAT(void)
3004 {
3005     /* PEMRPIXELFORMAT */
3006     TEST_TYPE(PEMRPIXELFORMAT, 4, 4);
3007     TEST_TYPE_POINTER(PEMRPIXELFORMAT, 48, 4);
3008 }
3009
3010 static void test_pack_PEMRPLGBLT(void)
3011 {
3012     /* PEMRPLGBLT */
3013     TEST_TYPE(PEMRPLGBLT, 4, 4);
3014     TEST_TYPE_POINTER(PEMRPLGBLT, 140, 4);
3015 }
3016
3017 static void test_pack_PEMRPOLYBEZIER(void)
3018 {
3019     /* PEMRPOLYBEZIER */
3020     TEST_TYPE(PEMRPOLYBEZIER, 4, 4);
3021     TEST_TYPE_POINTER(PEMRPOLYBEZIER, 36, 4);
3022 }
3023
3024 static void test_pack_PEMRPOLYBEZIER16(void)
3025 {
3026     /* PEMRPOLYBEZIER16 */
3027     TEST_TYPE(PEMRPOLYBEZIER16, 4, 4);
3028     TEST_TYPE_POINTER(PEMRPOLYBEZIER16, 32, 4);
3029 }
3030
3031 static void test_pack_PEMRPOLYBEZIERTO(void)
3032 {
3033     /* PEMRPOLYBEZIERTO */
3034     TEST_TYPE(PEMRPOLYBEZIERTO, 4, 4);
3035     TEST_TYPE_POINTER(PEMRPOLYBEZIERTO, 36, 4);
3036 }
3037
3038 static void test_pack_PEMRPOLYBEZIERTO16(void)
3039 {
3040     /* PEMRPOLYBEZIERTO16 */
3041     TEST_TYPE(PEMRPOLYBEZIERTO16, 4, 4);
3042     TEST_TYPE_POINTER(PEMRPOLYBEZIERTO16, 32, 4);
3043 }
3044
3045 static void test_pack_PEMRPOLYDRAW(void)
3046 {
3047     /* PEMRPOLYDRAW */
3048     TEST_TYPE(PEMRPOLYDRAW, 4, 4);
3049     TEST_TYPE_POINTER(PEMRPOLYDRAW, 40, 4);
3050 }
3051
3052 static void test_pack_PEMRPOLYDRAW16(void)
3053 {
3054     /* PEMRPOLYDRAW16 */
3055     TEST_TYPE(PEMRPOLYDRAW16, 4, 4);
3056     TEST_TYPE_POINTER(PEMRPOLYDRAW16, 36, 4);
3057 }
3058
3059 static void test_pack_PEMRPOLYGON(void)
3060 {
3061     /* PEMRPOLYGON */
3062     TEST_TYPE(PEMRPOLYGON, 4, 4);
3063     TEST_TYPE_POINTER(PEMRPOLYGON, 36, 4);
3064 }
3065
3066 static void test_pack_PEMRPOLYGON16(void)
3067 {
3068     /* PEMRPOLYGON16 */
3069     TEST_TYPE(PEMRPOLYGON16, 4, 4);
3070     TEST_TYPE_POINTER(PEMRPOLYGON16, 32, 4);
3071 }
3072
3073 static void test_pack_PEMRPOLYLINE(void)
3074 {
3075     /* PEMRPOLYLINE */
3076     TEST_TYPE(PEMRPOLYLINE, 4, 4);
3077     TEST_TYPE_POINTER(PEMRPOLYLINE, 36, 4);
3078 }
3079
3080 static void test_pack_PEMRPOLYLINE16(void)
3081 {
3082     /* PEMRPOLYLINE16 */
3083     TEST_TYPE(PEMRPOLYLINE16, 4, 4);
3084     TEST_TYPE_POINTER(PEMRPOLYLINE16, 32, 4);
3085 }
3086
3087 static void test_pack_PEMRPOLYLINETO(void)
3088 {
3089     /* PEMRPOLYLINETO */
3090     TEST_TYPE(PEMRPOLYLINETO, 4, 4);
3091     TEST_TYPE_POINTER(PEMRPOLYLINETO, 36, 4);
3092 }
3093
3094 static void test_pack_PEMRPOLYLINETO16(void)
3095 {
3096     /* PEMRPOLYLINETO16 */
3097     TEST_TYPE(PEMRPOLYLINETO16, 4, 4);
3098     TEST_TYPE_POINTER(PEMRPOLYLINETO16, 32, 4);
3099 }
3100
3101 static void test_pack_PEMRPOLYPOLYGON(void)
3102 {
3103     /* PEMRPOLYPOLYGON */
3104     TEST_TYPE(PEMRPOLYPOLYGON, 4, 4);
3105     TEST_TYPE_POINTER(PEMRPOLYPOLYGON, 44, 4);
3106 }
3107
3108 static void test_pack_PEMRPOLYPOLYGON16(void)
3109 {
3110     /* PEMRPOLYPOLYGON16 */
3111     TEST_TYPE(PEMRPOLYPOLYGON16, 4, 4);
3112     TEST_TYPE_POINTER(PEMRPOLYPOLYGON16, 40, 4);
3113 }
3114
3115 static void test_pack_PEMRPOLYPOLYLINE(void)
3116 {
3117     /* PEMRPOLYPOLYLINE */
3118     TEST_TYPE(PEMRPOLYPOLYLINE, 4, 4);
3119     TEST_TYPE_POINTER(PEMRPOLYPOLYLINE, 44, 4);
3120 }
3121
3122 static void test_pack_PEMRPOLYPOLYLINE16(void)
3123 {
3124     /* PEMRPOLYPOLYLINE16 */
3125     TEST_TYPE(PEMRPOLYPOLYLINE16, 4, 4);
3126     TEST_TYPE_POINTER(PEMRPOLYPOLYLINE16, 40, 4);
3127 }
3128
3129 static void test_pack_PEMRPOLYTEXTOUTA(void)
3130 {
3131     /* PEMRPOLYTEXTOUTA */
3132     TEST_TYPE(PEMRPOLYTEXTOUTA, 4, 4);
3133     TEST_TYPE_POINTER(PEMRPOLYTEXTOUTA, 80, 4);
3134 }
3135
3136 static void test_pack_PEMRPOLYTEXTOUTW(void)
3137 {
3138     /* PEMRPOLYTEXTOUTW */
3139     TEST_TYPE(PEMRPOLYTEXTOUTW, 4, 4);
3140     TEST_TYPE_POINTER(PEMRPOLYTEXTOUTW, 80, 4);
3141 }
3142
3143 static void test_pack_PEMRREALIZEPALETTE(void)
3144 {
3145     /* PEMRREALIZEPALETTE */
3146     TEST_TYPE(PEMRREALIZEPALETTE, 4, 4);
3147     TEST_TYPE_POINTER(PEMRREALIZEPALETTE, 8, 4);
3148 }
3149
3150 static void test_pack_PEMRRECTANGLE(void)
3151 {
3152     /* PEMRRECTANGLE */
3153     TEST_TYPE(PEMRRECTANGLE, 4, 4);
3154     TEST_TYPE_POINTER(PEMRRECTANGLE, 24, 4);
3155 }
3156
3157 static void test_pack_PEMRRESIZEPALETTE(void)
3158 {
3159     /* PEMRRESIZEPALETTE */
3160     TEST_TYPE(PEMRRESIZEPALETTE, 4, 4);
3161     TEST_TYPE_POINTER(PEMRRESIZEPALETTE, 16, 4);
3162 }
3163
3164 static void test_pack_PEMRRESTOREDC(void)
3165 {
3166     /* PEMRRESTOREDC */
3167     TEST_TYPE(PEMRRESTOREDC, 4, 4);
3168     TEST_TYPE_POINTER(PEMRRESTOREDC, 12, 4);
3169 }
3170
3171 static void test_pack_PEMRROUNDRECT(void)
3172 {
3173     /* PEMRROUNDRECT */
3174     TEST_TYPE(PEMRROUNDRECT, 4, 4);
3175     TEST_TYPE_POINTER(PEMRROUNDRECT, 32, 4);
3176 }
3177
3178 static void test_pack_PEMRSAVEDC(void)
3179 {
3180     /* PEMRSAVEDC */
3181     TEST_TYPE(PEMRSAVEDC, 4, 4);
3182     TEST_TYPE_POINTER(PEMRSAVEDC, 8, 4);
3183 }
3184
3185 static void test_pack_PEMRSCALEVIEWPORTEXTEX(void)
3186 {
3187     /* PEMRSCALEVIEWPORTEXTEX */
3188     TEST_TYPE(PEMRSCALEVIEWPORTEXTEX, 4, 4);
3189     TEST_TYPE_POINTER(PEMRSCALEVIEWPORTEXTEX, 24, 4);
3190 }
3191
3192 static void test_pack_PEMRSCALEWINDOWEXTEX(void)
3193 {
3194     /* PEMRSCALEWINDOWEXTEX */
3195     TEST_TYPE(PEMRSCALEWINDOWEXTEX, 4, 4);
3196     TEST_TYPE_POINTER(PEMRSCALEWINDOWEXTEX, 24, 4);
3197 }
3198
3199 static void test_pack_PEMRSELECTCLIPPATH(void)
3200 {
3201     /* PEMRSELECTCLIPPATH */
3202     TEST_TYPE(PEMRSELECTCLIPPATH, 4, 4);
3203     TEST_TYPE_POINTER(PEMRSELECTCLIPPATH, 12, 4);
3204 }
3205
3206 static void test_pack_PEMRSELECTCOLORSPACE(void)
3207 {
3208     /* PEMRSELECTCOLORSPACE */
3209     TEST_TYPE(PEMRSELECTCOLORSPACE, 4, 4);
3210     TEST_TYPE_POINTER(PEMRSELECTCOLORSPACE, 12, 4);
3211 }
3212
3213 static void test_pack_PEMRSELECTOBJECT(void)
3214 {
3215     /* PEMRSELECTOBJECT */
3216     TEST_TYPE(PEMRSELECTOBJECT, 4, 4);
3217     TEST_TYPE_POINTER(PEMRSELECTOBJECT, 12, 4);
3218 }
3219
3220 static void test_pack_PEMRSELECTPALETTE(void)
3221 {
3222     /* PEMRSELECTPALETTE */
3223     TEST_TYPE(PEMRSELECTPALETTE, 4, 4);
3224     TEST_TYPE_POINTER(PEMRSELECTPALETTE, 12, 4);
3225 }
3226
3227 static void test_pack_PEMRSETARCDIRECTION(void)
3228 {
3229     /* PEMRSETARCDIRECTION */
3230     TEST_TYPE(PEMRSETARCDIRECTION, 4, 4);
3231     TEST_TYPE_POINTER(PEMRSETARCDIRECTION, 12, 4);
3232 }
3233
3234 static void test_pack_PEMRSETBKCOLOR(void)
3235 {
3236     /* PEMRSETBKCOLOR */
3237     TEST_TYPE(PEMRSETBKCOLOR, 4, 4);
3238     TEST_TYPE_POINTER(PEMRSETBKCOLOR, 12, 4);
3239 }
3240
3241 static void test_pack_PEMRSETBKMODE(void)
3242 {
3243     /* PEMRSETBKMODE */
3244     TEST_TYPE(PEMRSETBKMODE, 4, 4);
3245     TEST_TYPE_POINTER(PEMRSETBKMODE, 12, 4);
3246 }
3247
3248 static void test_pack_PEMRSETBRUSHORGEX(void)
3249 {
3250     /* PEMRSETBRUSHORGEX */
3251     TEST_TYPE(PEMRSETBRUSHORGEX, 4, 4);
3252     TEST_TYPE_POINTER(PEMRSETBRUSHORGEX, 16, 4);
3253 }
3254
3255 static void test_pack_PEMRSETCOLORADJUSTMENT(void)
3256 {
3257     /* PEMRSETCOLORADJUSTMENT */
3258     TEST_TYPE(PEMRSETCOLORADJUSTMENT, 4, 4);
3259     TEST_TYPE_POINTER(PEMRSETCOLORADJUSTMENT, 32, 4);
3260 }
3261
3262 static void test_pack_PEMRSETCOLORSPACE(void)
3263 {
3264     /* PEMRSETCOLORSPACE */
3265     TEST_TYPE(PEMRSETCOLORSPACE, 4, 4);
3266     TEST_TYPE_POINTER(PEMRSETCOLORSPACE, 12, 4);
3267 }
3268
3269 static void test_pack_PEMRSETDIBITSTODEVICE(void)
3270 {
3271     /* PEMRSETDIBITSTODEVICE */
3272     TEST_TYPE(PEMRSETDIBITSTODEVICE, 4, 4);
3273     TEST_TYPE_POINTER(PEMRSETDIBITSTODEVICE, 76, 4);
3274 }
3275
3276 static void test_pack_PEMRSETICMMODE(void)
3277 {
3278     /* PEMRSETICMMODE */
3279     TEST_TYPE(PEMRSETICMMODE, 4, 4);
3280     TEST_TYPE_POINTER(PEMRSETICMMODE, 12, 4);
3281 }
3282
3283 static void test_pack_PEMRSETLAYOUT(void)
3284 {
3285     /* PEMRSETLAYOUT */
3286     TEST_TYPE(PEMRSETLAYOUT, 4, 4);
3287     TEST_TYPE_POINTER(PEMRSETLAYOUT, 12, 4);
3288 }
3289
3290 static void test_pack_PEMRSETMAPMODE(void)
3291 {
3292     /* PEMRSETMAPMODE */
3293     TEST_TYPE(PEMRSETMAPMODE, 4, 4);
3294     TEST_TYPE_POINTER(PEMRSETMAPMODE, 12, 4);
3295 }
3296
3297 static void test_pack_PEMRSETMAPPERFLAGS(void)
3298 {
3299     /* PEMRSETMAPPERFLAGS */
3300     TEST_TYPE(PEMRSETMAPPERFLAGS, 4, 4);
3301     TEST_TYPE_POINTER(PEMRSETMAPPERFLAGS, 12, 4);
3302 }
3303
3304 static void test_pack_PEMRSETMETARGN(void)
3305 {
3306     /* PEMRSETMETARGN */
3307     TEST_TYPE(PEMRSETMETARGN, 4, 4);
3308     TEST_TYPE_POINTER(PEMRSETMETARGN, 8, 4);
3309 }
3310
3311 static void test_pack_PEMRSETMITERLIMIT(void)
3312 {
3313     /* PEMRSETMITERLIMIT */
3314     TEST_TYPE(PEMRSETMITERLIMIT, 4, 4);
3315     TEST_TYPE_POINTER(PEMRSETMITERLIMIT, 12, 4);
3316 }
3317
3318 static void test_pack_PEMRSETPALETTEENTRIES(void)
3319 {
3320     /* PEMRSETPALETTEENTRIES */
3321     TEST_TYPE(PEMRSETPALETTEENTRIES, 4, 4);
3322     TEST_TYPE_POINTER(PEMRSETPALETTEENTRIES, 24, 4);
3323 }
3324
3325 static void test_pack_PEMRSETPIXELV(void)
3326 {
3327     /* PEMRSETPIXELV */
3328     TEST_TYPE(PEMRSETPIXELV, 4, 4);
3329     TEST_TYPE_POINTER(PEMRSETPIXELV, 20, 4);
3330 }
3331
3332 static void test_pack_PEMRSETPOLYFILLMODE(void)
3333 {
3334     /* PEMRSETPOLYFILLMODE */
3335     TEST_TYPE(PEMRSETPOLYFILLMODE, 4, 4);
3336     TEST_TYPE_POINTER(PEMRSETPOLYFILLMODE, 12, 4);
3337 }
3338
3339 static void test_pack_PEMRSETROP2(void)
3340 {
3341     /* PEMRSETROP2 */
3342     TEST_TYPE(PEMRSETROP2, 4, 4);
3343     TEST_TYPE_POINTER(PEMRSETROP2, 12, 4);
3344 }
3345
3346 static void test_pack_PEMRSETSTRETCHBLTMODE(void)
3347 {
3348     /* PEMRSETSTRETCHBLTMODE */
3349     TEST_TYPE(PEMRSETSTRETCHBLTMODE, 4, 4);
3350     TEST_TYPE_POINTER(PEMRSETSTRETCHBLTMODE, 12, 4);
3351 }
3352
3353 static void test_pack_PEMRSETTEXTALIGN(void)
3354 {
3355     /* PEMRSETTEXTALIGN */
3356     TEST_TYPE(PEMRSETTEXTALIGN, 4, 4);
3357     TEST_TYPE_POINTER(PEMRSETTEXTALIGN, 12, 4);
3358 }
3359
3360 static void test_pack_PEMRSETTEXTCOLOR(void)
3361 {
3362     /* PEMRSETTEXTCOLOR */
3363     TEST_TYPE(PEMRSETTEXTCOLOR, 4, 4);
3364     TEST_TYPE_POINTER(PEMRSETTEXTCOLOR, 12, 4);
3365 }
3366
3367 static void test_pack_PEMRSETVIEWPORTEXTEX(void)
3368 {
3369     /* PEMRSETVIEWPORTEXTEX */
3370     TEST_TYPE(PEMRSETVIEWPORTEXTEX, 4, 4);
3371     TEST_TYPE_POINTER(PEMRSETVIEWPORTEXTEX, 16, 4);
3372 }
3373
3374 static void test_pack_PEMRSETVIEWPORTORGEX(void)
3375 {
3376     /* PEMRSETVIEWPORTORGEX */
3377     TEST_TYPE(PEMRSETVIEWPORTORGEX, 4, 4);
3378     TEST_TYPE_POINTER(PEMRSETVIEWPORTORGEX, 16, 4);
3379 }
3380
3381 static void test_pack_PEMRSETWINDOWEXTEX(void)
3382 {
3383     /* PEMRSETWINDOWEXTEX */
3384     TEST_TYPE(PEMRSETWINDOWEXTEX, 4, 4);
3385     TEST_TYPE_POINTER(PEMRSETWINDOWEXTEX, 16, 4);
3386 }
3387
3388 static void test_pack_PEMRSETWINDOWORGEX(void)
3389 {
3390     /* PEMRSETWINDOWORGEX */
3391     TEST_TYPE(PEMRSETWINDOWORGEX, 4, 4);
3392     TEST_TYPE_POINTER(PEMRSETWINDOWORGEX, 16, 4);
3393 }
3394
3395 static void test_pack_PEMRSETWORLDTRANSFORM(void)
3396 {
3397     /* PEMRSETWORLDTRANSFORM */
3398     TEST_TYPE(PEMRSETWORLDTRANSFORM, 4, 4);
3399     TEST_TYPE_POINTER(PEMRSETWORLDTRANSFORM, 32, 4);
3400 }
3401
3402 static void test_pack_PEMRSTRETCHBLT(void)
3403 {
3404     /* PEMRSTRETCHBLT */
3405     TEST_TYPE(PEMRSTRETCHBLT, 4, 4);
3406     TEST_TYPE_POINTER(PEMRSTRETCHBLT, 108, 4);
3407 }
3408
3409 static void test_pack_PEMRSTRETCHDIBITS(void)
3410 {
3411     /* PEMRSTRETCHDIBITS */
3412     TEST_TYPE(PEMRSTRETCHDIBITS, 4, 4);
3413     TEST_TYPE_POINTER(PEMRSTRETCHDIBITS, 80, 4);
3414 }
3415
3416 static void test_pack_PEMRSTROKEANDFILLPATH(void)
3417 {
3418     /* PEMRSTROKEANDFILLPATH */
3419     TEST_TYPE(PEMRSTROKEANDFILLPATH, 4, 4);
3420     TEST_TYPE_POINTER(PEMRSTROKEANDFILLPATH, 24, 4);
3421 }
3422
3423 static void test_pack_PEMRSTROKEPATH(void)
3424 {
3425     /* PEMRSTROKEPATH */
3426     TEST_TYPE(PEMRSTROKEPATH, 4, 4);
3427     TEST_TYPE_POINTER(PEMRSTROKEPATH, 24, 4);
3428 }
3429
3430 static void test_pack_PEMRTEXT(void)
3431 {
3432     /* PEMRTEXT */
3433     TEST_TYPE(PEMRTEXT, 4, 4);
3434     TEST_TYPE_POINTER(PEMRTEXT, 40, 4);
3435 }
3436
3437 static void test_pack_PEMRWIDENPATH(void)
3438 {
3439     /* PEMRWIDENPATH */
3440     TEST_TYPE(PEMRWIDENPATH, 4, 4);
3441     TEST_TYPE_POINTER(PEMRWIDENPATH, 8, 4);
3442 }
3443
3444 static void test_pack_PENHMETAHEADER(void)
3445 {
3446     /* PENHMETAHEADER */
3447     TEST_TYPE(PENHMETAHEADER, 4, 4);
3448     TEST_TYPE_POINTER(PENHMETAHEADER, 108, 4);
3449 }
3450
3451 static void test_pack_PEXTLOGFONTA(void)
3452 {
3453     /* PEXTLOGFONTA */
3454     TEST_TYPE(PEXTLOGFONTA, 4, 4);
3455     TEST_TYPE_POINTER(PEXTLOGFONTA, 192, 4);
3456 }
3457
3458 static void test_pack_PEXTLOGFONTW(void)
3459 {
3460     /* PEXTLOGFONTW */
3461     TEST_TYPE(PEXTLOGFONTW, 4, 4);
3462     TEST_TYPE_POINTER(PEXTLOGFONTW, 320, 4);
3463 }
3464
3465 static void test_pack_PEXTLOGPEN(void)
3466 {
3467     /* PEXTLOGPEN */
3468     TEST_TYPE(PEXTLOGPEN, 4, 4);
3469     TEST_TYPE_POINTER(PEXTLOGPEN, 28, 4);
3470 }
3471
3472 static void test_pack_PFONTSIGNATURE(void)
3473 {
3474     /* PFONTSIGNATURE */
3475     TEST_TYPE(PFONTSIGNATURE, 4, 4);
3476     TEST_TYPE_POINTER(PFONTSIGNATURE, 24, 4);
3477 }
3478
3479 static void test_pack_PGRADIENT_RECT(void)
3480 {
3481     /* PGRADIENT_RECT */
3482     TEST_TYPE(PGRADIENT_RECT, 4, 4);
3483     TEST_TYPE_POINTER(PGRADIENT_RECT, 8, 4);
3484 }
3485
3486 static void test_pack_PGRADIENT_TRIANGLE(void)
3487 {
3488     /* PGRADIENT_TRIANGLE */
3489     TEST_TYPE(PGRADIENT_TRIANGLE, 4, 4);
3490     TEST_TYPE_POINTER(PGRADIENT_TRIANGLE, 12, 4);
3491 }
3492
3493 static void test_pack_PHANDLETABLE(void)
3494 {
3495     /* PHANDLETABLE */
3496     TEST_TYPE(PHANDLETABLE, 4, 4);
3497     TEST_TYPE_POINTER(PHANDLETABLE, 4, 4);
3498 }
3499
3500 static void test_pack_PIXELFORMATDESCRIPTOR(void)
3501 {
3502     /* PIXELFORMATDESCRIPTOR (pack 4) */
3503     TEST_TYPE(PIXELFORMATDESCRIPTOR, 40, 4);
3504     TEST_FIELD(PIXELFORMATDESCRIPTOR, WORD, nSize, 0, 2, 2);
3505     TEST_FIELD(PIXELFORMATDESCRIPTOR, WORD, nVersion, 2, 2, 2);
3506     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwFlags, 4, 4, 4);
3507     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, iPixelType, 8, 1, 1);
3508     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cColorBits, 9, 1, 1);
3509     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cRedBits, 10, 1, 1);
3510     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cRedShift, 11, 1, 1);
3511     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cGreenBits, 12, 1, 1);
3512     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cGreenShift, 13, 1, 1);
3513     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cBlueBits, 14, 1, 1);
3514     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cBlueShift, 15, 1, 1);
3515     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAlphaBits, 16, 1, 1);
3516     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAlphaShift, 17, 1, 1);
3517     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumBits, 18, 1, 1);
3518     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumRedBits, 19, 1, 1);
3519     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumGreenBits, 20, 1, 1);
3520     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumBlueBits, 21, 1, 1);
3521     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumAlphaBits, 22, 1, 1);
3522     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cDepthBits, 23, 1, 1);
3523     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cStencilBits, 24, 1, 1);
3524     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAuxBuffers, 25, 1, 1);
3525     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, iLayerType, 26, 1, 1);
3526     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, bReserved, 27, 1, 1);
3527     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwLayerMask, 28, 4, 4);
3528     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwVisibleMask, 32, 4, 4);
3529     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwDamageMask, 36, 4, 4);
3530 }
3531
3532 static void test_pack_PLOCALESIGNATURE(void)
3533 {
3534     /* PLOCALESIGNATURE */
3535     TEST_TYPE(PLOCALESIGNATURE, 4, 4);
3536     TEST_TYPE_POINTER(PLOCALESIGNATURE, 32, 4);
3537 }
3538
3539 static void test_pack_PLOGBRUSH(void)
3540 {
3541     /* PLOGBRUSH */
3542     TEST_TYPE(PLOGBRUSH, 4, 4);
3543     TEST_TYPE_POINTER(PLOGBRUSH, 12, 4);
3544 }
3545
3546 static void test_pack_PLOGFONTA(void)
3547 {
3548     /* PLOGFONTA */
3549     TEST_TYPE(PLOGFONTA, 4, 4);
3550     TEST_TYPE_POINTER(PLOGFONTA, 60, 4);
3551 }
3552
3553 static void test_pack_PLOGFONTW(void)
3554 {
3555     /* PLOGFONTW */
3556     TEST_TYPE(PLOGFONTW, 4, 4);
3557     TEST_TYPE_POINTER(PLOGFONTW, 92, 4);
3558 }
3559
3560 static void test_pack_PMETAHEADER(void)
3561 {
3562     /* PMETAHEADER */
3563     TEST_TYPE(PMETAHEADER, 4, 4);
3564     TEST_TYPE_POINTER(PMETAHEADER, 18, 2);
3565 }
3566
3567 static void test_pack_PMETARECORD(void)
3568 {
3569     /* PMETARECORD */
3570     TEST_TYPE(PMETARECORD, 4, 4);
3571     TEST_TYPE_POINTER(PMETARECORD, 8, 4);
3572 }
3573
3574 static void test_pack_PNEWTEXTMETRICA(void)
3575 {
3576     /* PNEWTEXTMETRICA */
3577     TEST_TYPE(PNEWTEXTMETRICA, 4, 4);
3578     TEST_TYPE_POINTER(PNEWTEXTMETRICA, 72, 4);
3579 }
3580
3581 static void test_pack_PNEWTEXTMETRICW(void)
3582 {
3583     /* PNEWTEXTMETRICW */
3584     TEST_TYPE(PNEWTEXTMETRICW, 4, 4);
3585     TEST_TYPE_POINTER(PNEWTEXTMETRICW, 76, 4);
3586 }
3587
3588 static void test_pack_POINTFX(void)
3589 {
3590     /* POINTFX (pack 4) */
3591     TEST_TYPE(POINTFX, 8, 2);
3592     TEST_FIELD(POINTFX, FIXED, x, 0, 4, 2);
3593     TEST_FIELD(POINTFX, FIXED, y, 4, 4, 2);
3594 }
3595
3596 static void test_pack_POLYTEXTA(void)
3597 {
3598     /* POLYTEXTA (pack 4) */
3599     TEST_TYPE(POLYTEXTA, 40, 4);
3600     TEST_FIELD(POLYTEXTA, INT, x, 0, 4, 4);
3601     TEST_FIELD(POLYTEXTA, INT, y, 4, 4, 4);
3602     TEST_FIELD(POLYTEXTA, UINT, n, 8, 4, 4);
3603     TEST_FIELD(POLYTEXTA, LPCSTR, lpstr, 12, 4, 4);
3604     TEST_FIELD(POLYTEXTA, UINT, uiFlags, 16, 4, 4);
3605     TEST_FIELD(POLYTEXTA, RECT, rcl, 20, 16, 4);
3606     TEST_FIELD(POLYTEXTA, INT *, pdx, 36, 4, 4);
3607 }
3608
3609 static void test_pack_POLYTEXTW(void)
3610 {
3611     /* POLYTEXTW (pack 4) */
3612     TEST_TYPE(POLYTEXTW, 40, 4);
3613     TEST_FIELD(POLYTEXTW, INT, x, 0, 4, 4);
3614     TEST_FIELD(POLYTEXTW, INT, y, 4, 4, 4);
3615     TEST_FIELD(POLYTEXTW, UINT, n, 8, 4, 4);
3616     TEST_FIELD(POLYTEXTW, LPCWSTR, lpstr, 12, 4, 4);
3617     TEST_FIELD(POLYTEXTW, UINT, uiFlags, 16, 4, 4);
3618     TEST_FIELD(POLYTEXTW, RECT, rcl, 20, 16, 4);
3619     TEST_FIELD(POLYTEXTW, INT *, pdx, 36, 4, 4);
3620 }
3621
3622 static void test_pack_POUTLINETEXTMETRICA(void)
3623 {
3624     /* POUTLINETEXTMETRICA */
3625     TEST_TYPE(POUTLINETEXTMETRICA, 4, 4);
3626     TEST_TYPE_POINTER(POUTLINETEXTMETRICA, 212, 4);
3627 }
3628
3629 static void test_pack_POUTLINETEXTMETRICW(void)
3630 {
3631     /* POUTLINETEXTMETRICW */
3632     TEST_TYPE(POUTLINETEXTMETRICW, 4, 4);
3633     TEST_TYPE_POINTER(POUTLINETEXTMETRICW, 216, 4);
3634 }
3635
3636 static void test_pack_PPELARRAY(void)
3637 {
3638     /* PPELARRAY */
3639     TEST_TYPE(PPELARRAY, 4, 4);
3640     TEST_TYPE_POINTER(PPELARRAY, 20, 4);
3641 }
3642
3643 static void test_pack_PPIXELFORMATDESCRIPTOR(void)
3644 {
3645     /* PPIXELFORMATDESCRIPTOR */
3646     TEST_TYPE(PPIXELFORMATDESCRIPTOR, 4, 4);
3647     TEST_TYPE_POINTER(PPIXELFORMATDESCRIPTOR, 40, 4);
3648 }
3649
3650 static void test_pack_PPOLYTEXTA(void)
3651 {
3652     /* PPOLYTEXTA */
3653     TEST_TYPE(PPOLYTEXTA, 4, 4);
3654     TEST_TYPE_POINTER(PPOLYTEXTA, 40, 4);
3655 }
3656
3657 static void test_pack_PPOLYTEXTW(void)
3658 {
3659     /* PPOLYTEXTW */
3660     TEST_TYPE(PPOLYTEXTW, 4, 4);
3661     TEST_TYPE_POINTER(PPOLYTEXTW, 40, 4);
3662 }
3663
3664 static void test_pack_PRGNDATA(void)
3665 {
3666     /* PRGNDATA */
3667     TEST_TYPE(PRGNDATA, 4, 4);
3668     TEST_TYPE_POINTER(PRGNDATA, 36, 4);
3669 }
3670
3671 static void test_pack_PRGNDATAHEADER(void)
3672 {
3673     /* PRGNDATAHEADER */
3674     TEST_TYPE(PRGNDATAHEADER, 4, 4);
3675     TEST_TYPE_POINTER(PRGNDATAHEADER, 32, 4);
3676 }
3677
3678 static void test_pack_PTEXTMETRICA(void)
3679 {
3680     /* PTEXTMETRICA */
3681     TEST_TYPE(PTEXTMETRICA, 4, 4);
3682     TEST_TYPE_POINTER(PTEXTMETRICA, 56, 4);
3683 }
3684
3685 static void test_pack_PTEXTMETRICW(void)
3686 {
3687     /* PTEXTMETRICW */
3688     TEST_TYPE(PTEXTMETRICW, 4, 4);
3689     TEST_TYPE_POINTER(PTEXTMETRICW, 60, 4);
3690 }
3691
3692 static void test_pack_PTRIVERTEX(void)
3693 {
3694     /* PTRIVERTEX */
3695     TEST_TYPE(PTRIVERTEX, 4, 4);
3696     TEST_TYPE_POINTER(PTRIVERTEX, 16, 4);
3697 }
3698
3699 static void test_pack_PXFORM(void)
3700 {
3701     /* PXFORM */
3702     TEST_TYPE(PXFORM, 4, 4);
3703     TEST_TYPE_POINTER(PXFORM, 24, 4);
3704 }
3705
3706 static void test_pack_RASTERIZER_STATUS(void)
3707 {
3708     /* RASTERIZER_STATUS (pack 4) */
3709     TEST_TYPE(RASTERIZER_STATUS, 6, 2);
3710     TEST_FIELD(RASTERIZER_STATUS, SHORT, nSize, 0, 2, 2);
3711     TEST_FIELD(RASTERIZER_STATUS, SHORT, wFlags, 2, 2, 2);
3712     TEST_FIELD(RASTERIZER_STATUS, SHORT, nLanguageID, 4, 2, 2);
3713 }
3714
3715 static void test_pack_RGBQUAD(void)
3716 {
3717     /* RGBQUAD (pack 4) */
3718     TEST_TYPE(RGBQUAD, 4, 1);
3719     TEST_FIELD(RGBQUAD, BYTE, rgbBlue, 0, 1, 1);
3720     TEST_FIELD(RGBQUAD, BYTE, rgbGreen, 1, 1, 1);
3721     TEST_FIELD(RGBQUAD, BYTE, rgbRed, 2, 1, 1);
3722     TEST_FIELD(RGBQUAD, BYTE, rgbReserved, 3, 1, 1);
3723 }
3724
3725 static void test_pack_RGBTRIPLE(void)
3726 {
3727     /* RGBTRIPLE (pack 4) */
3728     TEST_TYPE(RGBTRIPLE, 3, 1);
3729     TEST_FIELD(RGBTRIPLE, BYTE, rgbtBlue, 0, 1, 1);
3730     TEST_FIELD(RGBTRIPLE, BYTE, rgbtGreen, 1, 1, 1);
3731     TEST_FIELD(RGBTRIPLE, BYTE, rgbtRed, 2, 1, 1);
3732 }
3733
3734 static void test_pack_RGNDATA(void)
3735 {
3736     /* RGNDATA (pack 4) */
3737     TEST_TYPE(RGNDATA, 36, 4);
3738     TEST_FIELD(RGNDATA, RGNDATAHEADER, rdh, 0, 32, 4);
3739     TEST_FIELD(RGNDATA, char[1], Buffer, 32, 1, 1);
3740 }
3741
3742 static void test_pack_RGNDATAHEADER(void)
3743 {
3744     /* RGNDATAHEADER (pack 4) */
3745     TEST_TYPE(RGNDATAHEADER, 32, 4);
3746     TEST_FIELD(RGNDATAHEADER, DWORD, dwSize, 0, 4, 4);
3747     TEST_FIELD(RGNDATAHEADER, DWORD, iType, 4, 4, 4);
3748     TEST_FIELD(RGNDATAHEADER, DWORD, nCount, 8, 4, 4);
3749     TEST_FIELD(RGNDATAHEADER, DWORD, nRgnSize, 12, 4, 4);
3750     TEST_FIELD(RGNDATAHEADER, RECT, rcBound, 16, 16, 4);
3751 }
3752
3753 static void test_pack_TEXTMETRICA(void)
3754 {
3755     /* TEXTMETRICA (pack 4) */
3756     TEST_TYPE(TEXTMETRICA, 56, 4);
3757     TEST_FIELD(TEXTMETRICA, LONG, tmHeight, 0, 4, 4);
3758     TEST_FIELD(TEXTMETRICA, LONG, tmAscent, 4, 4, 4);
3759     TEST_FIELD(TEXTMETRICA, LONG, tmDescent, 8, 4, 4);
3760     TEST_FIELD(TEXTMETRICA, LONG, tmInternalLeading, 12, 4, 4);
3761     TEST_FIELD(TEXTMETRICA, LONG, tmExternalLeading, 16, 4, 4);
3762     TEST_FIELD(TEXTMETRICA, LONG, tmAveCharWidth, 20, 4, 4);
3763     TEST_FIELD(TEXTMETRICA, LONG, tmMaxCharWidth, 24, 4, 4);
3764     TEST_FIELD(TEXTMETRICA, LONG, tmWeight, 28, 4, 4);
3765     TEST_FIELD(TEXTMETRICA, LONG, tmOverhang, 32, 4, 4);
3766     TEST_FIELD(TEXTMETRICA, LONG, tmDigitizedAspectX, 36, 4, 4);
3767     TEST_FIELD(TEXTMETRICA, LONG, tmDigitizedAspectY, 40, 4, 4);
3768     TEST_FIELD(TEXTMETRICA, BYTE, tmFirstChar, 44, 1, 1);
3769     TEST_FIELD(TEXTMETRICA, BYTE, tmLastChar, 45, 1, 1);
3770     TEST_FIELD(TEXTMETRICA, BYTE, tmDefaultChar, 46, 1, 1);
3771     TEST_FIELD(TEXTMETRICA, BYTE, tmBreakChar, 47, 1, 1);
3772     TEST_FIELD(TEXTMETRICA, BYTE, tmItalic, 48, 1, 1);
3773     TEST_FIELD(TEXTMETRICA, BYTE, tmUnderlined, 49, 1, 1);
3774     TEST_FIELD(TEXTMETRICA, BYTE, tmStruckOut, 50, 1, 1);
3775     TEST_FIELD(TEXTMETRICA, BYTE, tmPitchAndFamily, 51, 1, 1);
3776     TEST_FIELD(TEXTMETRICA, BYTE, tmCharSet, 52, 1, 1);
3777 }
3778
3779 static void test_pack_TEXTMETRICW(void)
3780 {
3781     /* TEXTMETRICW (pack 4) */
3782     TEST_TYPE(TEXTMETRICW, 60, 4);
3783     TEST_FIELD(TEXTMETRICW, LONG, tmHeight, 0, 4, 4);
3784     TEST_FIELD(TEXTMETRICW, LONG, tmAscent, 4, 4, 4);
3785     TEST_FIELD(TEXTMETRICW, LONG, tmDescent, 8, 4, 4);
3786     TEST_FIELD(TEXTMETRICW, LONG, tmInternalLeading, 12, 4, 4);
3787     TEST_FIELD(TEXTMETRICW, LONG, tmExternalLeading, 16, 4, 4);
3788     TEST_FIELD(TEXTMETRICW, LONG, tmAveCharWidth, 20, 4, 4);
3789     TEST_FIELD(TEXTMETRICW, LONG, tmMaxCharWidth, 24, 4, 4);
3790     TEST_FIELD(TEXTMETRICW, LONG, tmWeight, 28, 4, 4);
3791     TEST_FIELD(TEXTMETRICW, LONG, tmOverhang, 32, 4, 4);
3792     TEST_FIELD(TEXTMETRICW, LONG, tmDigitizedAspectX, 36, 4, 4);
3793     TEST_FIELD(TEXTMETRICW, LONG, tmDigitizedAspectY, 40, 4, 4);
3794     TEST_FIELD(TEXTMETRICW, WCHAR, tmFirstChar, 44, 2, 2);
3795     TEST_FIELD(TEXTMETRICW, WCHAR, tmLastChar, 46, 2, 2);
3796     TEST_FIELD(TEXTMETRICW, WCHAR, tmDefaultChar, 48, 2, 2);
3797     TEST_FIELD(TEXTMETRICW, WCHAR, tmBreakChar, 50, 2, 2);
3798     TEST_FIELD(TEXTMETRICW, BYTE, tmItalic, 52, 1, 1);
3799     TEST_FIELD(TEXTMETRICW, BYTE, tmUnderlined, 53, 1, 1);
3800     TEST_FIELD(TEXTMETRICW, BYTE, tmStruckOut, 54, 1, 1);
3801     TEST_FIELD(TEXTMETRICW, BYTE, tmPitchAndFamily, 55, 1, 1);
3802     TEST_FIELD(TEXTMETRICW, BYTE, tmCharSet, 56, 1, 1);
3803 }
3804
3805 static void test_pack_TRIVERTEX(void)
3806 {
3807     /* TRIVERTEX (pack 4) */
3808     TEST_TYPE(TRIVERTEX, 16, 4);
3809     TEST_FIELD(TRIVERTEX, LONG, x, 0, 4, 4);
3810     TEST_FIELD(TRIVERTEX, LONG, y, 4, 4, 4);
3811     TEST_FIELD(TRIVERTEX, COLOR16, Red, 8, 2, 2);
3812     TEST_FIELD(TRIVERTEX, COLOR16, Green, 10, 2, 2);
3813     TEST_FIELD(TRIVERTEX, COLOR16, Blue, 12, 2, 2);
3814     TEST_FIELD(TRIVERTEX, COLOR16, Alpha, 14, 2, 2);
3815 }
3816
3817 static void test_pack_TTPOLYCURVE(void)
3818 {
3819     /* TTPOLYCURVE (pack 4) */
3820     TEST_TYPE(TTPOLYCURVE, 12, 2);
3821     TEST_FIELD(TTPOLYCURVE, WORD, wType, 0, 2, 2);
3822     TEST_FIELD(TTPOLYCURVE, WORD, cpfx, 2, 2, 2);
3823     TEST_FIELD(TTPOLYCURVE, POINTFX[1], apfx, 4, 8, 2);
3824 }
3825
3826 static void test_pack_TTPOLYGONHEADER(void)
3827 {
3828     /* TTPOLYGONHEADER (pack 4) */
3829     TEST_TYPE(TTPOLYGONHEADER, 16, 4);
3830     TEST_FIELD(TTPOLYGONHEADER, DWORD, cb, 0, 4, 4);
3831     TEST_FIELD(TTPOLYGONHEADER, DWORD, dwType, 4, 4, 4);
3832     TEST_FIELD(TTPOLYGONHEADER, POINTFX, pfxStart, 8, 8, 2);
3833 }
3834
3835 static void test_pack_XFORM(void)
3836 {
3837     /* XFORM (pack 4) */
3838     TEST_TYPE(XFORM, 24, 4);
3839     TEST_FIELD(XFORM, FLOAT, eM11, 0, 4, 4);
3840     TEST_FIELD(XFORM, FLOAT, eM12, 4, 4, 4);
3841     TEST_FIELD(XFORM, FLOAT, eM21, 8, 4, 4);
3842     TEST_FIELD(XFORM, FLOAT, eM22, 12, 4, 4);
3843     TEST_FIELD(XFORM, FLOAT, eDx, 16, 4, 4);
3844     TEST_FIELD(XFORM, FLOAT, eDy, 20, 4, 4);
3845 }
3846
3847 static void test_pack(void)
3848 {
3849     test_pack_ABC();
3850     test_pack_ABCFLOAT();
3851     test_pack_ABORTPROC();
3852     test_pack_BITMAP();
3853     test_pack_BITMAPCOREHEADER();
3854     test_pack_BITMAPCOREINFO();
3855     test_pack_BITMAPFILEHEADER();
3856     test_pack_BITMAPINFO();
3857     test_pack_BITMAPINFOHEADER();
3858     test_pack_BITMAPV4HEADER();
3859     test_pack_BITMAPV5HEADER();
3860     test_pack_BLENDFUNCTION();
3861     test_pack_CHARSETINFO();
3862     test_pack_CIEXYZ();
3863     test_pack_CIEXYZTRIPLE();
3864     test_pack_COLOR16();
3865     test_pack_COLORADJUSTMENT();
3866     test_pack_DEVMODEA();
3867     test_pack_DEVMODEW();
3868     test_pack_DIBSECTION();
3869     test_pack_DISPLAY_DEVICEA();
3870     test_pack_DISPLAY_DEVICEW();
3871     test_pack_DOCINFOA();
3872     test_pack_DOCINFOW();
3873     test_pack_EMR();
3874     test_pack_EMRABORTPATH();
3875     test_pack_EMRANGLEARC();
3876     test_pack_EMRARC();
3877     test_pack_EMRARCTO();
3878     test_pack_EMRBEGINPATH();
3879     test_pack_EMRBITBLT();
3880     test_pack_EMRCHORD();
3881     test_pack_EMRCLOSEFIGURE();
3882     test_pack_EMRCREATEBRUSHINDIRECT();
3883     test_pack_EMRCREATECOLORSPACE();
3884     test_pack_EMRCREATECOLORSPACEW();
3885     test_pack_EMRCREATEDIBPATTERNBRUSHPT();
3886     test_pack_EMRCREATEMONOBRUSH();
3887     test_pack_EMRCREATEPEN();
3888     test_pack_EMRDELETECOLORSPACE();
3889     test_pack_EMRDELETEOBJECT();
3890     test_pack_EMRELLIPSE();
3891     test_pack_EMRENDPATH();
3892     test_pack_EMREOF();
3893     test_pack_EMREXCLUDECLIPRECT();
3894     test_pack_EMREXTCREATEFONTINDIRECTW();
3895     test_pack_EMREXTCREATEPEN();
3896     test_pack_EMREXTFLOODFILL();
3897     test_pack_EMREXTSELECTCLIPRGN();
3898     test_pack_EMREXTTEXTOUTA();
3899     test_pack_EMREXTTEXTOUTW();
3900     test_pack_EMRFILLPATH();
3901     test_pack_EMRFILLRGN();
3902     test_pack_EMRFLATTENPATH();
3903     test_pack_EMRFORMAT();
3904     test_pack_EMRFRAMERGN();
3905     test_pack_EMRGDICOMMENT();
3906     test_pack_EMRGLSBOUNDEDRECORD();
3907     test_pack_EMRGLSRECORD();
3908     test_pack_EMRINTERSECTCLIPRECT();
3909     test_pack_EMRINVERTRGN();
3910     test_pack_EMRLINETO();
3911     test_pack_EMRMASKBLT();
3912     test_pack_EMRMODIFYWORLDTRANSFORM();
3913     test_pack_EMRMOVETOEX();
3914     test_pack_EMROFFSETCLIPRGN();
3915     test_pack_EMRPAINTRGN();
3916     test_pack_EMRPIE();
3917     test_pack_EMRPIXELFORMAT();
3918     test_pack_EMRPLGBLT();
3919     test_pack_EMRPOLYBEZIER();
3920     test_pack_EMRPOLYBEZIER16();
3921     test_pack_EMRPOLYBEZIERTO();
3922     test_pack_EMRPOLYBEZIERTO16();
3923     test_pack_EMRPOLYDRAW();
3924     test_pack_EMRPOLYDRAW16();
3925     test_pack_EMRPOLYGON();
3926     test_pack_EMRPOLYGON16();
3927     test_pack_EMRPOLYLINE();
3928     test_pack_EMRPOLYLINE16();
3929     test_pack_EMRPOLYLINETO();
3930     test_pack_EMRPOLYLINETO16();
3931     test_pack_EMRPOLYPOLYGON();
3932     test_pack_EMRPOLYPOLYGON16();
3933     test_pack_EMRPOLYPOLYLINE();
3934     test_pack_EMRPOLYPOLYLINE16();
3935     test_pack_EMRPOLYTEXTOUTA();
3936     test_pack_EMRPOLYTEXTOUTW();
3937     test_pack_EMRREALIZEPALETTE();
3938     test_pack_EMRRECTANGLE();
3939     test_pack_EMRRESIZEPALETTE();
3940     test_pack_EMRRESTOREDC();
3941     test_pack_EMRROUNDRECT();
3942     test_pack_EMRSAVEDC();
3943     test_pack_EMRSCALEVIEWPORTEXTEX();
3944     test_pack_EMRSCALEWINDOWEXTEX();
3945     test_pack_EMRSELECTCLIPPATH();
3946     test_pack_EMRSELECTCOLORSPACE();
3947     test_pack_EMRSELECTOBJECT();
3948     test_pack_EMRSELECTPALETTE();
3949     test_pack_EMRSETARCDIRECTION();
3950     test_pack_EMRSETBKCOLOR();
3951     test_pack_EMRSETBKMODE();
3952     test_pack_EMRSETBRUSHORGEX();
3953     test_pack_EMRSETCOLORADJUSTMENT();
3954     test_pack_EMRSETCOLORSPACE();
3955     test_pack_EMRSETDIBITSTODEVICE();
3956     test_pack_EMRSETICMMODE();
3957     test_pack_EMRSETLAYOUT();
3958     test_pack_EMRSETMAPMODE();
3959     test_pack_EMRSETMAPPERFLAGS();
3960     test_pack_EMRSETMETARGN();
3961     test_pack_EMRSETMITERLIMIT();
3962     test_pack_EMRSETPIXELV();
3963     test_pack_EMRSETPOLYFILLMODE();
3964     test_pack_EMRSETROP2();
3965     test_pack_EMRSETSTRETCHBLTMODE();
3966     test_pack_EMRSETTEXTALIGN();
3967     test_pack_EMRSETTEXTCOLOR();
3968     test_pack_EMRSETVIEWPORTEXTEX();
3969     test_pack_EMRSETVIEWPORTORGEX();
3970     test_pack_EMRSETWINDOWEXTEX();
3971     test_pack_EMRSETWINDOWORGEX();
3972     test_pack_EMRSETWORLDTRANSFORM();
3973     test_pack_EMRSTRETCHBLT();
3974     test_pack_EMRSTRETCHDIBITS();
3975     test_pack_EMRSTROKEANDFILLPATH();
3976     test_pack_EMRSTROKEPATH();
3977     test_pack_EMRTEXT();
3978     test_pack_EMRWIDENPATH();
3979     test_pack_ENHMETAHEADER();
3980     test_pack_ENHMETARECORD();
3981     test_pack_ENHMFENUMPROC();
3982     test_pack_ENUMLOGFONTA();
3983     test_pack_ENUMLOGFONTEXA();
3984     test_pack_ENUMLOGFONTEXW();
3985     test_pack_ENUMLOGFONTW();
3986     test_pack_EXTLOGFONTA();
3987     test_pack_EXTLOGFONTW();
3988     test_pack_EXTLOGPEN();
3989     test_pack_FIXED();
3990     test_pack_FONTENUMPROCA();
3991     test_pack_FONTENUMPROCW();
3992     test_pack_FONTSIGNATURE();
3993     test_pack_FXPT16DOT16();
3994     test_pack_FXPT2DOT30();
3995     test_pack_GCP_RESULTSA();
3996     test_pack_GCP_RESULTSW();
3997     test_pack_GLYPHMETRICS();
3998     test_pack_GOBJENUMPROC();
3999     test_pack_GRADIENT_RECT();
4000     test_pack_GRADIENT_TRIANGLE();
4001     test_pack_HANDLETABLE();
4002     test_pack_ICMENUMPROCA();
4003     test_pack_ICMENUMPROCW();
4004     test_pack_KERNINGPAIR();
4005     test_pack_LCSCSTYPE();
4006     test_pack_LCSGAMUTMATCH();
4007     test_pack_LINEDDAPROC();
4008     test_pack_LOCALESIGNATURE();
4009     test_pack_LOGBRUSH();
4010     test_pack_LOGCOLORSPACEA();
4011     test_pack_LOGCOLORSPACEW();
4012     test_pack_LOGFONTA();
4013     test_pack_LOGFONTW();
4014     test_pack_LOGPEN();
4015     test_pack_LPABC();
4016     test_pack_LPABCFLOAT();
4017     test_pack_LPBITMAP();
4018     test_pack_LPBITMAPCOREHEADER();
4019     test_pack_LPBITMAPCOREINFO();
4020     test_pack_LPBITMAPFILEHEADER();
4021     test_pack_LPBITMAPINFO();
4022     test_pack_LPBITMAPINFOHEADER();
4023     test_pack_LPBITMAPV5HEADER();
4024     test_pack_LPCHARSETINFO();
4025     test_pack_LPCIEXYZ();
4026     test_pack_LPCIEXYZTRIPLE();
4027     test_pack_LPCOLORADJUSTMENT();
4028     test_pack_LPDEVMODEA();
4029     test_pack_LPDEVMODEW();
4030     test_pack_LPDIBSECTION();
4031     test_pack_LPDISPLAY_DEVICEA();
4032     test_pack_LPDISPLAY_DEVICEW();
4033     test_pack_LPDOCINFOA();
4034     test_pack_LPDOCINFOW();
4035     test_pack_LPENHMETAHEADER();
4036     test_pack_LPENHMETARECORD();
4037     test_pack_LPENUMLOGFONTA();
4038     test_pack_LPENUMLOGFONTEXA();
4039     test_pack_LPENUMLOGFONTEXW();
4040     test_pack_LPENUMLOGFONTW();
4041     test_pack_LPEXTLOGFONTA();
4042     test_pack_LPEXTLOGFONTW();
4043     test_pack_LPEXTLOGPEN();
4044     test_pack_LPFONTSIGNATURE();
4045     test_pack_LPGCP_RESULTSA();
4046     test_pack_LPGCP_RESULTSW();
4047     test_pack_LPGLYPHMETRICS();
4048     test_pack_LPGRADIENT_RECT();
4049     test_pack_LPGRADIENT_TRIANGLE();
4050     test_pack_LPHANDLETABLE();
4051     test_pack_LPKERNINGPAIR();
4052     test_pack_LPLOCALESIGNATURE();
4053     test_pack_LPLOGBRUSH();
4054     test_pack_LPLOGCOLORSPACEA();
4055     test_pack_LPLOGCOLORSPACEW();
4056     test_pack_LPLOGFONTA();
4057     test_pack_LPLOGFONTW();
4058     test_pack_LPLOGPEN();
4059     test_pack_LPMAT2();
4060     test_pack_LPMETAFILEPICT();
4061     test_pack_LPMETAHEADER();
4062     test_pack_LPMETARECORD();
4063     test_pack_LPNEWTEXTMETRICA();
4064     test_pack_LPNEWTEXTMETRICW();
4065     test_pack_LPOUTLINETEXTMETRICA();
4066     test_pack_LPOUTLINETEXTMETRICW();
4067     test_pack_LPPANOSE();
4068     test_pack_LPPELARRAY();
4069     test_pack_LPPIXELFORMATDESCRIPTOR();
4070     test_pack_LPPOINTFX();
4071     test_pack_LPPOLYTEXTA();
4072     test_pack_LPPOLYTEXTW();
4073     test_pack_LPRASTERIZER_STATUS();
4074     test_pack_LPRGBQUAD();
4075     test_pack_LPRGNDATA();
4076     test_pack_LPTEXTMETRICA();
4077     test_pack_LPTEXTMETRICW();
4078     test_pack_LPTRIVERTEX();
4079     test_pack_LPTTPOLYCURVE();
4080     test_pack_LPTTPOLYGONHEADER();
4081     test_pack_LPXFORM();
4082     test_pack_MAT2();
4083     test_pack_METAFILEPICT();
4084     test_pack_METAHEADER();
4085     test_pack_METARECORD();
4086     test_pack_MFENUMPROC();
4087     test_pack_NEWTEXTMETRICA();
4088     test_pack_NEWTEXTMETRICEXA();
4089     test_pack_NEWTEXTMETRICEXW();
4090     test_pack_NEWTEXTMETRICW();
4091     test_pack_NPEXTLOGPEN();
4092     test_pack_OLDFONTENUMPROC();
4093     test_pack_OLDFONTENUMPROCA();
4094     test_pack_OLDFONTENUMPROCW();
4095     test_pack_OUTLINETEXTMETRICA();
4096     test_pack_OUTLINETEXTMETRICW();
4097     test_pack_PABC();
4098     test_pack_PABCFLOAT();
4099     test_pack_PANOSE();
4100     test_pack_PATTERN();
4101     test_pack_PBITMAP();
4102     test_pack_PBITMAPCOREHEADER();
4103     test_pack_PBITMAPCOREINFO();
4104     test_pack_PBITMAPFILEHEADER();
4105     test_pack_PBITMAPINFO();
4106     test_pack_PBITMAPINFOHEADER();
4107     test_pack_PBITMAPV4HEADER();
4108     test_pack_PBITMAPV5HEADER();
4109     test_pack_PBLENDFUNCTION();
4110     test_pack_PCHARSETINFO();
4111     test_pack_PCOLORADJUSTMENT();
4112     test_pack_PDEVMODEA();
4113     test_pack_PDEVMODEW();
4114     test_pack_PDIBSECTION();
4115     test_pack_PDISPLAY_DEVICEA();
4116     test_pack_PDISPLAY_DEVICEW();
4117     test_pack_PELARRAY();
4118     test_pack_PEMR();
4119     test_pack_PEMRABORTPATH();
4120     test_pack_PEMRANGLEARC();
4121     test_pack_PEMRARC();
4122     test_pack_PEMRARCTO();
4123     test_pack_PEMRBEGINPATH();
4124     test_pack_PEMRBITBLT();
4125     test_pack_PEMRCHORD();
4126     test_pack_PEMRCLOSEFIGURE();
4127     test_pack_PEMRCREATEBRUSHINDIRECT();
4128     test_pack_PEMRCREATECOLORSPACE();
4129     test_pack_PEMRCREATECOLORSPACEW();
4130     test_pack_PEMRCREATEDIBPATTERNBRUSHPT();
4131     test_pack_PEMRCREATEMONOBRUSH();
4132     test_pack_PEMRCREATEPALETTE();
4133     test_pack_PEMRCREATEPEN();
4134     test_pack_PEMRDELETECOLORSPACE();
4135     test_pack_PEMRDELETEOBJECT();
4136     test_pack_PEMRELLIPSE();
4137     test_pack_PEMRENDPATH();
4138     test_pack_PEMREOF();
4139     test_pack_PEMREXCLUDECLIPRECT();
4140     test_pack_PEMREXTCREATEFONTINDIRECTW();
4141     test_pack_PEMREXTCREATEPEN();
4142     test_pack_PEMREXTFLOODFILL();
4143     test_pack_PEMREXTSELECTCLIPRGN();
4144     test_pack_PEMREXTTEXTOUTA();
4145     test_pack_PEMREXTTEXTOUTW();
4146     test_pack_PEMRFILLPATH();
4147     test_pack_PEMRFILLRGN();
4148     test_pack_PEMRFLATTENPATH();
4149     test_pack_PEMRFORMAT();
4150     test_pack_PEMRFRAMERGN();
4151     test_pack_PEMRGDICOMMENT();
4152     test_pack_PEMRGLSBOUNDEDRECORD();
4153     test_pack_PEMRGLSRECORD();
4154     test_pack_PEMRINTERSECTCLIPRECT();
4155     test_pack_PEMRINVERTRGN();
4156     test_pack_PEMRLINETO();
4157     test_pack_PEMRMASKBLT();
4158     test_pack_PEMRMODIFYWORLDTRANSFORM();
4159     test_pack_PEMRMOVETOEX();
4160     test_pack_PEMROFFSETCLIPRGN();
4161     test_pack_PEMRPAINTRGN();
4162     test_pack_PEMRPIE();
4163     test_pack_PEMRPIXELFORMAT();
4164     test_pack_PEMRPLGBLT();
4165     test_pack_PEMRPOLYBEZIER();
4166     test_pack_PEMRPOLYBEZIER16();
4167     test_pack_PEMRPOLYBEZIERTO();
4168     test_pack_PEMRPOLYBEZIERTO16();
4169     test_pack_PEMRPOLYDRAW();
4170     test_pack_PEMRPOLYDRAW16();
4171     test_pack_PEMRPOLYGON();
4172     test_pack_PEMRPOLYGON16();
4173     test_pack_PEMRPOLYLINE();
4174     test_pack_PEMRPOLYLINE16();
4175     test_pack_PEMRPOLYLINETO();
4176     test_pack_PEMRPOLYLINETO16();
4177     test_pack_PEMRPOLYPOLYGON();
4178     test_pack_PEMRPOLYPOLYGON16();
4179     test_pack_PEMRPOLYPOLYLINE();
4180     test_pack_PEMRPOLYPOLYLINE16();
4181     test_pack_PEMRPOLYTEXTOUTA();
4182     test_pack_PEMRPOLYTEXTOUTW();
4183     test_pack_PEMRREALIZEPALETTE();
4184     test_pack_PEMRRECTANGLE();
4185     test_pack_PEMRRESIZEPALETTE();
4186     test_pack_PEMRRESTOREDC();
4187     test_pack_PEMRROUNDRECT();
4188     test_pack_PEMRSAVEDC();
4189     test_pack_PEMRSCALEVIEWPORTEXTEX();
4190     test_pack_PEMRSCALEWINDOWEXTEX();
4191     test_pack_PEMRSELECTCLIPPATH();
4192     test_pack_PEMRSELECTCOLORSPACE();
4193     test_pack_PEMRSELECTOBJECT();
4194     test_pack_PEMRSELECTPALETTE();
4195     test_pack_PEMRSETARCDIRECTION();
4196     test_pack_PEMRSETBKCOLOR();
4197     test_pack_PEMRSETBKMODE();
4198     test_pack_PEMRSETBRUSHORGEX();
4199     test_pack_PEMRSETCOLORADJUSTMENT();
4200     test_pack_PEMRSETCOLORSPACE();
4201     test_pack_PEMRSETDIBITSTODEVICE();
4202     test_pack_PEMRSETICMMODE();
4203     test_pack_PEMRSETLAYOUT();
4204     test_pack_PEMRSETMAPMODE();
4205     test_pack_PEMRSETMAPPERFLAGS();
4206     test_pack_PEMRSETMETARGN();
4207     test_pack_PEMRSETMITERLIMIT();
4208     test_pack_PEMRSETPALETTEENTRIES();
4209     test_pack_PEMRSETPIXELV();
4210     test_pack_PEMRSETPOLYFILLMODE();
4211     test_pack_PEMRSETROP2();
4212     test_pack_PEMRSETSTRETCHBLTMODE();
4213     test_pack_PEMRSETTEXTALIGN();
4214     test_pack_PEMRSETTEXTCOLOR();
4215     test_pack_PEMRSETVIEWPORTEXTEX();
4216     test_pack_PEMRSETVIEWPORTORGEX();
4217     test_pack_PEMRSETWINDOWEXTEX();
4218     test_pack_PEMRSETWINDOWORGEX();
4219     test_pack_PEMRSETWORLDTRANSFORM();
4220     test_pack_PEMRSTRETCHBLT();
4221     test_pack_PEMRSTRETCHDIBITS();
4222     test_pack_PEMRSTROKEANDFILLPATH();
4223     test_pack_PEMRSTROKEPATH();
4224     test_pack_PEMRTEXT();
4225     test_pack_PEMRWIDENPATH();
4226     test_pack_PENHMETAHEADER();
4227     test_pack_PEXTLOGFONTA();
4228     test_pack_PEXTLOGFONTW();
4229     test_pack_PEXTLOGPEN();
4230     test_pack_PFONTSIGNATURE();
4231     test_pack_PGRADIENT_RECT();
4232     test_pack_PGRADIENT_TRIANGLE();
4233     test_pack_PHANDLETABLE();
4234     test_pack_PIXELFORMATDESCRIPTOR();
4235     test_pack_PLOCALESIGNATURE();
4236     test_pack_PLOGBRUSH();
4237     test_pack_PLOGFONTA();
4238     test_pack_PLOGFONTW();
4239     test_pack_PMETAHEADER();
4240     test_pack_PMETARECORD();
4241     test_pack_PNEWTEXTMETRICA();
4242     test_pack_PNEWTEXTMETRICW();
4243     test_pack_POINTFX();
4244     test_pack_POLYTEXTA();
4245     test_pack_POLYTEXTW();
4246     test_pack_POUTLINETEXTMETRICA();
4247     test_pack_POUTLINETEXTMETRICW();
4248     test_pack_PPELARRAY();
4249     test_pack_PPIXELFORMATDESCRIPTOR();
4250     test_pack_PPOLYTEXTA();
4251     test_pack_PPOLYTEXTW();
4252     test_pack_PRGNDATA();
4253     test_pack_PRGNDATAHEADER();
4254     test_pack_PTEXTMETRICA();
4255     test_pack_PTEXTMETRICW();
4256     test_pack_PTRIVERTEX();
4257     test_pack_PXFORM();
4258     test_pack_RASTERIZER_STATUS();
4259     test_pack_RGBQUAD();
4260     test_pack_RGBTRIPLE();
4261     test_pack_RGNDATA();
4262     test_pack_RGNDATAHEADER();
4263     test_pack_TEXTMETRICA();
4264     test_pack_TEXTMETRICW();
4265     test_pack_TRIVERTEX();
4266     test_pack_TTPOLYCURVE();
4267     test_pack_TTPOLYGONHEADER();
4268     test_pack_XFORM();
4269 }
4270
4271 START_TEST(generated)
4272 {
4273     test_pack();
4274 }