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

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