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_WINNT 0x0501
  10
  11 #define WINE_NOWINSOCK
  12
  13 #include "windows.h"
  14
  15 #include "wine/test.h"
  16
  17 /***********************************************************************
  18  * Compability macros
  19  */
  20
  21 #define DWORD_PTR UINT_PTR
  22 #define LONG_PTR INT_PTR
  23 #define ULONG_PTR UINT_PTR
  24
  25 /***********************************************************************
  26  * Windows API extension
  27  */
  28
  29 #if (_MSC_VER >= 1300) && defined(__cplusplus)
  30 # define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
  31 #elif defined(__GNUC__)
  32 # define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
  33 #else
  34 /* FIXME: Not sure if is possible to do without compiler extension */
  35 #endif
  36
  37 #if (_MSC_VER >= 1300) && defined(__cplusplus)
  38 # define _TYPE_ALIGNMENT(type) __alignof(type)
  39 #elif defined(__GNUC__)
  40 # define _TYPE_ALIGNMENT(type) __alignof__(type)
  41 #else
  42 /*
  43  * FIXME: Not sure if is possible to do without compiler extension
  44  *        (if type is not just a name that is, if so the normal)
  45  *         TYPE_ALIGNMENT can be used)
  46  */
  47 #endif
  48
  49 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
  50 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
  51 #endif
  52
  53 /***********************************************************************
  54  * Test helper macros
  55  */
  56
  57 #ifdef FIELD_ALIGNMENT
  58 # define TEST_FIELD_ALIGNMENT(type, field, align) \
  59    ok(FIELD_ALIGNMENT(type, field) == align, \
  60        "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")", \
  61            FIELD_ALIGNMENT(type, field))
  62 #else
  63 # define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
  64 #endif
  65
  66 #define TEST_FIELD_OFFSET(type, field, offset) \
  67     ok(FIELD_OFFSET(type, field) == offset, \
  68         "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")", \
  69              FIELD_OFFSET(type, field))
  70
  71 #ifdef _TYPE_ALIGNMENT
  72 #define TEST__TYPE_ALIGNMENT(type, align) \
  73     ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")", _TYPE_ALIGNMENT(type))
  74 #else
  75 # define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
  76 #endif
  77
  78 #ifdef TYPE_ALIGNMENT
  79 #define TEST_TYPE_ALIGNMENT(type, align) \
  80     ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")", TYPE_ALIGNMENT(type))
  81 #else
  82 # define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
  83 #endif
  84
  85 #define TEST_TYPE_SIZE(type, size) \
  86     ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")", sizeof(type))
  87
  88 /***********************************************************************
  89  * Test macros
  90  */
  91
  92 #define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
  93   TEST_TYPE_SIZE(field_type, field_size); \
  94   TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
  95   TEST_FIELD_OFFSET(type, field_name, field_offset); \
  96
  97 #define TEST_TYPE(type, size, align) \
  98   TEST_TYPE_ALIGNMENT(type, align); \
  99   TEST_TYPE_SIZE(type, size)
 100
 101 #define TEST_TYPE_POINTER(type, size, align) \
 102     TEST__TYPE_ALIGNMENT(*(type)0, align); \
 103     TEST_TYPE_SIZE(*(type)0, size)
 104
 105 #define TEST_TYPE_SIGNED(type) \
 106     ok((type) -1 < 0, "(" #type ") -1 < 0");
 107
 108 #define TEST_TYPE_UNSIGNED(type) \
 109      ok((type) -1 > 0, "(" #type ") -1 > 0");
 110
 111 void test_pack(void)
 112 {
 113     /* ABC (pack 4) */
 114     TEST_TYPE(ABC, 12, 4);
 115     TEST_FIELD(ABC, INT, abcA, 0, 4, 4);
 116     TEST_FIELD(ABC, UINT, abcB, 4, 4, 4);
 117     TEST_FIELD(ABC, INT, abcC, 8, 4, 4);
 118
 119     /* ABCFLOAT (pack 4) */
 120     TEST_TYPE(ABCFLOAT, 12, 4);
 121     TEST_FIELD(ABCFLOAT, FLOAT, abcfA, 0, 4, 4);
 122     TEST_FIELD(ABCFLOAT, FLOAT, abcfB, 4, 4, 4);
 123     TEST_FIELD(ABCFLOAT, FLOAT, abcfC, 8, 4, 4);
 124
 125     /* ABORTPROC */
 126
 127     /* BITMAP (pack 4) */
 128     TEST_TYPE(BITMAP, 24, 4);
 129     TEST_FIELD(BITMAP, INT, bmType, 0, 4, 4);
 130     TEST_FIELD(BITMAP, INT, bmWidth, 4, 4, 4);
 131     TEST_FIELD(BITMAP, INT, bmHeight, 8, 4, 4);
 132     TEST_FIELD(BITMAP, INT, bmWidthBytes, 12, 4, 4);
 133     TEST_FIELD(BITMAP, WORD, bmPlanes, 16, 2, 2);
 134     TEST_FIELD(BITMAP, WORD, bmBitsPixel, 18, 2, 2);
 135     TEST_FIELD(BITMAP, LPVOID, bmBits, 20, 4, 4);
 136
 137     /* BITMAPCOREHEADER (pack 4) */
 138     TEST_TYPE(BITMAPCOREHEADER, 12, 4);
 139     TEST_FIELD(BITMAPCOREHEADER, DWORD, bcSize, 0, 4, 4);
 140     TEST_FIELD(BITMAPCOREHEADER, WORD, bcWidth, 4, 2, 2);
 141     TEST_FIELD(BITMAPCOREHEADER, WORD, bcHeight, 6, 2, 2);
 142     TEST_FIELD(BITMAPCOREHEADER, WORD, bcPlanes, 8, 2, 2);
 143     TEST_FIELD(BITMAPCOREHEADER, WORD, bcBitCount, 10, 2, 2);
 144
 145     /* BITMAPCOREINFO (pack 4) */
 146     TEST_TYPE(BITMAPCOREINFO, 16, 4);
 147     TEST_FIELD(BITMAPCOREINFO, BITMAPCOREHEADER, bmciHeader, 0, 12, 4);
 148     TEST_FIELD(BITMAPCOREINFO, RGBTRIPLE[1], bmciColors, 12, 3, 1);
 149
 150     /* BITMAPFILEHEADER (pack 2) */
 151     TEST_TYPE(BITMAPFILEHEADER, 14, 2);
 152     TEST_FIELD(BITMAPFILEHEADER, WORD, bfType, 0, 2, 2);
 153     TEST_FIELD(BITMAPFILEHEADER, DWORD, bfSize, 2, 4, 2);
 154     TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved1, 6, 2, 2);
 155     TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved2, 8, 2, 2);
 156     TEST_FIELD(BITMAPFILEHEADER, DWORD, bfOffBits, 10, 4, 2);
 157
 158     /* BITMAPINFO (pack 4) */
 159     TEST_TYPE(BITMAPINFO, 44, 4);
 160     TEST_FIELD(BITMAPINFO, BITMAPINFOHEADER, bmiHeader, 0, 40, 4);
 161     TEST_FIELD(BITMAPINFO, RGBQUAD[1], bmiColors, 40, 4, 1);
 162
 163     /* BITMAPINFOHEADER (pack 4) */
 164     TEST_TYPE(BITMAPINFOHEADER, 40, 4);
 165     TEST_FIELD(BITMAPINFOHEADER, DWORD, biSize, 0, 4, 4);
 166     TEST_FIELD(BITMAPINFOHEADER, LONG, biWidth, 4, 4, 4);
 167     TEST_FIELD(BITMAPINFOHEADER, LONG, biHeight, 8, 4, 4);
 168     TEST_FIELD(BITMAPINFOHEADER, WORD, biPlanes, 12, 2, 2);
 169     TEST_FIELD(BITMAPINFOHEADER, WORD, biBitCount, 14, 2, 2);
 170     TEST_FIELD(BITMAPINFOHEADER, DWORD, biCompression, 16, 4, 4);
 171     TEST_FIELD(BITMAPINFOHEADER, DWORD, biSizeImage, 20, 4, 4);
 172     TEST_FIELD(BITMAPINFOHEADER, LONG, biXPelsPerMeter, 24, 4, 4);
 173     TEST_FIELD(BITMAPINFOHEADER, LONG, biYPelsPerMeter, 28, 4, 4);
 174     TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrUsed, 32, 4, 4);
 175     TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrImportant, 36, 4, 4);
 176
 177     /* BITMAPV4HEADER (pack 4) */
 178     TEST_TYPE(BITMAPV4HEADER, 108, 4);
 179     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4Size, 0, 4, 4);
 180     TEST_FIELD(BITMAPV4HEADER, LONG, bV4Width, 4, 4, 4);
 181     TEST_FIELD(BITMAPV4HEADER, LONG, bV4Height, 8, 4, 4);
 182     TEST_FIELD(BITMAPV4HEADER, WORD, bV4Planes, 12, 2, 2);
 183     TEST_FIELD(BITMAPV4HEADER, WORD, bV4BitCount, 14, 2, 2);
 184     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4V4Compression, 16, 4, 4);
 185     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4SizeImage, 20, 4, 4);
 186     TEST_FIELD(BITMAPV4HEADER, LONG, bV4XPelsPerMeter, 24, 4, 4);
 187     TEST_FIELD(BITMAPV4HEADER, LONG, bV4YPelsPerMeter, 28, 4, 4);
 188     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrUsed, 32, 4, 4);
 189     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrImportant, 36, 4, 4);
 190     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4RedMask, 40, 4, 4);
 191     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GreenMask, 44, 4, 4);
 192     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4BlueMask, 48, 4, 4);
 193     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4AlphaMask, 52, 4, 4);
 194     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4CSType, 56, 4, 4);
 195     TEST_FIELD(BITMAPV4HEADER, CIEXYZTRIPLE, bV4Endpoints, 60, 36, 4);
 196     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaRed, 96, 4, 4);
 197     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaGreen, 100, 4, 4);
 198     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaBlue, 104, 4, 4);
 199
 200     /* BITMAPV5HEADER (pack 4) */
 201     TEST_TYPE(BITMAPV5HEADER, 124, 4);
 202     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Size, 0, 4, 4);
 203     TEST_FIELD(BITMAPV5HEADER, LONG, bV5Width, 4, 4, 4);
 204     TEST_FIELD(BITMAPV5HEADER, LONG, bV5Height, 8, 4, 4);
 205     TEST_FIELD(BITMAPV5HEADER, WORD, bV5Planes, 12, 2, 2);
 206     TEST_FIELD(BITMAPV5HEADER, WORD, bV5BitCount, 14, 2, 2);
 207     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Compression, 16, 4, 4);
 208     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5SizeImage, 20, 4, 4);
 209     TEST_FIELD(BITMAPV5HEADER, LONG, bV5XPelsPerMeter, 24, 4, 4);
 210     TEST_FIELD(BITMAPV5HEADER, LONG, bV5YPelsPerMeter, 28, 4, 4);
 211     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrUsed, 32, 4, 4);
 212     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrImportant, 36, 4, 4);
 213     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5RedMask, 40, 4, 4);
 214     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GreenMask, 44, 4, 4);
 215     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5BlueMask, 48, 4, 4);
 216     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5AlphaMask, 52, 4, 4);
 217     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5CSType, 56, 4, 4);
 218     TEST_FIELD(BITMAPV5HEADER, CIEXYZTRIPLE, bV5Endpoints, 60, 36, 4);
 219     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaRed, 96, 4, 4);
 220     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaGreen, 100, 4, 4);
 221     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaBlue, 104, 4, 4);
 222     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Intent, 108, 4, 4);
 223     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileData, 112, 4, 4);
 224     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileSize, 116, 4, 4);
 225     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Reserved, 120, 4, 4);
 226
 227     /* BLENDFUNCTION (pack 4) */
 228     TEST_TYPE(BLENDFUNCTION, 4, 1);
 229     TEST_FIELD(BLENDFUNCTION, BYTE, BlendOp, 0, 1, 1);
 230     TEST_FIELD(BLENDFUNCTION, BYTE, BlendFlags, 1, 1, 1);
 231     TEST_FIELD(BLENDFUNCTION, BYTE, SourceConstantAlpha, 2, 1, 1);
 232     TEST_FIELD(BLENDFUNCTION, BYTE, AlphaFormat, 3, 1, 1);
 233
 234     /* CHARSETINFO (pack 4) */
 235     TEST_TYPE(CHARSETINFO, 32, 4);
 236     TEST_FIELD(CHARSETINFO, UINT, ciCharset, 0, 4, 4);
 237     TEST_FIELD(CHARSETINFO, UINT, ciACP, 4, 4, 4);
 238     TEST_FIELD(CHARSETINFO, FONTSIGNATURE, fs, 8, 24, 4);
 239
 240     /* CIEXYZ (pack 4) */
 241     TEST_TYPE(CIEXYZ, 12, 4);
 242     TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzX, 0, 4, 4);
 243     TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzY, 4, 4, 4);
 244     TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzZ, 8, 4, 4);
 245
 246     /* CIEXYZTRIPLE (pack 4) */
 247     TEST_TYPE(CIEXYZTRIPLE, 36, 4);
 248     TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzRed, 0, 12, 4);
 249     TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzGreen, 12, 12, 4);
 250     TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzBlue, 24, 12, 4);
 251
 252     /* COLOR16 */
 253     TEST_TYPE(COLOR16, 2, 2);
 254
 255     /* COLORADJUSTMENT (pack 4) */
 256     TEST_TYPE(COLORADJUSTMENT, 24, 2);
 257     TEST_FIELD(COLORADJUSTMENT, WORD, caSize, 0, 2, 2);
 258     TEST_FIELD(COLORADJUSTMENT, WORD, caFlags, 2, 2, 2);
 259     TEST_FIELD(COLORADJUSTMENT, WORD, caIlluminantIndex, 4, 2, 2);
 260     TEST_FIELD(COLORADJUSTMENT, WORD, caRedGamma, 6, 2, 2);
 261     TEST_FIELD(COLORADJUSTMENT, WORD, caGreenGamma, 8, 2, 2);
 262     TEST_FIELD(COLORADJUSTMENT, WORD, caBlueGamma, 10, 2, 2);
 263     TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceBlack, 12, 2, 2);
 264     TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceWhite, 14, 2, 2);
 265     TEST_FIELD(COLORADJUSTMENT, SHORT, caContrast, 16, 2, 2);
 266     TEST_FIELD(COLORADJUSTMENT, SHORT, caBrightness, 18, 2, 2);
 267     TEST_FIELD(COLORADJUSTMENT, SHORT, caColorfulness, 20, 2, 2);
 268     TEST_FIELD(COLORADJUSTMENT, SHORT, caRedGreenTint, 22, 2, 2);
 269
 270     /* DIBSECTION (pack 4) */
 271     TEST_TYPE(DIBSECTION, 84, 4);
 272     TEST_FIELD(DIBSECTION, BITMAP, dsBm, 0, 24, 4);
 273     TEST_FIELD(DIBSECTION, BITMAPINFOHEADER, dsBmih, 24, 40, 4);
 274     TEST_FIELD(DIBSECTION, DWORD[3], dsBitfields, 64, 12, 4);
 275     TEST_FIELD(DIBSECTION, HANDLE, dshSection, 76, 4, 4);
 276     TEST_FIELD(DIBSECTION, DWORD, dsOffset, 80, 4, 4);
 277
 278     /* DISPLAY_DEVICEA (pack 4) */
 279     TEST_FIELD(DISPLAY_DEVICEA, DWORD, cb, 0, 4, 4);
 280     TEST_FIELD(DISPLAY_DEVICEA, CHAR[32], DeviceName, 4, 32, 1);
 281     TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceString, 36, 128, 1);
 282     TEST_FIELD(DISPLAY_DEVICEA, DWORD, StateFlags, 164, 4, 4);
 283
 284     /* DISPLAY_DEVICEW (pack 4) */
 285     TEST_FIELD(DISPLAY_DEVICEW, DWORD, cb, 0, 4, 4);
 286     TEST_FIELD(DISPLAY_DEVICEW, WCHAR[32], DeviceName, 4, 64, 2);
 287     TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceString, 68, 256, 2);
 288     TEST_FIELD(DISPLAY_DEVICEW, DWORD, StateFlags, 324, 4, 4);
 289
 290     /* DOCINFOA (pack 4) */
 291     TEST_TYPE(DOCINFOA, 20, 4);
 292     TEST_FIELD(DOCINFOA, INT, cbSize, 0, 4, 4);
 293     TEST_FIELD(DOCINFOA, LPCSTR, lpszDocName, 4, 4, 4);
 294     TEST_FIELD(DOCINFOA, LPCSTR, lpszOutput, 8, 4, 4);
 295     TEST_FIELD(DOCINFOA, LPCSTR, lpszDatatype, 12, 4, 4);
 296     TEST_FIELD(DOCINFOA, DWORD, fwType, 16, 4, 4);
 297
 298     /* DOCINFOW (pack 4) */
 299     TEST_TYPE(DOCINFOW, 20, 4);
 300     TEST_FIELD(DOCINFOW, INT, cbSize, 0, 4, 4);
 301     TEST_FIELD(DOCINFOW, LPCWSTR, lpszDocName, 4, 4, 4);
 302     TEST_FIELD(DOCINFOW, LPCWSTR, lpszOutput, 8, 4, 4);
 303     TEST_FIELD(DOCINFOW, LPCWSTR, lpszDatatype, 12, 4, 4);
 304     TEST_FIELD(DOCINFOW, DWORD, fwType, 16, 4, 4);
 305
 306     /* EMR (pack 4) */
 307     TEST_TYPE(EMR, 8, 4);
 308     TEST_FIELD(EMR, DWORD, iType, 0, 4, 4);
 309     TEST_FIELD(EMR, DWORD, nSize, 4, 4, 4);
 310
 311     /* EMRABORTPATH (pack 4) */
 312     TEST_TYPE(EMRABORTPATH, 8, 4);
 313     TEST_FIELD(EMRABORTPATH, EMR, emr, 0, 8, 4);
 314
 315     /* EMRANGLEARC (pack 4) */
 316     TEST_TYPE(EMRANGLEARC, 28, 4);
 317     TEST_FIELD(EMRANGLEARC, EMR, emr, 0, 8, 4);
 318     TEST_FIELD(EMRANGLEARC, POINTL, ptlCenter, 8, 8, 4);
 319     TEST_FIELD(EMRANGLEARC, DWORD, nRadius, 16, 4, 4);
 320     TEST_FIELD(EMRANGLEARC, FLOAT, eStartAngle, 20, 4, 4);
 321     TEST_FIELD(EMRANGLEARC, FLOAT, eSweepAngle, 24, 4, 4);
 322
 323     /* EMRARC (pack 4) */
 324     TEST_TYPE(EMRARC, 40, 4);
 325     TEST_FIELD(EMRARC, EMR, emr, 0, 8, 4);
 326     TEST_FIELD(EMRARC, RECTL, rclBox, 8, 16, 4);
 327     TEST_FIELD(EMRARC, POINTL, ptlStart, 24, 8, 4);
 328     TEST_FIELD(EMRARC, POINTL, ptlEnd, 32, 8, 4);
 329
 330     /* EMRBITBLT (pack 4) */
 331     TEST_TYPE(EMRBITBLT, 100, 4);
 332     TEST_FIELD(EMRBITBLT, EMR, emr, 0, 8, 4);
 333     TEST_FIELD(EMRBITBLT, RECTL, rclBounds, 8, 16, 4);
 334     TEST_FIELD(EMRBITBLT, LONG, xDest, 24, 4, 4);
 335     TEST_FIELD(EMRBITBLT, LONG, yDest, 28, 4, 4);
 336     TEST_FIELD(EMRBITBLT, LONG, cxDest, 32, 4, 4);
 337     TEST_FIELD(EMRBITBLT, LONG, cyDest, 36, 4, 4);
 338     TEST_FIELD(EMRBITBLT, DWORD, dwRop, 40, 4, 4);
 339     TEST_FIELD(EMRBITBLT, LONG, xSrc, 44, 4, 4);
 340     TEST_FIELD(EMRBITBLT, LONG, ySrc, 48, 4, 4);
 341     TEST_FIELD(EMRBITBLT, XFORM, xformSrc, 52, 24, 4);
 342     TEST_FIELD(EMRBITBLT, COLORREF, crBkColorSrc, 76, 4, 4);
 343     TEST_FIELD(EMRBITBLT, DWORD, iUsageSrc, 80, 4, 4);
 344     TEST_FIELD(EMRBITBLT, DWORD, offBmiSrc, 84, 4, 4);
 345     TEST_FIELD(EMRBITBLT, DWORD, cbBmiSrc, 88, 4, 4);
 346     TEST_FIELD(EMRBITBLT, DWORD, offBitsSrc, 92, 4, 4);
 347     TEST_FIELD(EMRBITBLT, DWORD, cbBitsSrc, 96, 4, 4);
 348
 349     /* EMRCREATEBRUSHINDIRECT (pack 4) */
 350     TEST_TYPE(EMRCREATEBRUSHINDIRECT, 24, 4);
 351     TEST_FIELD(EMRCREATEBRUSHINDIRECT, EMR, emr, 0, 8, 4);
 352     TEST_FIELD(EMRCREATEBRUSHINDIRECT, DWORD, ihBrush, 8, 4, 4);
 353     TEST_FIELD(EMRCREATEBRUSHINDIRECT, LOGBRUSH, lb, 12, 12, 4);
 354
 355     /* EMRCREATEDIBPATTERNBRUSHPT (pack 4) */
 356     TEST_TYPE(EMRCREATEDIBPATTERNBRUSHPT, 32, 4);
 357     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, EMR, emr, 0, 8, 4);
 358     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, ihBrush, 8, 4, 4);
 359     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, iUsage, 12, 4, 4);
 360     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBmi, 16, 4, 4);
 361     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBmi, 20, 4, 4);
 362     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBits, 24, 4, 4);
 363     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBits, 28, 4, 4);
 364
 365     /* EMRCREATEMONOBRUSH (pack 4) */
 366     TEST_TYPE(EMRCREATEMONOBRUSH, 32, 4);
 367     TEST_FIELD(EMRCREATEMONOBRUSH, EMR, emr, 0, 8, 4);
 368     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, ihBrush, 8, 4, 4);
 369     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, iUsage, 12, 4, 4);
 370     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBmi, 16, 4, 4);
 371     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBmi, 20, 4, 4);
 372     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBits, 24, 4, 4);
 373     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBits, 28, 4, 4);
 374
 375     /* EMRCREATEPEN (pack 4) */
 376     TEST_TYPE(EMRCREATEPEN, 28, 4);
 377     TEST_FIELD(EMRCREATEPEN, EMR, emr, 0, 8, 4);
 378     TEST_FIELD(EMRCREATEPEN, DWORD, ihPen, 8, 4, 4);
 379     TEST_FIELD(EMRCREATEPEN, LOGPEN, lopn, 12, 16, 4);
 380
 381     /* EMRDELETECOLORSPACE (pack 4) */
 382     TEST_TYPE(EMRDELETECOLORSPACE, 12, 4);
 383     TEST_FIELD(EMRDELETECOLORSPACE, EMR, emr, 0, 8, 4);
 384     TEST_FIELD(EMRDELETECOLORSPACE, DWORD, ihCS, 8, 4, 4);
 385
 386     /* EMRDELETEOBJECT (pack 4) */
 387     TEST_TYPE(EMRDELETEOBJECT, 12, 4);
 388     TEST_FIELD(EMRDELETEOBJECT, EMR, emr, 0, 8, 4);
 389     TEST_FIELD(EMRDELETEOBJECT, DWORD, ihObject, 8, 4, 4);
 390
 391     /* EMRELLIPSE (pack 4) */
 392     TEST_TYPE(EMRELLIPSE, 24, 4);
 393     TEST_FIELD(EMRELLIPSE, EMR, emr, 0, 8, 4);
 394     TEST_FIELD(EMRELLIPSE, RECTL, rclBox, 8, 16, 4);
 395
 396     /* EMREOF (pack 4) */
 397     TEST_TYPE(EMREOF, 20, 4);
 398     TEST_FIELD(EMREOF, EMR, emr, 0, 8, 4);
 399     TEST_FIELD(EMREOF, DWORD, nPalEntries, 8, 4, 4);
 400     TEST_FIELD(EMREOF, DWORD, offPalEntries, 12, 4, 4);
 401     TEST_FIELD(EMREOF, DWORD, nSizeLast, 16, 4, 4);
 402
 403     /* EMREXCLUDECLIPRECT (pack 4) */
 404     TEST_TYPE(EMREXCLUDECLIPRECT, 24, 4);
 405     TEST_FIELD(EMREXCLUDECLIPRECT, EMR, emr, 0, 8, 4);
 406     TEST_FIELD(EMREXCLUDECLIPRECT, RECTL, rclClip, 8, 16, 4);
 407
 408     /* EMREXTCREATEFONTINDIRECTW (pack 4) */
 409     TEST_TYPE(EMREXTCREATEFONTINDIRECTW, 332, 4);
 410     TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EMR, emr, 0, 8, 4);
 411     TEST_FIELD(EMREXTCREATEFONTINDIRECTW, DWORD, ihFont, 8, 4, 4);
 412     TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EXTLOGFONTW, elfw, 12, 320, 4);
 413
 414     /* EMREXTCREATEPEN (pack 4) */
 415     TEST_TYPE(EMREXTCREATEPEN, 56, 4);
 416     TEST_FIELD(EMREXTCREATEPEN, EMR, emr, 0, 8, 4);
 417     TEST_FIELD(EMREXTCREATEPEN, DWORD, ihPen, 8, 4, 4);
 418     TEST_FIELD(EMREXTCREATEPEN, DWORD, offBmi, 12, 4, 4);
 419     TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBmi, 16, 4, 4);
 420     TEST_FIELD(EMREXTCREATEPEN, DWORD, offBits, 20, 4, 4);
 421     TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBits, 24, 4, 4);
 422     TEST_FIELD(EMREXTCREATEPEN, EXTLOGPEN, elp, 28, 28, 4);
 423
 424     /* EMREXTFLOODFILL (pack 4) */
 425     TEST_TYPE(EMREXTFLOODFILL, 24, 4);
 426     TEST_FIELD(EMREXTFLOODFILL, EMR, emr, 0, 8, 4);
 427     TEST_FIELD(EMREXTFLOODFILL, POINTL, ptlStart, 8, 8, 4);
 428     TEST_FIELD(EMREXTFLOODFILL, COLORREF, crColor, 16, 4, 4);
 429     TEST_FIELD(EMREXTFLOODFILL, DWORD, iMode, 20, 4, 4);
 430
 431     /* EMREXTSELECTCLIPRGN (pack 4) */
 432     TEST_TYPE(EMREXTSELECTCLIPRGN, 20, 4);
 433     TEST_FIELD(EMREXTSELECTCLIPRGN, EMR, emr, 0, 8, 4);
 434     TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, cbRgnData, 8, 4, 4);
 435     TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, iMode, 12, 4, 4);
 436     TEST_FIELD(EMREXTSELECTCLIPRGN, BYTE[1], RgnData, 16, 1, 1);
 437
 438     /* EMREXTTEXTOUTA (pack 4) */
 439     TEST_TYPE(EMREXTTEXTOUTA, 76, 4);
 440     TEST_FIELD(EMREXTTEXTOUTA, EMR, emr, 0, 8, 4);
 441     TEST_FIELD(EMREXTTEXTOUTA, RECTL, rclBounds, 8, 16, 4);
 442     TEST_FIELD(EMREXTTEXTOUTA, DWORD, iGraphicsMode, 24, 4, 4);
 443     TEST_FIELD(EMREXTTEXTOUTA, FLOAT, exScale, 28, 4, 4);
 444     TEST_FIELD(EMREXTTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
 445     TEST_FIELD(EMREXTTEXTOUTA, EMRTEXT, emrtext, 36, 40, 4);
 446
 447     /* EMRFILLPATH (pack 4) */
 448     TEST_TYPE(EMRFILLPATH, 24, 4);
 449     TEST_FIELD(EMRFILLPATH, EMR, emr, 0, 8, 4);
 450     TEST_FIELD(EMRFILLPATH, RECTL, rclBounds, 8, 16, 4);
 451
 452     /* EMRFILLRGN (pack 4) */
 453     TEST_TYPE(EMRFILLRGN, 36, 4);
 454     TEST_FIELD(EMRFILLRGN, EMR, emr, 0, 8, 4);
 455     TEST_FIELD(EMRFILLRGN, RECTL, rclBounds, 8, 16, 4);
 456     TEST_FIELD(EMRFILLRGN, DWORD, cbRgnData, 24, 4, 4);
 457     TEST_FIELD(EMRFILLRGN, DWORD, ihBrush, 28, 4, 4);
 458     TEST_FIELD(EMRFILLRGN, BYTE[1], RgnData, 32, 1, 1);
 459
 460     /* EMRFORMAT (pack 4) */
 461     TEST_TYPE(EMRFORMAT, 16, 4);
 462     TEST_FIELD(EMRFORMAT, DWORD, dSignature, 0, 4, 4);
 463     TEST_FIELD(EMRFORMAT, DWORD, nVersion, 4, 4, 4);
 464     TEST_FIELD(EMRFORMAT, DWORD, cbData, 8, 4, 4);
 465     TEST_FIELD(EMRFORMAT, DWORD, offData, 12, 4, 4);
 466
 467     /* EMRFRAMERGN (pack 4) */
 468     TEST_TYPE(EMRFRAMERGN, 44, 4);
 469     TEST_FIELD(EMRFRAMERGN, EMR, emr, 0, 8, 4);
 470     TEST_FIELD(EMRFRAMERGN, RECTL, rclBounds, 8, 16, 4);
 471     TEST_FIELD(EMRFRAMERGN, DWORD, cbRgnData, 24, 4, 4);
 472     TEST_FIELD(EMRFRAMERGN, DWORD, ihBrush, 28, 4, 4);
 473     TEST_FIELD(EMRFRAMERGN, SIZEL, szlStroke, 32, 8, 4);
 474     TEST_FIELD(EMRFRAMERGN, BYTE[1], RgnData, 40, 1, 1);
 475
 476     /* EMRGDICOMMENT (pack 4) */
 477     TEST_TYPE(EMRGDICOMMENT, 16, 4);
 478     TEST_FIELD(EMRGDICOMMENT, EMR, emr, 0, 8, 4);
 479     TEST_FIELD(EMRGDICOMMENT, DWORD, cbData, 8, 4, 4);
 480     TEST_FIELD(EMRGDICOMMENT, BYTE[1], Data, 12, 1, 1);
 481
 482     /* EMRGLSBOUNDEDRECORD (pack 4) */
 483     TEST_TYPE(EMRGLSBOUNDEDRECORD, 32, 4);
 484     TEST_FIELD(EMRGLSBOUNDEDRECORD, EMR, emr, 0, 8, 4);
 485     TEST_FIELD(EMRGLSBOUNDEDRECORD, RECTL, rclBounds, 8, 16, 4);
 486     TEST_FIELD(EMRGLSBOUNDEDRECORD, DWORD, cbData, 24, 4, 4);
 487     TEST_FIELD(EMRGLSBOUNDEDRECORD, BYTE[1], Data, 28, 1, 1);
 488
 489     /* EMRGLSRECORD (pack 4) */
 490     TEST_TYPE(EMRGLSRECORD, 16, 4);
 491     TEST_FIELD(EMRGLSRECORD, EMR, emr, 0, 8, 4);
 492     TEST_FIELD(EMRGLSRECORD, DWORD, cbData, 8, 4, 4);
 493     TEST_FIELD(EMRGLSRECORD, BYTE[1], Data, 12, 1, 1);
 494
 495     /* EMRINVERTRGN (pack 4) */
 496     TEST_TYPE(EMRINVERTRGN, 32, 4);
 497     TEST_FIELD(EMRINVERTRGN, EMR, emr, 0, 8, 4);
 498     TEST_FIELD(EMRINVERTRGN, RECTL, rclBounds, 8, 16, 4);
 499     TEST_FIELD(EMRINVERTRGN, DWORD, cbRgnData, 24, 4, 4);
 500     TEST_FIELD(EMRINVERTRGN, BYTE[1], RgnData, 28, 1, 1);
 501
 502     /* EMRLINETO (pack 4) */
 503     TEST_TYPE(EMRLINETO, 16, 4);
 504     TEST_FIELD(EMRLINETO, EMR, emr, 0, 8, 4);
 505     TEST_FIELD(EMRLINETO, POINTL, ptl, 8, 8, 4);
 506
 507     /* EMRMASKBLT (pack 4) */
 508     TEST_TYPE(EMRMASKBLT, 128, 4);
 509     TEST_FIELD(EMRMASKBLT, EMR, emr, 0, 8, 4);
 510     TEST_FIELD(EMRMASKBLT, RECTL, rclBounds, 8, 16, 4);
 511     TEST_FIELD(EMRMASKBLT, LONG, xDest, 24, 4, 4);
 512     TEST_FIELD(EMRMASKBLT, LONG, yDest, 28, 4, 4);
 513     TEST_FIELD(EMRMASKBLT, LONG, cxDest, 32, 4, 4);
 514     TEST_FIELD(EMRMASKBLT, LONG, cyDest, 36, 4, 4);
 515     TEST_FIELD(EMRMASKBLT, DWORD, dwRop, 40, 4, 4);
 516     TEST_FIELD(EMRMASKBLT, LONG, xSrc, 44, 4, 4);
 517     TEST_FIELD(EMRMASKBLT, LONG, ySrc, 48, 4, 4);
 518     TEST_FIELD(EMRMASKBLT, XFORM, xformSrc, 52, 24, 4);
 519     TEST_FIELD(EMRMASKBLT, COLORREF, crBkColorSrc, 76, 4, 4);
 520     TEST_FIELD(EMRMASKBLT, DWORD, iUsageSrc, 80, 4, 4);
 521     TEST_FIELD(EMRMASKBLT, DWORD, offBmiSrc, 84, 4, 4);
 522     TEST_FIELD(EMRMASKBLT, DWORD, cbBmiSrc, 88, 4, 4);
 523     TEST_FIELD(EMRMASKBLT, DWORD, offBitsSrc, 92, 4, 4);
 524     TEST_FIELD(EMRMASKBLT, DWORD, cbBitsSrc, 96, 4, 4);
 525     TEST_FIELD(EMRMASKBLT, LONG, xMask, 100, 4, 4);
 526     TEST_FIELD(EMRMASKBLT, LONG, yMask, 104, 4, 4);
 527     TEST_FIELD(EMRMASKBLT, DWORD, iUsageMask, 108, 4, 4);
 528     TEST_FIELD(EMRMASKBLT, DWORD, offBmiMask, 112, 4, 4);
 529     TEST_FIELD(EMRMASKBLT, DWORD, cbBmiMask, 116, 4, 4);
 530     TEST_FIELD(EMRMASKBLT, DWORD, offBitsMask, 120, 4, 4);
 531     TEST_FIELD(EMRMASKBLT, DWORD, cbBitsMask, 124, 4, 4);
 532
 533     /* EMRMODIFYWORLDTRANSFORM (pack 4) */
 534     TEST_TYPE(EMRMODIFYWORLDTRANSFORM, 36, 4);
 535     TEST_FIELD(EMRMODIFYWORLDTRANSFORM, EMR, emr, 0, 8, 4);
 536     TEST_FIELD(EMRMODIFYWORLDTRANSFORM, XFORM, xform, 8, 24, 4);
 537     TEST_FIELD(EMRMODIFYWORLDTRANSFORM, DWORD, iMode, 32, 4, 4);
 538
 539     /* EMROFFSETCLIPRGN (pack 4) */
 540     TEST_TYPE(EMROFFSETCLIPRGN, 16, 4);
 541     TEST_FIELD(EMROFFSETCLIPRGN, EMR, emr, 0, 8, 4);
 542     TEST_FIELD(EMROFFSETCLIPRGN, POINTL, ptlOffset, 8, 8, 4);
 543
 544     /* EMRPIXELFORMAT (pack 4) */
 545     TEST_TYPE(EMRPIXELFORMAT, 48, 4);
 546     TEST_FIELD(EMRPIXELFORMAT, EMR, emr, 0, 8, 4);
 547     TEST_FIELD(EMRPIXELFORMAT, PIXELFORMATDESCRIPTOR, pfd, 8, 40, 4);
 548
 549     /* EMRPLGBLT (pack 4) */
 550     TEST_TYPE(EMRPLGBLT, 140, 4);
 551     TEST_FIELD(EMRPLGBLT, EMR, emr, 0, 8, 4);
 552     TEST_FIELD(EMRPLGBLT, RECTL, rclBounds, 8, 16, 4);
 553     TEST_FIELD(EMRPLGBLT, POINTL[3], aptlDest, 24, 24, 4);
 554     TEST_FIELD(EMRPLGBLT, LONG, xSrc, 48, 4, 4);
 555     TEST_FIELD(EMRPLGBLT, LONG, ySrc, 52, 4, 4);
 556     TEST_FIELD(EMRPLGBLT, LONG, cxSrc, 56, 4, 4);
 557     TEST_FIELD(EMRPLGBLT, LONG, cySrc, 60, 4, 4);
 558     TEST_FIELD(EMRPLGBLT, XFORM, xformSrc, 64, 24, 4);
 559     TEST_FIELD(EMRPLGBLT, COLORREF, crBkColorSrc, 88, 4, 4);
 560     TEST_FIELD(EMRPLGBLT, DWORD, iUsageSrc, 92, 4, 4);
 561     TEST_FIELD(EMRPLGBLT, DWORD, offBmiSrc, 96, 4, 4);
 562     TEST_FIELD(EMRPLGBLT, DWORD, cbBmiSrc, 100, 4, 4);
 563     TEST_FIELD(EMRPLGBLT, DWORD, offBitsSrc, 104, 4, 4);
 564     TEST_FIELD(EMRPLGBLT, DWORD, cbBitsSrc, 108, 4, 4);
 565     TEST_FIELD(EMRPLGBLT, LONG, xMask, 112, 4, 4);
 566     TEST_FIELD(EMRPLGBLT, LONG, yMask, 116, 4, 4);
 567     TEST_FIELD(EMRPLGBLT, DWORD, iUsageMask, 120, 4, 4);
 568     TEST_FIELD(EMRPLGBLT, DWORD, offBmiMask, 124, 4, 4);
 569     TEST_FIELD(EMRPLGBLT, DWORD, cbBmiMask, 128, 4, 4);
 570     TEST_FIELD(EMRPLGBLT, DWORD, offBitsMask, 132, 4, 4);
 571     TEST_FIELD(EMRPLGBLT, DWORD, cbBitsMask, 136, 4, 4);
 572
 573     /* EMRPOLYDRAW (pack 4) */
 574     TEST_TYPE(EMRPOLYDRAW, 40, 4);
 575     TEST_FIELD(EMRPOLYDRAW, EMR, emr, 0, 8, 4);
 576     TEST_FIELD(EMRPOLYDRAW, RECTL, rclBounds, 8, 16, 4);
 577     TEST_FIELD(EMRPOLYDRAW, DWORD, cptl, 24, 4, 4);
 578     TEST_FIELD(EMRPOLYDRAW, POINTL[1], aptl, 28, 8, 4);
 579     TEST_FIELD(EMRPOLYDRAW, BYTE[1], abTypes, 36, 1, 1);
 580
 581     /* EMRPOLYLINE (pack 4) */
 582     TEST_TYPE(EMRPOLYLINE, 36, 4);
 583     TEST_FIELD(EMRPOLYLINE, EMR, emr, 0, 8, 4);
 584     TEST_FIELD(EMRPOLYLINE, RECTL, rclBounds, 8, 16, 4);
 585     TEST_FIELD(EMRPOLYLINE, DWORD, cptl, 24, 4, 4);
 586     TEST_FIELD(EMRPOLYLINE, POINTL[1], aptl, 28, 8, 4);
 587
 588     /* EMRPOLYPOLYLINE (pack 4) */
 589     TEST_TYPE(EMRPOLYPOLYLINE, 44, 4);
 590     TEST_FIELD(EMRPOLYPOLYLINE, EMR, emr, 0, 8, 4);
 591     TEST_FIELD(EMRPOLYPOLYLINE, RECTL, rclBounds, 8, 16, 4);
 592     TEST_FIELD(EMRPOLYPOLYLINE, DWORD, nPolys, 24, 4, 4);
 593     TEST_FIELD(EMRPOLYPOLYLINE, DWORD, cptl, 28, 4, 4);
 594     TEST_FIELD(EMRPOLYPOLYLINE, DWORD[1], aPolyCounts, 32, 4, 4);
 595     TEST_FIELD(EMRPOLYPOLYLINE, POINTL[1], aptl, 36, 8, 4);
 596
 597     /* EMRPOLYTEXTOUTA (pack 4) */
 598     TEST_TYPE(EMRPOLYTEXTOUTA, 80, 4);
 599     TEST_FIELD(EMRPOLYTEXTOUTA, EMR, emr, 0, 8, 4);
 600     TEST_FIELD(EMRPOLYTEXTOUTA, RECTL, rclBounds, 8, 16, 4);
 601     TEST_FIELD(EMRPOLYTEXTOUTA, DWORD, iGraphicsMode, 24, 4, 4);
 602     TEST_FIELD(EMRPOLYTEXTOUTA, FLOAT, exScale, 28, 4, 4);
 603     TEST_FIELD(EMRPOLYTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
 604     TEST_FIELD(EMRPOLYTEXTOUTA, LONG, cStrings, 36, 4, 4);
 605     TEST_FIELD(EMRPOLYTEXTOUTA, EMRTEXT[1], aemrtext, 40, 40, 4);
 606
 607     /* EMRRESIZEPALETTE (pack 4) */
 608     TEST_TYPE(EMRRESIZEPALETTE, 16, 4);
 609     TEST_FIELD(EMRRESIZEPALETTE, EMR, emr, 0, 8, 4);
 610     TEST_FIELD(EMRRESIZEPALETTE, DWORD, ihPal, 8, 4, 4);
 611     TEST_FIELD(EMRRESIZEPALETTE, DWORD, cEntries, 12, 4, 4);
 612
 613     /* EMRRESTOREDC (pack 4) */
 614     TEST_TYPE(EMRRESTOREDC, 12, 4);
 615     TEST_FIELD(EMRRESTOREDC, EMR, emr, 0, 8, 4);
 616     TEST_FIELD(EMRRESTOREDC, LONG, iRelative, 8, 4, 4);
 617
 618     /* EMRROUNDRECT (pack 4) */
 619     TEST_TYPE(EMRROUNDRECT, 32, 4);
 620     TEST_FIELD(EMRROUNDRECT, EMR, emr, 0, 8, 4);
 621     TEST_FIELD(EMRROUNDRECT, RECTL, rclBox, 8, 16, 4);
 622     TEST_FIELD(EMRROUNDRECT, SIZEL, szlCorner, 24, 8, 4);
 623
 624     /* EMRSCALEVIEWPORTEXTEX (pack 4) */
 625     TEST_TYPE(EMRSCALEVIEWPORTEXTEX, 24, 4);
 626     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, EMR, emr, 0, 8, 4);
 627     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, xNum, 8, 4, 4);
 628     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, xDenom, 12, 4, 4);
 629     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yNum, 16, 4, 4);
 630     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yDenom, 20, 4, 4);
 631
 632     /* EMRSELECTCLIPPATH (pack 4) */
 633     TEST_TYPE(EMRSELECTCLIPPATH, 12, 4);
 634     TEST_FIELD(EMRSELECTCLIPPATH, EMR, emr, 0, 8, 4);
 635     TEST_FIELD(EMRSELECTCLIPPATH, DWORD, iMode, 8, 4, 4);
 636
 637     /* EMRSELECTPALETTE (pack 4) */
 638     TEST_TYPE(EMRSELECTPALETTE, 12, 4);
 639     TEST_FIELD(EMRSELECTPALETTE, EMR, emr, 0, 8, 4);
 640     TEST_FIELD(EMRSELECTPALETTE, DWORD, ihPal, 8, 4, 4);
 641
 642     /* EMRSETARCDIRECTION (pack 4) */
 643     TEST_TYPE(EMRSETARCDIRECTION, 12, 4);
 644     TEST_FIELD(EMRSETARCDIRECTION, EMR, emr, 0, 8, 4);
 645     TEST_FIELD(EMRSETARCDIRECTION, DWORD, iArcDirection, 8, 4, 4);
 646
 647     /* EMRSETBKCOLOR (pack 4) */
 648     TEST_TYPE(EMRSETBKCOLOR, 12, 4);
 649     TEST_FIELD(EMRSETBKCOLOR, EMR, emr, 0, 8, 4);
 650     TEST_FIELD(EMRSETBKCOLOR, COLORREF, crColor, 8, 4, 4);
 651
 652     /* EMRSETBRUSHORGEX (pack 4) */
 653     TEST_TYPE(EMRSETBRUSHORGEX, 16, 4);
 654     TEST_FIELD(EMRSETBRUSHORGEX, EMR, emr, 0, 8, 4);
 655     TEST_FIELD(EMRSETBRUSHORGEX, POINTL, ptlOrigin, 8, 8, 4);
 656
 657     /* EMRSETCOLORADJUSTMENT (pack 4) */
 658     TEST_TYPE(EMRSETCOLORADJUSTMENT, 32, 4);
 659     TEST_FIELD(EMRSETCOLORADJUSTMENT, EMR, emr, 0, 8, 4);
 660     TEST_FIELD(EMRSETCOLORADJUSTMENT, COLORADJUSTMENT, ColorAdjustment, 8, 24, 2);
 661
 662     /* EMRSETDIBITSTODEVICE (pack 4) */
 663     TEST_TYPE(EMRSETDIBITSTODEVICE, 76, 4);
 664     TEST_FIELD(EMRSETDIBITSTODEVICE, EMR, emr, 0, 8, 4);
 665     TEST_FIELD(EMRSETDIBITSTODEVICE, RECTL, rclBounds, 8, 16, 4);
 666     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, xDest, 24, 4, 4);
 667     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, yDest, 28, 4, 4);
 668     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, xSrc, 32, 4, 4);
 669     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, ySrc, 36, 4, 4);
 670     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, cxSrc, 40, 4, 4);
 671     TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, cySrc, 44, 4, 4);
 672     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, offBmiSrc, 48, 4, 4);
 673     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cbBmiSrc, 52, 4, 4);
 674     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, offBitsSrc, 56, 4, 4);
 675     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cbBitsSrc, 60, 4, 4);
 676     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iUsageSrc, 64, 4, 4);
 677     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iStartScan, 68, 4, 4);
 678     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cScans, 72, 4, 4);
 679
 680     /* EMRSETMAPPERFLAGS (pack 4) */
 681     TEST_TYPE(EMRSETMAPPERFLAGS, 12, 4);
 682     TEST_FIELD(EMRSETMAPPERFLAGS, EMR, emr, 0, 8, 4);
 683     TEST_FIELD(EMRSETMAPPERFLAGS, DWORD, dwFlags, 8, 4, 4);
 684
 685     /* EMRSETMITERLIMIT (pack 4) */
 686     TEST_TYPE(EMRSETMITERLIMIT, 12, 4);
 687     TEST_FIELD(EMRSETMITERLIMIT, EMR, emr, 0, 8, 4);
 688     TEST_FIELD(EMRSETMITERLIMIT, FLOAT, eMiterLimit, 8, 4, 4);
 689
 690     /* EMRSETPIXELV (pack 4) */
 691     TEST_TYPE(EMRSETPIXELV, 20, 4);
 692     TEST_FIELD(EMRSETPIXELV, EMR, emr, 0, 8, 4);
 693     TEST_FIELD(EMRSETPIXELV, POINTL, ptlPixel, 8, 8, 4);
 694     TEST_FIELD(EMRSETPIXELV, COLORREF, crColor, 16, 4, 4);
 695
 696     /* EMRSETVIEWPORTEXTEX (pack 4) */
 697     TEST_TYPE(EMRSETVIEWPORTEXTEX, 16, 4);
 698     TEST_FIELD(EMRSETVIEWPORTEXTEX, EMR, emr, 0, 8, 4);
 699     TEST_FIELD(EMRSETVIEWPORTEXTEX, SIZEL, szlExtent, 8, 8, 4);
 700
 701     /* EMRSETWORLDTRANSFORM (pack 4) */
 702     TEST_TYPE(EMRSETWORLDTRANSFORM, 32, 4);
 703     TEST_FIELD(EMRSETWORLDTRANSFORM, EMR, emr, 0, 8, 4);
 704     TEST_FIELD(EMRSETWORLDTRANSFORM, XFORM, xform, 8, 24, 4);
 705
 706     /* EMRSTRETCHBLT (pack 4) */
 707     TEST_TYPE(EMRSTRETCHBLT, 108, 4);
 708     TEST_FIELD(EMRSTRETCHBLT, EMR, emr, 0, 8, 4);
 709     TEST_FIELD(EMRSTRETCHBLT, RECTL, rclBounds, 8, 16, 4);
 710     TEST_FIELD(EMRSTRETCHBLT, LONG, xDest, 24, 4, 4);
 711     TEST_FIELD(EMRSTRETCHBLT, LONG, yDest, 28, 4, 4);
 712     TEST_FIELD(EMRSTRETCHBLT, LONG, cxDest, 32, 4, 4);
 713     TEST_FIELD(EMRSTRETCHBLT, LONG, cyDest, 36, 4, 4);
 714     TEST_FIELD(EMRSTRETCHBLT, DWORD, dwRop, 40, 4, 4);
 715     TEST_FIELD(EMRSTRETCHBLT, LONG, xSrc, 44, 4, 4);
 716     TEST_FIELD(EMRSTRETCHBLT, LONG, ySrc, 48, 4, 4);
 717     TEST_FIELD(EMRSTRETCHBLT, XFORM, xformSrc, 52, 24, 4);
 718     TEST_FIELD(EMRSTRETCHBLT, COLORREF, crBkColorSrc, 76, 4, 4);
 719     TEST_FIELD(EMRSTRETCHBLT, DWORD, iUsageSrc, 80, 4, 4);
 720     TEST_FIELD(EMRSTRETCHBLT, DWORD, offBmiSrc, 84, 4, 4);
 721     TEST_FIELD(EMRSTRETCHBLT, DWORD, cbBmiSrc, 88, 4, 4);
 722     TEST_FIELD(EMRSTRETCHBLT, DWORD, offBitsSrc, 92, 4, 4);
 723     TEST_FIELD(EMRSTRETCHBLT, DWORD, cbBitsSrc, 96, 4, 4);
 724     TEST_FIELD(EMRSTRETCHBLT, LONG, cxSrc, 100, 4, 4);
 725     TEST_FIELD(EMRSTRETCHBLT, LONG, cySrc, 104, 4, 4);
 726
 727     /* EMRSTRETCHDIBITS (pack 4) */
 728     TEST_TYPE(EMRSTRETCHDIBITS, 80, 4);
 729     TEST_FIELD(EMRSTRETCHDIBITS, EMR, emr, 0, 8, 4);
 730     TEST_FIELD(EMRSTRETCHDIBITS, RECTL, rclBounds, 8, 16, 4);
 731     TEST_FIELD(EMRSTRETCHDIBITS, LONG, xDest, 24, 4, 4);
 732     TEST_FIELD(EMRSTRETCHDIBITS, LONG, yDest, 28, 4, 4);
 733     TEST_FIELD(EMRSTRETCHDIBITS, LONG, xSrc, 32, 4, 4);
 734     TEST_FIELD(EMRSTRETCHDIBITS, LONG, ySrc, 36, 4, 4);
 735     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cxSrc, 40, 4, 4);
 736     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cySrc, 44, 4, 4);
 737     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, offBmiSrc, 48, 4, 4);
 738     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, cbBmiSrc, 52, 4, 4);
 739     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, offBitsSrc, 56, 4, 4);
 740     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, cbBitsSrc, 60, 4, 4);
 741     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, iUsageSrc, 64, 4, 4);
 742     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, dwRop, 68, 4, 4);
 743     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cxDest, 72, 4, 4);
 744     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cyDest, 76, 4, 4);
 745
 746     /* EMRTEXT (pack 4) */
 747     TEST_TYPE(EMRTEXT, 40, 4);
 748     TEST_FIELD(EMRTEXT, POINTL, ptlReference, 0, 8, 4);
 749     TEST_FIELD(EMRTEXT, DWORD, nChars, 8, 4, 4);
 750     TEST_FIELD(EMRTEXT, DWORD, offString, 12, 4, 4);
 751     TEST_FIELD(EMRTEXT, DWORD, fOptions, 16, 4, 4);
 752     TEST_FIELD(EMRTEXT, RECTL, rcl, 20, 16, 4);
 753     TEST_FIELD(EMRTEXT, DWORD, offDx, 36, 4, 4);
 754
 755     /* ENHMETAHEADER (pack 4) */
 756     TEST_FIELD(ENHMETAHEADER, DWORD, iType, 0, 4, 4);
 757     TEST_FIELD(ENHMETAHEADER, DWORD, nSize, 4, 4, 4);
 758     TEST_FIELD(ENHMETAHEADER, RECTL, rclBounds, 8, 16, 4);
 759     TEST_FIELD(ENHMETAHEADER, RECTL, rclFrame, 24, 16, 4);
 760     TEST_FIELD(ENHMETAHEADER, DWORD, dSignature, 40, 4, 4);
 761     TEST_FIELD(ENHMETAHEADER, DWORD, nVersion, 44, 4, 4);
 762     TEST_FIELD(ENHMETAHEADER, DWORD, nBytes, 48, 4, 4);
 763     TEST_FIELD(ENHMETAHEADER, DWORD, nRecords, 52, 4, 4);
 764     TEST_FIELD(ENHMETAHEADER, WORD, nHandles, 56, 2, 2);
 765     TEST_FIELD(ENHMETAHEADER, WORD, sReserved, 58, 2, 2);
 766     TEST_FIELD(ENHMETAHEADER, DWORD, nDescription, 60, 4, 4);
 767     TEST_FIELD(ENHMETAHEADER, DWORD, offDescription, 64, 4, 4);
 768     TEST_FIELD(ENHMETAHEADER, DWORD, nPalEntries, 68, 4, 4);
 769     TEST_FIELD(ENHMETAHEADER, SIZEL, szlDevice, 72, 8, 4);
 770     TEST_FIELD(ENHMETAHEADER, SIZEL, szlMillimeters, 80, 8, 4);
 771     TEST_FIELD(ENHMETAHEADER, DWORD, cbPixelFormat, 88, 4, 4);
 772     TEST_FIELD(ENHMETAHEADER, DWORD, offPixelFormat, 92, 4, 4);
 773     TEST_FIELD(ENHMETAHEADER, DWORD, bOpenGL, 96, 4, 4);
 774
 775     /* ENHMETARECORD (pack 4) */
 776     TEST_TYPE(ENHMETARECORD, 12, 4);
 777     TEST_FIELD(ENHMETARECORD, DWORD, iType, 0, 4, 4);
 778     TEST_FIELD(ENHMETARECORD, DWORD, nSize, 4, 4, 4);
 779     TEST_FIELD(ENHMETARECORD, DWORD[1], dParm, 8, 4, 4);
 780
 781     /* ENHMFENUMPROC */
 782
 783     /* ENUMLOGFONTA (pack 4) */
 784     TEST_TYPE(ENUMLOGFONTA, 156, 4);
 785     TEST_FIELD(ENUMLOGFONTA, LOGFONTA, elfLogFont, 0, 60, 4);
 786     TEST_FIELD(ENUMLOGFONTA, BYTE[LF_FULLFACESIZE], elfFullName, 60, 64, 1);
 787     TEST_FIELD(ENUMLOGFONTA, BYTE[LF_FACESIZE], elfStyle, 124, 32, 1);
 788
 789     /* ENUMLOGFONTEXA (pack 4) */
 790     TEST_TYPE(ENUMLOGFONTEXA, 188, 4);
 791     TEST_FIELD(ENUMLOGFONTEXA, LOGFONTA, elfLogFont, 0, 60, 4);
 792     TEST_FIELD(ENUMLOGFONTEXA, BYTE[LF_FULLFACESIZE], elfFullName, 60, 64, 1);
 793     TEST_FIELD(ENUMLOGFONTEXA, BYTE[LF_FACESIZE], elfStyle, 124, 32, 1);
 794     TEST_FIELD(ENUMLOGFONTEXA, BYTE[LF_FACESIZE], elfScript, 156, 32, 1);
 795
 796     /* ENUMLOGFONTEXW (pack 4) */
 797     TEST_TYPE(ENUMLOGFONTEXW, 348, 4);
 798     TEST_FIELD(ENUMLOGFONTEXW, LOGFONTW, elfLogFont, 0, 92, 4);
 799     TEST_FIELD(ENUMLOGFONTEXW, WCHAR[LF_FULLFACESIZE], elfFullName, 92, 128, 2);
 800     TEST_FIELD(ENUMLOGFONTEXW, WCHAR[LF_FACESIZE], elfStyle, 220, 64, 2);
 801     TEST_FIELD(ENUMLOGFONTEXW, WCHAR[LF_FACESIZE], elfScript, 284, 64, 2);
 802
 803     /* ENUMLOGFONTW (pack 4) */
 804     TEST_TYPE(ENUMLOGFONTW, 284, 4);
 805     TEST_FIELD(ENUMLOGFONTW, LOGFONTW, elfLogFont, 0, 92, 4);
 806     TEST_FIELD(ENUMLOGFONTW, WCHAR[LF_FULLFACESIZE], elfFullName, 92, 128, 2);
 807     TEST_FIELD(ENUMLOGFONTW, WCHAR[LF_FACESIZE], elfStyle, 220, 64, 2);
 808
 809     /* EXTLOGFONTA (pack 4) */
 810     TEST_TYPE(EXTLOGFONTA, 192, 4);
 811     TEST_FIELD(EXTLOGFONTA, LOGFONTA, elfLogFont, 0, 60, 4);
 812     TEST_FIELD(EXTLOGFONTA, BYTE[LF_FULLFACESIZE], elfFullName, 60, 64, 1);
 813     TEST_FIELD(EXTLOGFONTA, BYTE[LF_FACESIZE], elfStyle, 124, 32, 1);
 814     TEST_FIELD(EXTLOGFONTA, DWORD, elfVersion, 156, 4, 4);
 815     TEST_FIELD(EXTLOGFONTA, DWORD, elfStyleSize, 160, 4, 4);
 816     TEST_FIELD(EXTLOGFONTA, DWORD, elfMatch, 164, 4, 4);
 817     TEST_FIELD(EXTLOGFONTA, DWORD, elfReserved, 168, 4, 4);
 818     TEST_FIELD(EXTLOGFONTA, BYTE[ELF_VENDOR_SIZE], elfVendorId, 172, 4, 1);
 819     TEST_FIELD(EXTLOGFONTA, DWORD, elfCulture, 176, 4, 4);
 820     TEST_FIELD(EXTLOGFONTA, PANOSE, elfPanose, 180, 10, 1);
 821
 822     /* EXTLOGFONTW (pack 4) */
 823     TEST_TYPE(EXTLOGFONTW, 320, 4);
 824     TEST_FIELD(EXTLOGFONTW, LOGFONTW, elfLogFont, 0, 92, 4);
 825     TEST_FIELD(EXTLOGFONTW, WCHAR[LF_FULLFACESIZE], elfFullName, 92, 128, 2);
 826     TEST_FIELD(EXTLOGFONTW, WCHAR[LF_FACESIZE], elfStyle, 220, 64, 2);
 827     TEST_FIELD(EXTLOGFONTW, DWORD, elfVersion, 284, 4, 4);
 828     TEST_FIELD(EXTLOGFONTW, DWORD, elfStyleSize, 288, 4, 4);
 829     TEST_FIELD(EXTLOGFONTW, DWORD, elfMatch, 292, 4, 4);
 830     TEST_FIELD(EXTLOGFONTW, DWORD, elfReserved, 296, 4, 4);
 831     TEST_FIELD(EXTLOGFONTW, BYTE[ELF_VENDOR_SIZE], elfVendorId, 300, 4, 1);
 832     TEST_FIELD(EXTLOGFONTW, DWORD, elfCulture, 304, 4, 4);
 833     TEST_FIELD(EXTLOGFONTW, PANOSE, elfPanose, 308, 10, 1);
 834
 835     /* EXTLOGPEN (pack 4) */
 836     TEST_TYPE(EXTLOGPEN, 28, 4);
 837     TEST_FIELD(EXTLOGPEN, DWORD, elpPenStyle, 0, 4, 4);
 838     TEST_FIELD(EXTLOGPEN, DWORD, elpWidth, 4, 4, 4);
 839     TEST_FIELD(EXTLOGPEN, UINT, elpBrushStyle, 8, 4, 4);
 840     TEST_FIELD(EXTLOGPEN, COLORREF, elpColor, 12, 4, 4);
 841     TEST_FIELD(EXTLOGPEN, LONG, elpHatch, 16, 4, 4);
 842     TEST_FIELD(EXTLOGPEN, DWORD, elpNumEntries, 20, 4, 4);
 843     TEST_FIELD(EXTLOGPEN, DWORD[1], elpStyleEntry, 24, 4, 4);
 844
 845     /* FIXED (pack 4) */
 846     TEST_TYPE(FIXED, 4, 2);
 847     TEST_FIELD(FIXED, WORD, fract, 0, 2, 2);
 848     TEST_FIELD(FIXED, SHORT, value, 2, 2, 2);
 849
 850     /* FONTENUMPROCA */
 851
 852     /* FONTENUMPROCEXA */
 853
 854     /* FONTENUMPROCEXW */
 855
 856     /* FONTENUMPROCW */
 857
 858     /* FONTSIGNATURE (pack 4) */
 859     TEST_TYPE(FONTSIGNATURE, 24, 4);
 860     TEST_FIELD(FONTSIGNATURE, DWORD[4], fsUsb, 0, 16, 4);
 861     TEST_FIELD(FONTSIGNATURE, DWORD[2], fsCsb, 16, 8, 4);
 862
 863     /* FXPT16DOT16 */
 864     TEST_TYPE(FXPT16DOT16, 4, 4);
 865
 866     /* FXPT2DOT30 */
 867     TEST_TYPE(FXPT2DOT30, 4, 4);
 868
 869     /* GCP_RESULTSA (pack 4) */
 870     TEST_TYPE(GCP_RESULTSA, 36, 4);
 871     TEST_FIELD(GCP_RESULTSA, DWORD, lStructSize, 0, 4, 4);
 872     TEST_FIELD(GCP_RESULTSA, LPSTR, lpOutString, 4, 4, 4);
 873     TEST_FIELD(GCP_RESULTSA, UINT *, lpOrder, 8, 4, 4);
 874     TEST_FIELD(GCP_RESULTSA, INT *, lpDx, 12, 4, 4);
 875     TEST_FIELD(GCP_RESULTSA, INT *, lpCaretPos, 16, 4, 4);
 876     TEST_FIELD(GCP_RESULTSA, LPSTR, lpClass, 20, 4, 4);
 877     TEST_FIELD(GCP_RESULTSA, LPWSTR, lpGlyphs, 24, 4, 4);
 878     TEST_FIELD(GCP_RESULTSA, UINT, nGlyphs, 28, 4, 4);
 879     TEST_FIELD(GCP_RESULTSA, UINT, nMaxFit, 32, 4, 4);
 880
 881     /* GCP_RESULTSW (pack 4) */
 882     TEST_TYPE(GCP_RESULTSW, 36, 4);
 883     TEST_FIELD(GCP_RESULTSW, DWORD, lStructSize, 0, 4, 4);
 884     TEST_FIELD(GCP_RESULTSW, LPWSTR, lpOutString, 4, 4, 4);
 885     TEST_FIELD(GCP_RESULTSW, UINT *, lpOrder, 8, 4, 4);
 886     TEST_FIELD(GCP_RESULTSW, INT *, lpDx, 12, 4, 4);
 887     TEST_FIELD(GCP_RESULTSW, INT *, lpCaretPos, 16, 4, 4);
 888     TEST_FIELD(GCP_RESULTSW, LPSTR, lpClass, 20, 4, 4);
 889     TEST_FIELD(GCP_RESULTSW, LPWSTR, lpGlyphs, 24, 4, 4);
 890     TEST_FIELD(GCP_RESULTSW, UINT, nGlyphs, 28, 4, 4);
 891     TEST_FIELD(GCP_RESULTSW, UINT, nMaxFit, 32, 4, 4);
 892
 893     /* GLYPHMETRICS (pack 4) */
 894     TEST_TYPE(GLYPHMETRICS, 20, 4);
 895     TEST_FIELD(GLYPHMETRICS, UINT, gmBlackBoxX, 0, 4, 4);
 896     TEST_FIELD(GLYPHMETRICS, UINT, gmBlackBoxY, 4, 4, 4);
 897     TEST_FIELD(GLYPHMETRICS, POINT, gmptGlyphOrigin, 8, 8, 4);
 898     TEST_FIELD(GLYPHMETRICS, SHORT, gmCellIncX, 16, 2, 2);
 899     TEST_FIELD(GLYPHMETRICS, SHORT, gmCellIncY, 18, 2, 2);
 900
 901     /* GOBJENUMPROC */
 902
 903     /* GRADIENT_RECT (pack 4) */
 904     TEST_TYPE(GRADIENT_RECT, 8, 4);
 905     TEST_FIELD(GRADIENT_RECT, ULONG, UpperLeft, 0, 4, 4);
 906     TEST_FIELD(GRADIENT_RECT, ULONG, LowerRight, 4, 4, 4);
 907
 908     /* GRADIENT_TRIANGLE (pack 4) */
 909     TEST_TYPE(GRADIENT_TRIANGLE, 12, 4);
 910     TEST_FIELD(GRADIENT_TRIANGLE, ULONG, Vertex1, 0, 4, 4);
 911     TEST_FIELD(GRADIENT_TRIANGLE, ULONG, Vertex2, 4, 4, 4);
 912     TEST_FIELD(GRADIENT_TRIANGLE, ULONG, Vertex3, 8, 4, 4);
 913
 914     /* HANDLETABLE (pack 4) */
 915     TEST_TYPE(HANDLETABLE, 4, 4);
 916     TEST_FIELD(HANDLETABLE, HGDIOBJ[1], objectHandle, 0, 4, 4);
 917
 918     /* KERNINGPAIR (pack 4) */
 919     TEST_TYPE(KERNINGPAIR, 8, 4);
 920     TEST_FIELD(KERNINGPAIR, WORD, wFirst, 0, 2, 2);
 921     TEST_FIELD(KERNINGPAIR, WORD, wSecond, 2, 2, 2);
 922     TEST_FIELD(KERNINGPAIR, INT, iKernAmount, 4, 4, 4);
 923
 924     /* LCSCSTYPE */
 925     TEST_TYPE(LCSCSTYPE, 4, 4);
 926
 927     /* LCSGAMUTMATCH */
 928     TEST_TYPE(LCSGAMUTMATCH, 4, 4);
 929
 930     /* LINEDDAPROC */
 931
 932     /* LOCALESIGNATURE (pack 4) */
 933     TEST_TYPE(LOCALESIGNATURE, 32, 4);
 934     TEST_FIELD(LOCALESIGNATURE, DWORD[4], lsUsb, 0, 16, 4);
 935     TEST_FIELD(LOCALESIGNATURE, DWORD[2], lsCsbDefault, 16, 8, 4);
 936     TEST_FIELD(LOCALESIGNATURE, DWORD[2], lsCsbSupported, 24, 8, 4);
 937
 938     /* LOGBRUSH (pack 4) */
 939     TEST_TYPE(LOGBRUSH, 12, 4);
 940     TEST_FIELD(LOGBRUSH, UINT, lbStyle, 0, 4, 4);
 941     TEST_FIELD(LOGBRUSH, COLORREF, lbColor, 4, 4, 4);
 942     TEST_FIELD(LOGBRUSH, INT, lbHatch, 8, 4, 4);
 943
 944     /* LOGCOLORSPACEA (pack 4) */
 945     TEST_TYPE(LOGCOLORSPACEA, 328, 4);
 946     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsSignature, 0, 4, 4);
 947     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsVersion, 4, 4, 4);
 948     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsSize, 8, 4, 4);
 949     TEST_FIELD(LOGCOLORSPACEA, LCSCSTYPE, lcsCSType, 12, 4, 4);
 950     TEST_FIELD(LOGCOLORSPACEA, LCSGAMUTMATCH, lcsIntent, 16, 4, 4);
 951     TEST_FIELD(LOGCOLORSPACEA, CIEXYZTRIPLE, lcsEndpoints, 20, 36, 4);
 952     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsGammaRed, 56, 4, 4);
 953     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsGammaGreen, 60, 4, 4);
 954     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsGammaBlue, 64, 4, 4);
 955     TEST_FIELD(LOGCOLORSPACEA, CHAR[MAX_PATH], lcsFilename, 68, 260, 1);
 956
 957     /* LOGCOLORSPACEW (pack 4) */
 958     TEST_TYPE(LOGCOLORSPACEW, 588, 4);
 959     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsSignature, 0, 4, 4);
 960     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsVersion, 4, 4, 4);
 961     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsSize, 8, 4, 4);
 962     TEST_FIELD(LOGCOLORSPACEW, LCSCSTYPE, lcsCSType, 12, 4, 4);
 963     TEST_FIELD(LOGCOLORSPACEW, LCSGAMUTMATCH, lcsIntent, 16, 4, 4);
 964     TEST_FIELD(LOGCOLORSPACEW, CIEXYZTRIPLE, lcsEndpoints, 20, 36, 4);
 965     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsGammaRed, 56, 4, 4);
 966     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsGammaGreen, 60, 4, 4);
 967     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsGammaBlue, 64, 4, 4);
 968     TEST_FIELD(LOGCOLORSPACEW, WCHAR[MAX_PATH], lcsFilename, 68, 520, 2);
 969
 970     /* LOGFONTA (pack 4) */
 971     TEST_TYPE(LOGFONTA, 60, 4);
 972     TEST_FIELD(LOGFONTA, LONG, lfHeight, 0, 4, 4);
 973     TEST_FIELD(LOGFONTA, LONG, lfWidth, 4, 4, 4);
 974     TEST_FIELD(LOGFONTA, LONG, lfEscapement, 8, 4, 4);
 975     TEST_FIELD(LOGFONTA, LONG, lfOrientation, 12, 4, 4);
 976     TEST_FIELD(LOGFONTA, LONG, lfWeight, 16, 4, 4);
 977     TEST_FIELD(LOGFONTA, BYTE, lfItalic, 20, 1, 1);
 978     TEST_FIELD(LOGFONTA, BYTE, lfUnderline, 21, 1, 1);
 979     TEST_FIELD(LOGFONTA, BYTE, lfStrikeOut, 22, 1, 1);
 980     TEST_FIELD(LOGFONTA, BYTE, lfCharSet, 23, 1, 1);
 981     TEST_FIELD(LOGFONTA, BYTE, lfOutPrecision, 24, 1, 1);
 982     TEST_FIELD(LOGFONTA, BYTE, lfClipPrecision, 25, 1, 1);
 983     TEST_FIELD(LOGFONTA, BYTE, lfQuality, 26, 1, 1);
 984     TEST_FIELD(LOGFONTA, BYTE, lfPitchAndFamily, 27, 1, 1);
 985     TEST_FIELD(LOGFONTA, CHAR[LF_FACESIZE], lfFaceName, 28, 32, 1);
 986
 987     /* LOGFONTW (pack 4) */
 988     TEST_TYPE(LOGFONTW, 92, 4);
 989     TEST_FIELD(LOGFONTW, LONG, lfHeight, 0, 4, 4);
 990     TEST_FIELD(LOGFONTW, LONG, lfWidth, 4, 4, 4);
 991     TEST_FIELD(LOGFONTW, LONG, lfEscapement, 8, 4, 4);
 992     TEST_FIELD(LOGFONTW, LONG, lfOrientation, 12, 4, 4);
 993     TEST_FIELD(LOGFONTW, LONG, lfWeight, 16, 4, 4);
 994     TEST_FIELD(LOGFONTW, BYTE, lfItalic, 20, 1, 1);
 995     TEST_FIELD(LOGFONTW, BYTE, lfUnderline, 21, 1, 1);
 996     TEST_FIELD(LOGFONTW, BYTE, lfStrikeOut, 22, 1, 1);
 997     TEST_FIELD(LOGFONTW, BYTE, lfCharSet, 23, 1, 1);
 998     TEST_FIELD(LOGFONTW, BYTE, lfOutPrecision, 24, 1, 1);
 999     TEST_FIELD(LOGFONTW, BYTE, lfClipPrecision, 25, 1, 1);
