git.oblomov.eu Git - wine/blob - dlls/gdi32/tests/generated.c

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