dlls/gdi/tests/generated.c

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