1000     TEST_FIELD(LOGFONTW, BYTE, lfQuality, 26, 1, 1);
1001     TEST_FIELD(LOGFONTW, BYTE, lfPitchAndFamily, 27, 1, 1);
1002     TEST_FIELD(LOGFONTW, WCHAR[LF_FACESIZE], lfFaceName, 28, 64, 2);
1003
1004     /* LOGPEN (pack 4) */
1005     TEST_TYPE(LOGPEN, 16, 4);
1006     TEST_FIELD(LOGPEN, UINT, lopnStyle, 0, 4, 4);
1007     TEST_FIELD(LOGPEN, POINT, lopnWidth, 4, 8, 4);
1008     TEST_FIELD(LOGPEN, COLORREF, lopnColor, 12, 4, 4);
1009
1010     /* LPABC */
1011     TEST_TYPE(LPABC, 4, 4);
1012     TEST_TYPE_POINTER(LPABC, 12, 4);
1013
1014     /* LPABCFLOAT */
1015     TEST_TYPE(LPABCFLOAT, 4, 4);
1016     TEST_TYPE_POINTER(LPABCFLOAT, 12, 4);
1017
1018     /* LPBITMAP */
1019     TEST_TYPE(LPBITMAP, 4, 4);
1020     TEST_TYPE_POINTER(LPBITMAP, 24, 4);
1021
1022     /* LPBITMAPCOREHEADER */
1023     TEST_TYPE(LPBITMAPCOREHEADER, 4, 4);
1024     TEST_TYPE_POINTER(LPBITMAPCOREHEADER, 12, 4);
1025
1026     /* LPBITMAPCOREINFO */
1027     TEST_TYPE(LPBITMAPCOREINFO, 4, 4);
1028     TEST_TYPE_POINTER(LPBITMAPCOREINFO, 16, 4);
1029
1030     /* LPBITMAPFILEHEADER */
1031     TEST_TYPE(LPBITMAPFILEHEADER, 4, 4);
1032     TEST_TYPE_POINTER(LPBITMAPFILEHEADER, 14, 2);
1033
1034     /* LPBITMAPINFO */
1035     TEST_TYPE(LPBITMAPINFO, 4, 4);
1036     TEST_TYPE_POINTER(LPBITMAPINFO, 44, 4);
1037
1038     /* LPBITMAPINFOHEADER */
1039     TEST_TYPE(LPBITMAPINFOHEADER, 4, 4);
1040     TEST_TYPE_POINTER(LPBITMAPINFOHEADER, 40, 4);
1041
1042     /* LPBITMAPV5HEADER */
1043     TEST_TYPE(LPBITMAPV5HEADER, 4, 4);
1044     TEST_TYPE_POINTER(LPBITMAPV5HEADER, 124, 4);
1045
1046     /* LPCHARSETINFO */
1047     TEST_TYPE(LPCHARSETINFO, 4, 4);
1048     TEST_TYPE_POINTER(LPCHARSETINFO, 32, 4);
1049
1050     /* LPCIEXYZ */
1051     TEST_TYPE(LPCIEXYZ, 4, 4);
1052     TEST_TYPE_POINTER(LPCIEXYZ, 12, 4);
1053
1054     /* LPCIEXYZTRIPLE */
1055     TEST_TYPE(LPCIEXYZTRIPLE, 4, 4);
1056     TEST_TYPE_POINTER(LPCIEXYZTRIPLE, 36, 4);
1057
1058     /* LPCOLORADJUSTMENT */
1059     TEST_TYPE(LPCOLORADJUSTMENT, 4, 4);
1060     TEST_TYPE_POINTER(LPCOLORADJUSTMENT, 24, 2);
1061
1062     /* LPDEVMODEA */
1063     TEST_TYPE(LPDEVMODEA, 4, 4);
1064
1065     /* LPDEVMODEW */
1066     TEST_TYPE(LPDEVMODEW, 4, 4);
1067
1068     /* LPDIBSECTION */
1069     TEST_TYPE(LPDIBSECTION, 4, 4);
1070     TEST_TYPE_POINTER(LPDIBSECTION, 84, 4);
1071
1072     /* LPDISPLAY_DEVICEA */
1073     TEST_TYPE(LPDISPLAY_DEVICEA, 4, 4);
1074
1075     /* LPDISPLAY_DEVICEW */
1076     TEST_TYPE(LPDISPLAY_DEVICEW, 4, 4);
1077
1078     /* LPDOCINFOA */
1079     TEST_TYPE(LPDOCINFOA, 4, 4);
1080     TEST_TYPE_POINTER(LPDOCINFOA, 20, 4);
1081
1082     /* LPDOCINFOW */
1083     TEST_TYPE(LPDOCINFOW, 4, 4);
1084     TEST_TYPE_POINTER(LPDOCINFOW, 20, 4);
1085
1086     /* LPENHMETAHEADER */
1087     TEST_TYPE(LPENHMETAHEADER, 4, 4);
1088
1089     /* LPENHMETARECORD */
1090     TEST_TYPE(LPENHMETARECORD, 4, 4);
1091     TEST_TYPE_POINTER(LPENHMETARECORD, 12, 4);
1092
1093     /* LPENUMLOGFONTA */
1094     TEST_TYPE(LPENUMLOGFONTA, 4, 4);
1095     TEST_TYPE_POINTER(LPENUMLOGFONTA, 156, 4);
1096
1097     /* LPENUMLOGFONTEXA */
1098     TEST_TYPE(LPENUMLOGFONTEXA, 4, 4);
1099     TEST_TYPE_POINTER(LPENUMLOGFONTEXA, 188, 4);
1100
1101     /* LPENUMLOGFONTEXW */
1102     TEST_TYPE(LPENUMLOGFONTEXW, 4, 4);
1103     TEST_TYPE_POINTER(LPENUMLOGFONTEXW, 348, 4);
1104
1105     /* LPENUMLOGFONTW */
1106     TEST_TYPE(LPENUMLOGFONTW, 4, 4);
1107     TEST_TYPE_POINTER(LPENUMLOGFONTW, 284, 4);
1108
1109     /* LPEXTLOGFONTA */
1110     TEST_TYPE(LPEXTLOGFONTA, 4, 4);
1111     TEST_TYPE_POINTER(LPEXTLOGFONTA, 192, 4);
1112
1113     /* LPEXTLOGFONTW */
1114     TEST_TYPE(LPEXTLOGFONTW, 4, 4);
1115     TEST_TYPE_POINTER(LPEXTLOGFONTW, 320, 4);
1116
1117     /* LPEXTLOGPEN */
1118     TEST_TYPE(LPEXTLOGPEN, 4, 4);
1119     TEST_TYPE_POINTER(LPEXTLOGPEN, 28, 4);
1120
1121     /* LPFONTSIGNATURE */
1122     TEST_TYPE(LPFONTSIGNATURE, 4, 4);
1123     TEST_TYPE_POINTER(LPFONTSIGNATURE, 24, 4);
1124
1125     /* LPGCP_RESULTSA */
1126     TEST_TYPE(LPGCP_RESULTSA, 4, 4);
1127     TEST_TYPE_POINTER(LPGCP_RESULTSA, 36, 4);
1128
1129     /* LPGCP_RESULTSW */
1130     TEST_TYPE(LPGCP_RESULTSW, 4, 4);
1131     TEST_TYPE_POINTER(LPGCP_RESULTSW, 36, 4);
1132
1133     /* LPGLYPHMETRICS */
1134     TEST_TYPE(LPGLYPHMETRICS, 4, 4);
1135     TEST_TYPE_POINTER(LPGLYPHMETRICS, 20, 4);
1136
1137     /* LPGRADIENT_RECT */
1138     TEST_TYPE(LPGRADIENT_RECT, 4, 4);
1139     TEST_TYPE_POINTER(LPGRADIENT_RECT, 8, 4);
1140
1141     /* LPGRADIENT_TRIANGLE */
1142     TEST_TYPE(LPGRADIENT_TRIANGLE, 4, 4);
1143     TEST_TYPE_POINTER(LPGRADIENT_TRIANGLE, 12, 4);
1144
1145     /* LPHANDLETABLE */
1146     TEST_TYPE(LPHANDLETABLE, 4, 4);
1147     TEST_TYPE_POINTER(LPHANDLETABLE, 4, 4);
1148
1149     /* LPKERNINGPAIR */
1150     TEST_TYPE(LPKERNINGPAIR, 4, 4);
1151     TEST_TYPE_POINTER(LPKERNINGPAIR, 8, 4);
1152
1153     /* LPLOGBRUSH */
1154     TEST_TYPE(LPLOGBRUSH, 4, 4);
1155     TEST_TYPE_POINTER(LPLOGBRUSH, 12, 4);
1156
1157     /* LPLOGCOLORSPACEA */
1158     TEST_TYPE(LPLOGCOLORSPACEA, 4, 4);
1159     TEST_TYPE_POINTER(LPLOGCOLORSPACEA, 328, 4);
1160
1161     /* LPLOGCOLORSPACEW */
1162     TEST_TYPE(LPLOGCOLORSPACEW, 4, 4);
1163     TEST_TYPE_POINTER(LPLOGCOLORSPACEW, 588, 4);
1164
1165     /* LPLOGFONTA */
1166     TEST_TYPE(LPLOGFONTA, 4, 4);
1167     TEST_TYPE_POINTER(LPLOGFONTA, 60, 4);
1168
1169     /* LPLOGFONTW */
1170     TEST_TYPE(LPLOGFONTW, 4, 4);
1171     TEST_TYPE_POINTER(LPLOGFONTW, 92, 4);
1172
1173     /* LPLOGPEN */
1174     TEST_TYPE(LPLOGPEN, 4, 4);
1175     TEST_TYPE_POINTER(LPLOGPEN, 16, 4);
1176
1177     /* LPMAT2 */
1178     TEST_TYPE(LPMAT2, 4, 4);
1179     TEST_TYPE_POINTER(LPMAT2, 16, 2);
1180
1181     /* LPMETAFILEPICT */
1182     TEST_TYPE(LPMETAFILEPICT, 4, 4);
1183     TEST_TYPE_POINTER(LPMETAFILEPICT, 16, 4);
1184
1185     /* LPMETAHEADER */
1186     TEST_TYPE(LPMETAHEADER, 4, 4);
1187     TEST_TYPE_POINTER(LPMETAHEADER, 18, 2);
1188
1189     /* LPMETARECORD */
1190     TEST_TYPE(LPMETARECORD, 4, 4);
1191     TEST_TYPE_POINTER(LPMETARECORD, 8, 4);
1192
1193     /* LPNEWTEXTMETRICA */
1194     TEST_TYPE(LPNEWTEXTMETRICA, 4, 4);
1195     TEST_TYPE_POINTER(LPNEWTEXTMETRICA, 72, 4);
1196
1197     /* LPNEWTEXTMETRICW */
1198     TEST_TYPE(LPNEWTEXTMETRICW, 4, 4);
1199     TEST_TYPE_POINTER(LPNEWTEXTMETRICW, 76, 4);
1200
1201     /* LPOUTLINETEXTMETRICA */
1202     TEST_TYPE(LPOUTLINETEXTMETRICA, 4, 4);
1203     TEST_TYPE_POINTER(LPOUTLINETEXTMETRICA, 212, 4);
1204
1205     /* LPOUTLINETEXTMETRICW */
1206     TEST_TYPE(LPOUTLINETEXTMETRICW, 4, 4);
1207     TEST_TYPE_POINTER(LPOUTLINETEXTMETRICW, 216, 4);
1208
1209     /* LPPANOSE */
1210     TEST_TYPE(LPPANOSE, 4, 4);
1211     TEST_TYPE_POINTER(LPPANOSE, 10, 1);
1212
1213     /* LPPELARRAY */
1214     TEST_TYPE(LPPELARRAY, 4, 4);
1215     TEST_TYPE_POINTER(LPPELARRAY, 20, 4);
1216
1217     /* LPPIXELFORMATDESCRIPTOR */
1218     TEST_TYPE(LPPIXELFORMATDESCRIPTOR, 4, 4);
1219     TEST_TYPE_POINTER(LPPIXELFORMATDESCRIPTOR, 40, 4);
1220
1221     /* LPPOINTFX */
1222     TEST_TYPE(LPPOINTFX, 4, 4);
1223     TEST_TYPE_POINTER(LPPOINTFX, 8, 2);
1224
1225     /* LPPOLYTEXTA */
1226     TEST_TYPE(LPPOLYTEXTA, 4, 4);
1227     TEST_TYPE_POINTER(LPPOLYTEXTA, 40, 4);
1228
1229     /* LPPOLYTEXTW */
1230     TEST_TYPE(LPPOLYTEXTW, 4, 4);
1231     TEST_TYPE_POINTER(LPPOLYTEXTW, 40, 4);
1232
1233     /* LPRASTERIZER_STATUS */
1234     TEST_TYPE(LPRASTERIZER_STATUS, 4, 4);
1235     TEST_TYPE_POINTER(LPRASTERIZER_STATUS, 6, 2);
1236
1237     /* LPRGBQUAD */
1238     TEST_TYPE(LPRGBQUAD, 4, 4);
1239     TEST_TYPE_POINTER(LPRGBQUAD, 4, 1);
1240
1241     /* LPRGNDATA */
1242     TEST_TYPE(LPRGNDATA, 4, 4);
1243     TEST_TYPE_POINTER(LPRGNDATA, 36, 4);
1244
1245     /* LPTEXTMETRICA */
1246     TEST_TYPE(LPTEXTMETRICA, 4, 4);
1247     TEST_TYPE_POINTER(LPTEXTMETRICA, 56, 4);
1248
1249     /* LPTEXTMETRICW */
1250     TEST_TYPE(LPTEXTMETRICW, 4, 4);
1251     TEST_TYPE_POINTER(LPTEXTMETRICW, 60, 4);
1252
1253     /* LPTRIVERTEX */
1254     TEST_TYPE(LPTRIVERTEX, 4, 4);
1255     TEST_TYPE_POINTER(LPTRIVERTEX, 16, 4);
1256
1257     /* LPTTPOLYCURVE */
1258     TEST_TYPE(LPTTPOLYCURVE, 4, 4);
1259     TEST_TYPE_POINTER(LPTTPOLYCURVE, 12, 2);
1260
1261     /* LPTTPOLYGONHEADER */
1262     TEST_TYPE(LPTTPOLYGONHEADER, 4, 4);
1263     TEST_TYPE_POINTER(LPTTPOLYGONHEADER, 16, 4);
1264
1265     /* LPXFORM */
1266     TEST_TYPE(LPXFORM, 4, 4);
1267     TEST_TYPE_POINTER(LPXFORM, 24, 4);
1268
1269     /* MAT2 (pack 4) */
1270     TEST_TYPE(MAT2, 16, 2);
1271     TEST_FIELD(MAT2, FIXED, eM11, 0, 4, 2);
1272     TEST_FIELD(MAT2, FIXED, eM12, 4, 4, 2);
1273     TEST_FIELD(MAT2, FIXED, eM21, 8, 4, 2);
1274     TEST_FIELD(MAT2, FIXED, eM22, 12, 4, 2);
1275
1276     /* METAFILEPICT (pack 4) */
1277     TEST_TYPE(METAFILEPICT, 16, 4);
1278     TEST_FIELD(METAFILEPICT, LONG, mm, 0, 4, 4);
1279     TEST_FIELD(METAFILEPICT, LONG, xExt, 4, 4, 4);
1280     TEST_FIELD(METAFILEPICT, LONG, yExt, 8, 4, 4);
1281     TEST_FIELD(METAFILEPICT, HMETAFILE, hMF, 12, 4, 4);
1282
1283     /* METAHEADER (pack 2) */
1284     TEST_TYPE(METAHEADER, 18, 2);
1285     TEST_FIELD(METAHEADER, WORD, mtType, 0, 2, 2);
1286     TEST_FIELD(METAHEADER, WORD, mtHeaderSize, 2, 2, 2);
1287     TEST_FIELD(METAHEADER, WORD, mtVersion, 4, 2, 2);
1288     TEST_FIELD(METAHEADER, DWORD, mtSize, 6, 4, 2);
1289     TEST_FIELD(METAHEADER, WORD, mtNoObjects, 10, 2, 2);
1290     TEST_FIELD(METAHEADER, DWORD, mtMaxRecord, 12, 4, 2);
1291     TEST_FIELD(METAHEADER, WORD, mtNoParameters, 16, 2, 2);
1292
1293     /* METARECORD (pack 4) */
1294     TEST_TYPE(METARECORD, 8, 4);
1295     TEST_FIELD(METARECORD, DWORD, rdSize, 0, 4, 4);
1296     TEST_FIELD(METARECORD, WORD, rdFunction, 4, 2, 2);
1297     TEST_FIELD(METARECORD, WORD[1], rdParm, 6, 2, 2);
1298
1299     /* MFENUMPROC */
1300
1301     /* NEWTEXTMETRICA (pack 4) */
1302     TEST_TYPE(NEWTEXTMETRICA, 72, 4);
1303     TEST_FIELD(NEWTEXTMETRICA, LONG, tmHeight, 0, 4, 4);
1304     TEST_FIELD(NEWTEXTMETRICA, LONG, tmAscent, 4, 4, 4);
1305     TEST_FIELD(NEWTEXTMETRICA, LONG, tmDescent, 8, 4, 4);
1306     TEST_FIELD(NEWTEXTMETRICA, LONG, tmInternalLeading, 12, 4, 4);
1307     TEST_FIELD(NEWTEXTMETRICA, LONG, tmExternalLeading, 16, 4, 4);
1308     TEST_FIELD(NEWTEXTMETRICA, LONG, tmAveCharWidth, 20, 4, 4);
1309     TEST_FIELD(NEWTEXTMETRICA, LONG, tmMaxCharWidth, 24, 4, 4);
1310     TEST_FIELD(NEWTEXTMETRICA, LONG, tmWeight, 28, 4, 4);
1311     TEST_FIELD(NEWTEXTMETRICA, LONG, tmOverhang, 32, 4, 4);
1312     TEST_FIELD(NEWTEXTMETRICA, LONG, tmDigitizedAspectX, 36, 4, 4);
1313     TEST_FIELD(NEWTEXTMETRICA, LONG, tmDigitizedAspectY, 40, 4, 4);
1314     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmFirstChar, 44, 1, 1);
1315     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmLastChar, 45, 1, 1);
1316     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmDefaultChar, 46, 1, 1);
1317     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmBreakChar, 47, 1, 1);
1318     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmItalic, 48, 1, 1);
1319     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmUnderlined, 49, 1, 1);
1320     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmStruckOut, 50, 1, 1);
1321     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmPitchAndFamily, 51, 1, 1);
1322     TEST_FIELD(NEWTEXTMETRICA, BYTE, tmCharSet, 52, 1, 1);
1323     TEST_FIELD(NEWTEXTMETRICA, DWORD, ntmFlags, 56, 4, 4);
1324     TEST_FIELD(NEWTEXTMETRICA, UINT, ntmSizeEM, 60, 4, 4);
1325     TEST_FIELD(NEWTEXTMETRICA, UINT, ntmCellHeight, 64, 4, 4);
1326     TEST_FIELD(NEWTEXTMETRICA, UINT, ntmAvgWidth, 68, 4, 4);
1327
1328     /* NEWTEXTMETRICEXA (pack 4) */
1329     TEST_TYPE(NEWTEXTMETRICEXA, 96, 4);
1330     TEST_FIELD(NEWTEXTMETRICEXA, NEWTEXTMETRICA, ntmTm, 0, 72, 4);
1331     TEST_FIELD(NEWTEXTMETRICEXA, FONTSIGNATURE, ntmFontSig, 72, 24, 4);
1332
1333     /* NEWTEXTMETRICEXW (pack 4) */
1334     TEST_TYPE(NEWTEXTMETRICEXW, 100, 4);
1335     TEST_FIELD(NEWTEXTMETRICEXW, NEWTEXTMETRICW, ntmTm, 0, 76, 4);
1336     TEST_FIELD(NEWTEXTMETRICEXW, FONTSIGNATURE, ntmFontSig, 76, 24, 4);
1337
1338     /* NEWTEXTMETRICW (pack 4) */
1339     TEST_TYPE(NEWTEXTMETRICW, 76, 4);
1340     TEST_FIELD(NEWTEXTMETRICW, LONG, tmHeight, 0, 4, 4);
1341     TEST_FIELD(NEWTEXTMETRICW, LONG, tmAscent, 4, 4, 4);
1342     TEST_FIELD(NEWTEXTMETRICW, LONG, tmDescent, 8, 4, 4);
1343     TEST_FIELD(NEWTEXTMETRICW, LONG, tmInternalLeading, 12, 4, 4);
1344     TEST_FIELD(NEWTEXTMETRICW, LONG, tmExternalLeading, 16, 4, 4);
1345     TEST_FIELD(NEWTEXTMETRICW, LONG, tmAveCharWidth, 20, 4, 4);
1346     TEST_FIELD(NEWTEXTMETRICW, LONG, tmMaxCharWidth, 24, 4, 4);
1347     TEST_FIELD(NEWTEXTMETRICW, LONG, tmWeight, 28, 4, 4);
1348     TEST_FIELD(NEWTEXTMETRICW, LONG, tmOverhang, 32, 4, 4);
1349     TEST_FIELD(NEWTEXTMETRICW, LONG, tmDigitizedAspectX, 36, 4, 4);
1350     TEST_FIELD(NEWTEXTMETRICW, LONG, tmDigitizedAspectY, 40, 4, 4);
1351     TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmFirstChar, 44, 2, 2);
1352     TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmLastChar, 46, 2, 2);
1353     TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmDefaultChar, 48, 2, 2);
1354     TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmBreakChar, 50, 2, 2);
1355     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmItalic, 52, 1, 1);
1356     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmUnderlined, 53, 1, 1);
1357     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmStruckOut, 54, 1, 1);
1358     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmPitchAndFamily, 55, 1, 1);
1359     TEST_FIELD(NEWTEXTMETRICW, BYTE, tmCharSet, 56, 1, 1);
1360     TEST_FIELD(NEWTEXTMETRICW, DWORD, ntmFlags, 60, 4, 4);
1361     TEST_FIELD(NEWTEXTMETRICW, UINT, ntmSizeEM, 64, 4, 4);
1362     TEST_FIELD(NEWTEXTMETRICW, UINT, ntmCellHeight, 68, 4, 4);
1363     TEST_FIELD(NEWTEXTMETRICW, UINT, ntmAvgWidth, 72, 4, 4);
1364
1365     /* NPEXTLOGPEN */
1366     TEST_TYPE(NPEXTLOGPEN, 4, 4);
1367     TEST_TYPE_POINTER(NPEXTLOGPEN, 28, 4);
1368
1369     /* OLDFONTENUMPROCA */
1370
1371     /* OLDFONTENUMPROCW */
1372
1373     /* OUTLINETEXTMETRICA (pack 4) */
1374     TEST_TYPE(OUTLINETEXTMETRICA, 212, 4);
1375     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmSize, 0, 4, 4);
1376     TEST_FIELD(OUTLINETEXTMETRICA, TEXTMETRICA, otmTextMetrics, 4, 56, 4);
1377     TEST_FIELD(OUTLINETEXTMETRICA, BYTE, otmFiller, 60, 1, 1);
1378     TEST_FIELD(OUTLINETEXTMETRICA, PANOSE, otmPanoseNumber, 61, 10, 1);
1379     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmfsSelection, 72, 4, 4);
1380     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmfsType, 76, 4, 4);
1381     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsCharSlopeRise, 80, 4, 4);
1382     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsCharSlopeRun, 84, 4, 4);
1383     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmItalicAngle, 88, 4, 4);
1384     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmEMSquare, 92, 4, 4);
1385     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmAscent, 96, 4, 4);
1386     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmDescent, 100, 4, 4);
1387     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmLineGap, 104, 4, 4);
1388     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmsCapEmHeight, 108, 4, 4);
1389     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmsXHeight, 112, 4, 4);
1390     TEST_FIELD(OUTLINETEXTMETRICA, RECT, otmrcFontBox, 116, 16, 4);
1391     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmMacAscent, 132, 4, 4);
1392     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmMacDescent, 136, 4, 4);
1393     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmMacLineGap, 140, 4, 4);
1394     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmusMinimumPPEM, 144, 4, 4);
1395     TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSubscriptSize, 148, 8, 4);
1396     TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSubscriptOffset, 156, 8, 4);
1397     TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSuperscriptSize, 164, 8, 4);
1398     TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSuperscriptOffset, 172, 8, 4);
1399     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmsStrikeoutSize, 180, 4, 4);
1400     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsStrikeoutPosition, 184, 4, 4);
1401     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsUnderscoreSize, 188, 4, 4);
1402     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsUnderscorePosition, 192, 4, 4);
1403     TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpFamilyName, 196, 4, 4);
1404     TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpFaceName, 200, 4, 4);
1405     TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpStyleName, 204, 4, 4);
1406     TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpFullName, 208, 4, 4);
1407
1408     /* OUTLINETEXTMETRICW (pack 4) */
1409     TEST_TYPE(OUTLINETEXTMETRICW, 216, 4);
1410     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmSize, 0, 4, 4);
1411     TEST_FIELD(OUTLINETEXTMETRICW, TEXTMETRICW, otmTextMetrics, 4, 60, 4);
1412     TEST_FIELD(OUTLINETEXTMETRICW, BYTE, otmFiller, 64, 1, 1);
1413     TEST_FIELD(OUTLINETEXTMETRICW, PANOSE, otmPanoseNumber, 65, 10, 1);
1414     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmfsSelection, 76, 4, 4);
1415     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmfsType, 80, 4, 4);
1416     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsCharSlopeRise, 84, 4, 4);
1417     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsCharSlopeRun, 88, 4, 4);
1418     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmItalicAngle, 92, 4, 4);
1419     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmEMSquare, 96, 4, 4);
1420     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmAscent, 100, 4, 4);
1421     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmDescent, 104, 4, 4);
1422     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmLineGap, 108, 4, 4);
1423     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmsCapEmHeight, 112, 4, 4);
1424     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmsXHeight, 116, 4, 4);
1425     TEST_FIELD(OUTLINETEXTMETRICW, RECT, otmrcFontBox, 120, 16, 4);
1426     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmMacAscent, 136, 4, 4);
1427     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmMacDescent, 140, 4, 4);
1428     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmMacLineGap, 144, 4, 4);
1429     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmusMinimumPPEM, 148, 4, 4);
1430     TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSubscriptSize, 152, 8, 4);
1431     TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSubscriptOffset, 160, 8, 4);
1432     TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSuperscriptSize, 168, 8, 4);
1433     TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSuperscriptOffset, 176, 8, 4);
1434     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmsStrikeoutSize, 184, 4, 4);
1435     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsStrikeoutPosition, 188, 4, 4);
1436     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsUnderscoreSize, 192, 4, 4);
1437     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsUnderscorePosition, 196, 4, 4);
1438     TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpFamilyName, 200, 4, 4);
1439     TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpFaceName, 204, 4, 4);
1440     TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpStyleName, 208, 4, 4);
1441     TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpFullName, 212, 4, 4);
1442
1443     /* PABC */
1444     TEST_TYPE(PABC, 4, 4);
1445     TEST_TYPE_POINTER(PABC, 12, 4);
1446
1447     /* PABCFLOAT */
1448     TEST_TYPE(PABCFLOAT, 4, 4);
1449     TEST_TYPE_POINTER(PABCFLOAT, 12, 4);
1450
1451     /* PANOSE (pack 4) */
1452     TEST_TYPE(PANOSE, 10, 1);
1453     TEST_FIELD(PANOSE, BYTE, bFamilyType, 0, 1, 1);
1454     TEST_FIELD(PANOSE, BYTE, bSerifStyle, 1, 1, 1);
1455     TEST_FIELD(PANOSE, BYTE, bWeight, 2, 1, 1);
1456     TEST_FIELD(PANOSE, BYTE, bProportion, 3, 1, 1);
1457     TEST_FIELD(PANOSE, BYTE, bContrast, 4, 1, 1);
1458     TEST_FIELD(PANOSE, BYTE, bStrokeVariation, 5, 1, 1);
1459     TEST_FIELD(PANOSE, BYTE, bArmStyle, 6, 1, 1);
1460     TEST_FIELD(PANOSE, BYTE, bLetterform, 7, 1, 1);
1461     TEST_FIELD(PANOSE, BYTE, bMidline, 8, 1, 1);
1462     TEST_FIELD(PANOSE, BYTE, bXHeight, 9, 1, 1);
1463
1464     /* PATTERN */
1465     TEST_TYPE(PATTERN, 12, 4);
1466
1467     /* PBITMAP */
1468     TEST_TYPE(PBITMAP, 4, 4);
1469     TEST_TYPE_POINTER(PBITMAP, 24, 4);
1470
1471     /* PBITMAPCOREHEADER */
1472     TEST_TYPE(PBITMAPCOREHEADER, 4, 4);
1473     TEST_TYPE_POINTER(PBITMAPCOREHEADER, 12, 4);
1474
1475     /* PBITMAPCOREINFO */
1476     TEST_TYPE(PBITMAPCOREINFO, 4, 4);
1477     TEST_TYPE_POINTER(PBITMAPCOREINFO, 16, 4);
1478
1479     /* PBITMAPFILEHEADER */
1480     TEST_TYPE(PBITMAPFILEHEADER, 4, 4);
1481     TEST_TYPE_POINTER(PBITMAPFILEHEADER, 14, 2);
1482
1483     /* PBITMAPINFO */
1484     TEST_TYPE(PBITMAPINFO, 4, 4);
1485     TEST_TYPE_POINTER(PBITMAPINFO, 44, 4);
1486
1487     /* PBITMAPINFOHEADER */
1488     TEST_TYPE(PBITMAPINFOHEADER, 4, 4);
1489     TEST_TYPE_POINTER(PBITMAPINFOHEADER, 40, 4);
1490
1491     /* PBITMAPV4HEADER */
1492     TEST_TYPE(PBITMAPV4HEADER, 4, 4);
1493     TEST_TYPE_POINTER(PBITMAPV4HEADER, 108, 4);
1494
1495     /* PBITMAPV5HEADER */
1496     TEST_TYPE(PBITMAPV5HEADER, 4, 4);
1497     TEST_TYPE_POINTER(PBITMAPV5HEADER, 124, 4);
1498
1499     /* PBLENDFUNCTION */
1500     TEST_TYPE(PBLENDFUNCTION, 4, 4);
1501     TEST_TYPE_POINTER(PBLENDFUNCTION, 4, 1);
1502
1503     /* PCHARSETINFO */
1504     TEST_TYPE(PCHARSETINFO, 4, 4);
1505     TEST_TYPE_POINTER(PCHARSETINFO, 32, 4);
1506
1507     /* PCOLORADJUSTMENT */
1508     TEST_TYPE(PCOLORADJUSTMENT, 4, 4);
1509     TEST_TYPE_POINTER(PCOLORADJUSTMENT, 24, 2);
1510
1511     /* PDEVMODEA */
1512     TEST_TYPE(PDEVMODEA, 4, 4);
1513
1514     /* PDEVMODEW */
1515     TEST_TYPE(PDEVMODEW, 4, 4);
1516
1517     /* PDIBSECTION */
1518     TEST_TYPE(PDIBSECTION, 4, 4);
1519     TEST_TYPE_POINTER(PDIBSECTION, 84, 4);
1520
1521     /* PDISPLAY_DEVICEA */
1522     TEST_TYPE(PDISPLAY_DEVICEA, 4, 4);
1523
1524     /* PDISPLAY_DEVICEW */
1525     TEST_TYPE(PDISPLAY_DEVICEW, 4, 4);
1526
1527     /* PELARRAY (pack 4) */
1528     TEST_TYPE(PELARRAY, 20, 4);
1529     TEST_FIELD(PELARRAY, LONG, paXCount, 0, 4, 4);
1530     TEST_FIELD(PELARRAY, LONG, paYCount, 4, 4, 4);
1531     TEST_FIELD(PELARRAY, LONG, paXExt, 8, 4, 4);
1532     TEST_FIELD(PELARRAY, LONG, paYExt, 12, 4, 4);
1533     TEST_FIELD(PELARRAY, BYTE, paRGBs, 16, 1, 1);
1534
1535     /* PEMR */
1536     TEST_TYPE(PEMR, 4, 4);
1537     TEST_TYPE_POINTER(PEMR, 8, 4);
1538
1539     /* PEMRABORTPATH */
1540     TEST_TYPE(PEMRABORTPATH, 4, 4);
1541     TEST_TYPE_POINTER(PEMRABORTPATH, 8, 4);
1542
1543     /* PEMRANGLEARC */
1544     TEST_TYPE(PEMRANGLEARC, 4, 4);
1545     TEST_TYPE_POINTER(PEMRANGLEARC, 28, 4);
1546
1547     /* PEMRARC */
1548     TEST_TYPE(PEMRARC, 4, 4);
1549     TEST_TYPE_POINTER(PEMRARC, 40, 4);
1550
1551     /* PEMRARCTO */
1552     TEST_TYPE(PEMRARCTO, 4, 4);
1553     TEST_TYPE_POINTER(PEMRARCTO, 40, 4);
1554
1555     /* PEMRBEGINPATH */
1556     TEST_TYPE(PEMRBEGINPATH, 4, 4);
1557     TEST_TYPE_POINTER(PEMRBEGINPATH, 8, 4);
1558
1559     /* PEMRBITBLT */
1560     TEST_TYPE(PEMRBITBLT, 4, 4);
1561     TEST_TYPE_POINTER(PEMRBITBLT, 100, 4);
1562
1563     /* PEMRCHORD */
1564     TEST_TYPE(PEMRCHORD, 4, 4);
1565     TEST_TYPE_POINTER(PEMRCHORD, 40, 4);
1566
1567     /* PEMRCLOSEFIGURE */
1568     TEST_TYPE(PEMRCLOSEFIGURE, 4, 4);
1569     TEST_TYPE_POINTER(PEMRCLOSEFIGURE, 8, 4);
1570
1571     /* PEMRCREATEBRUSHINDIRECT */
1572     TEST_TYPE(PEMRCREATEBRUSHINDIRECT, 4, 4);
1573     TEST_TYPE_POINTER(PEMRCREATEBRUSHINDIRECT, 24, 4);
1574
1575     /* PEMRCREATEDIBPATTERNBRUSHPT */
1576     TEST_TYPE(PEMRCREATEDIBPATTERNBRUSHPT, 4, 4);
1577     TEST_TYPE_POINTER(PEMRCREATEDIBPATTERNBRUSHPT, 32, 4);
1578
1579     /* PEMRCREATEMONOBRUSH */
1580     TEST_TYPE(PEMRCREATEMONOBRUSH, 4, 4);
1581     TEST_TYPE_POINTER(PEMRCREATEMONOBRUSH, 32, 4);
1582
1583     /* PEMRCREATEPALETTE */
1584     TEST_TYPE(PEMRCREATEPALETTE, 4, 4);
1585     TEST_TYPE_POINTER(PEMRCREATEPALETTE, 20, 4);
1586
1587     /* PEMRCREATEPEN */
1588     TEST_TYPE(PEMRCREATEPEN, 4, 4);
1589     TEST_TYPE_POINTER(PEMRCREATEPEN, 28, 4);
1590
1591     /* PEMRDELETECOLORSPACE */
1592     TEST_TYPE(PEMRDELETECOLORSPACE, 4, 4);
1593     TEST_TYPE_POINTER(PEMRDELETECOLORSPACE, 12, 4);
1594
1595     /* PEMRDELETEOBJECT */
1596     TEST_TYPE(PEMRDELETEOBJECT, 4, 4);
1597     TEST_TYPE_POINTER(PEMRDELETEOBJECT, 12, 4);
1598
1599     /* PEMRELLIPSE */
1600     TEST_TYPE(PEMRELLIPSE, 4, 4);
1601     TEST_TYPE_POINTER(PEMRELLIPSE, 24, 4);
1602
1603     /* PEMRENDPATH */
1604     TEST_TYPE(PEMRENDPATH, 4, 4);
1605     TEST_TYPE_POINTER(PEMRENDPATH, 8, 4);
1606
1607     /* PEMREOF */
1608     TEST_TYPE(PEMREOF, 4, 4);
1609     TEST_TYPE_POINTER(PEMREOF, 20, 4);
1610
1611     /* PEMREXCLUDECLIPRECT */
1612     TEST_TYPE(PEMREXCLUDECLIPRECT, 4, 4);
1613     TEST_TYPE_POINTER(PEMREXCLUDECLIPRECT, 24, 4);
1614
1615     /* PEMREXTCREATEFONTINDIRECTW */
1616     TEST_TYPE(PEMREXTCREATEFONTINDIRECTW, 4, 4);
1617     TEST_TYPE_POINTER(PEMREXTCREATEFONTINDIRECTW, 332, 4);
1618
1619     /* PEMREXTCREATEPEN */
1620     TEST_TYPE(PEMREXTCREATEPEN, 4, 4);
1621     TEST_TYPE_POINTER(PEMREXTCREATEPEN, 56, 4);
1622
1623     /* PEMREXTFLOODFILL */
1624     TEST_TYPE(PEMREXTFLOODFILL, 4, 4);
1625     TEST_TYPE_POINTER(PEMREXTFLOODFILL, 24, 4);
1626
1627     /* PEMREXTSELECTCLIPRGN */
1628     TEST_TYPE(PEMREXTSELECTCLIPRGN, 4, 4);
1629     TEST_TYPE_POINTER(PEMREXTSELECTCLIPRGN, 20, 4);
1630
1631     /* PEMREXTTEXTOUTA */
1632     TEST_TYPE(PEMREXTTEXTOUTA, 4, 4);
1633     TEST_TYPE_POINTER(PEMREXTTEXTOUTA, 76, 4);
1634
1635     /* PEMREXTTEXTOUTW */
1636     TEST_TYPE(PEMREXTTEXTOUTW, 4, 4);
1637     TEST_TYPE_POINTER(PEMREXTTEXTOUTW, 76, 4);
1638
1639     /* PEMRFILLPATH */
1640     TEST_TYPE(PEMRFILLPATH, 4, 4);
1641     TEST_TYPE_POINTER(PEMRFILLPATH, 24, 4);
1642
1643     /* PEMRFILLRGN */
1644     TEST_TYPE(PEMRFILLRGN, 4, 4);
1645     TEST_TYPE_POINTER(PEMRFILLRGN, 36, 4);
1646
1647     /* PEMRFLATTENPATH */
1648     TEST_TYPE(PEMRFLATTENPATH, 4, 4);
1649     TEST_TYPE_POINTER(PEMRFLATTENPATH, 8, 4);
1650
1651     /* PEMRFORMAT */
1652     TEST_TYPE(PEMRFORMAT, 4, 4);
1653     TEST_TYPE_POINTER(PEMRFORMAT, 16, 4);
1654
1655     /* PEMRFRAMERGN */
1656     TEST_TYPE(PEMRFRAMERGN, 4, 4);
1657     TEST_TYPE_POINTER(PEMRFRAMERGN, 44, 4);
1658
1659     /* PEMRGDICOMMENT */
1660     TEST_TYPE(PEMRGDICOMMENT, 4, 4);
1661     TEST_TYPE_POINTER(PEMRGDICOMMENT, 16, 4);
1662
1663     /* PEMRGLSBOUNDEDRECORD */
1664     TEST_TYPE(PEMRGLSBOUNDEDRECORD, 4, 4);
1665     TEST_TYPE_POINTER(PEMRGLSBOUNDEDRECORD, 32, 4);
1666
1667     /* PEMRGLSRECORD */
1668     TEST_TYPE(PEMRGLSRECORD, 4, 4);
1669     TEST_TYPE_POINTER(PEMRGLSRECORD, 16, 4);
1670
1671     /* PEMRINTERSECTCLIPRECT */
1672     TEST_TYPE(PEMRINTERSECTCLIPRECT, 4, 4);
1673     TEST_TYPE_POINTER(PEMRINTERSECTCLIPRECT, 24, 4);
1674
1675     /* PEMRINVERTRGN */
1676     TEST_TYPE(PEMRINVERTRGN, 4, 4);
1677     TEST_TYPE_POINTER(PEMRINVERTRGN, 32, 4);
1678
1679     /* PEMRLINETO */
1680     TEST_TYPE(PEMRLINETO, 4, 4);
1681     TEST_TYPE_POINTER(PEMRLINETO, 16, 4);
1682
1683     /* PEMRMASKBLT */
1684     TEST_TYPE(PEMRMASKBLT, 4, 4);
1685     TEST_TYPE_POINTER(PEMRMASKBLT, 128, 4);
1686
1687     /* PEMRMODIFYWORLDTRANSFORM */
1688     TEST_TYPE(PEMRMODIFYWORLDTRANSFORM, 4, 4);
1689     TEST_TYPE_POINTER(PEMRMODIFYWORLDTRANSFORM, 36, 4);
1690
1691     /* PEMRMOVETOEX */
1692     TEST_TYPE(PEMRMOVETOEX, 4, 4);
1693     TEST_TYPE_POINTER(PEMRMOVETOEX, 16, 4);
1694
1695     /* PEMROFFSETCLIPRGN */
1696     TEST_TYPE(PEMROFFSETCLIPRGN, 4, 4);
1697     TEST_TYPE_POINTER(PEMROFFSETCLIPRGN, 16, 4);
1698
1699     /* PEMRPAINTRGN */
1700     TEST_TYPE(PEMRPAINTRGN, 4, 4);
1701     TEST_TYPE_POINTER(PEMRPAINTRGN, 32, 4);
1702
1703     /* PEMRPIE */
1704     TEST_TYPE(PEMRPIE, 4, 4);
1705     TEST_TYPE_POINTER(PEMRPIE, 40, 4);
1706
1707     /* PEMRPIXELFORMAT */
1708     TEST_TYPE(PEMRPIXELFORMAT, 4, 4);
1709     TEST_TYPE_POINTER(PEMRPIXELFORMAT, 48, 4);
1710
1711     /* PEMRPLGBLT */
1712     TEST_TYPE(PEMRPLGBLT, 4, 4);
1713     TEST_TYPE_POINTER(PEMRPLGBLT, 140, 4);
1714
1715     /* PEMRPOLYBEZIER */
1716     TEST_TYPE(PEMRPOLYBEZIER, 4, 4);
1717     TEST_TYPE_POINTER(PEMRPOLYBEZIER, 36, 4);
1718
1719     /* PEMRPOLYBEZIERTO */
1720     TEST_TYPE(PEMRPOLYBEZIERTO, 4, 4);
1721     TEST_TYPE_POINTER(PEMRPOLYBEZIERTO, 36, 4);
1722
1723     /* PEMRPOLYDRAW */
1724     TEST_TYPE(PEMRPOLYDRAW, 4, 4);
1725     TEST_TYPE_POINTER(PEMRPOLYDRAW, 40, 4);
1726
1727     /* PEMRPOLYGON */
1728     TEST_TYPE(PEMRPOLYGON, 4, 4);
1729     TEST_TYPE_POINTER(PEMRPOLYGON, 36, 4);
1730
1731     /* PEMRPOLYLINE */
1732     TEST_TYPE(PEMRPOLYLINE, 4, 4);
1733     TEST_TYPE_POINTER(PEMRPOLYLINE, 36, 4);
1734
1735     /* PEMRPOLYLINETO */
1736     TEST_TYPE(PEMRPOLYLINETO, 4, 4);
1737     TEST_TYPE_POINTER(PEMRPOLYLINETO, 36, 4);
1738
1739     /* PEMRPOLYPOLYGON */
1740     TEST_TYPE(PEMRPOLYPOLYGON, 4, 4);
1741     TEST_TYPE_POINTER(PEMRPOLYPOLYGON, 44, 4);
1742
1743     /* PEMRPOLYPOLYLINE */
1744     TEST_TYPE(PEMRPOLYPOLYLINE, 4, 4);
1745     TEST_TYPE_POINTER(PEMRPOLYPOLYLINE, 44, 4);
1746
1747     /* PEMRPOLYTEXTOUTA */
1748     TEST_TYPE(PEMRPOLYTEXTOUTA, 4, 4);
1749     TEST_TYPE_POINTER(PEMRPOLYTEXTOUTA, 80, 4);
1750
1751     /* PEMRPOLYTEXTOUTW */
1752     TEST_TYPE(PEMRPOLYTEXTOUTW, 4, 4);
1753     TEST_TYPE_POINTER(PEMRPOLYTEXTOUTW, 80, 4);
1754
1755     /* PEMRREALIZEPALETTE */
1756     TEST_TYPE(PEMRREALIZEPALETTE, 4, 4);
1757     TEST_TYPE_POINTER(PEMRREALIZEPALETTE, 8, 4);
1758
1759     /* PEMRRECTANGLE */
1760     TEST_TYPE(PEMRRECTANGLE, 4, 4);
1761     TEST_TYPE_POINTER(PEMRRECTANGLE, 24, 4);
1762
1763     /* PEMRRESIZEPALETTE */
1764     TEST_TYPE(PEMRRESIZEPALETTE, 4, 4);
1765     TEST_TYPE_POINTER(PEMRRESIZEPALETTE, 16, 4);
1766
1767     /* PEMRRESTOREDC */
1768     TEST_TYPE(PEMRRESTOREDC, 4, 4);
1769     TEST_TYPE_POINTER(PEMRRESTOREDC, 12, 4);
1770
1771     /* PEMRROUNDRECT */
1772     TEST_TYPE(PEMRROUNDRECT, 4, 4);
1773     TEST_TYPE_POINTER(PEMRROUNDRECT, 32, 4);
1774
1775     /* PEMRSAVEDC */
1776     TEST_TYPE(PEMRSAVEDC, 4, 4);
1777     TEST_TYPE_POINTER(PEMRSAVEDC, 8, 4);
1778
1779     /* PEMRSCALEVIEWPORTEXTEX */
1780     TEST_TYPE(PEMRSCALEVIEWPORTEXTEX, 4, 4);
1781     TEST_TYPE_POINTER(PEMRSCALEVIEWPORTEXTEX, 24, 4);
1782
1783     /* PEMRSCALEWINDOWEXTEX */
1784     TEST_TYPE(PEMRSCALEWINDOWEXTEX, 4, 4);
1785     TEST_TYPE_POINTER(PEMRSCALEWINDOWEXTEX, 24, 4);
1786
1787     /* PEMRSELECTCLIPPATH */
1788     TEST_TYPE(PEMRSELECTCLIPPATH, 4, 4);
1789     TEST_TYPE_POINTER(PEMRSELECTCLIPPATH, 12, 4);
1790
1791     /* PEMRSELECTCOLORSPACE */
1792     TEST_TYPE(PEMRSELECTCOLORSPACE, 4, 4);
1793     TEST_TYPE_POINTER(PEMRSELECTCOLORSPACE, 12, 4);
1794
1795     /* PEMRSELECTOBJECT */
1796     TEST_TYPE(PEMRSELECTOBJECT, 4, 4);
1797     TEST_TYPE_POINTER(PEMRSELECTOBJECT, 12, 4);
1798
1799     /* PEMRSELECTPALETTE */
1800     TEST_TYPE(PEMRSELECTPALETTE, 4, 4);
1801     TEST_TYPE_POINTER(PEMRSELECTPALETTE, 12, 4);
1802
1803     /* PEMRSETARCDIRECTION */
1804     TEST_TYPE(PEMRSETARCDIRECTION, 4, 4);
1805     TEST_TYPE_POINTER(PEMRSETARCDIRECTION, 12, 4);
1806
1807     /* PEMRSETBKCOLOR */
1808     TEST_TYPE(PEMRSETBKCOLOR, 4, 4);
1809     TEST_TYPE_POINTER(PEMRSETBKCOLOR, 12, 4);
1810
1811     /* PEMRSETBKMODE */
1812     TEST_TYPE(PEMRSETBKMODE, 4, 4);
1813     TEST_TYPE_POINTER(PEMRSETBKMODE, 12, 4);
1814
1815     /* PEMRSETBRUSHORGEX */
1816     TEST_TYPE(PEMRSETBRUSHORGEX, 4, 4);
1817     TEST_TYPE_POINTER(PEMRSETBRUSHORGEX, 16, 4);
1818
1819     /* PEMRSETCOLORADJUSTMENT */
1820     TEST_TYPE(PEMRSETCOLORADJUSTMENT, 4, 4);
1821     TEST_TYPE_POINTER(PEMRSETCOLORADJUSTMENT, 32, 4);
1822
1823     /* PEMRSETDIBITSTODEVICE */
1824     TEST_TYPE(PEMRSETDIBITSTODEVICE, 4, 4);
1825     TEST_TYPE_POINTER(PEMRSETDIBITSTODEVICE, 76, 4);
1826
1827     /* PEMRSETMAPMODE */
1828     TEST_TYPE(PEMRSETMAPMODE, 4, 4);
1829     TEST_TYPE_POINTER(PEMRSETMAPMODE, 12, 4);
1830
1831     /* PEMRSETMAPPERFLAGS */
1832     TEST_TYPE(PEMRSETMAPPERFLAGS, 4, 4);
1833     TEST_TYPE_POINTER(PEMRSETMAPPERFLAGS, 12, 4);
1834
1835     /* PEMRSETMETARGN */
1836     TEST_TYPE(PEMRSETMETARGN, 4, 4);
1837     TEST_TYPE_POINTER(PEMRSETMETARGN, 8, 4);
1838
1839     /* PEMRSETMITERLIMIT */
1840     TEST_TYPE(PEMRSETMITERLIMIT, 4, 4);
1841     TEST_TYPE_POINTER(PEMRSETMITERLIMIT, 12, 4);
1842
1843     /* PEMRSETPALETTEENTRIES */
1844     TEST_TYPE(PEMRSETPALETTEENTRIES, 4, 4);
1845     TEST_TYPE_POINTER(PEMRSETPALETTEENTRIES, 24, 4);
1846
1847     /* PEMRSETPIXELV */
1848     TEST_TYPE(PEMRSETPIXELV, 4, 4);
1849     TEST_TYPE_POINTER(PEMRSETPIXELV, 20, 4);
1850
1851     /* PEMRSETPOLYFILLMODE */
1852     TEST_TYPE(PEMRSETPOLYFILLMODE, 4, 4);
1853     TEST_TYPE_POINTER(PEMRSETPOLYFILLMODE, 12, 4);
1854
1855     /* PEMRSETROP2 */
1856     TEST_TYPE(PEMRSETROP2, 4, 4);
1857     TEST_TYPE_POINTER(PEMRSETROP2, 12, 4);
1858
1859     /* PEMRSETSTRETCHBLTMODE */
1860     TEST_TYPE(PEMRSETSTRETCHBLTMODE, 4, 4);
1861     TEST_TYPE_POINTER(PEMRSETSTRETCHBLTMODE, 12, 4);
1862
1863     /* PEMRSETTEXTALIGN */
1864     TEST_TYPE(PEMRSETTEXTALIGN, 4, 4);
1865     TEST_TYPE_POINTER(PEMRSETTEXTALIGN, 12, 4);
1866
1867     /* PEMRSETTEXTCOLOR */
1868     TEST_TYPE(PEMRSETTEXTCOLOR, 4, 4);
1869     TEST_TYPE_POINTER(PEMRSETTEXTCOLOR, 12, 4);
1870
1871     /* PEMRSETVIEWPORTEXTEX */
1872     TEST_TYPE(PEMRSETVIEWPORTEXTEX, 4, 4);
1873     TEST_TYPE_POINTER(PEMRSETVIEWPORTEXTEX, 16, 4);
1874
1875     /* PEMRSETVIEWPORTORGEX */
1876     TEST_TYPE(PEMRSETVIEWPORTORGEX, 4, 4);
1877     TEST_TYPE_POINTER(PEMRSETVIEWPORTORGEX, 16, 4);
1878
1879     /* PEMRSETWINDOWEXTEX */
1880     TEST_TYPE(PEMRSETWINDOWEXTEX, 4, 4);
1881     TEST_TYPE_POINTER(PEMRSETWINDOWEXTEX, 16, 4);
1882
1883     /* PEMRSETWINDOWORGEX */
1884     TEST_TYPE(PEMRSETWINDOWORGEX, 4, 4);
1885     TEST_TYPE_POINTER(PEMRSETWINDOWORGEX, 16, 4);
1886
1887     /* PEMRSETWORLDTRANSFORM */
1888     TEST_TYPE(PEMRSETWORLDTRANSFORM, 4, 4);
1889     TEST_TYPE_POINTER(PEMRSETWORLDTRANSFORM, 32, 4);
1890
1891     /* PEMRSTRETCHBLT */
1892     TEST_TYPE(PEMRSTRETCHBLT, 4, 4);
1893     TEST_TYPE_POINTER(PEMRSTRETCHBLT, 108, 4);
1894
1895     /* PEMRSTRETCHDIBITS */
1896     TEST_TYPE(PEMRSTRETCHDIBITS, 4, 4);
1897     TEST_TYPE_POINTER(PEMRSTRETCHDIBITS, 80, 4);
1898
1899     /* PEMRSTROKEANDFILLPATH */
1900     TEST_TYPE(PEMRSTROKEANDFILLPATH, 4, 4);
1901     TEST_TYPE_POINTER(PEMRSTROKEANDFILLPATH, 24, 4);
1902
1903     /* PEMRSTROKEPATH */
1904     TEST_TYPE(PEMRSTROKEPATH, 4, 4);
1905     TEST_TYPE_POINTER(PEMRSTROKEPATH, 24, 4);
1906
1907     /* PEMRTEXT */
1908     TEST_TYPE(PEMRTEXT, 4, 4);
1909     TEST_TYPE_POINTER(PEMRTEXT, 40, 4);
1910
1911     /* PEMRWIDENPATH */
1912     TEST_TYPE(PEMRWIDENPATH, 4, 4);
1913     TEST_TYPE_POINTER(PEMRWIDENPATH, 8, 4);
1914
1915     /* PENHMETAHEADER */
1916     TEST_TYPE(PENHMETAHEADER, 4, 4);
1917
1918     /* PEXTLOGFONTA */
1919     TEST_TYPE(PEXTLOGFONTA, 4, 4);
1920     TEST_TYPE_POINTER(PEXTLOGFONTA, 192, 4);
1921
1922     /* PEXTLOGFONTW */
1923     TEST_TYPE(PEXTLOGFONTW, 4, 4);
1924     TEST_TYPE_POINTER(PEXTLOGFONTW, 320, 4);
1925
1926     /* PEXTLOGPEN */
1927     TEST_TYPE(PEXTLOGPEN, 4, 4);
1928     TEST_TYPE_POINTER(PEXTLOGPEN, 28, 4);
1929
1930     /* PFONTSIGNATURE */
1931     TEST_TYPE(PFONTSIGNATURE, 4, 4);
1932     TEST_TYPE_POINTER(PFONTSIGNATURE, 24, 4);
1933
1934     /* PGRADIENT_RECT */
1935     TEST_TYPE(PGRADIENT_RECT, 4, 4);
1936     TEST_TYPE_POINTER(PGRADIENT_RECT, 8, 4);
1937
1938     /* PGRADIENT_TRIANGLE */
1939     TEST_TYPE(PGRADIENT_TRIANGLE, 4, 4);
1940     TEST_TYPE_POINTER(PGRADIENT_TRIANGLE, 12, 4);
1941
1942     /* PHANDLETABLE */
1943     TEST_TYPE(PHANDLETABLE, 4, 4);
1944     TEST_TYPE_POINTER(PHANDLETABLE, 4, 4);
1945
1946     /* PIXELFORMATDESCRIPTOR (pack 4) */
1947     TEST_TYPE(PIXELFORMATDESCRIPTOR, 40, 4);
1948     TEST_FIELD(PIXELFORMATDESCRIPTOR, WORD, nSize, 0, 2, 2);
1949     TEST_FIELD(PIXELFORMATDESCRIPTOR, WORD, nVersion, 2, 2, 2);
1950     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwFlags, 4, 4, 4);
1951     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, iPixelType, 8, 1, 1);
1952     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cColorBits, 9, 1, 1);
1953     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cRedBits, 10, 1, 1);
1954     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cRedShift, 11, 1, 1);
1955     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cGreenBits, 12, 1, 1);
1956     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cGreenShift, 13, 1, 1);
1957     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cBlueBits, 14, 1, 1);
1958     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cBlueShift, 15, 1, 1);
1959     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAlphaBits, 16, 1, 1);
1960     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAlphaShift, 17, 1, 1);
1961     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumBits, 18, 1, 1);
1962     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumRedBits, 19, 1, 1);
1963     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumGreenBits, 20, 1, 1);
1964     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumBlueBits, 21, 1, 1);
1965     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumAlphaBits, 22, 1, 1);
1966     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cDepthBits, 23, 1, 1);
1967     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cStencilBits, 24, 1, 1);
1968     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAuxBuffers, 25, 1, 1);
1969     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, iLayerType, 26, 1, 1);
1970     TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, bReserved, 27, 1, 1);
1971     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwLayerMask, 28, 4, 4);
1972     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwVisibleMask, 32, 4, 4);
1973     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwDamageMask, 36, 4, 4);
1974
1975     /* PLOGBRUSH */
1976     TEST_TYPE(PLOGBRUSH, 4, 4);
1977     TEST_TYPE_POINTER(PLOGBRUSH, 12, 4);
1978
1979     /* PLOGFONTA */
1980     TEST_TYPE(PLOGFONTA, 4, 4);
1981     TEST_TYPE_POINTER(PLOGFONTA, 60, 4);
1982
1983     /* PLOGFONTW */
1984     TEST_TYPE(PLOGFONTW, 4, 4);
1985     TEST_TYPE_POINTER(PLOGFONTW, 92, 4);
1986
1987     /* PMETAHEADER */
1988     TEST_TYPE(PMETAHEADER, 4, 4);
1989     TEST_TYPE_POINTER(PMETAHEADER, 18, 2);
1990
1991     /* PMETARECORD */
1992     TEST_TYPE(PMETARECORD, 4, 4);
1993     TEST_TYPE_POINTER(PMETARECORD, 8, 4);
1994
1995     /* PNEWTEXTMETRICA */
1996     TEST_TYPE(PNEWTEXTMETRICA, 4, 4);
1997     TEST_TYPE_POINTER(PNEWTEXTMETRICA, 72, 4);
1998
1999     /* PNEWTEXTMETRICW */
2000     TEST_TYPE(PNEWTEXTMETRICW, 4, 4);
2001     TEST_TYPE_POINTER(PNEWTEXTMETRICW, 76, 4);
2002
2003     /* POINTFX (pack 4) */
2004     TEST_TYPE(POINTFX, 8, 2);
2005     TEST_FIELD(POINTFX, FIXED, x, 0, 4, 2);
2006     TEST_FIELD(POINTFX, FIXED, y, 4, 4, 2);
2007
2008     /* POLYTEXTA (pack 4) */
2009     TEST_TYPE(POLYTEXTA, 40, 4);
2010     TEST_FIELD(POLYTEXTA, INT, x, 0, 4, 4);
2011     TEST_FIELD(POLYTEXTA, INT, y, 4, 4, 4);
2012     TEST_FIELD(POLYTEXTA, UINT, n, 8, 4, 4);
2013     TEST_FIELD(POLYTEXTA, LPCSTR, lpstr, 12, 4, 4);
2014     TEST_FIELD(POLYTEXTA, UINT, uiFlags, 16, 4, 4);
2015     TEST_FIELD(POLYTEXTA, RECT, rcl, 20, 16, 4);
2016     TEST_FIELD(POLYTEXTA, INT *, pdx, 36, 4, 4);
2017
2018     /* POLYTEXTW (pack 4) */
2019     TEST_TYPE(POLYTEXTW, 40, 4);
2020     TEST_FIELD(POLYTEXTW, INT, x, 0, 4, 4);
2021     TEST_FIELD(POLYTEXTW, INT, y, 4, 4, 4);
2022     TEST_FIELD(POLYTEXTW, UINT, n, 8, 4, 4);
2023     TEST_FIELD(POLYTEXTW, LPCWSTR, lpstr, 12, 4, 4);
2024     TEST_FIELD(POLYTEXTW, UINT, uiFlags, 16, 4, 4);
2025     TEST_FIELD(POLYTEXTW, RECT, rcl, 20, 16, 4);
2026     TEST_FIELD(POLYTEXTW, INT *, pdx, 36, 4, 4);
2027
2028     /* POUTLINETEXTMETRICA */
2029     TEST_TYPE(POUTLINETEXTMETRICA, 4, 4);
2030     TEST_TYPE_POINTER(POUTLINETEXTMETRICA, 212, 4);
2031
2032     /* POUTLINETEXTMETRICW */
2033     TEST_TYPE(POUTLINETEXTMETRICW, 4, 4);
2034     TEST_TYPE_POINTER(POUTLINETEXTMETRICW, 216, 4);
2035
2036     /* PPELARRAY */
2037     TEST_TYPE(PPELARRAY, 4, 4);
2038     TEST_TYPE_POINTER(PPELARRAY, 20, 4);
2039
2040     /* PPIXELFORMATDESCRIPTOR */
2041     TEST_TYPE(PPIXELFORMATDESCRIPTOR, 4, 4);
2042     TEST_TYPE_POINTER(PPIXELFORMATDESCRIPTOR, 40, 4);
2043
2044     /* PPOLYTEXTA */
2045     TEST_TYPE(PPOLYTEXTA, 4, 4);
2046     TEST_TYPE_POINTER(PPOLYTEXTA, 40, 4);
2047
2048     /* PPOLYTEXTW */
2049     TEST_TYPE(PPOLYTEXTW, 4, 4);
2050     TEST_TYPE_POINTER(PPOLYTEXTW, 40, 4);
2051
2052     /* PRGNDATA */
2053     TEST_TYPE(PRGNDATA, 4, 4);
2054     TEST_TYPE_POINTER(PRGNDATA, 36, 4);
2055
2056     /* PRGNDATAHEADER */
2057     TEST_TYPE(PRGNDATAHEADER, 4, 4);
2058     TEST_TYPE_POINTER(PRGNDATAHEADER, 32, 4);
2059
2060     /* PTEXTMETRICA */
2061     TEST_TYPE(PTEXTMETRICA, 4, 4);
2062     TEST_TYPE_POINTER(PTEXTMETRICA, 56, 4);
2063
2064     /* PTEXTMETRICW */
2065     TEST_TYPE(PTEXTMETRICW, 4, 4);
2066     TEST_TYPE_POINTER(PTEXTMETRICW, 60, 4);
2067
2068     /* PTRIVERTEX */
2069     TEST_TYPE(PTRIVERTEX, 4, 4);
2070     TEST_TYPE_POINTER(PTRIVERTEX, 16, 4);
2071
2072     /* PXFORM */
2073     TEST_TYPE(PXFORM, 4, 4);
2074     TEST_TYPE_POINTER(PXFORM, 24, 4);
2075
2076     /* RASTERIZER_STATUS (pack 4) */
2077     TEST_TYPE(RASTERIZER_STATUS, 6, 2);
2078     TEST_FIELD(RASTERIZER_STATUS, SHORT, nSize, 0, 2, 2);
2079     TEST_FIELD(RASTERIZER_STATUS, SHORT, wFlags, 2, 2, 2);
2080     TEST_FIELD(RASTERIZER_STATUS, SHORT, nLanguageID, 4, 2, 2);
2081
2082     /* RGBQUAD (pack 4) */
2083     TEST_TYPE(RGBQUAD, 4, 1);
2084     TEST_FIELD(RGBQUAD, BYTE, rgbBlue, 0, 1, 1);
2085     TEST_FIELD(RGBQUAD, BYTE, rgbGreen, 1, 1, 1);
2086     TEST_FIELD(RGBQUAD, BYTE, rgbRed, 2, 1, 1);
2087     TEST_FIELD(RGBQUAD, BYTE, rgbReserved, 3, 1, 1);
2088
2089     /* RGBTRIPLE (pack 4) */
2090     TEST_TYPE(RGBTRIPLE, 3, 1);
2091     TEST_FIELD(RGBTRIPLE, BYTE, rgbtBlue, 0, 1, 1);
2092     TEST_FIELD(RGBTRIPLE, BYTE, rgbtGreen, 1, 1, 1);
2093     TEST_FIELD(RGBTRIPLE, BYTE, rgbtRed, 2, 1, 1);
2094
2095     /* RGNDATA (pack 4) */
2096     TEST_TYPE(RGNDATA, 36, 4);
2097     TEST_FIELD(RGNDATA, RGNDATAHEADER, rdh, 0, 32, 4);
2098     TEST_FIELD(RGNDATA, char[1], Buffer, 32, 1, 1);
2099
2100     /* RGNDATAHEADER (pack 4) */
2101     TEST_TYPE(RGNDATAHEADER, 32, 4);
2102     TEST_FIELD(RGNDATAHEADER, DWORD, dwSize, 0, 4, 4);
2103     TEST_FIELD(RGNDATAHEADER, DWORD, iType, 4, 4, 4);
2104     TEST_FIELD(RGNDATAHEADER, DWORD, nCount, 8, 4, 4);
2105     TEST_FIELD(RGNDATAHEADER, DWORD, nRgnSize, 12, 4, 4);
2106     TEST_FIELD(RGNDATAHEADER, RECT, rcBound, 16, 16, 4);
2107
2108     /* TEXTMETRICA (pack 4) */
2109     TEST_TYPE(TEXTMETRICA, 56, 4);
2110     TEST_FIELD(TEXTMETRICA, LONG, tmHeight, 0, 4, 4);
2111     TEST_FIELD(TEXTMETRICA, LONG, tmAscent, 4, 4, 4);
2112     TEST_FIELD(TEXTMETRICA, LONG, tmDescent, 8, 4, 4);
2113     TEST_FIELD(TEXTMETRICA, LONG, tmInternalLeading, 12, 4, 4);
2114     TEST_FIELD(TEXTMETRICA, LONG, tmExternalLeading, 16, 4, 4);
2115     TEST_FIELD(TEXTMETRICA, LONG, tmAveCharWidth, 20, 4, 4);
2116     TEST_FIELD(TEXTMETRICA, LONG, tmMaxCharWidth, 24, 4, 4);
2117     TEST_FIELD(TEXTMETRICA, LONG, tmWeight, 28, 4, 4);
2118     TEST_FIELD(TEXTMETRICA, LONG, tmOverhang, 32, 4, 4);
2119     TEST_FIELD(TEXTMETRICA, LONG, tmDigitizedAspectX, 36, 4, 4);
2120     TEST_FIELD(TEXTMETRICA, LONG, tmDigitizedAspectY, 40, 4, 4);
2121     TEST_FIELD(TEXTMETRICA, BYTE, tmFirstChar, 44, 1, 1);
2122     TEST_FIELD(TEXTMETRICA, BYTE, tmLastChar, 45, 1, 1);
2123     TEST_FIELD(TEXTMETRICA, BYTE, tmDefaultChar, 46, 1, 1);
2124     TEST_FIELD(TEXTMETRICA, BYTE, tmBreakChar, 47, 1, 1);
2125     TEST_FIELD(TEXTMETRICA, BYTE, tmItalic, 48, 1, 1);
2126     TEST_FIELD(TEXTMETRICA, BYTE, tmUnderlined, 49, 1, 1);
2127     TEST_FIELD(TEXTMETRICA, BYTE, tmStruckOut, 50, 1, 1);
2128     TEST_FIELD(TEXTMETRICA, BYTE, tmPitchAndFamily, 51, 1, 1);
2129     TEST_FIELD(TEXTMETRICA, BYTE, tmCharSet, 52, 1, 1);
2130
2131     /* TEXTMETRICW (pack 4) */
2132     TEST_TYPE(TEXTMETRICW, 60, 4);
2133     TEST_FIELD(TEXTMETRICW, LONG, tmHeight, 0, 4, 4);
2134     TEST_FIELD(TEXTMETRICW, LONG, tmAscent, 4, 4, 4);
2135     TEST_FIELD(TEXTMETRICW, LONG, tmDescent, 8, 4, 4);
2136     TEST_FIELD(TEXTMETRICW, LONG, tmInternalLeading, 12, 4, 4);
2137     TEST_FIELD(TEXTMETRICW, LONG, tmExternalLeading, 16, 4, 4);
2138     TEST_FIELD(TEXTMETRICW, LONG, tmAveCharWidth, 20, 4, 4);
2139     TEST_FIELD(TEXTMETRICW, LONG, tmMaxCharWidth, 24, 4, 4);
2140     TEST_FIELD(TEXTMETRICW, LONG, tmWeight, 28, 4, 4);
2141     TEST_FIELD(TEXTMETRICW, LONG, tmOverhang, 32, 4, 4);
2142     TEST_FIELD(TEXTMETRICW, LONG, tmDigitizedAspectX, 36, 4, 4);
2143     TEST_FIELD(TEXTMETRICW, LONG, tmDigitizedAspectY, 40, 4, 4);
2144     TEST_FIELD(TEXTMETRICW, WCHAR, tmFirstChar, 44, 2, 2);
2145     TEST_FIELD(TEXTMETRICW, WCHAR, tmLastChar, 46, 2, 2);
2146     TEST_FIELD(TEXTMETRICW, WCHAR, tmDefaultChar, 48, 2, 2);
2147     TEST_FIELD(TEXTMETRICW, WCHAR, tmBreakChar, 50, 2, 2);
2148     TEST_FIELD(TEXTMETRICW, BYTE, tmItalic, 52, 1, 1);
2149     TEST_FIELD(TEXTMETRICW, BYTE, tmUnderlined, 53, 1, 1);
2150     TEST_FIELD(TEXTMETRICW, BYTE, tmStruckOut, 54, 1, 1);
2151     TEST_FIELD(TEXTMETRICW, BYTE, tmPitchAndFamily, 55, 1, 1);
2152     TEST_FIELD(TEXTMETRICW, BYTE, tmCharSet, 56, 1, 1);
2153
2154     /* TRIVERTEX (pack 4) */
2155     TEST_TYPE(TRIVERTEX, 16, 4);
2156     TEST_FIELD(TRIVERTEX, LONG, x, 0, 4, 4);
2157     TEST_FIELD(TRIVERTEX, LONG, y, 4, 4, 4);
2158     TEST_FIELD(TRIVERTEX, COLOR16, Red, 8, 2, 2);
2159     TEST_FIELD(TRIVERTEX, COLOR16, Green, 10, 2, 2);
2160     TEST_FIELD(TRIVERTEX, COLOR16, Blue, 12, 2, 2);
2161     TEST_FIELD(TRIVERTEX, COLOR16, Alpha, 14, 2, 2);
2162
2163     /* TTPOLYCURVE (pack 4) */
2164     TEST_TYPE(TTPOLYCURVE, 12, 2);
2165     TEST_FIELD(TTPOLYCURVE, WORD, wType, 0, 2, 2);
2166     TEST_FIELD(TTPOLYCURVE, WORD, cpfx, 2, 2, 2);
2167     TEST_FIELD(TTPOLYCURVE, POINTFX[1], apfx, 4, 8, 2);
2168
2169     /* TTPOLYGONHEADER (pack 4) */
2170     TEST_TYPE(TTPOLYGONHEADER, 16, 4);
2171     TEST_FIELD(TTPOLYGONHEADER, DWORD, cb, 0, 4, 4);
2172     TEST_FIELD(TTPOLYGONHEADER, DWORD, dwType, 4, 4, 4);
2173     TEST_FIELD(TTPOLYGONHEADER, POINTFX, pfxStart, 8, 8, 2);
2174
2175     /* XFORM (pack 4) */
2176     TEST_TYPE(XFORM, 24, 4);
2177     TEST_FIELD(XFORM, FLOAT, eM11, 0, 4, 4);
2178     TEST_FIELD(XFORM, FLOAT, eM12, 4, 4, 4);
2179     TEST_FIELD(XFORM, FLOAT, eM21, 8, 4, 4);
2180     TEST_FIELD(XFORM, FLOAT, eM22, 12, 4, 4);
2181     TEST_FIELD(XFORM, FLOAT, eDx, 16, 4, 4);
2182     TEST_FIELD(XFORM, FLOAT, eDy, 20, 4, 4);
2183
2184 }
2185
2186 START_TEST(generated)
2187 {
2188     test_pack();
2189 }