modules/rostests/winetests/gdi32/generated.c

   1 /* File generated automatically from tools/winapi/tests.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 WINE_NOWINSOCK
   9
  10 #include "windows.h"
  11
  12 #include "wine/test.h"
  13
  14 /***********************************************************************
  15  * Compatibility macros
  16  */
  17
  18 #define DWORD_PTR UINT_PTR
  19 #define LONG_PTR INT_PTR
  20 #define ULONG_PTR UINT_PTR
  21
  22 /***********************************************************************
  23  * Windows API extension
  24  */
  25
  26 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
  27 # define _TYPE_ALIGNMENT(type) __alignof(type)
  28 #elif defined(__GNUC__)
  29 # define _TYPE_ALIGNMENT(type) __alignof__(type)
  30 #else
  31 /*
  32  * FIXME: May not be possible without a compiler extension
  33  *        (if type is not just a name that is, otherwise the normal
  34  *         TYPE_ALIGNMENT can be used)
  35  */
  36 #endif
  37
  38 #if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)
  39 #pragma warning(disable:4116)
  40 #endif
  41
  42 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
  43 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
  44 #endif
  45
  46 /***********************************************************************
  47  * Test helper macros
  48  */
  49
  50 #define TEST_TYPE_SIZE(type, size)             C_ASSERT(sizeof(type) == size);
  51
  52 #ifdef TYPE_ALIGNMENT
  53 # define TEST_TYPE_ALIGN(type, align)          C_ASSERT(TYPE_ALIGNMENT(type) == align);
  54 #else
  55 # define TEST_TYPE_ALIGN(type, align)
  56 #endif
  57
  58 #ifdef _TYPE_ALIGNMENT
  59 # define TEST_TARGET_ALIGN(type, align)        C_ASSERT(_TYPE_ALIGNMENT(*(type)0) == align);
  60 # define TEST_FIELD_ALIGN(type, field, align)  C_ASSERT(_TYPE_ALIGNMENT(((type*)0)->field) == align);
  61 #else
  62 # define TEST_TARGET_ALIGN(type, align)
  63 # define TEST_FIELD_ALIGN(type, field, align)
  64 #endif
  65
  66 #define TEST_FIELD_OFFSET(type, field, offset) C_ASSERT(FIELD_OFFSET(type, field) == offset);
  67
  68 #define TEST_TARGET_SIZE(type, size)            TEST_TYPE_SIZE(*(type)0, size)
  69 #define TEST_FIELD_SIZE(type, field, size)      TEST_TYPE_SIZE((((type*)0)->field), size)
  70 #define TEST_TYPE_SIGNED(type)                  C_ASSERT((type) -1 < 0);
  71 #define TEST_TYPE_UNSIGNED(type)                C_ASSERT((type) -1 > 0);
  72
  73
  74 #ifdef _WIN64
  75
  76 static void test_pack_ABC(void)
  77 {
  78     /* ABC */
  79     TEST_TYPE_SIZE   (ABC, 12)
  80     TEST_TYPE_ALIGN  (ABC, 4)
  81     TEST_FIELD_SIZE  (ABC, abcA, 4)
  82     TEST_FIELD_ALIGN (ABC, abcA, 4)
  83     TEST_FIELD_OFFSET(ABC, abcA, 0)
  84     TEST_FIELD_SIZE  (ABC, abcB, 4)
  85     TEST_FIELD_ALIGN (ABC, abcB, 4)
  86     TEST_FIELD_OFFSET(ABC, abcB, 4)
  87     TEST_FIELD_SIZE  (ABC, abcC, 4)
  88     TEST_FIELD_ALIGN (ABC, abcC, 4)
  89     TEST_FIELD_OFFSET(ABC, abcC, 8)
  90 }
  91
  92 static void test_pack_ABCFLOAT(void)
  93 {
  94     /* ABCFLOAT */
  95     TEST_TYPE_SIZE   (ABCFLOAT, 12)
  96     TEST_TYPE_ALIGN  (ABCFLOAT, 4)
  97     TEST_FIELD_SIZE  (ABCFLOAT, abcfA, 4)
  98     TEST_FIELD_ALIGN (ABCFLOAT, abcfA, 4)
  99     TEST_FIELD_OFFSET(ABCFLOAT, abcfA, 0)
 100     TEST_FIELD_SIZE  (ABCFLOAT, abcfB, 4)
 101     TEST_FIELD_ALIGN (ABCFLOAT, abcfB, 4)
 102     TEST_FIELD_OFFSET(ABCFLOAT, abcfB, 4)
 103     TEST_FIELD_SIZE  (ABCFLOAT, abcfC, 4)
 104     TEST_FIELD_ALIGN (ABCFLOAT, abcfC, 4)
 105     TEST_FIELD_OFFSET(ABCFLOAT, abcfC, 8)
 106 }
 107
 108 static void test_pack_ABORTPROC(void)
 109 {
 110     /* ABORTPROC */
 111     TEST_TYPE_SIZE   (ABORTPROC, 8)
 112     TEST_TYPE_ALIGN  (ABORTPROC, 8)
 113 }
 114
 115 static void test_pack_BITMAP(void)
 116 {
 117     /* BITMAP */
 118     TEST_TYPE_SIZE   (BITMAP, 32)
 119     TEST_TYPE_ALIGN  (BITMAP, 8)
 120     TEST_FIELD_SIZE  (BITMAP, bmType, 4)
 121     TEST_FIELD_ALIGN (BITMAP, bmType, 4)
 122     TEST_FIELD_OFFSET(BITMAP, bmType, 0)
 123     TEST_FIELD_SIZE  (BITMAP, bmWidth, 4)
 124     TEST_FIELD_ALIGN (BITMAP, bmWidth, 4)
 125     TEST_FIELD_OFFSET(BITMAP, bmWidth, 4)
 126     TEST_FIELD_SIZE  (BITMAP, bmHeight, 4)
 127     TEST_FIELD_ALIGN (BITMAP, bmHeight, 4)
 128     TEST_FIELD_OFFSET(BITMAP, bmHeight, 8)
 129     TEST_FIELD_SIZE  (BITMAP, bmWidthBytes, 4)
 130     TEST_FIELD_ALIGN (BITMAP, bmWidthBytes, 4)
 131     TEST_FIELD_OFFSET(BITMAP, bmWidthBytes, 12)
 132     TEST_FIELD_SIZE  (BITMAP, bmPlanes, 2)
 133     TEST_FIELD_ALIGN (BITMAP, bmPlanes, 2)
 134     TEST_FIELD_OFFSET(BITMAP, bmPlanes, 16)
 135     TEST_FIELD_SIZE  (BITMAP, bmBitsPixel, 2)
 136     TEST_FIELD_ALIGN (BITMAP, bmBitsPixel, 2)
 137     TEST_FIELD_OFFSET(BITMAP, bmBitsPixel, 18)
 138     TEST_FIELD_SIZE  (BITMAP, bmBits, 8)
 139     TEST_FIELD_ALIGN (BITMAP, bmBits, 8)
 140     TEST_FIELD_OFFSET(BITMAP, bmBits, 24)
 141 }
 142
 143 static void test_pack_BITMAPCOREHEADER(void)
 144 {
 145     /* BITMAPCOREHEADER */
 146     TEST_TYPE_SIZE   (BITMAPCOREHEADER, 12)
 147     TEST_TYPE_ALIGN  (BITMAPCOREHEADER, 4)
 148     TEST_FIELD_SIZE  (BITMAPCOREHEADER, bcSize, 4)
 149     TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcSize, 4)
 150     TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcSize, 0)
 151     TEST_FIELD_SIZE  (BITMAPCOREHEADER, bcWidth, 2)
 152     TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcWidth, 2)
 153     TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcWidth, 4)
 154     TEST_FIELD_SIZE  (BITMAPCOREHEADER, bcHeight, 2)
 155     TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcHeight, 2)
 156     TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcHeight, 6)
 157     TEST_FIELD_SIZE  (BITMAPCOREHEADER, bcPlanes, 2)
 158     TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcPlanes, 2)
 159     TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcPlanes, 8)
 160     TEST_FIELD_SIZE  (BITMAPCOREHEADER, bcBitCount, 2)
 161     TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcBitCount, 2)
 162     TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcBitCount, 10)
 163 }
 164
 165 static void test_pack_BITMAPCOREINFO(void)
 166 {
 167     /* BITMAPCOREINFO */
 168     TEST_TYPE_SIZE   (BITMAPCOREINFO, 16)
 169     TEST_TYPE_ALIGN  (BITMAPCOREINFO, 4)
 170     TEST_FIELD_SIZE  (BITMAPCOREINFO, bmciHeader, 12)
 171     TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciHeader, 4)
 172     TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciHeader, 0)
 173     TEST_FIELD_SIZE  (BITMAPCOREINFO, bmciColors, 3)
 174     TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciColors, 1)
 175     TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciColors, 12)
 176 }
 177
 178 static void test_pack_BITMAPFILEHEADER(void)
 179 {
 180     /* BITMAPFILEHEADER (pack 2) */
 181     TEST_TYPE_SIZE   (BITMAPFILEHEADER, 14)
 182     TEST_TYPE_ALIGN  (BITMAPFILEHEADER, 2)
 183     TEST_FIELD_SIZE  (BITMAPFILEHEADER, bfType, 2)
 184     TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfType, 2)
 185     TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfType, 0)
 186     TEST_FIELD_SIZE  (BITMAPFILEHEADER, bfSize, 4)
 187     TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfSize, 2)
 188     TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfSize, 2)
 189     TEST_FIELD_SIZE  (BITMAPFILEHEADER, bfReserved1, 2)
 190     TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved1, 2)
 191     TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved1, 6)
 192     TEST_FIELD_SIZE  (BITMAPFILEHEADER, bfReserved2, 2)
 193     TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved2, 2)
 194     TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved2, 8)
 195     TEST_FIELD_SIZE  (BITMAPFILEHEADER, bfOffBits, 4)
 196     TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfOffBits, 2)
 197     TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfOffBits, 10)
 198 }
 199
 200 static void test_pack_BITMAPINFO(void)
 201 {
 202     /* BITMAPINFO */
 203     TEST_TYPE_SIZE   (BITMAPINFO, 44)
 204     TEST_TYPE_ALIGN  (BITMAPINFO, 4)
 205     TEST_FIELD_SIZE  (BITMAPINFO, bmiHeader, 40)
 206     TEST_FIELD_ALIGN (BITMAPINFO, bmiHeader, 4)
 207     TEST_FIELD_OFFSET(BITMAPINFO, bmiHeader, 0)
 208     TEST_FIELD_SIZE  (BITMAPINFO, bmiColors, 4)
 209     TEST_FIELD_ALIGN (BITMAPINFO, bmiColors, 1)
 210     TEST_FIELD_OFFSET(BITMAPINFO, bmiColors, 40)
 211 }
 212
 213 static void test_pack_BITMAPINFOHEADER(void)
 214 {
 215     /* BITMAPINFOHEADER */
 216     TEST_TYPE_SIZE   (BITMAPINFOHEADER, 40)
 217     TEST_TYPE_ALIGN  (BITMAPINFOHEADER, 4)
 218     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biSize, 4)
 219     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biSize, 4)
 220     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biSize, 0)
 221     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biWidth, 4)
 222     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biWidth, 4)
 223     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biWidth, 4)
 224     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biHeight, 4)
 225     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biHeight, 4)
 226     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biHeight, 8)
 227     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biPlanes, 2)
 228     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biPlanes, 2)
 229     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biPlanes, 12)
 230     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biBitCount, 2)
 231     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biBitCount, 2)
 232     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biBitCount, 14)
 233     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biCompression, 4)
 234     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biCompression, 4)
 235     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biCompression, 16)
 236     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biSizeImage, 4)
 237     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biSizeImage, 4)
 238     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biSizeImage, 20)
 239     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biXPelsPerMeter, 4)
 240     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biXPelsPerMeter, 4)
 241     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biXPelsPerMeter, 24)
 242     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biYPelsPerMeter, 4)
 243     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biYPelsPerMeter, 4)
 244     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biYPelsPerMeter, 28)
 245     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biClrUsed, 4)
 246     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrUsed, 4)
 247     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrUsed, 32)
 248     TEST_FIELD_SIZE  (BITMAPINFOHEADER, biClrImportant, 4)
 249     TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrImportant, 4)
 250     TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrImportant, 36)
 251 }
 252
 253 static void test_pack_BITMAPV4HEADER(void)
 254 {
 255     /* BITMAPV4HEADER */
 256     TEST_TYPE_SIZE   (BITMAPV4HEADER, 108)
 257     TEST_TYPE_ALIGN  (BITMAPV4HEADER, 4)
 258     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4Size, 4)
 259     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Size, 4)
 260     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Size, 0)
 261     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4Width, 4)
 262     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Width, 4)
 263     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Width, 4)
 264     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4Height, 4)
 265     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Height, 4)
 266     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Height, 8)
 267     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4Planes, 2)
 268     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Planes, 2)
 269     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Planes, 12)
 270     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4BitCount, 2)
 271     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BitCount, 2)
 272     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BitCount, 14)
 273     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4V4Compression, 4)
 274     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4V4Compression, 4)
 275     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4V4Compression, 16)
 276     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4SizeImage, 4)
 277     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4SizeImage, 4)
 278     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4SizeImage, 20)
 279     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4XPelsPerMeter, 4)
 280     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4XPelsPerMeter, 4)
 281     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4XPelsPerMeter, 24)
 282     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4YPelsPerMeter, 4)
 283     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4YPelsPerMeter, 4)
 284     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4YPelsPerMeter, 28)
 285     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4ClrUsed, 4)
 286     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrUsed, 4)
 287     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrUsed, 32)
 288     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4ClrImportant, 4)
 289     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrImportant, 4)
 290     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrImportant, 36)
 291     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4RedMask, 4)
 292     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4RedMask, 4)
 293     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4RedMask, 40)
 294     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4GreenMask, 4)
 295     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GreenMask, 4)
 296     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GreenMask, 44)
 297     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4BlueMask, 4)
 298     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BlueMask, 4)
 299     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BlueMask, 48)
 300     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4AlphaMask, 4)
 301     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4AlphaMask, 4)
 302     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4AlphaMask, 52)
 303     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4CSType, 4)
 304     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4CSType, 4)
 305     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4CSType, 56)
 306     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4Endpoints, 36)
 307     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Endpoints, 4)
 308     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Endpoints, 60)
 309     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4GammaRed, 4)
 310     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaRed, 4)
 311     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaRed, 96)
 312     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4GammaGreen, 4)
 313     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaGreen, 4)
 314     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaGreen, 100)
 315     TEST_FIELD_SIZE  (BITMAPV4HEADER, bV4GammaBlue, 4)
 316     TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaBlue, 4)
 317     TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaBlue, 104)
 318 }
 319
 320 static void test_pack_BITMAPV5HEADER(void)
 321 {
 322     /* BITMAPV5HEADER */
 323     TEST_TYPE_SIZE   (BITMAPV5HEADER, 124)
 324     TEST_TYPE_ALIGN  (BITMAPV5HEADER, 4)
 325     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5Size, 4)
 326     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Size, 4)
 327     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Size, 0)
 328     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5Width, 4)
 329     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Width, 4)
 330     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Width, 4)
 331     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5Height, 4)
 332     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Height, 4)
 333     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Height, 8)
 334     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5Planes, 2)
 335     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Planes, 2)
 336     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Planes, 12)
 337     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5BitCount, 2)
 338     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BitCount, 2)
 339     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BitCount, 14)
 340     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5Compression, 4)
 341     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Compression, 4)
 342     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Compression, 16)
 343     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5SizeImage, 4)
 344     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5SizeImage, 4)
 345     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5SizeImage, 20)
 346     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5XPelsPerMeter, 4)
 347     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5XPelsPerMeter, 4)
 348     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5XPelsPerMeter, 24)
 349     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5YPelsPerMeter, 4)
 350     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5YPelsPerMeter, 4)
 351     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5YPelsPerMeter, 28)
 352     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5ClrUsed, 4)
 353     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrUsed, 4)
 354     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrUsed, 32)
 355     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5ClrImportant, 4)
 356     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrImportant, 4)
 357     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrImportant, 36)
 358     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5RedMask, 4)
 359     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5RedMask, 4)
 360     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5RedMask, 40)
 361     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5GreenMask, 4)
 362     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GreenMask, 4)
 363     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GreenMask, 44)
 364     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5BlueMask, 4)
 365     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BlueMask, 4)
 366     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BlueMask, 48)
 367     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5AlphaMask, 4)
 368     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5AlphaMask, 4)
 369     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5AlphaMask, 52)
 370     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5CSType, 4)
 371     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5CSType, 4)
 372     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5CSType, 56)
 373     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5Endpoints, 36)
 374     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Endpoints, 4)
 375     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Endpoints, 60)
 376     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5GammaRed, 4)
 377     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaRed, 4)
 378     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaRed, 96)
 379     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5GammaGreen, 4)
 380     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaGreen, 4)
 381     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaGreen, 100)
 382     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5GammaBlue, 4)
 383     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaBlue, 4)
 384     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaBlue, 104)
 385     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5Intent, 4)
 386     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Intent, 4)
 387     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Intent, 108)
 388     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5ProfileData, 4)
 389     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileData, 4)
 390     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileData, 112)
 391     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5ProfileSize, 4)
 392     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileSize, 4)
 393     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileSize, 116)
 394     TEST_FIELD_SIZE  (BITMAPV5HEADER, bV5Reserved, 4)
 395     TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Reserved, 4)
 396     TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Reserved, 120)
 397 }
 398
 399 static void test_pack_BLENDFUNCTION(void)
 400 {
 401     /* BLENDFUNCTION */
 402     TEST_TYPE_SIZE   (BLENDFUNCTION, 4)
 403     TEST_TYPE_ALIGN  (BLENDFUNCTION, 1)
 404     TEST_FIELD_SIZE  (BLENDFUNCTION, BlendOp, 1)
 405     TEST_FIELD_ALIGN (BLENDFUNCTION, BlendOp, 1)
 406     TEST_FIELD_OFFSET(BLENDFUNCTION, BlendOp, 0)
 407     TEST_FIELD_SIZE  (BLENDFUNCTION, BlendFlags, 1)
 408     TEST_FIELD_ALIGN (BLENDFUNCTION, BlendFlags, 1)
 409     TEST_FIELD_OFFSET(BLENDFUNCTION, BlendFlags, 1)
 410     TEST_FIELD_SIZE  (BLENDFUNCTION, SourceConstantAlpha, 1)
 411     TEST_FIELD_ALIGN (BLENDFUNCTION, SourceConstantAlpha, 1)
 412     TEST_FIELD_OFFSET(BLENDFUNCTION, SourceConstantAlpha, 2)
 413     TEST_FIELD_SIZE  (BLENDFUNCTION, AlphaFormat, 1)
 414     TEST_FIELD_ALIGN (BLENDFUNCTION, AlphaFormat, 1)
 415     TEST_FIELD_OFFSET(BLENDFUNCTION, AlphaFormat, 3)
 416 }
 417
 418 static void test_pack_CHARSETINFO(void)
 419 {
 420     /* CHARSETINFO */
 421     TEST_TYPE_SIZE   (CHARSETINFO, 32)
 422     TEST_TYPE_ALIGN  (CHARSETINFO, 4)
 423     TEST_FIELD_SIZE  (CHARSETINFO, ciCharset, 4)
 424     TEST_FIELD_ALIGN (CHARSETINFO, ciCharset, 4)
 425     TEST_FIELD_OFFSET(CHARSETINFO, ciCharset, 0)
 426     TEST_FIELD_SIZE  (CHARSETINFO, ciACP, 4)
 427     TEST_FIELD_ALIGN (CHARSETINFO, ciACP, 4)
 428     TEST_FIELD_OFFSET(CHARSETINFO, ciACP, 4)
 429     TEST_FIELD_SIZE  (CHARSETINFO, fs, 24)
 430     TEST_FIELD_ALIGN (CHARSETINFO, fs, 4)
 431     TEST_FIELD_OFFSET(CHARSETINFO, fs, 8)
 432 }
 433
 434 static void test_pack_CIEXYZ(void)
 435 {
 436     /* CIEXYZ */
 437     TEST_TYPE_SIZE   (CIEXYZ, 12)
 438     TEST_TYPE_ALIGN  (CIEXYZ, 4)
 439     TEST_FIELD_SIZE  (CIEXYZ, ciexyzX, 4)
 440     TEST_FIELD_ALIGN (CIEXYZ, ciexyzX, 4)
 441     TEST_FIELD_OFFSET(CIEXYZ, ciexyzX, 0)
 442     TEST_FIELD_SIZE  (CIEXYZ, ciexyzY, 4)
 443     TEST_FIELD_ALIGN (CIEXYZ, ciexyzY, 4)
 444     TEST_FIELD_OFFSET(CIEXYZ, ciexyzY, 4)
 445     TEST_FIELD_SIZE  (CIEXYZ, ciexyzZ, 4)
 446     TEST_FIELD_ALIGN (CIEXYZ, ciexyzZ, 4)
 447     TEST_FIELD_OFFSET(CIEXYZ, ciexyzZ, 8)
 448 }
 449
 450 static void test_pack_CIEXYZTRIPLE(void)
 451 {
 452     /* CIEXYZTRIPLE */
 453     TEST_TYPE_SIZE   (CIEXYZTRIPLE, 36)
 454     TEST_TYPE_ALIGN  (CIEXYZTRIPLE, 4)
 455     TEST_FIELD_SIZE  (CIEXYZTRIPLE, ciexyzRed, 12)
 456     TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzRed, 4)
 457     TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzRed, 0)
 458     TEST_FIELD_SIZE  (CIEXYZTRIPLE, ciexyzGreen, 12)
 459     TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzGreen, 4)
 460     TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzGreen, 12)
 461     TEST_FIELD_SIZE  (CIEXYZTRIPLE, ciexyzBlue, 12)
 462     TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzBlue, 4)
 463     TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzBlue, 24)
 464 }
 465
 466 static void test_pack_COLOR16(void)
 467 {
 468     /* COLOR16 */
 469     TEST_TYPE_SIZE   (COLOR16, 2)
 470     TEST_TYPE_ALIGN  (COLOR16, 2)
 471 }
 472
 473 static void test_pack_COLORADJUSTMENT(void)
 474 {
 475     /* COLORADJUSTMENT */
 476     TEST_TYPE_SIZE   (COLORADJUSTMENT, 24)
 477     TEST_TYPE_ALIGN  (COLORADJUSTMENT, 2)
 478     TEST_FIELD_SIZE  (COLORADJUSTMENT, caSize, 2)
 479     TEST_FIELD_ALIGN (COLORADJUSTMENT, caSize, 2)
 480     TEST_FIELD_OFFSET(COLORADJUSTMENT, caSize, 0)
 481     TEST_FIELD_SIZE  (COLORADJUSTMENT, caFlags, 2)
 482     TEST_FIELD_ALIGN (COLORADJUSTMENT, caFlags, 2)
 483     TEST_FIELD_OFFSET(COLORADJUSTMENT, caFlags, 2)
 484     TEST_FIELD_SIZE  (COLORADJUSTMENT, caIlluminantIndex, 2)
 485     TEST_FIELD_ALIGN (COLORADJUSTMENT, caIlluminantIndex, 2)
 486     TEST_FIELD_OFFSET(COLORADJUSTMENT, caIlluminantIndex, 4)
 487     TEST_FIELD_SIZE  (COLORADJUSTMENT, caRedGamma, 2)
 488     TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGamma, 2)
 489     TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGamma, 6)
 490     TEST_FIELD_SIZE  (COLORADJUSTMENT, caGreenGamma, 2)
 491     TEST_FIELD_ALIGN (COLORADJUSTMENT, caGreenGamma, 2)
 492     TEST_FIELD_OFFSET(COLORADJUSTMENT, caGreenGamma, 8)
 493     TEST_FIELD_SIZE  (COLORADJUSTMENT, caBlueGamma, 2)
 494     TEST_FIELD_ALIGN (COLORADJUSTMENT, caBlueGamma, 2)
 495     TEST_FIELD_OFFSET(COLORADJUSTMENT, caBlueGamma, 10)
 496     TEST_FIELD_SIZE  (COLORADJUSTMENT, caReferenceBlack, 2)
 497     TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceBlack, 2)
 498     TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceBlack, 12)
 499     TEST_FIELD_SIZE  (COLORADJUSTMENT, caReferenceWhite, 2)
 500     TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceWhite, 2)
 501     TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceWhite, 14)
 502     TEST_FIELD_SIZE  (COLORADJUSTMENT, caContrast, 2)
 503     TEST_FIELD_ALIGN (COLORADJUSTMENT, caContrast, 2)
 504     TEST_FIELD_OFFSET(COLORADJUSTMENT, caContrast, 16)
 505     TEST_FIELD_SIZE  (COLORADJUSTMENT, caBrightness, 2)
 506     TEST_FIELD_ALIGN (COLORADJUSTMENT, caBrightness, 2)
 507     TEST_FIELD_OFFSET(COLORADJUSTMENT, caBrightness, 18)
 508     TEST_FIELD_SIZE  (COLORADJUSTMENT, caColorfulness, 2)
 509     TEST_FIELD_ALIGN (COLORADJUSTMENT, caColorfulness, 2)
 510     TEST_FIELD_OFFSET(COLORADJUSTMENT, caColorfulness, 20)
 511     TEST_FIELD_SIZE  (COLORADJUSTMENT, caRedGreenTint, 2)
 512     TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGreenTint, 2)
 513     TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGreenTint, 22)
 514 }
 515
 516 static void test_pack_DEVMODEA(void)
 517 {
 518     /* DEVMODEA */
 519     TEST_FIELD_SIZE  (DEVMODEA, dmDeviceName, 32)
 520     TEST_FIELD_ALIGN (DEVMODEA, dmDeviceName, 1)
 521     TEST_FIELD_OFFSET(DEVMODEA, dmDeviceName, 0)
 522     TEST_FIELD_SIZE  (DEVMODEA, dmSpecVersion, 2)
 523     TEST_FIELD_ALIGN (DEVMODEA, dmSpecVersion, 2)
 524     TEST_FIELD_OFFSET(DEVMODEA, dmSpecVersion, 32)
 525     TEST_FIELD_SIZE  (DEVMODEA, dmDriverVersion, 2)
 526     TEST_FIELD_ALIGN (DEVMODEA, dmDriverVersion, 2)
 527     TEST_FIELD_OFFSET(DEVMODEA, dmDriverVersion, 34)
 528     TEST_FIELD_SIZE  (DEVMODEA, dmSize, 2)
 529     TEST_FIELD_ALIGN (DEVMODEA, dmSize, 2)
 530     TEST_FIELD_OFFSET(DEVMODEA, dmSize, 36)
 531     TEST_FIELD_SIZE  (DEVMODEA, dmDriverExtra, 2)
 532     TEST_FIELD_ALIGN (DEVMODEA, dmDriverExtra, 2)
 533     TEST_FIELD_OFFSET(DEVMODEA, dmDriverExtra, 38)
 534     TEST_FIELD_SIZE  (DEVMODEA, dmFields, 4)
 535     TEST_FIELD_ALIGN (DEVMODEA, dmFields, 4)
 536     TEST_FIELD_OFFSET(DEVMODEA, dmFields, 40)
 537 }
 538
 539 static void test_pack_DEVMODEW(void)
 540 {
 541     /* DEVMODEW */
 542     TEST_FIELD_SIZE  (DEVMODEW, dmDeviceName, 64)
 543     TEST_FIELD_ALIGN (DEVMODEW, dmDeviceName, 2)
 544     TEST_FIELD_OFFSET(DEVMODEW, dmDeviceName, 0)
 545     TEST_FIELD_SIZE  (DEVMODEW, dmSpecVersion, 2)
 546     TEST_FIELD_ALIGN (DEVMODEW, dmSpecVersion, 2)
 547     TEST_FIELD_OFFSET(DEVMODEW, dmSpecVersion, 64)
 548     TEST_FIELD_SIZE  (DEVMODEW, dmDriverVersion, 2)
 549     TEST_FIELD_ALIGN (DEVMODEW, dmDriverVersion, 2)
 550     TEST_FIELD_OFFSET(DEVMODEW, dmDriverVersion, 66)
 551     TEST_FIELD_SIZE  (DEVMODEW, dmSize, 2)
 552     TEST_FIELD_ALIGN (DEVMODEW, dmSize, 2)
 553     TEST_FIELD_OFFSET(DEVMODEW, dmSize, 68)
 554     TEST_FIELD_SIZE  (DEVMODEW, dmDriverExtra, 2)
 555     TEST_FIELD_ALIGN (DEVMODEW, dmDriverExtra, 2)
 556     TEST_FIELD_OFFSET(DEVMODEW, dmDriverExtra, 70)
 557     TEST_FIELD_SIZE  (DEVMODEW, dmFields, 4)
 558     TEST_FIELD_ALIGN (DEVMODEW, dmFields, 4)
 559     TEST_FIELD_OFFSET(DEVMODEW, dmFields, 72)
 560 }
 561
 562 static void test_pack_DIBSECTION(void)
 563 {
 564     /* DIBSECTION */
 565     TEST_TYPE_SIZE   (DIBSECTION, 104)
 566     TEST_TYPE_ALIGN  (DIBSECTION, 8)
 567     TEST_FIELD_SIZE  (DIBSECTION, dsBm, 32)
 568     TEST_FIELD_ALIGN (DIBSECTION, dsBm, 8)
 569     TEST_FIELD_OFFSET(DIBSECTION, dsBm, 0)
 570     TEST_FIELD_SIZE  (DIBSECTION, dsBmih, 40)
 571     TEST_FIELD_ALIGN (DIBSECTION, dsBmih, 4)
 572     TEST_FIELD_OFFSET(DIBSECTION, dsBmih, 32)
 573     TEST_FIELD_SIZE  (DIBSECTION, dsBitfields, 12)
 574     TEST_FIELD_ALIGN (DIBSECTION, dsBitfields, 4)
 575     TEST_FIELD_OFFSET(DIBSECTION, dsBitfields, 72)
 576     TEST_FIELD_SIZE  (DIBSECTION, dshSection, 8)
 577     TEST_FIELD_ALIGN (DIBSECTION, dshSection, 8)
 578     TEST_FIELD_OFFSET(DIBSECTION, dshSection, 88)
 579     TEST_FIELD_SIZE  (DIBSECTION, dsOffset, 4)
 580     TEST_FIELD_ALIGN (DIBSECTION, dsOffset, 4)
 581     TEST_FIELD_OFFSET(DIBSECTION, dsOffset, 96)
 582 }
 583
 584 static void test_pack_DISPLAY_DEVICEA(void)
 585 {
 586     /* DISPLAY_DEVICEA */
 587     TEST_TYPE_SIZE   (DISPLAY_DEVICEA, 424)
 588     TEST_TYPE_ALIGN  (DISPLAY_DEVICEA, 4)
 589     TEST_FIELD_SIZE  (DISPLAY_DEVICEA, cb, 4)
 590     TEST_FIELD_ALIGN (DISPLAY_DEVICEA, cb, 4)
 591     TEST_FIELD_OFFSET(DISPLAY_DEVICEA, cb, 0)
 592     TEST_FIELD_SIZE  (DISPLAY_DEVICEA, DeviceName, 32)
 593     TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceName, 1)
 594     TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceName, 4)
 595     TEST_FIELD_SIZE  (DISPLAY_DEVICEA, DeviceString, 128)
 596     TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceString, 1)
 597     TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceString, 36)
 598     TEST_FIELD_SIZE  (DISPLAY_DEVICEA, StateFlags, 4)
 599     TEST_FIELD_ALIGN (DISPLAY_DEVICEA, StateFlags, 4)
 600     TEST_FIELD_OFFSET(DISPLAY_DEVICEA, StateFlags, 164)
 601     TEST_FIELD_SIZE  (DISPLAY_DEVICEA, DeviceID, 128)
 602     TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceID, 1)
 603     TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceID, 168)
 604     TEST_FIELD_SIZE  (DISPLAY_DEVICEA, DeviceKey, 128)
 605     TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceKey, 1)
 606     TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceKey, 296)
 607 }
 608
 609 static void test_pack_DISPLAY_DEVICEW(void)
 610 {
 611     /* DISPLAY_DEVICEW */
 612     TEST_TYPE_SIZE   (DISPLAY_DEVICEW, 840)
 613     TEST_TYPE_ALIGN  (DISPLAY_DEVICEW, 4)
 614     TEST_FIELD_SIZE  (DISPLAY_DEVICEW, cb, 4)
 615     TEST_FIELD_ALIGN (DISPLAY_DEVICEW, cb, 4)
 616     TEST_FIELD_OFFSET(DISPLAY_DEVICEW, cb, 0)
 617     TEST_FIELD_SIZE  (DISPLAY_DEVICEW, DeviceName, 64)
 618     TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceName, 2)
 619     TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceName, 4)
 620     TEST_FIELD_SIZE  (DISPLAY_DEVICEW, DeviceString, 256)
 621     TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceString, 2)
 622     TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceString, 68)
 623     TEST_FIELD_SIZE  (DISPLAY_DEVICEW, StateFlags, 4)
 624     TEST_FIELD_ALIGN (DISPLAY_DEVICEW, StateFlags, 4)
 625     TEST_FIELD_OFFSET(DISPLAY_DEVICEW, StateFlags, 324)
 626     TEST_FIELD_SIZE  (DISPLAY_DEVICEW, DeviceID, 256)
 627     TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceID, 2)
 628     TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceID, 328)
 629     TEST_FIELD_SIZE  (DISPLAY_DEVICEW, DeviceKey, 256)
 630     TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceKey, 2)
 631     TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceKey, 584)
 632 }
 633
 634 static void test_pack_DOCINFOA(void)
 635 {
 636     /* DOCINFOA */
 637     TEST_TYPE_SIZE   (DOCINFOA, 40)
 638     TEST_TYPE_ALIGN  (DOCINFOA, 8)
 639     TEST_FIELD_SIZE  (DOCINFOA, cbSize, 4)
 640     TEST_FIELD_ALIGN (DOCINFOA, cbSize, 4)
 641     TEST_FIELD_OFFSET(DOCINFOA, cbSize, 0)
 642     TEST_FIELD_SIZE  (DOCINFOA, lpszDocName, 8)
 643     TEST_FIELD_ALIGN (DOCINFOA, lpszDocName, 8)
 644     TEST_FIELD_OFFSET(DOCINFOA, lpszDocName, 8)
 645     TEST_FIELD_SIZE  (DOCINFOA, lpszOutput, 8)
 646     TEST_FIELD_ALIGN (DOCINFOA, lpszOutput, 8)
 647     TEST_FIELD_OFFSET(DOCINFOA, lpszOutput, 16)
 648     TEST_FIELD_SIZE  (DOCINFOA, lpszDatatype, 8)
 649     TEST_FIELD_ALIGN (DOCINFOA, lpszDatatype, 8)
 650     TEST_FIELD_OFFSET(DOCINFOA, lpszDatatype, 24)
 651     TEST_FIELD_SIZE  (DOCINFOA, fwType, 4)
 652     TEST_FIELD_ALIGN (DOCINFOA, fwType, 4)
 653     TEST_FIELD_OFFSET(DOCINFOA, fwType, 32)
 654 }
 655
 656 static void test_pack_DOCINFOW(void)
 657 {
 658     /* DOCINFOW */
 659     TEST_TYPE_SIZE   (DOCINFOW, 40)
 660     TEST_TYPE_ALIGN  (DOCINFOW, 8)
 661     TEST_FIELD_SIZE  (DOCINFOW, cbSize, 4)
 662     TEST_FIELD_ALIGN (DOCINFOW, cbSize, 4)
 663     TEST_FIELD_OFFSET(DOCINFOW, cbSize, 0)
 664     TEST_FIELD_SIZE  (DOCINFOW, lpszDocName, 8)
 665     TEST_FIELD_ALIGN (DOCINFOW, lpszDocName, 8)
 666     TEST_FIELD_OFFSET(DOCINFOW, lpszDocName, 8)
 667     TEST_FIELD_SIZE  (DOCINFOW, lpszOutput, 8)
 668     TEST_FIELD_ALIGN (DOCINFOW, lpszOutput, 8)
 669     TEST_FIELD_OFFSET(DOCINFOW, lpszOutput, 16)
 670     TEST_FIELD_SIZE  (DOCINFOW, lpszDatatype, 8)
 671     TEST_FIELD_ALIGN (DOCINFOW, lpszDatatype, 8)
 672     TEST_FIELD_OFFSET(DOCINFOW, lpszDatatype, 24)
 673     TEST_FIELD_SIZE  (DOCINFOW, fwType, 4)
 674     TEST_FIELD_ALIGN (DOCINFOW, fwType, 4)
 675     TEST_FIELD_OFFSET(DOCINFOW, fwType, 32)
 676 }
 677
 678 static void test_pack_EMR(void)
 679 {
 680     /* EMR */
 681     TEST_TYPE_SIZE   (EMR, 8)
 682     TEST_TYPE_ALIGN  (EMR, 4)
 683     TEST_FIELD_SIZE  (EMR, iType, 4)
 684     TEST_FIELD_ALIGN (EMR, iType, 4)
 685     TEST_FIELD_OFFSET(EMR, iType, 0)
 686     TEST_FIELD_SIZE  (EMR, nSize, 4)
 687     TEST_FIELD_ALIGN (EMR, nSize, 4)
 688     TEST_FIELD_OFFSET(EMR, nSize, 4)
 689 }
 690
 691 static void test_pack_EMRABORTPATH(void)
 692 {
 693     /* EMRABORTPATH */
 694     TEST_TYPE_SIZE   (EMRABORTPATH, 8)
 695     TEST_TYPE_ALIGN  (EMRABORTPATH, 4)
 696     TEST_FIELD_SIZE  (EMRABORTPATH, emr, 8)
 697     TEST_FIELD_ALIGN (EMRABORTPATH, emr, 4)
 698     TEST_FIELD_OFFSET(EMRABORTPATH, emr, 0)
 699 }
 700
 701 static void test_pack_EMRANGLEARC(void)
 702 {
 703     /* EMRANGLEARC */
 704     TEST_TYPE_SIZE   (EMRANGLEARC, 28)
 705     TEST_TYPE_ALIGN  (EMRANGLEARC, 4)
 706     TEST_FIELD_SIZE  (EMRANGLEARC, emr, 8)
 707     TEST_FIELD_ALIGN (EMRANGLEARC, emr, 4)
 708     TEST_FIELD_OFFSET(EMRANGLEARC, emr, 0)
 709     TEST_FIELD_SIZE  (EMRANGLEARC, ptlCenter, 8)
 710     TEST_FIELD_ALIGN (EMRANGLEARC, ptlCenter, 4)
 711     TEST_FIELD_OFFSET(EMRANGLEARC, ptlCenter, 8)
 712     TEST_FIELD_SIZE  (EMRANGLEARC, nRadius, 4)
 713     TEST_FIELD_ALIGN (EMRANGLEARC, nRadius, 4)
 714     TEST_FIELD_OFFSET(EMRANGLEARC, nRadius, 16)
 715     TEST_FIELD_SIZE  (EMRANGLEARC, eStartAngle, 4)
 716     TEST_FIELD_ALIGN (EMRANGLEARC, eStartAngle, 4)
 717     TEST_FIELD_OFFSET(EMRANGLEARC, eStartAngle, 20)
 718     TEST_FIELD_SIZE  (EMRANGLEARC, eSweepAngle, 4)
 719     TEST_FIELD_ALIGN (EMRANGLEARC, eSweepAngle, 4)
 720     TEST_FIELD_OFFSET(EMRANGLEARC, eSweepAngle, 24)
 721 }
 722
 723 static void test_pack_EMRARC(void)
 724 {
 725     /* EMRARC */
 726     TEST_TYPE_SIZE   (EMRARC, 40)
 727     TEST_TYPE_ALIGN  (EMRARC, 4)
 728     TEST_FIELD_SIZE  (EMRARC, emr, 8)
 729     TEST_FIELD_ALIGN (EMRARC, emr, 4)
 730     TEST_FIELD_OFFSET(EMRARC, emr, 0)
 731     TEST_FIELD_SIZE  (EMRARC, rclBox, 16)
 732     TEST_FIELD_ALIGN (EMRARC, rclBox, 4)
 733     TEST_FIELD_OFFSET(EMRARC, rclBox, 8)
 734     TEST_FIELD_SIZE  (EMRARC, ptlStart, 8)
 735     TEST_FIELD_ALIGN (EMRARC, ptlStart, 4)
 736     TEST_FIELD_OFFSET(EMRARC, ptlStart, 24)
 737     TEST_FIELD_SIZE  (EMRARC, ptlEnd, 8)
 738     TEST_FIELD_ALIGN (EMRARC, ptlEnd, 4)
 739     TEST_FIELD_OFFSET(EMRARC, ptlEnd, 32)
 740 }
 741
 742 static void test_pack_EMRARCTO(void)
 743 {
 744     /* EMRARCTO */
 745     TEST_TYPE_SIZE   (EMRARCTO, 40)
 746     TEST_TYPE_ALIGN  (EMRARCTO, 4)
 747     TEST_FIELD_SIZE  (EMRARCTO, emr, 8)
 748     TEST_FIELD_ALIGN (EMRARCTO, emr, 4)
 749     TEST_FIELD_OFFSET(EMRARCTO, emr, 0)
 750     TEST_FIELD_SIZE  (EMRARCTO, rclBox, 16)
 751     TEST_FIELD_ALIGN (EMRARCTO, rclBox, 4)
 752     TEST_FIELD_OFFSET(EMRARCTO, rclBox, 8)
 753     TEST_FIELD_SIZE  (EMRARCTO, ptlStart, 8)
 754     TEST_FIELD_ALIGN (EMRARCTO, ptlStart, 4)
 755     TEST_FIELD_OFFSET(EMRARCTO, ptlStart, 24)
 756     TEST_FIELD_SIZE  (EMRARCTO, ptlEnd, 8)
 757     TEST_FIELD_ALIGN (EMRARCTO, ptlEnd, 4)
 758     TEST_FIELD_OFFSET(EMRARCTO, ptlEnd, 32)
 759 }
 760
 761 static void test_pack_EMRBEGINPATH(void)
 762 {
 763     /* EMRBEGINPATH */
 764     TEST_TYPE_SIZE   (EMRBEGINPATH, 8)
 765     TEST_TYPE_ALIGN  (EMRBEGINPATH, 4)
 766     TEST_FIELD_SIZE  (EMRBEGINPATH, emr, 8)
 767     TEST_FIELD_ALIGN (EMRBEGINPATH, emr, 4)
 768     TEST_FIELD_OFFSET(EMRBEGINPATH, emr, 0)
 769 }
 770
 771 static void test_pack_EMRBITBLT(void)
 772 {
 773     /* EMRBITBLT */
 774     TEST_TYPE_SIZE   (EMRBITBLT, 100)
 775     TEST_TYPE_ALIGN  (EMRBITBLT, 4)
 776     TEST_FIELD_SIZE  (EMRBITBLT, emr, 8)
 777     TEST_FIELD_ALIGN (EMRBITBLT, emr, 4)
 778     TEST_FIELD_OFFSET(EMRBITBLT, emr, 0)
 779     TEST_FIELD_SIZE  (EMRBITBLT, rclBounds, 16)
 780     TEST_FIELD_ALIGN (EMRBITBLT, rclBounds, 4)
 781     TEST_FIELD_OFFSET(EMRBITBLT, rclBounds, 8)
 782     TEST_FIELD_SIZE  (EMRBITBLT, xDest, 4)
 783     TEST_FIELD_ALIGN (EMRBITBLT, xDest, 4)
 784     TEST_FIELD_OFFSET(EMRBITBLT, xDest, 24)
 785     TEST_FIELD_SIZE  (EMRBITBLT, yDest, 4)
 786     TEST_FIELD_ALIGN (EMRBITBLT, yDest, 4)
 787     TEST_FIELD_OFFSET(EMRBITBLT, yDest, 28)
 788     TEST_FIELD_SIZE  (EMRBITBLT, cxDest, 4)
 789     TEST_FIELD_ALIGN (EMRBITBLT, cxDest, 4)
 790     TEST_FIELD_OFFSET(EMRBITBLT, cxDest, 32)
 791     TEST_FIELD_SIZE  (EMRBITBLT, cyDest, 4)
 792     TEST_FIELD_ALIGN (EMRBITBLT, cyDest, 4)
 793     TEST_FIELD_OFFSET(EMRBITBLT, cyDest, 36)
 794     TEST_FIELD_SIZE  (EMRBITBLT, dwRop, 4)
 795     TEST_FIELD_ALIGN (EMRBITBLT, dwRop, 4)
 796     TEST_FIELD_OFFSET(EMRBITBLT, dwRop, 40)
 797     TEST_FIELD_SIZE  (EMRBITBLT, xSrc, 4)
 798     TEST_FIELD_ALIGN (EMRBITBLT, xSrc, 4)
 799     TEST_FIELD_OFFSET(EMRBITBLT, xSrc, 44)
 800     TEST_FIELD_SIZE  (EMRBITBLT, ySrc, 4)
 801     TEST_FIELD_ALIGN (EMRBITBLT, ySrc, 4)
 802     TEST_FIELD_OFFSET(EMRBITBLT, ySrc, 48)
 803     TEST_FIELD_SIZE  (EMRBITBLT, xformSrc, 24)
 804     TEST_FIELD_ALIGN (EMRBITBLT, xformSrc, 4)
 805     TEST_FIELD_OFFSET(EMRBITBLT, xformSrc, 52)
 806     TEST_FIELD_SIZE  (EMRBITBLT, crBkColorSrc, 4)
 807     TEST_FIELD_ALIGN (EMRBITBLT, crBkColorSrc, 4)
 808     TEST_FIELD_OFFSET(EMRBITBLT, crBkColorSrc, 76)
 809     TEST_FIELD_SIZE  (EMRBITBLT, iUsageSrc, 4)
 810     TEST_FIELD_ALIGN (EMRBITBLT, iUsageSrc, 4)
 811     TEST_FIELD_OFFSET(EMRBITBLT, iUsageSrc, 80)
 812     TEST_FIELD_SIZE  (EMRBITBLT, offBmiSrc, 4)
 813     TEST_FIELD_ALIGN (EMRBITBLT, offBmiSrc, 4)
 814     TEST_FIELD_OFFSET(EMRBITBLT, offBmiSrc, 84)
 815     TEST_FIELD_SIZE  (EMRBITBLT, cbBmiSrc, 4)
 816     TEST_FIELD_ALIGN (EMRBITBLT, cbBmiSrc, 4)
 817     TEST_FIELD_OFFSET(EMRBITBLT, cbBmiSrc, 88)
 818     TEST_FIELD_SIZE  (EMRBITBLT, offBitsSrc, 4)
 819     TEST_FIELD_ALIGN (EMRBITBLT, offBitsSrc, 4)
 820     TEST_FIELD_OFFSET(EMRBITBLT, offBitsSrc, 92)
 821     TEST_FIELD_SIZE  (EMRBITBLT, cbBitsSrc, 4)
 822     TEST_FIELD_ALIGN (EMRBITBLT, cbBitsSrc, 4)
 823     TEST_FIELD_OFFSET(EMRBITBLT, cbBitsSrc, 96)
 824 }
 825
 826 static void test_pack_EMRCHORD(void)
 827 {
 828     /* EMRCHORD */
 829     TEST_TYPE_SIZE   (EMRCHORD, 40)
 830     TEST_TYPE_ALIGN  (EMRCHORD, 4)
 831     TEST_FIELD_SIZE  (EMRCHORD, emr, 8)
 832     TEST_FIELD_ALIGN (EMRCHORD, emr, 4)
 833     TEST_FIELD_OFFSET(EMRCHORD, emr, 0)
 834     TEST_FIELD_SIZE  (EMRCHORD, rclBox, 16)
 835     TEST_FIELD_ALIGN (EMRCHORD, rclBox, 4)
 836     TEST_FIELD_OFFSET(EMRCHORD, rclBox, 8)
 837     TEST_FIELD_SIZE  (EMRCHORD, ptlStart, 8)
 838     TEST_FIELD_ALIGN (EMRCHORD, ptlStart, 4)
 839     TEST_FIELD_OFFSET(EMRCHORD, ptlStart, 24)
 840     TEST_FIELD_SIZE  (EMRCHORD, ptlEnd, 8)
 841     TEST_FIELD_ALIGN (EMRCHORD, ptlEnd, 4)
 842     TEST_FIELD_OFFSET(EMRCHORD, ptlEnd, 32)
 843 }
 844
 845 static void test_pack_EMRCLOSEFIGURE(void)
 846 {
 847     /* EMRCLOSEFIGURE */
 848     TEST_TYPE_SIZE   (EMRCLOSEFIGURE, 8)
 849     TEST_TYPE_ALIGN  (EMRCLOSEFIGURE, 4)
 850     TEST_FIELD_SIZE  (EMRCLOSEFIGURE, emr, 8)
 851     TEST_FIELD_ALIGN (EMRCLOSEFIGURE, emr, 4)
 852     TEST_FIELD_OFFSET(EMRCLOSEFIGURE, emr, 0)
 853 }
 854
 855 static void test_pack_EMRCREATEBRUSHINDIRECT(void)
 856 {
 857     /* EMRCREATEBRUSHINDIRECT */
 858     TEST_TYPE_SIZE   (EMRCREATEBRUSHINDIRECT, 24)
 859     TEST_TYPE_ALIGN  (EMRCREATEBRUSHINDIRECT, 4)
 860     TEST_FIELD_SIZE  (EMRCREATEBRUSHINDIRECT, emr, 8)
 861     TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, emr, 4)
 862     TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, emr, 0)
 863     TEST_FIELD_SIZE  (EMRCREATEBRUSHINDIRECT, ihBrush, 4)
 864     TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, ihBrush, 4)
 865     TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, ihBrush, 8)
 866     TEST_FIELD_SIZE  (EMRCREATEBRUSHINDIRECT, lb, 12)
 867     TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, lb, 4)
 868     TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, lb, 12)
 869 }
 870
 871 static void test_pack_EMRCREATECOLORSPACE(void)
 872 {
 873     /* EMRCREATECOLORSPACE */
 874     TEST_TYPE_SIZE   (EMRCREATECOLORSPACE, 340)
 875     TEST_TYPE_ALIGN  (EMRCREATECOLORSPACE, 4)
 876     TEST_FIELD_SIZE  (EMRCREATECOLORSPACE, emr, 8)
 877     TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, emr, 4)
 878     TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, emr, 0)
 879     TEST_FIELD_SIZE  (EMRCREATECOLORSPACE, ihCS, 4)
 880     TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, ihCS, 4)
 881     TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, ihCS, 8)
 882     TEST_FIELD_SIZE  (EMRCREATECOLORSPACE, lcs, 328)
 883     TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, lcs, 4)
 884     TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, lcs, 12)
 885 }
 886
 887 static void test_pack_EMRCREATECOLORSPACEW(void)
 888 {
 889     /* EMRCREATECOLORSPACEW */
 890     TEST_TYPE_SIZE   (EMRCREATECOLORSPACEW, 612)
 891     TEST_TYPE_ALIGN  (EMRCREATECOLORSPACEW, 4)
 892     TEST_FIELD_SIZE  (EMRCREATECOLORSPACEW, emr, 8)
 893     TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, emr, 4)
 894     TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, emr, 0)
 895     TEST_FIELD_SIZE  (EMRCREATECOLORSPACEW, ihCS, 4)
 896     TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, ihCS, 4)
 897     TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, ihCS, 8)
 898     TEST_FIELD_SIZE  (EMRCREATECOLORSPACEW, lcs, 588)
 899     TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, lcs, 4)
 900     TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, lcs, 12)
 901     TEST_FIELD_SIZE  (EMRCREATECOLORSPACEW, dwFlags, 4)
 902     TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, dwFlags, 4)
 903     TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, dwFlags, 600)
 904     TEST_FIELD_SIZE  (EMRCREATECOLORSPACEW, cbData, 4)
 905     TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, cbData, 4)
 906     TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, cbData, 604)
 907     TEST_FIELD_SIZE  (EMRCREATECOLORSPACEW, Data, 1)
 908     TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, Data, 1)
 909     TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, Data, 608)
 910 }
 911
 912 static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void)
 913 {
 914     /* EMRCREATEDIBPATTERNBRUSHPT */
 915     TEST_TYPE_SIZE   (EMRCREATEDIBPATTERNBRUSHPT, 32)
 916     TEST_TYPE_ALIGN  (EMRCREATEDIBPATTERNBRUSHPT, 4)
 917     TEST_FIELD_SIZE  (EMRCREATEDIBPATTERNBRUSHPT, emr, 8)
 918     TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, emr, 4)
 919     TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, emr, 0)
 920     TEST_FIELD_SIZE  (EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 4)
 921     TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 4)
 922     TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 8)
 923     TEST_FIELD_SIZE  (EMRCREATEDIBPATTERNBRUSHPT, iUsage, 4)
 924     TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, iUsage, 4)
 925     TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, iUsage, 12)
 926     TEST_FIELD_SIZE  (EMRCREATEDIBPATTERNBRUSHPT, offBmi, 4)
 927     TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, offBmi, 4)
 928     TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, offBmi, 16)
 929     TEST_FIELD_SIZE  (EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 4)
 930     TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 4)
 931     TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 20)
 932     TEST_FIELD_SIZE  (EMRCREATEDIBPATTERNBRUSHPT, offBits, 4)
 933     TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, offBits, 4)
 934     TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, offBits, 24)
 935     TEST_FIELD_SIZE  (EMRCREATEDIBPATTERNBRUSHPT, cbBits, 4)
 936     TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, cbBits, 4)
 937     TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, cbBits, 28)
 938 }
 939
 940 static void test_pack_EMRCREATEMONOBRUSH(void)
 941 {
 942     /* EMRCREATEMONOBRUSH */
 943     TEST_TYPE_SIZE   (EMRCREATEMONOBRUSH, 32)
 944     TEST_TYPE_ALIGN  (EMRCREATEMONOBRUSH, 4)
 945     TEST_FIELD_SIZE  (EMRCREATEMONOBRUSH, emr, 8)
 946     TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, emr, 4)
 947     TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, emr, 0)
 948     TEST_FIELD_SIZE  (EMRCREATEMONOBRUSH, ihBrush, 4)
 949     TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, ihBrush, 4)
 950     TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, ihBrush, 8)
 951     TEST_FIELD_SIZE  (EMRCREATEMONOBRUSH, iUsage, 4)
 952     TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, iUsage, 4)
 953     TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, iUsage, 12)
 954     TEST_FIELD_SIZE  (EMRCREATEMONOBRUSH, offBmi, 4)
 955     TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, offBmi, 4)
 956     TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, offBmi, 16)
 957     TEST_FIELD_SIZE  (EMRCREATEMONOBRUSH, cbBmi, 4)
 958     TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, cbBmi, 4)
 959     TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, cbBmi, 20)
 960     TEST_FIELD_SIZE  (EMRCREATEMONOBRUSH, offBits, 4)
 961     TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, offBits, 4)
 962     TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, offBits, 24)
 963     TEST_FIELD_SIZE  (EMRCREATEMONOBRUSH, cbBits, 4)
 964     TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, cbBits, 4)
 965     TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, cbBits, 28)
 966 }
 967
 968 static void test_pack_EMRCREATEPEN(void)
 969 {
 970     /* EMRCREATEPEN */
 971     TEST_TYPE_SIZE   (EMRCREATEPEN, 28)
 972     TEST_TYPE_ALIGN  (EMRCREATEPEN, 4)
 973     TEST_FIELD_SIZE  (EMRCREATEPEN, emr, 8)
 974     TEST_FIELD_ALIGN (EMRCREATEPEN, emr, 4)
 975     TEST_FIELD_OFFSET(EMRCREATEPEN, emr, 0)
 976     TEST_FIELD_SIZE  (EMRCREATEPEN, ihPen, 4)
 977     TEST_FIELD_ALIGN (EMRCREATEPEN, ihPen, 4)
 978     TEST_FIELD_OFFSET(EMRCREATEPEN, ihPen, 8)
 979     TEST_FIELD_SIZE  (EMRCREATEPEN, lopn, 16)
 980     TEST_FIELD_ALIGN (EMRCREATEPEN, lopn, 4)
 981     TEST_FIELD_OFFSET(EMRCREATEPEN, lopn, 12)
 982 }
 983
 984 static void test_pack_EMRDELETECOLORSPACE(void)
 985 {
 986     /* EMRDELETECOLORSPACE */
 987     TEST_TYPE_SIZE   (EMRDELETECOLORSPACE, 12)
 988     TEST_TYPE_ALIGN  (EMRDELETECOLORSPACE, 4)
 989     TEST_FIELD_SIZE  (EMRDELETECOLORSPACE, emr, 8)
 990     TEST_FIELD_ALIGN (EMRDELETECOLORSPACE, emr, 4)
 991     TEST_FIELD_OFFSET(EMRDELETECOLORSPACE, emr, 0)
 992     TEST_FIELD_SIZE  (EMRDELETECOLORSPACE, ihCS, 4)
 993     TEST_FIELD_ALIGN (EMRDELETECOLORSPACE, ihCS, 4)
 994     TEST_FIELD_OFFSET(EMRDELETECOLORSPACE, ihCS, 8)
 995 }
 996
 997 static void test_pack_EMRDELETEOBJECT(void)
 998 {
 999     /* EMRDELETEOBJECT */
1000     TEST_TYPE_SIZE   (EMRDELETEOBJECT, 12)
1001     TEST_TYPE_ALIGN  (EMRDELETEOBJECT, 4)
1002     TEST_FIELD_SIZE  (EMRDELETEOBJECT, emr, 8)
1003     TEST_FIELD_ALIGN (EMRDELETEOBJECT, emr, 4)
1004     TEST_FIELD_OFFSET(EMRDELETEOBJECT, emr, 0)
1005     TEST_FIELD_SIZE  (EMRDELETEOBJECT, ihObject, 4)
1006     TEST_FIELD_ALIGN (EMRDELETEOBJECT, ihObject, 4)
1007     TEST_FIELD_OFFSET(EMRDELETEOBJECT, ihObject, 8)
1008 }
1009
1010 static void test_pack_EMRELLIPSE(void)
1011 {
1012     /* EMRELLIPSE */
1013     TEST_TYPE_SIZE   (EMRELLIPSE, 24)
1014     TEST_TYPE_ALIGN  (EMRELLIPSE, 4)
1015     TEST_FIELD_SIZE  (EMRELLIPSE, emr, 8)
1016     TEST_FIELD_ALIGN (EMRELLIPSE, emr, 4)
1017     TEST_FIELD_OFFSET(EMRELLIPSE, emr, 0)
1018     TEST_FIELD_SIZE  (EMRELLIPSE, rclBox, 16)
1019     TEST_FIELD_ALIGN (EMRELLIPSE, rclBox, 4)
1020     TEST_FIELD_OFFSET(EMRELLIPSE, rclBox, 8)
1021 }
1022
1023 static void test_pack_EMRENDPATH(void)
1024 {
1025     /* EMRENDPATH */
1026     TEST_TYPE_SIZE   (EMRENDPATH, 8)
1027     TEST_TYPE_ALIGN  (EMRENDPATH, 4)
1028     TEST_FIELD_SIZE  (EMRENDPATH, emr, 8)
1029     TEST_FIELD_ALIGN (EMRENDPATH, emr, 4)
1030     TEST_FIELD_OFFSET(EMRENDPATH, emr, 0)
1031 }
1032
1033 static void test_pack_EMREOF(void)
1034 {
1035     /* EMREOF */
1036     TEST_TYPE_SIZE   (EMREOF, 20)
1037     TEST_TYPE_ALIGN  (EMREOF, 4)
1038     TEST_FIELD_SIZE  (EMREOF, emr, 8)
1039     TEST_FIELD_ALIGN (EMREOF, emr, 4)
1040     TEST_FIELD_OFFSET(EMREOF, emr, 0)
1041     TEST_FIELD_SIZE  (EMREOF, nPalEntries, 4)
1042     TEST_FIELD_ALIGN (EMREOF, nPalEntries, 4)
1043     TEST_FIELD_OFFSET(EMREOF, nPalEntries, 8)
1044     TEST_FIELD_SIZE  (EMREOF, offPalEntries, 4)
1045     TEST_FIELD_ALIGN (EMREOF, offPalEntries, 4)
1046     TEST_FIELD_OFFSET(EMREOF, offPalEntries, 12)
1047     TEST_FIELD_SIZE  (EMREOF, nSizeLast, 4)
1048     TEST_FIELD_ALIGN (EMREOF, nSizeLast, 4)
1049     TEST_FIELD_OFFSET(EMREOF, nSizeLast, 16)
1050 }
1051
1052 static void test_pack_EMREXCLUDECLIPRECT(void)
1053 {
1054     /* EMREXCLUDECLIPRECT */
1055     TEST_TYPE_SIZE   (EMREXCLUDECLIPRECT, 24)
1056     TEST_TYPE_ALIGN  (EMREXCLUDECLIPRECT, 4)
1057     TEST_FIELD_SIZE  (EMREXCLUDECLIPRECT, emr, 8)
1058     TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, emr, 4)
1059     TEST_FIELD_OFFSET(EMREXCLUDECLIPRECT, emr, 0)
1060     TEST_FIELD_SIZE  (EMREXCLUDECLIPRECT, rclClip, 16)
1061     TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, rclClip, 4)
1062     TEST_FIELD_OFFSET(EMREXCLUDECLIPRECT, rclClip, 8)
1063 }
1064
1065 static void test_pack_EMREXTCREATEFONTINDIRECTW(void)
1066 {
1067     /* EMREXTCREATEFONTINDIRECTW */
1068     TEST_TYPE_SIZE   (EMREXTCREATEFONTINDIRECTW, 332)
1069     TEST_TYPE_ALIGN  (EMREXTCREATEFONTINDIRECTW, 4)
1070     TEST_FIELD_SIZE  (EMREXTCREATEFONTINDIRECTW, emr, 8)
1071     TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, emr, 4)
1072     TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, emr, 0)
1073     TEST_FIELD_SIZE  (EMREXTCREATEFONTINDIRECTW, ihFont, 4)
1074     TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, ihFont, 4)
1075     TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, ihFont, 8)
1076     TEST_FIELD_SIZE  (EMREXTCREATEFONTINDIRECTW, elfw, 320)
1077     TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, elfw, 4)
1078     TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, elfw, 12)
1079 }
1080
1081 static void test_pack_EMREXTCREATEPEN(void)
1082 {
1083     /* EMREXTCREATEPEN */
1084     TEST_TYPE_SIZE   (EMREXTCREATEPEN, 64)
1085     TEST_TYPE_ALIGN  (EMREXTCREATEPEN, 8)
1086     TEST_FIELD_SIZE  (EMREXTCREATEPEN, emr, 8)
1087     TEST_FIELD_ALIGN (EMREXTCREATEPEN, emr, 4)
1088     TEST_FIELD_OFFSET(EMREXTCREATEPEN, emr, 0)
1089     TEST_FIELD_SIZE  (EMREXTCREATEPEN, ihPen, 4)
1090     TEST_FIELD_ALIGN (EMREXTCREATEPEN, ihPen, 4)
1091     TEST_FIELD_OFFSET(EMREXTCREATEPEN, ihPen, 8)
1092     TEST_FIELD_SIZE  (EMREXTCREATEPEN, offBmi, 4)
1093     TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBmi, 4)
1094     TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBmi, 12)
1095     TEST_FIELD_SIZE  (EMREXTCREATEPEN, cbBmi, 4)
1096     TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBmi, 4)
1097     TEST_FIELD_OFFSET(EMREXTCREATEPEN, cbBmi, 16)
1098     TEST_FIELD_SIZE  (EMREXTCREATEPEN, offBits, 4)
1099     TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBits, 4)
1100     TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBits, 20)
1101     TEST_FIELD_SIZE  (EMREXTCREATEPEN, cbBits, 4)
1102     TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBits, 4)
1103     TEST_FIELD_OFFSET(EMREXTCREATEPEN, cbBits, 24)
1104     TEST_FIELD_SIZE  (EMREXTCREATEPEN, elp, 32)
1105     TEST_FIELD_ALIGN (EMREXTCREATEPEN, elp, 8)
1106     TEST_FIELD_OFFSET(EMREXTCREATEPEN, elp, 32)
1107 }
1108
1109 static void test_pack_EMREXTFLOODFILL(void)
1110 {
1111     /* EMREXTFLOODFILL */
1112     TEST_TYPE_SIZE   (EMREXTFLOODFILL, 24)
1113     TEST_TYPE_ALIGN  (EMREXTFLOODFILL, 4)
1114     TEST_FIELD_SIZE  (EMREXTFLOODFILL, emr, 8)
1115     TEST_FIELD_ALIGN (EMREXTFLOODFILL, emr, 4)
1116     TEST_FIELD_OFFSET(EMREXTFLOODFILL, emr, 0)
1117     TEST_FIELD_SIZE  (EMREXTFLOODFILL, ptlStart, 8)
1118     TEST_FIELD_ALIGN (EMREXTFLOODFILL, ptlStart, 4)
1119     TEST_FIELD_OFFSET(EMREXTFLOODFILL, ptlStart, 8)
1120     TEST_FIELD_SIZE  (EMREXTFLOODFILL, crColor, 4)
1121     TEST_FIELD_ALIGN (EMREXTFLOODFILL, crColor, 4)
1122     TEST_FIELD_OFFSET(EMREXTFLOODFILL, crColor, 16)
1123     TEST_FIELD_SIZE  (EMREXTFLOODFILL, iMode, 4)
1124     TEST_FIELD_ALIGN (EMREXTFLOODFILL, iMode, 4)
1125     TEST_FIELD_OFFSET(EMREXTFLOODFILL, iMode, 20)
1126 }
1127
1128 static void test_pack_EMREXTSELECTCLIPRGN(void)
1129 {
1130     /* EMREXTSELECTCLIPRGN */
1131     TEST_TYPE_SIZE   (EMREXTSELECTCLIPRGN, 20)
1132     TEST_TYPE_ALIGN  (EMREXTSELECTCLIPRGN, 4)
1133     TEST_FIELD_SIZE  (EMREXTSELECTCLIPRGN, emr, 8)
1134     TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, emr, 4)
1135     TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, emr, 0)
1136     TEST_FIELD_SIZE  (EMREXTSELECTCLIPRGN, cbRgnData, 4)
1137     TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, cbRgnData, 4)
1138     TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, cbRgnData, 8)
1139     TEST_FIELD_SIZE  (EMREXTSELECTCLIPRGN, iMode, 4)
1140     TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, iMode, 4)
1141     TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, iMode, 12)
1142     TEST_FIELD_SIZE  (EMREXTSELECTCLIPRGN, RgnData, 1)
1143     TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, RgnData, 1)
1144     TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, RgnData, 16)
1145 }
1146
1147 static void test_pack_EMREXTTEXTOUTA(void)
1148 {
1149     /* EMREXTTEXTOUTA */
1150     TEST_TYPE_SIZE   (EMREXTTEXTOUTA, 76)
1151     TEST_TYPE_ALIGN  (EMREXTTEXTOUTA, 4)
1152     TEST_FIELD_SIZE  (EMREXTTEXTOUTA, emr, 8)
1153     TEST_FIELD_ALIGN (EMREXTTEXTOUTA, emr, 4)
1154     TEST_FIELD_OFFSET(EMREXTTEXTOUTA, emr, 0)
1155     TEST_FIELD_SIZE  (EMREXTTEXTOUTA, rclBounds, 16)
1156     TEST_FIELD_ALIGN (EMREXTTEXTOUTA, rclBounds, 4)
1157     TEST_FIELD_OFFSET(EMREXTTEXTOUTA, rclBounds, 8)
1158     TEST_FIELD_SIZE  (EMREXTTEXTOUTA, iGraphicsMode, 4)
1159     TEST_FIELD_ALIGN (EMREXTTEXTOUTA, iGraphicsMode, 4)
1160     TEST_FIELD_OFFSET(EMREXTTEXTOUTA, iGraphicsMode, 24)
1161     TEST_FIELD_SIZE  (EMREXTTEXTOUTA, exScale, 4)
1162     TEST_FIELD_ALIGN (EMREXTTEXTOUTA, exScale, 4)
1163     TEST_FIELD_OFFSET(EMREXTTEXTOUTA, exScale, 28)
1164     TEST_FIELD_SIZE  (EMREXTTEXTOUTA, eyScale, 4)
1165     TEST_FIELD_ALIGN (EMREXTTEXTOUTA, eyScale, 4)
1166     TEST_FIELD_OFFSET(EMREXTTEXTOUTA, eyScale, 32)
1167     TEST_FIELD_SIZE  (EMREXTTEXTOUTA, emrtext, 40)
1168     TEST_FIELD_ALIGN (EMREXTTEXTOUTA, emrtext, 4)
1169     TEST_FIELD_OFFSET(EMREXTTEXTOUTA, emrtext, 36)
1170 }
1171
1172 static void test_pack_EMREXTTEXTOUTW(void)
1173 {
1174     /* EMREXTTEXTOUTW */
1175     TEST_TYPE_SIZE   (EMREXTTEXTOUTW, 76)
1176     TEST_TYPE_ALIGN  (EMREXTTEXTOUTW, 4)
1177     TEST_FIELD_SIZE  (EMREXTTEXTOUTW, emr, 8)
1178     TEST_FIELD_ALIGN (EMREXTTEXTOUTW, emr, 4)
1179     TEST_FIELD_OFFSET(EMREXTTEXTOUTW, emr, 0)
1180     TEST_FIELD_SIZE  (EMREXTTEXTOUTW, rclBounds, 16)
1181     TEST_FIELD_ALIGN (EMREXTTEXTOUTW, rclBounds, 4)
1182     TEST_FIELD_OFFSET(EMREXTTEXTOUTW, rclBounds, 8)
1183     TEST_FIELD_SIZE  (EMREXTTEXTOUTW, iGraphicsMode, 4)
1184     TEST_FIELD_ALIGN (EMREXTTEXTOUTW, iGraphicsMode, 4)
1185     TEST_FIELD_OFFSET(EMREXTTEXTOUTW, iGraphicsMode, 24)
1186     TEST_FIELD_SIZE  (EMREXTTEXTOUTW, exScale, 4)
1187     TEST_FIELD_ALIGN (EMREXTTEXTOUTW, exScale, 4)
1188     TEST_FIELD_OFFSET(EMREXTTEXTOUTW, exScale, 28)
1189     TEST_FIELD_SIZE  (EMREXTTEXTOUTW, eyScale, 4)
1190     TEST_FIELD_ALIGN (EMREXTTEXTOUTW, eyScale, 4)
1191     TEST_FIELD_OFFSET(EMREXTTEXTOUTW, eyScale, 32)
1192     TEST_FIELD_SIZE  (EMREXTTEXTOUTW, emrtext, 40)
1193     TEST_FIELD_ALIGN (EMREXTTEXTOUTW, emrtext, 4)
1194     TEST_FIELD_OFFSET(EMREXTTEXTOUTW, emrtext, 36)
1195 }
1196
1197 static void test_pack_EMRFILLPATH(void)
1198 {
1199     /* EMRFILLPATH */
1200     TEST_TYPE_SIZE   (EMRFILLPATH, 24)
1201     TEST_TYPE_ALIGN  (EMRFILLPATH, 4)
1202     TEST_FIELD_SIZE  (EMRFILLPATH, emr, 8)
1203     TEST_FIELD_ALIGN (EMRFILLPATH, emr, 4)
1204     TEST_FIELD_OFFSET(EMRFILLPATH, emr, 0)
1205     TEST_FIELD_SIZE  (EMRFILLPATH, rclBounds, 16)
1206     TEST_FIELD_ALIGN (EMRFILLPATH, rclBounds, 4)
1207     TEST_FIELD_OFFSET(EMRFILLPATH, rclBounds, 8)
1208 }
1209
1210 static void test_pack_EMRFILLRGN(void)
1211 {
1212     /* EMRFILLRGN */
1213     TEST_TYPE_SIZE   (EMRFILLRGN, 36)
1214     TEST_TYPE_ALIGN  (EMRFILLRGN, 4)
1215     TEST_FIELD_SIZE  (EMRFILLRGN, emr, 8)
1216     TEST_FIELD_ALIGN (EMRFILLRGN, emr, 4)
1217     TEST_FIELD_OFFSET(EMRFILLRGN, emr, 0)
1218     TEST_FIELD_SIZE  (EMRFILLRGN, rclBounds, 16)
1219     TEST_FIELD_ALIGN (EMRFILLRGN, rclBounds, 4)
1220     TEST_FIELD_OFFSET(EMRFILLRGN, rclBounds, 8)
1221     TEST_FIELD_SIZE  (EMRFILLRGN, cbRgnData, 4)
1222     TEST_FIELD_ALIGN (EMRFILLRGN, cbRgnData, 4)
1223     TEST_FIELD_OFFSET(EMRFILLRGN, cbRgnData, 24)
1224     TEST_FIELD_SIZE  (EMRFILLRGN, ihBrush, 4)
1225     TEST_FIELD_ALIGN (EMRFILLRGN, ihBrush, 4)
1226     TEST_FIELD_OFFSET(EMRFILLRGN, ihBrush, 28)
1227     TEST_FIELD_SIZE  (EMRFILLRGN, RgnData, 1)
1228     TEST_FIELD_ALIGN (EMRFILLRGN, RgnData, 1)
1229     TEST_FIELD_OFFSET(EMRFILLRGN, RgnData, 32)
1230 }
1231
1232 static void test_pack_EMRFLATTENPATH(void)
1233 {
1234     /* EMRFLATTENPATH */
1235     TEST_TYPE_SIZE   (EMRFLATTENPATH, 8)
1236     TEST_TYPE_ALIGN  (EMRFLATTENPATH, 4)
1237     TEST_FIELD_SIZE  (EMRFLATTENPATH, emr, 8)
1238     TEST_FIELD_ALIGN (EMRFLATTENPATH, emr, 4)
1239     TEST_FIELD_OFFSET(EMRFLATTENPATH, emr, 0)
1240 }
1241
1242 static void test_pack_EMRFORMAT(void)
1243 {
1244     /* EMRFORMAT */
1245     TEST_TYPE_SIZE   (EMRFORMAT, 16)
1246     TEST_TYPE_ALIGN  (EMRFORMAT, 4)
1247     TEST_FIELD_SIZE  (EMRFORMAT, dSignature, 4)
1248     TEST_FIELD_ALIGN (EMRFORMAT, dSignature, 4)
1249     TEST_FIELD_OFFSET(EMRFORMAT, dSignature, 0)
1250     TEST_FIELD_SIZE  (EMRFORMAT, nVersion, 4)
1251     TEST_FIELD_ALIGN (EMRFORMAT, nVersion, 4)
1252     TEST_FIELD_OFFSET(EMRFORMAT, nVersion, 4)
1253     TEST_FIELD_SIZE  (EMRFORMAT, cbData, 4)
1254     TEST_FIELD_ALIGN (EMRFORMAT, cbData, 4)
1255     TEST_FIELD_OFFSET(EMRFORMAT, cbData, 8)
1256     TEST_FIELD_SIZE  (EMRFORMAT, offData, 4)
1257     TEST_FIELD_ALIGN (EMRFORMAT, offData, 4)
1258     TEST_FIELD_OFFSET(EMRFORMAT, offData, 12)
1259 }
1260
1261 static void test_pack_EMRFRAMERGN(void)
1262 {
1263     /* EMRFRAMERGN */
1264     TEST_TYPE_SIZE   (EMRFRAMERGN, 44)
1265     TEST_TYPE_ALIGN  (EMRFRAMERGN, 4)
1266     TEST_FIELD_SIZE  (EMRFRAMERGN, emr, 8)
1267     TEST_FIELD_ALIGN (EMRFRAMERGN, emr, 4)
1268     TEST_FIELD_OFFSET(EMRFRAMERGN, emr, 0)
1269     TEST_FIELD_SIZE  (EMRFRAMERGN, rclBounds, 16)
1270     TEST_FIELD_ALIGN (EMRFRAMERGN, rclBounds, 4)
1271     TEST_FIELD_OFFSET(EMRFRAMERGN, rclBounds, 8)
1272     TEST_FIELD_SIZE  (EMRFRAMERGN, cbRgnData, 4)
1273     TEST_FIELD_ALIGN (EMRFRAMERGN, cbRgnData, 4)
1274     TEST_FIELD_OFFSET(EMRFRAMERGN, cbRgnData, 24)
1275     TEST_FIELD_SIZE  (EMRFRAMERGN, ihBrush, 4)
1276     TEST_FIELD_ALIGN (EMRFRAMERGN, ihBrush, 4)
1277     TEST_FIELD_OFFSET(EMRFRAMERGN, ihBrush, 28)
1278     TEST_FIELD_SIZE  (EMRFRAMERGN, szlStroke, 8)
1279     TEST_FIELD_ALIGN (EMRFRAMERGN, szlStroke, 4)
1280     TEST_FIELD_OFFSET(EMRFRAMERGN, szlStroke, 32)
1281     TEST_FIELD_SIZE  (EMRFRAMERGN, RgnData, 1)
1282     TEST_FIELD_ALIGN (EMRFRAMERGN, RgnData, 1)
1283     TEST_FIELD_OFFSET(EMRFRAMERGN, RgnData, 40)
1284 }
1285
1286 static void test_pack_EMRGDICOMMENT(void)
1287 {
1288     /* EMRGDICOMMENT */
1289     TEST_TYPE_SIZE   (EMRGDICOMMENT, 16)
1290     TEST_TYPE_ALIGN  (EMRGDICOMMENT, 4)
1291     TEST_FIELD_SIZE  (EMRGDICOMMENT, emr, 8)
1292     TEST_FIELD_ALIGN (EMRGDICOMMENT, emr, 4)
1293     TEST_FIELD_OFFSET(EMRGDICOMMENT, emr, 0)
1294     TEST_FIELD_SIZE  (EMRGDICOMMENT, cbData, 4)
1295     TEST_FIELD_ALIGN (EMRGDICOMMENT, cbData, 4)
1296     TEST_FIELD_OFFSET(EMRGDICOMMENT, cbData, 8)
1297     TEST_FIELD_SIZE  (EMRGDICOMMENT, Data, 1)
1298     TEST_FIELD_ALIGN (EMRGDICOMMENT, Data, 1)
1299     TEST_FIELD_OFFSET(EMRGDICOMMENT, Data, 12)
1300 }
1301
1302 static void test_pack_EMRGLSBOUNDEDRECORD(void)
1303 {
1304     /* EMRGLSBOUNDEDRECORD */
1305     TEST_TYPE_SIZE   (EMRGLSBOUNDEDRECORD, 32)
1306     TEST_TYPE_ALIGN  (EMRGLSBOUNDEDRECORD, 4)
1307     TEST_FIELD_SIZE  (EMRGLSBOUNDEDRECORD, emr, 8)
1308     TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, emr, 4)
1309     TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, emr, 0)
1310     TEST_FIELD_SIZE  (EMRGLSBOUNDEDRECORD, rclBounds, 16)
1311     TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, rclBounds, 4)
1312     TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, rclBounds, 8)
1313     TEST_FIELD_SIZE  (EMRGLSBOUNDEDRECORD, cbData, 4)
1314     TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, cbData, 4)
1315     TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, cbData, 24)
1316     TEST_FIELD_SIZE  (EMRGLSBOUNDEDRECORD, Data, 1)
1317     TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, Data, 1)
1318     TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, Data, 28)
1319 }
1320
1321 static void test_pack_EMRGLSRECORD(void)
1322 {
1323     /* EMRGLSRECORD */
1324     TEST_TYPE_SIZE   (EMRGLSRECORD, 16)
1325     TEST_TYPE_ALIGN  (EMRGLSRECORD, 4)
1326     TEST_FIELD_SIZE  (EMRGLSRECORD, emr, 8)
1327     TEST_FIELD_ALIGN (EMRGLSRECORD, emr, 4)
1328     TEST_FIELD_OFFSET(EMRGLSRECORD, emr, 0)
1329     TEST_FIELD_SIZE  (EMRGLSRECORD, cbData, 4)
1330     TEST_FIELD_ALIGN (EMRGLSRECORD, cbData, 4)
1331     TEST_FIELD_OFFSET(EMRGLSRECORD, cbData, 8)
1332     TEST_FIELD_SIZE  (EMRGLSRECORD, Data, 1)
1333     TEST_FIELD_ALIGN (EMRGLSRECORD, Data, 1)
1334     TEST_FIELD_OFFSET(EMRGLSRECORD, Data, 12)
1335 }
1336
1337 static void test_pack_EMRINTERSECTCLIPRECT(void)
1338 {
1339     /* EMRINTERSECTCLIPRECT */
1340     TEST_TYPE_SIZE   (EMRINTERSECTCLIPRECT, 24)
1341     TEST_TYPE_ALIGN  (EMRINTERSECTCLIPRECT, 4)
1342     TEST_FIELD_SIZE  (EMRINTERSECTCLIPRECT, emr, 8)
1343     TEST_FIELD_ALIGN (EMRINTERSECTCLIPRECT, emr, 4)
1344     TEST_FIELD_OFFSET(EMRINTERSECTCLIPRECT, emr, 0)
1345     TEST_FIELD_SIZE  (EMRINTERSECTCLIPRECT, rclClip, 16)
1346     TEST_FIELD_ALIGN (EMRINTERSECTCLIPRECT, rclClip, 4)
1347     TEST_FIELD_OFFSET(EMRINTERSECTCLIPRECT, rclClip, 8)
1348 }
1349
1350 static void test_pack_EMRINVERTRGN(void)
1351 {
1352     /* EMRINVERTRGN */
1353     TEST_TYPE_SIZE   (EMRINVERTRGN, 32)
1354     TEST_TYPE_ALIGN  (EMRINVERTRGN, 4)
1355     TEST_FIELD_SIZE  (EMRINVERTRGN, emr, 8)
1356     TEST_FIELD_ALIGN (EMRINVERTRGN, emr, 4)
1357     TEST_FIELD_OFFSET(EMRINVERTRGN, emr, 0)
1358     TEST_FIELD_SIZE  (EMRINVERTRGN, rclBounds, 16)
1359     TEST_FIELD_ALIGN (EMRINVERTRGN, rclBounds, 4)
1360     TEST_FIELD_OFFSET(EMRINVERTRGN, rclBounds, 8)
1361     TEST_FIELD_SIZE  (EMRINVERTRGN, cbRgnData, 4)
1362     TEST_FIELD_ALIGN (EMRINVERTRGN, cbRgnData, 4)
1363     TEST_FIELD_OFFSET(EMRINVERTRGN, cbRgnData, 24)
1364     TEST_FIELD_SIZE  (EMRINVERTRGN, RgnData, 1)
1365     TEST_FIELD_ALIGN (EMRINVERTRGN, RgnData, 1)
1366     TEST_FIELD_OFFSET(EMRINVERTRGN, RgnData, 28)
1367 }
1368
1369 static void test_pack_EMRLINETO(void)
1370 {
1371     /* EMRLINETO */
1372     TEST_TYPE_SIZE   (EMRLINETO, 16)
1373     TEST_TYPE_ALIGN  (EMRLINETO, 4)
1374     TEST_FIELD_SIZE  (EMRLINETO, emr, 8)
1375     TEST_FIELD_ALIGN (EMRLINETO, emr, 4)
1376     TEST_FIELD_OFFSET(EMRLINETO, emr, 0)
1377     TEST_FIELD_SIZE  (EMRLINETO, ptl, 8)
1378     TEST_FIELD_ALIGN (EMRLINETO, ptl, 4)
1379     TEST_FIELD_OFFSET(EMRLINETO, ptl, 8)
1380 }
1381
1382 static void test_pack_EMRMASKBLT(void)
1383 {
1384     /* EMRMASKBLT */
1385     TEST_TYPE_SIZE   (EMRMASKBLT, 128)
1386     TEST_TYPE_ALIGN  (EMRMASKBLT, 4)
1387     TEST_FIELD_SIZE  (EMRMASKBLT, emr, 8)
1388     TEST_FIELD_ALIGN (EMRMASKBLT, emr, 4)
1389     TEST_FIELD_OFFSET(EMRMASKBLT, emr, 0)
1390     TEST_FIELD_SIZE  (EMRMASKBLT, rclBounds, 16)
1391     TEST_FIELD_ALIGN (EMRMASKBLT, rclBounds, 4)
1392     TEST_FIELD_OFFSET(EMRMASKBLT, rclBounds, 8)
1393     TEST_FIELD_SIZE  (EMRMASKBLT, xDest, 4)
1394     TEST_FIELD_ALIGN (EMRMASKBLT, xDest, 4)
1395     TEST_FIELD_OFFSET(EMRMASKBLT, xDest, 24)
1396     TEST_FIELD_SIZE  (EMRMASKBLT, yDest, 4)
1397     TEST_FIELD_ALIGN (EMRMASKBLT, yDest, 4)
1398     TEST_FIELD_OFFSET(EMRMASKBLT, yDest, 28)
1399     TEST_FIELD_SIZE  (EMRMASKBLT, cxDest, 4)
1400     TEST_FIELD_ALIGN (EMRMASKBLT, cxDest, 4)
1401     TEST_FIELD_OFFSET(EMRMASKBLT, cxDest, 32)
1402     TEST_FIELD_SIZE  (EMRMASKBLT, cyDest, 4)
1403     TEST_FIELD_ALIGN (EMRMASKBLT, cyDest, 4)
1404     TEST_FIELD_OFFSET(EMRMASKBLT, cyDest, 36)
1405     TEST_FIELD_SIZE  (EMRMASKBLT, dwRop, 4)
1406     TEST_FIELD_ALIGN (EMRMASKBLT, dwRop, 4)
1407     TEST_FIELD_OFFSET(EMRMASKBLT, dwRop, 40)
1408     TEST_FIELD_SIZE  (EMRMASKBLT, xSrc, 4)
1409     TEST_FIELD_ALIGN (EMRMASKBLT, xSrc, 4)
1410     TEST_FIELD_OFFSET(EMRMASKBLT, xSrc, 44)
1411     TEST_FIELD_SIZE  (EMRMASKBLT, ySrc, 4)
1412     TEST_FIELD_ALIGN (EMRMASKBLT, ySrc, 4)
1413     TEST_FIELD_OFFSET(EMRMASKBLT, ySrc, 48)
1414     TEST_FIELD_SIZE  (EMRMASKBLT, xformSrc, 24)
1415     TEST_FIELD_ALIGN (EMRMASKBLT, xformSrc, 4)
1416     TEST_FIELD_OFFSET(EMRMASKBLT, xformSrc, 52)
1417     TEST_FIELD_SIZE  (EMRMASKBLT, crBkColorSrc, 4)
1418     TEST_FIELD_ALIGN (EMRMASKBLT, crBkColorSrc, 4)
1419     TEST_FIELD_OFFSET(EMRMASKBLT, crBkColorSrc, 76)
1420     TEST_FIELD_SIZE  (EMRMASKBLT, iUsageSrc, 4)
1421     TEST_FIELD_ALIGN (EMRMASKBLT, iUsageSrc, 4)
1422     TEST_FIELD_OFFSET(EMRMASKBLT, iUsageSrc, 80)
1423     TEST_FIELD_SIZE  (EMRMASKBLT, offBmiSrc, 4)
1424     TEST_FIELD_ALIGN (EMRMASKBLT, offBmiSrc, 4)
1425     TEST_FIELD_OFFSET(EMRMASKBLT, offBmiSrc, 84)
1426     TEST_FIELD_SIZE  (EMRMASKBLT, cbBmiSrc, 4)
1427     TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiSrc, 4)
1428     TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiSrc, 88)
1429     TEST_FIELD_SIZE  (EMRMASKBLT, offBitsSrc, 4)
1430     TEST_FIELD_ALIGN (EMRMASKBLT, offBitsSrc, 4)
1431     TEST_FIELD_OFFSET(EMRMASKBLT, offBitsSrc, 92)
1432     TEST_FIELD_SIZE  (EMRMASKBLT, cbBitsSrc, 4)
1433     TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsSrc, 4)
1434     TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsSrc, 96)
1435     TEST_FIELD_SIZE  (EMRMASKBLT, xMask, 4)
1436     TEST_FIELD_ALIGN (EMRMASKBLT, xMask, 4)
1437     TEST_FIELD_OFFSET(EMRMASKBLT, xMask, 100)
1438     TEST_FIELD_SIZE  (EMRMASKBLT, yMask, 4)
1439     TEST_FIELD_ALIGN (EMRMASKBLT, yMask, 4)
1440     TEST_FIELD_OFFSET(EMRMASKBLT, yMask, 104)
1441     TEST_FIELD_SIZE  (EMRMASKBLT, iUsageMask, 4)
1442     TEST_FIELD_ALIGN (EMRMASKBLT, iUsageMask, 4)
1443     TEST_FIELD_OFFSET(EMRMASKBLT, iUsageMask, 108)
1444     TEST_FIELD_SIZE  (EMRMASKBLT, offBmiMask, 4)
1445     TEST_FIELD_ALIGN (EMRMASKBLT, offBmiMask, 4)
1446     TEST_FIELD_OFFSET(EMRMASKBLT, offBmiMask, 112)
1447     TEST_FIELD_SIZE  (EMRMASKBLT, cbBmiMask, 4)
1448     TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiMask, 4)
1449     TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiMask, 116)
1450     TEST_FIELD_SIZE  (EMRMASKBLT, offBitsMask, 4)
1451     TEST_FIELD_ALIGN (EMRMASKBLT, offBitsMask, 4)
1452     TEST_FIELD_OFFSET(EMRMASKBLT, offBitsMask, 120)
1453     TEST_FIELD_SIZE  (EMRMASKBLT, cbBitsMask, 4)
1454     TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsMask, 4)
1455     TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsMask, 124)
1456 }
1457
1458 static void test_pack_EMRMODIFYWORLDTRANSFORM(void)
1459 {
1460     /* EMRMODIFYWORLDTRANSFORM */
1461     TEST_TYPE_SIZE   (EMRMODIFYWORLDTRANSFORM, 36)
1462     TEST_TYPE_ALIGN  (EMRMODIFYWORLDTRANSFORM, 4)
1463     TEST_FIELD_SIZE  (EMRMODIFYWORLDTRANSFORM, emr, 8)
1464     TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, emr, 4)
1465     TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, emr, 0)
1466     TEST_FIELD_SIZE  (EMRMODIFYWORLDTRANSFORM, xform, 24)
1467     TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, xform, 4)
1468     TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, xform, 8)
1469     TEST_FIELD_SIZE  (EMRMODIFYWORLDTRANSFORM, iMode, 4)
1470     TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, iMode, 4)
1471     TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, iMode, 32)
1472 }
1473
1474 static void test_pack_EMRMOVETOEX(void)
1475 {
1476     /* EMRMOVETOEX */
1477     TEST_TYPE_SIZE   (EMRMOVETOEX, 16)
1478     TEST_TYPE_ALIGN  (EMRMOVETOEX, 4)
1479     TEST_FIELD_SIZE  (EMRMOVETOEX, emr, 8)
1480     TEST_FIELD_ALIGN (EMRMOVETOEX, emr, 4)
1481     TEST_FIELD_OFFSET(EMRMOVETOEX, emr, 0)
1482     TEST_FIELD_SIZE  (EMRMOVETOEX, ptl, 8)
1483     TEST_FIELD_ALIGN (EMRMOVETOEX, ptl, 4)
1484     TEST_FIELD_OFFSET(EMRMOVETOEX, ptl, 8)
1485 }
1486
1487 static void test_pack_EMROFFSETCLIPRGN(void)
1488 {
1489     /* EMROFFSETCLIPRGN */
1490     TEST_TYPE_SIZE   (EMROFFSETCLIPRGN, 16)
1491     TEST_TYPE_ALIGN  (EMROFFSETCLIPRGN, 4)
1492     TEST_FIELD_SIZE  (EMROFFSETCLIPRGN, emr, 8)
1493     TEST_FIELD_ALIGN (EMROFFSETCLIPRGN, emr, 4)
1494     TEST_FIELD_OFFSET(EMROFFSETCLIPRGN, emr, 0)
1495     TEST_FIELD_SIZE  (EMROFFSETCLIPRGN, ptlOffset, 8)
1496     TEST_FIELD_ALIGN (EMROFFSETCLIPRGN, ptlOffset, 4)
1497     TEST_FIELD_OFFSET(EMROFFSETCLIPRGN, ptlOffset, 8)
1498 }
1499
1500 static void test_pack_EMRPAINTRGN(void)
1501 {
1502     /* EMRPAINTRGN */
1503     TEST_TYPE_SIZE   (EMRPAINTRGN, 32)
1504     TEST_TYPE_ALIGN  (EMRPAINTRGN, 4)
1505     TEST_FIELD_SIZE  (EMRPAINTRGN, emr, 8)
1506     TEST_FIELD_ALIGN (EMRPAINTRGN, emr, 4)
1507     TEST_FIELD_OFFSET(EMRPAINTRGN, emr, 0)
1508     TEST_FIELD_SIZE  (EMRPAINTRGN, rclBounds, 16)
1509     TEST_FIELD_ALIGN (EMRPAINTRGN, rclBounds, 4)
1510     TEST_FIELD_OFFSET(EMRPAINTRGN, rclBounds, 8)
1511     TEST_FIELD_SIZE  (EMRPAINTRGN, cbRgnData, 4)
1512     TEST_FIELD_ALIGN (EMRPAINTRGN, cbRgnData, 4)
1513     TEST_FIELD_OFFSET(EMRPAINTRGN, cbRgnData, 24)
1514     TEST_FIELD_SIZE  (EMRPAINTRGN, RgnData, 1)
1515     TEST_FIELD_ALIGN (EMRPAINTRGN, RgnData, 1)
1516     TEST_FIELD_OFFSET(EMRPAINTRGN, RgnData, 28)
1517 }
1518
1519 static void test_pack_EMRPIE(void)
1520 {
1521     /* EMRPIE */
1522     TEST_TYPE_SIZE   (EMRPIE, 40)
1523     TEST_TYPE_ALIGN  (EMRPIE, 4)
1524     TEST_FIELD_SIZE  (EMRPIE, emr, 8)
1525     TEST_FIELD_ALIGN (EMRPIE, emr, 4)
1526     TEST_FIELD_OFFSET(EMRPIE, emr, 0)
1527     TEST_FIELD_SIZE  (EMRPIE, rclBox, 16)
1528     TEST_FIELD_ALIGN (EMRPIE, rclBox, 4)
1529     TEST_FIELD_OFFSET(EMRPIE, rclBox, 8)
1530     TEST_FIELD_SIZE  (EMRPIE, ptlStart, 8)
1531     TEST_FIELD_ALIGN (EMRPIE, ptlStart, 4)
1532     TEST_FIELD_OFFSET(EMRPIE, ptlStart, 24)
1533     TEST_FIELD_SIZE  (EMRPIE, ptlEnd, 8)
1534     TEST_FIELD_ALIGN (EMRPIE, ptlEnd, 4)
1535     TEST_FIELD_OFFSET(EMRPIE, ptlEnd, 32)
1536 }
1537
1538 static void test_pack_EMRPIXELFORMAT(void)
1539 {
1540     /* EMRPIXELFORMAT */
1541     TEST_TYPE_SIZE   (EMRPIXELFORMAT, 48)
1542     TEST_TYPE_ALIGN  (EMRPIXELFORMAT, 4)
1543     TEST_FIELD_SIZE  (EMRPIXELFORMAT, emr, 8)
1544     TEST_FIELD_ALIGN (EMRPIXELFORMAT, emr, 4)
1545     TEST_FIELD_OFFSET(EMRPIXELFORMAT, emr, 0)
1546     TEST_FIELD_SIZE  (EMRPIXELFORMAT, pfd, 40)
1547     TEST_FIELD_ALIGN (EMRPIXELFORMAT, pfd, 4)
1548     TEST_FIELD_OFFSET(EMRPIXELFORMAT, pfd, 8)
1549 }
1550
1551 static void test_pack_EMRPLGBLT(void)
1552 {
1553     /* EMRPLGBLT */
1554     TEST_TYPE_SIZE   (EMRPLGBLT, 140)
1555     TEST_TYPE_ALIGN  (EMRPLGBLT, 4)
1556     TEST_FIELD_SIZE  (EMRPLGBLT, emr, 8)
1557     TEST_FIELD_ALIGN (EMRPLGBLT, emr, 4)
1558     TEST_FIELD_OFFSET(EMRPLGBLT, emr, 0)
1559     TEST_FIELD_SIZE  (EMRPLGBLT, rclBounds, 16)
1560     TEST_FIELD_ALIGN (EMRPLGBLT, rclBounds, 4)
1561     TEST_FIELD_OFFSET(EMRPLGBLT, rclBounds, 8)
1562     TEST_FIELD_SIZE  (EMRPLGBLT, aptlDest, 24)
1563     TEST_FIELD_ALIGN (EMRPLGBLT, aptlDest, 4)
1564     TEST_FIELD_OFFSET(EMRPLGBLT, aptlDest, 24)
1565     TEST_FIELD_SIZE  (EMRPLGBLT, xSrc, 4)
1566     TEST_FIELD_ALIGN (EMRPLGBLT, xSrc, 4)
1567     TEST_FIELD_OFFSET(EMRPLGBLT, xSrc, 48)
1568     TEST_FIELD_SIZE  (EMRPLGBLT, ySrc, 4)
1569     TEST_FIELD_ALIGN (EMRPLGBLT, ySrc, 4)
1570     TEST_FIELD_OFFSET(EMRPLGBLT, ySrc, 52)
1571     TEST_FIELD_SIZE  (EMRPLGBLT, cxSrc, 4)
1572     TEST_FIELD_ALIGN (EMRPLGBLT, cxSrc, 4)
1573     TEST_FIELD_OFFSET(EMRPLGBLT, cxSrc, 56)
1574     TEST_FIELD_SIZE  (EMRPLGBLT, cySrc, 4)
1575     TEST_FIELD_ALIGN (EMRPLGBLT, cySrc, 4)
1576     TEST_FIELD_OFFSET(EMRPLGBLT, cySrc, 60)
1577     TEST_FIELD_SIZE  (EMRPLGBLT, xformSrc, 24)
1578     TEST_FIELD_ALIGN (EMRPLGBLT, xformSrc, 4)
1579     TEST_FIELD_OFFSET(EMRPLGBLT, xformSrc, 64)
1580     TEST_FIELD_SIZE  (EMRPLGBLT, crBkColorSrc, 4)
1581     TEST_FIELD_ALIGN (EMRPLGBLT, crBkColorSrc, 4)
1582     TEST_FIELD_OFFSET(EMRPLGBLT, crBkColorSrc, 88)
1583     TEST_FIELD_SIZE  (EMRPLGBLT, iUsageSrc, 4)
1584     TEST_FIELD_ALIGN (EMRPLGBLT, iUsageSrc, 4)
1585     TEST_FIELD_OFFSET(EMRPLGBLT, iUsageSrc, 92)
1586     TEST_FIELD_SIZE  (EMRPLGBLT, offBmiSrc, 4)
1587     TEST_FIELD_ALIGN (EMRPLGBLT, offBmiSrc, 4)
1588     TEST_FIELD_OFFSET(EMRPLGBLT, offBmiSrc, 96)
1589     TEST_FIELD_SIZE  (EMRPLGBLT, cbBmiSrc, 4)
1590     TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiSrc, 4)
1591     TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiSrc, 100)
1592     TEST_FIELD_SIZE  (EMRPLGBLT, offBitsSrc, 4)
1593     TEST_FIELD_ALIGN (EMRPLGBLT, offBitsSrc, 4)
1594     TEST_FIELD_OFFSET(EMRPLGBLT, offBitsSrc, 104)
1595     TEST_FIELD_SIZE  (EMRPLGBLT, cbBitsSrc, 4)
1596     TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsSrc, 4)
1597     TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsSrc, 108)
1598     TEST_FIELD_SIZE  (EMRPLGBLT, xMask, 4)
1599     TEST_FIELD_ALIGN (EMRPLGBLT, xMask, 4)
1600     TEST_FIELD_OFFSET(EMRPLGBLT, xMask, 112)
1601     TEST_FIELD_SIZE  (EMRPLGBLT, yMask, 4)
1602     TEST_FIELD_ALIGN (EMRPLGBLT, yMask, 4)
1603     TEST_FIELD_OFFSET(EMRPLGBLT, yMask, 116)
1604     TEST_FIELD_SIZE  (EMRPLGBLT, iUsageMask, 4)
1605     TEST_FIELD_ALIGN (EMRPLGBLT, iUsageMask, 4)
1606     TEST_FIELD_OFFSET(EMRPLGBLT, iUsageMask, 120)
1607     TEST_FIELD_SIZE  (EMRPLGBLT, offBmiMask, 4)
1608     TEST_FIELD_ALIGN (EMRPLGBLT, offBmiMask, 4)
1609     TEST_FIELD_OFFSET(EMRPLGBLT, offBmiMask, 124)
1610     TEST_FIELD_SIZE  (EMRPLGBLT, cbBmiMask, 4)
1611     TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiMask, 4)
1612     TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiMask, 128)
1613     TEST_FIELD_SIZE  (EMRPLGBLT, offBitsMask, 4)
1614     TEST_FIELD_ALIGN (EMRPLGBLT, offBitsMask, 4)
1615     TEST_FIELD_OFFSET(EMRPLGBLT, offBitsMask, 132)
1616     TEST_FIELD_SIZE  (EMRPLGBLT, cbBitsMask, 4)
1617     TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsMask, 4)
1618     TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsMask, 136)
1619 }
1620
1621 static void test_pack_EMRPOLYBEZIER(void)
1622 {
1623     /* EMRPOLYBEZIER */
1624     TEST_TYPE_SIZE   (EMRPOLYBEZIER, 36)
1625     TEST_TYPE_ALIGN  (EMRPOLYBEZIER, 4)
1626     TEST_FIELD_SIZE  (EMRPOLYBEZIER, emr, 8)
1627     TEST_FIELD_ALIGN (EMRPOLYBEZIER, emr, 4)
1628     TEST_FIELD_OFFSET(EMRPOLYBEZIER, emr, 0)
1629     TEST_FIELD_SIZE  (EMRPOLYBEZIER, rclBounds, 16)
1630     TEST_FIELD_ALIGN (EMRPOLYBEZIER, rclBounds, 4)
1631     TEST_FIELD_OFFSET(EMRPOLYBEZIER, rclBounds, 8)
1632     TEST_FIELD_SIZE  (EMRPOLYBEZIER, cptl, 4)
1633     TEST_FIELD_ALIGN (EMRPOLYBEZIER, cptl, 4)
1634     TEST_FIELD_OFFSET(EMRPOLYBEZIER, cptl, 24)
1635     TEST_FIELD_SIZE  (EMRPOLYBEZIER, aptl, 8)
1636     TEST_FIELD_ALIGN (EMRPOLYBEZIER, aptl, 4)
1637     TEST_FIELD_OFFSET(EMRPOLYBEZIER, aptl, 28)
1638 }
1639
1640 static void test_pack_EMRPOLYBEZIER16(void)
1641 {
1642     /* EMRPOLYBEZIER16 */
1643     TEST_TYPE_SIZE   (EMRPOLYBEZIER16, 32)
1644     TEST_TYPE_ALIGN  (EMRPOLYBEZIER16, 4)
1645     TEST_FIELD_SIZE  (EMRPOLYBEZIER16, emr, 8)
1646     TEST_FIELD_ALIGN (EMRPOLYBEZIER16, emr, 4)
1647     TEST_FIELD_OFFSET(EMRPOLYBEZIER16, emr, 0)
1648     TEST_FIELD_SIZE  (EMRPOLYBEZIER16, rclBounds, 16)
1649     TEST_FIELD_ALIGN (EMRPOLYBEZIER16, rclBounds, 4)
1650     TEST_FIELD_OFFSET(EMRPOLYBEZIER16, rclBounds, 8)
1651     TEST_FIELD_SIZE  (EMRPOLYBEZIER16, cpts, 4)
1652     TEST_FIELD_ALIGN (EMRPOLYBEZIER16, cpts, 4)
1653     TEST_FIELD_OFFSET(EMRPOLYBEZIER16, cpts, 24)
1654     TEST_FIELD_SIZE  (EMRPOLYBEZIER16, apts, 4)
1655     TEST_FIELD_ALIGN (EMRPOLYBEZIER16, apts, 2)
1656     TEST_FIELD_OFFSET(EMRPOLYBEZIER16, apts, 28)
1657 }
1658
1659 static void test_pack_EMRPOLYBEZIERTO(void)
1660 {
1661     /* EMRPOLYBEZIERTO */
1662     TEST_TYPE_SIZE   (EMRPOLYBEZIERTO, 36)
1663     TEST_TYPE_ALIGN  (EMRPOLYBEZIERTO, 4)
1664     TEST_FIELD_SIZE  (EMRPOLYBEZIERTO, emr, 8)
1665     TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, emr, 4)
1666     TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, emr, 0)
1667     TEST_FIELD_SIZE  (EMRPOLYBEZIERTO, rclBounds, 16)
1668     TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, rclBounds, 4)
1669     TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, rclBounds, 8)
1670     TEST_FIELD_SIZE  (EMRPOLYBEZIERTO, cptl, 4)
1671     TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, cptl, 4)
1672     TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, cptl, 24)
1673     TEST_FIELD_SIZE  (EMRPOLYBEZIERTO, aptl, 8)
1674     TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, aptl, 4)
1675     TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, aptl, 28)
1676 }
1677
1678 static void test_pack_EMRPOLYBEZIERTO16(void)
1679 {
1680     /* EMRPOLYBEZIERTO16 */
1681     TEST_TYPE_SIZE   (EMRPOLYBEZIERTO16, 32)
1682     TEST_TYPE_ALIGN  (EMRPOLYBEZIERTO16, 4)
1683     TEST_FIELD_SIZE  (EMRPOLYBEZIERTO16, emr, 8)
1684     TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, emr, 4)
1685     TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, emr, 0)
1686     TEST_FIELD_SIZE  (EMRPOLYBEZIERTO16, rclBounds, 16)
1687     TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, rclBounds, 4)
1688     TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, rclBounds, 8)
1689     TEST_FIELD_SIZE  (EMRPOLYBEZIERTO16, cpts, 4)
1690     TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, cpts, 4)
1691     TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, cpts, 24)
1692     TEST_FIELD_SIZE  (EMRPOLYBEZIERTO16, apts, 4)
1693     TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, apts, 2)
1694     TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, apts, 28)
1695 }
1696
1697 static void test_pack_EMRPOLYDRAW(void)
1698 {
1699     /* EMRPOLYDRAW */
1700     TEST_TYPE_SIZE   (EMRPOLYDRAW, 40)
1701     TEST_TYPE_ALIGN  (EMRPOLYDRAW, 4)
1702     TEST_FIELD_SIZE  (EMRPOLYDRAW, emr, 8)
1703     TEST_FIELD_ALIGN (EMRPOLYDRAW, emr, 4)
1704     TEST_FIELD_OFFSET(EMRPOLYDRAW, emr, 0)
1705     TEST_FIELD_SIZE  (EMRPOLYDRAW, rclBounds, 16)
1706     TEST_FIELD_ALIGN (EMRPOLYDRAW, rclBounds, 4)
1707     TEST_FIELD_OFFSET(EMRPOLYDRAW, rclBounds, 8)
1708     TEST_FIELD_SIZE  (EMRPOLYDRAW, cptl, 4)
1709     TEST_FIELD_ALIGN (EMRPOLYDRAW, cptl, 4)
1710     TEST_FIELD_OFFSET(EMRPOLYDRAW, cptl, 24)
1711     TEST_FIELD_SIZE  (EMRPOLYDRAW, aptl, 8)
1712     TEST_FIELD_ALIGN (EMRPOLYDRAW, aptl, 4)
1713     TEST_FIELD_OFFSET(EMRPOLYDRAW, aptl, 28)
1714     TEST_FIELD_SIZE  (EMRPOLYDRAW, abTypes, 1)
1715     TEST_FIELD_ALIGN (EMRPOLYDRAW, abTypes, 1)
1716     TEST_FIELD_OFFSET(EMRPOLYDRAW, abTypes, 36)
1717 }
1718
1719 static void test_pack_EMRPOLYDRAW16(void)
1720 {
1721     /* EMRPOLYDRAW16 */
1722     TEST_TYPE_SIZE   (EMRPOLYDRAW16, 36)
1723     TEST_TYPE_ALIGN  (EMRPOLYDRAW16, 4)
1724     TEST_FIELD_SIZE  (EMRPOLYDRAW16, emr, 8)
1725     TEST_FIELD_ALIGN (EMRPOLYDRAW16, emr, 4)
1726     TEST_FIELD_OFFSET(EMRPOLYDRAW16, emr, 0)
1727     TEST_FIELD_SIZE  (EMRPOLYDRAW16, rclBounds, 16)
1728     TEST_FIELD_ALIGN (EMRPOLYDRAW16, rclBounds, 4)
1729     TEST_FIELD_OFFSET(EMRPOLYDRAW16, rclBounds, 8)
1730     TEST_FIELD_SIZE  (EMRPOLYDRAW16, cpts, 4)
1731     TEST_FIELD_ALIGN (EMRPOLYDRAW16, cpts, 4)
1732     TEST_FIELD_OFFSET(EMRPOLYDRAW16, cpts, 24)
1733     TEST_FIELD_SIZE  (EMRPOLYDRAW16, apts, 4)
1734     TEST_FIELD_ALIGN (EMRPOLYDRAW16, apts, 2)
1735     TEST_FIELD_OFFSET(EMRPOLYDRAW16, apts, 28)
1736     TEST_FIELD_SIZE  (EMRPOLYDRAW16, abTypes, 1)
1737     TEST_FIELD_ALIGN (EMRPOLYDRAW16, abTypes, 1)
1738     TEST_FIELD_OFFSET(EMRPOLYDRAW16, abTypes, 32)
1739 }
1740
1741 static void test_pack_EMRPOLYGON(void)
1742 {
1743     /* EMRPOLYGON */
1744     TEST_TYPE_SIZE   (EMRPOLYGON, 36)
1745     TEST_TYPE_ALIGN  (EMRPOLYGON, 4)
1746     TEST_FIELD_SIZE  (EMRPOLYGON, emr, 8)
1747     TEST_FIELD_ALIGN (EMRPOLYGON, emr, 4)
1748     TEST_FIELD_OFFSET(EMRPOLYGON, emr, 0)
1749     TEST_FIELD_SIZE  (EMRPOLYGON, rclBounds, 16)
1750     TEST_FIELD_ALIGN (EMRPOLYGON, rclBounds, 4)
1751     TEST_FIELD_OFFSET(EMRPOLYGON, rclBounds, 8)
1752     TEST_FIELD_SIZE  (EMRPOLYGON, cptl, 4)
1753     TEST_FIELD_ALIGN (EMRPOLYGON, cptl, 4)
1754     TEST_FIELD_OFFSET(EMRPOLYGON, cptl, 24)
1755     TEST_FIELD_SIZE  (EMRPOLYGON, aptl, 8)
1756     TEST_FIELD_ALIGN (EMRPOLYGON, aptl, 4)
1757     TEST_FIELD_OFFSET(EMRPOLYGON, aptl, 28)
1758 }
1759
1760 static void test_pack_EMRPOLYGON16(void)
1761 {
1762     /* EMRPOLYGON16 */
1763     TEST_TYPE_SIZE   (EMRPOLYGON16, 32)
1764     TEST_TYPE_ALIGN  (EMRPOLYGON16, 4)
1765     TEST_FIELD_SIZE  (EMRPOLYGON16, emr, 8)
1766     TEST_FIELD_ALIGN (EMRPOLYGON16, emr, 4)
1767     TEST_FIELD_OFFSET(EMRPOLYGON16, emr, 0)
1768     TEST_FIELD_SIZE  (EMRPOLYGON16, rclBounds, 16)
1769     TEST_FIELD_ALIGN (EMRPOLYGON16, rclBounds, 4)
1770     TEST_FIELD_OFFSET(EMRPOLYGON16, rclBounds, 8)
1771     TEST_FIELD_SIZE  (EMRPOLYGON16, cpts, 4)
1772     TEST_FIELD_ALIGN (EMRPOLYGON16, cpts, 4)
1773     TEST_FIELD_OFFSET(EMRPOLYGON16, cpts, 24)
1774     TEST_FIELD_SIZE  (EMRPOLYGON16, apts, 4)
1775     TEST_FIELD_ALIGN (EMRPOLYGON16, apts, 2)
1776     TEST_FIELD_OFFSET(EMRPOLYGON16, apts, 28)
1777 }
1778
1779 static void test_pack_EMRPOLYLINE(void)
1780 {
1781     /* EMRPOLYLINE */
1782     TEST_TYPE_SIZE   (EMRPOLYLINE, 36)
1783     TEST_TYPE_ALIGN  (EMRPOLYLINE, 4)
1784     TEST_FIELD_SIZE  (EMRPOLYLINE, emr, 8)
1785     TEST_FIELD_ALIGN (EMRPOLYLINE, emr, 4)
1786     TEST_FIELD_OFFSET(EMRPOLYLINE, emr, 0)
1787     TEST_FIELD_SIZE  (EMRPOLYLINE, rclBounds, 16)
1788     TEST_FIELD_ALIGN (EMRPOLYLINE, rclBounds, 4)
1789     TEST_FIELD_OFFSET(EMRPOLYLINE, rclBounds, 8)
1790     TEST_FIELD_SIZE  (EMRPOLYLINE, cptl, 4)
1791     TEST_FIELD_ALIGN (EMRPOLYLINE, cptl, 4)
1792     TEST_FIELD_OFFSET(EMRPOLYLINE, cptl, 24)
1793     TEST_FIELD_SIZE  (EMRPOLYLINE, aptl, 8)
1794     TEST_FIELD_ALIGN (EMRPOLYLINE, aptl, 4)
1795     TEST_FIELD_OFFSET(EMRPOLYLINE, aptl, 28)
1796 }
1797
1798 static void test_pack_EMRPOLYLINE16(void)
1799 {
1800     /* EMRPOLYLINE16 */
1801     TEST_TYPE_SIZE   (EMRPOLYLINE16, 32)
1802     TEST_TYPE_ALIGN  (EMRPOLYLINE16, 4)
1803     TEST_FIELD_SIZE  (EMRPOLYLINE16, emr, 8)
1804     TEST_FIELD_ALIGN (EMRPOLYLINE16, emr, 4)
1805     TEST_FIELD_OFFSET(EMRPOLYLINE16, emr, 0)
1806     TEST_FIELD_SIZE  (EMRPOLYLINE16, rclBounds, 16)
1807     TEST_FIELD_ALIGN (EMRPOLYLINE16, rclBounds, 4)
1808     TEST_FIELD_OFFSET(EMRPOLYLINE16, rclBounds, 8)
1809     TEST_FIELD_SIZE  (EMRPOLYLINE16, cpts, 4)
1810     TEST_FIELD_ALIGN (EMRPOLYLINE16, cpts, 4)
1811     TEST_FIELD_OFFSET(EMRPOLYLINE16, cpts, 24)
1812     TEST_FIELD_SIZE  (EMRPOLYLINE16, apts, 4)
1813     TEST_FIELD_ALIGN (EMRPOLYLINE16, apts, 2)
1814     TEST_FIELD_OFFSET(EMRPOLYLINE16, apts, 28)
1815 }
1816
1817 static void test_pack_EMRPOLYLINETO(void)
1818 {
1819     /* EMRPOLYLINETO */
1820     TEST_TYPE_SIZE   (EMRPOLYLINETO, 36)
1821     TEST_TYPE_ALIGN  (EMRPOLYLINETO, 4)
1822     TEST_FIELD_SIZE  (EMRPOLYLINETO, emr, 8)
1823     TEST_FIELD_ALIGN (EMRPOLYLINETO, emr, 4)
1824     TEST_FIELD_OFFSET(EMRPOLYLINETO, emr, 0)
1825     TEST_FIELD_SIZE  (EMRPOLYLINETO, rclBounds, 16)
1826     TEST_FIELD_ALIGN (EMRPOLYLINETO, rclBounds, 4)
1827     TEST_FIELD_OFFSET(EMRPOLYLINETO, rclBounds, 8)
1828     TEST_FIELD_SIZE  (EMRPOLYLINETO, cptl, 4)
1829     TEST_FIELD_ALIGN (EMRPOLYLINETO, cptl, 4)
1830     TEST_FIELD_OFFSET(EMRPOLYLINETO, cptl, 24)
1831     TEST_FIELD_SIZE  (EMRPOLYLINETO, aptl, 8)
1832     TEST_FIELD_ALIGN (EMRPOLYLINETO, aptl, 4)
1833     TEST_FIELD_OFFSET(EMRPOLYLINETO, aptl, 28)
1834 }
1835
1836 static void test_pack_EMRPOLYLINETO16(void)
1837 {
1838     /* EMRPOLYLINETO16 */
1839     TEST_TYPE_SIZE   (EMRPOLYLINETO16, 32)
1840     TEST_TYPE_ALIGN  (EMRPOLYLINETO16, 4)
1841     TEST_FIELD_SIZE  (EMRPOLYLINETO16, emr, 8)
1842     TEST_FIELD_ALIGN (EMRPOLYLINETO16, emr, 4)
1843     TEST_FIELD_OFFSET(EMRPOLYLINETO16, emr, 0)
1844     TEST_FIELD_SIZE  (EMRPOLYLINETO16, rclBounds, 16)
1845     TEST_FIELD_ALIGN (EMRPOLYLINETO16, rclBounds, 4)
1846     TEST_FIELD_OFFSET(EMRPOLYLINETO16, rclBounds, 8)
1847     TEST_FIELD_SIZE  (EMRPOLYLINETO16, cpts, 4)
1848     TEST_FIELD_ALIGN (EMRPOLYLINETO16, cpts, 4)
1849     TEST_FIELD_OFFSET(EMRPOLYLINETO16, cpts, 24)
1850     TEST_FIELD_SIZE  (EMRPOLYLINETO16, apts, 4)
1851     TEST_FIELD_ALIGN (EMRPOLYLINETO16, apts, 2)
1852     TEST_FIELD_OFFSET(EMRPOLYLINETO16, apts, 28)
1853 }
1854
1855 static void test_pack_EMRPOLYPOLYGON(void)
1856 {
1857     /* EMRPOLYPOLYGON */
1858     TEST_TYPE_SIZE   (EMRPOLYPOLYGON, 44)
1859     TEST_TYPE_ALIGN  (EMRPOLYPOLYGON, 4)
1860     TEST_FIELD_SIZE  (EMRPOLYPOLYGON, emr, 8)
1861     TEST_FIELD_ALIGN (EMRPOLYPOLYGON, emr, 4)
1862     TEST_FIELD_OFFSET(EMRPOLYPOLYGON, emr, 0)
1863     TEST_FIELD_SIZE  (EMRPOLYPOLYGON, rclBounds, 16)
1864     TEST_FIELD_ALIGN (EMRPOLYPOLYGON, rclBounds, 4)
1865     TEST_FIELD_OFFSET(EMRPOLYPOLYGON, rclBounds, 8)
1866     TEST_FIELD_SIZE  (EMRPOLYPOLYGON, nPolys, 4)
1867     TEST_FIELD_ALIGN (EMRPOLYPOLYGON, nPolys, 4)
1868     TEST_FIELD_OFFSET(EMRPOLYPOLYGON, nPolys, 24)
1869     TEST_FIELD_SIZE  (EMRPOLYPOLYGON, cptl, 4)
1870     TEST_FIELD_ALIGN (EMRPOLYPOLYGON, cptl, 4)
1871     TEST_FIELD_OFFSET(EMRPOLYPOLYGON, cptl, 28)
1872     TEST_FIELD_SIZE  (EMRPOLYPOLYGON, aPolyCounts, 4)
1873     TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aPolyCounts, 4)
1874     TEST_FIELD_OFFSET(EMRPOLYPOLYGON, aPolyCounts, 32)
1875     TEST_FIELD_SIZE  (EMRPOLYPOLYGON, aptl, 8)
1876     TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aptl, 4)
1877     TEST_FIELD_OFFSET(EMRPOLYPOLYGON, aptl, 36)
1878 }
1879
1880 static void test_pack_EMRPOLYPOLYGON16(void)
1881 {
1882     /* EMRPOLYPOLYGON16 */
1883     TEST_TYPE_SIZE   (EMRPOLYPOLYGON16, 40)
1884     TEST_TYPE_ALIGN  (EMRPOLYPOLYGON16, 4)
1885     TEST_FIELD_SIZE  (EMRPOLYPOLYGON16, emr, 8)
1886     TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, emr, 4)
1887     TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, emr, 0)
1888     TEST_FIELD_SIZE  (EMRPOLYPOLYGON16, rclBounds, 16)
1889     TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, rclBounds, 4)
1890     TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, rclBounds, 8)
1891     TEST_FIELD_SIZE  (EMRPOLYPOLYGON16, nPolys, 4)
1892     TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, nPolys, 4)
1893     TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, nPolys, 24)
1894     TEST_FIELD_SIZE  (EMRPOLYPOLYGON16, cpts, 4)
1895     TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, cpts, 4)
1896     TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, cpts, 28)
1897     TEST_FIELD_SIZE  (EMRPOLYPOLYGON16, aPolyCounts, 4)
1898     TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, aPolyCounts, 4)
1899     TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, aPolyCounts, 32)
1900     TEST_FIELD_SIZE  (EMRPOLYPOLYGON16, apts, 4)
1901     TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, apts, 2)
1902     TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, apts, 36)
1903 }
1904
1905 static void test_pack_EMRPOLYPOLYLINE(void)
1906 {
1907     /* EMRPOLYPOLYLINE */
1908     TEST_TYPE_SIZE   (EMRPOLYPOLYLINE, 44)
1909     TEST_TYPE_ALIGN  (EMRPOLYPOLYLINE, 4)
1910     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE, emr, 8)
1911     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, emr, 4)
1912     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, emr, 0)
1913     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE, rclBounds, 16)
1914     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, rclBounds, 4)
1915     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, rclBounds, 8)
1916     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE, nPolys, 4)
1917     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, nPolys, 4)
1918     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, nPolys, 24)
1919     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE, cptl, 4)
1920     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, cptl, 4)
1921     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, cptl, 28)
1922     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE, aPolyCounts, 4)
1923     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, aPolyCounts, 4)
1924     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, aPolyCounts, 32)
1925     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE, aptl, 8)
1926     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, aptl, 4)
1927     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, aptl, 36)
1928 }
1929
1930 static void test_pack_EMRPOLYPOLYLINE16(void)
1931 {
1932     /* EMRPOLYPOLYLINE16 */
1933     TEST_TYPE_SIZE   (EMRPOLYPOLYLINE16, 40)
1934     TEST_TYPE_ALIGN  (EMRPOLYPOLYLINE16, 4)
1935     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE16, emr, 8)
1936     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, emr, 4)
1937     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, emr, 0)
1938     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE16, rclBounds, 16)
1939     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, rclBounds, 4)
1940     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, rclBounds, 8)
1941     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE16, nPolys, 4)
1942     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, nPolys, 4)
1943     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, nPolys, 24)
1944     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE16, cpts, 4)
1945     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, cpts, 4)
1946     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, cpts, 28)
1947     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE16, aPolyCounts, 4)
1948     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, aPolyCounts, 4)
1949     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, aPolyCounts, 32)
1950     TEST_FIELD_SIZE  (EMRPOLYPOLYLINE16, apts, 4)
1951     TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, apts, 2)
1952     TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, apts, 36)
1953 }
1954
1955 static void test_pack_EMRPOLYTEXTOUTA(void)
1956 {
1957     /* EMRPOLYTEXTOUTA */
1958     TEST_TYPE_SIZE   (EMRPOLYTEXTOUTA, 80)
1959     TEST_TYPE_ALIGN  (EMRPOLYTEXTOUTA, 4)
1960     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTA, emr, 8)
1961     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, emr, 4)
1962     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, emr, 0)
1963     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTA, rclBounds, 16)
1964     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, rclBounds, 4)
1965     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, rclBounds, 8)
1966     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTA, iGraphicsMode, 4)
1967     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, iGraphicsMode, 4)
1968     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, iGraphicsMode, 24)
1969     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTA, exScale, 4)
1970     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, exScale, 4)
1971     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, exScale, 28)
1972     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTA, eyScale, 4)
1973     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, eyScale, 4)
1974     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, eyScale, 32)
1975     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTA, cStrings, 4)
1976     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, cStrings, 4)
1977     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, cStrings, 36)
1978     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTA, aemrtext, 40)
1979     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, aemrtext, 4)
1980     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, aemrtext, 40)
1981 }
1982
1983 static void test_pack_EMRPOLYTEXTOUTW(void)
1984 {
1985     /* EMRPOLYTEXTOUTW */
1986     TEST_TYPE_SIZE   (EMRPOLYTEXTOUTW, 80)
1987     TEST_TYPE_ALIGN  (EMRPOLYTEXTOUTW, 4)
1988     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTW, emr, 8)
1989     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, emr, 4)
1990     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, emr, 0)
1991     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTW, rclBounds, 16)
1992     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, rclBounds, 4)
1993     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, rclBounds, 8)
1994     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTW, iGraphicsMode, 4)
1995     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, iGraphicsMode, 4)
1996     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, iGraphicsMode, 24)
1997     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTW, exScale, 4)
1998     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, exScale, 4)
1999     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, exScale, 28)
2000     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTW, eyScale, 4)
2001     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, eyScale, 4)
2002     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, eyScale, 32)
2003     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTW, cStrings, 4)
2004     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, cStrings, 4)
2005     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, cStrings, 36)
2006     TEST_FIELD_SIZE  (EMRPOLYTEXTOUTW, aemrtext, 40)
2007     TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, aemrtext, 4)
2008     TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, aemrtext, 40)
2009 }
2010
2011 static void test_pack_EMRREALIZEPALETTE(void)
2012 {
2013     /* EMRREALIZEPALETTE */
2014     TEST_TYPE_SIZE   (EMRREALIZEPALETTE, 8)
2015     TEST_TYPE_ALIGN  (EMRREALIZEPALETTE, 4)
2016     TEST_FIELD_SIZE  (EMRREALIZEPALETTE, emr, 8)
2017     TEST_FIELD_ALIGN (EMRREALIZEPALETTE, emr, 4)
2018     TEST_FIELD_OFFSET(EMRREALIZEPALETTE, emr, 0)
2019 }
2020
2021 static void test_pack_EMRRECTANGLE(void)
2022 {
2023     /* EMRRECTANGLE */
2024     TEST_TYPE_SIZE   (EMRRECTANGLE, 24)
2025     TEST_TYPE_ALIGN  (EMRRECTANGLE, 4)
2026     TEST_FIELD_SIZE  (EMRRECTANGLE, emr, 8)
2027     TEST_FIELD_ALIGN (EMRRECTANGLE, emr, 4)
2028     TEST_FIELD_OFFSET(EMRRECTANGLE, emr, 0)
2029     TEST_FIELD_SIZE  (EMRRECTANGLE, rclBox, 16)
2030     TEST_FIELD_ALIGN (EMRRECTANGLE, rclBox, 4)
2031     TEST_FIELD_OFFSET(EMRRECTANGLE, rclBox, 8)
2032 }
2033
2034 static void test_pack_EMRRESIZEPALETTE(void)
2035 {
2036     /* EMRRESIZEPALETTE */
2037     TEST_TYPE_SIZE   (EMRRESIZEPALETTE, 16)
2038     TEST_TYPE_ALIGN  (EMRRESIZEPALETTE, 4)
2039     TEST_FIELD_SIZE  (EMRRESIZEPALETTE, emr, 8)
2040     TEST_FIELD_ALIGN (EMRRESIZEPALETTE, emr, 4)
2041     TEST_FIELD_OFFSET(EMRRESIZEPALETTE, emr, 0)
2042     TEST_FIELD_SIZE  (EMRRESIZEPALETTE, ihPal, 4)
2043     TEST_FIELD_ALIGN (EMRRESIZEPALETTE, ihPal, 4)
2044     TEST_FIELD_OFFSET(EMRRESIZEPALETTE, ihPal, 8)
2045     TEST_FIELD_SIZE  (EMRRESIZEPALETTE, cEntries, 4)
2046     TEST_FIELD_ALIGN (EMRRESIZEPALETTE, cEntries, 4)
2047     TEST_FIELD_OFFSET(EMRRESIZEPALETTE, cEntries, 12)
2048 }
2049
2050 static void test_pack_EMRRESTOREDC(void)
2051 {
2052     /* EMRRESTOREDC */
2053     TEST_TYPE_SIZE   (EMRRESTOREDC, 12)
2054     TEST_TYPE_ALIGN  (EMRRESTOREDC, 4)
2055     TEST_FIELD_SIZE  (EMRRESTOREDC, emr, 8)
2056     TEST_FIELD_ALIGN (EMRRESTOREDC, emr, 4)
2057     TEST_FIELD_OFFSET(EMRRESTOREDC, emr, 0)
2058     TEST_FIELD_SIZE  (EMRRESTOREDC, iRelative, 4)
2059     TEST_FIELD_ALIGN (EMRRESTOREDC, iRelative, 4)
2060     TEST_FIELD_OFFSET(EMRRESTOREDC, iRelative, 8)
2061 }
2062
2063 static void test_pack_EMRROUNDRECT(void)
2064 {
2065     /* EMRROUNDRECT */
2066     TEST_TYPE_SIZE   (EMRROUNDRECT, 32)
2067     TEST_TYPE_ALIGN  (EMRROUNDRECT, 4)
2068     TEST_FIELD_SIZE  (EMRROUNDRECT, emr, 8)
2069     TEST_FIELD_ALIGN (EMRROUNDRECT, emr, 4)
2070     TEST_FIELD_OFFSET(EMRROUNDRECT, emr, 0)
2071     TEST_FIELD_SIZE  (EMRROUNDRECT, rclBox, 16)
2072     TEST_FIELD_ALIGN (EMRROUNDRECT, rclBox, 4)
2073     TEST_FIELD_OFFSET(EMRROUNDRECT, rclBox, 8)
2074     TEST_FIELD_SIZE  (EMRROUNDRECT, szlCorner, 8)
2075     TEST_FIELD_ALIGN (EMRROUNDRECT, szlCorner, 4)
2076     TEST_FIELD_OFFSET(EMRROUNDRECT, szlCorner, 24)
2077 }
2078
2079 static void test_pack_EMRSAVEDC(void)
2080 {
2081     /* EMRSAVEDC */
2082     TEST_TYPE_SIZE   (EMRSAVEDC, 8)
2083     TEST_TYPE_ALIGN  (EMRSAVEDC, 4)
2084     TEST_FIELD_SIZE  (EMRSAVEDC, emr, 8)
2085     TEST_FIELD_ALIGN (EMRSAVEDC, emr, 4)
2086     TEST_FIELD_OFFSET(EMRSAVEDC, emr, 0)
2087 }
2088
2089 static void test_pack_EMRSCALEVIEWPORTEXTEX(void)
2090 {
2091     /* EMRSCALEVIEWPORTEXTEX */
2092     TEST_TYPE_SIZE   (EMRSCALEVIEWPORTEXTEX, 24)
2093     TEST_TYPE_ALIGN  (EMRSCALEVIEWPORTEXTEX, 4)
2094     TEST_FIELD_SIZE  (EMRSCALEVIEWPORTEXTEX, emr, 8)
2095     TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, emr, 4)
2096     TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, emr, 0)
2097     TEST_FIELD_SIZE  (EMRSCALEVIEWPORTEXTEX, xNum, 4)
2098     TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, xNum, 4)
2099     TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, xNum, 8)
2100     TEST_FIELD_SIZE  (EMRSCALEVIEWPORTEXTEX, xDenom, 4)
2101     TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, xDenom, 4)
2102     TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, xDenom, 12)
2103     TEST_FIELD_SIZE  (EMRSCALEVIEWPORTEXTEX, yNum, 4)
2104     TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, yNum, 4)
2105     TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, yNum, 16)
2106     TEST_FIELD_SIZE  (EMRSCALEVIEWPORTEXTEX, yDenom, 4)
2107     TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, yDenom, 4)
2108     TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, yDenom, 20)
2109 }
2110
2111 static void test_pack_EMRSCALEWINDOWEXTEX(void)
2112 {
2113     /* EMRSCALEWINDOWEXTEX */
2114     TEST_TYPE_SIZE   (EMRSCALEWINDOWEXTEX, 24)
2115     TEST_TYPE_ALIGN  (EMRSCALEWINDOWEXTEX, 4)
2116     TEST_FIELD_SIZE  (EMRSCALEWINDOWEXTEX, emr, 8)
2117     TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, emr, 4)
2118     TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, emr, 0)
2119     TEST_FIELD_SIZE  (EMRSCALEWINDOWEXTEX, xNum, 4)
2120     TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, xNum, 4)
2121     TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, xNum, 8)
2122     TEST_FIELD_SIZE  (EMRSCALEWINDOWEXTEX, xDenom, 4)
2123     TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, xDenom, 4)
2124     TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, xDenom, 12)
2125     TEST_FIELD_SIZE  (EMRSCALEWINDOWEXTEX, yNum, 4)
2126     TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, yNum, 4)
2127     TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, yNum, 16)
2128     TEST_FIELD_SIZE  (EMRSCALEWINDOWEXTEX, yDenom, 4)
2129     TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, yDenom, 4)
2130     TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, yDenom, 20)
2131 }
2132
2133 static void test_pack_EMRSELECTCLIPPATH(void)
2134 {
2135     /* EMRSELECTCLIPPATH */
2136     TEST_TYPE_SIZE   (EMRSELECTCLIPPATH, 12)
2137     TEST_TYPE_ALIGN  (EMRSELECTCLIPPATH, 4)
2138     TEST_FIELD_SIZE  (EMRSELECTCLIPPATH, emr, 8)
2139     TEST_FIELD_ALIGN (EMRSELECTCLIPPATH, emr, 4)
2140     TEST_FIELD_OFFSET(EMRSELECTCLIPPATH, emr, 0)
2141     TEST_FIELD_SIZE  (EMRSELECTCLIPPATH, iMode, 4)
2142     TEST_FIELD_ALIGN (EMRSELECTCLIPPATH, iMode, 4)
2143     TEST_FIELD_OFFSET(EMRSELECTCLIPPATH, iMode, 8)
2144 }
2145
2146 static void test_pack_EMRSELECTCOLORSPACE(void)
2147 {
2148     /* EMRSELECTCOLORSPACE */
2149     TEST_TYPE_SIZE   (EMRSELECTCOLORSPACE, 12)
2150     TEST_TYPE_ALIGN  (EMRSELECTCOLORSPACE, 4)
2151     TEST_FIELD_SIZE  (EMRSELECTCOLORSPACE, emr, 8)
2152     TEST_FIELD_ALIGN (EMRSELECTCOLORSPACE, emr, 4)
2153     TEST_FIELD_OFFSET(EMRSELECTCOLORSPACE, emr, 0)
2154     TEST_FIELD_SIZE  (EMRSELECTCOLORSPACE, ihCS, 4)
2155     TEST_FIELD_ALIGN (EMRSELECTCOLORSPACE, ihCS, 4)
2156     TEST_FIELD_OFFSET(EMRSELECTCOLORSPACE, ihCS, 8)
2157 }
2158
2159 static void test_pack_EMRSELECTOBJECT(void)
2160 {
2161     /* EMRSELECTOBJECT */
2162     TEST_TYPE_SIZE   (EMRSELECTOBJECT, 12)
2163     TEST_TYPE_ALIGN  (EMRSELECTOBJECT, 4)
2164     TEST_FIELD_SIZE  (EMRSELECTOBJECT, emr, 8)
2165     TEST_FIELD_ALIGN (EMRSELECTOBJECT, emr, 4)
2166     TEST_FIELD_OFFSET(EMRSELECTOBJECT, emr, 0)
2167     TEST_FIELD_SIZE  (EMRSELECTOBJECT, ihObject, 4)
2168     TEST_FIELD_ALIGN (EMRSELECTOBJECT, ihObject, 4)
2169     TEST_FIELD_OFFSET(EMRSELECTOBJECT, ihObject, 8)
2170 }
2171
2172 static void test_pack_EMRSELECTPALETTE(void)
2173 {
2174     /* EMRSELECTPALETTE */
2175     TEST_TYPE_SIZE   (EMRSELECTPALETTE, 12)
2176     TEST_TYPE_ALIGN  (EMRSELECTPALETTE, 4)
2177     TEST_FIELD_SIZE  (EMRSELECTPALETTE, emr, 8)
2178     TEST_FIELD_ALIGN (EMRSELECTPALETTE, emr, 4)
2179     TEST_FIELD_OFFSET(EMRSELECTPALETTE, emr, 0)
2180     TEST_FIELD_SIZE  (EMRSELECTPALETTE, ihPal, 4)
2181     TEST_FIELD_ALIGN (EMRSELECTPALETTE, ihPal, 4)
2182     TEST_FIELD_OFFSET(EMRSELECTPALETTE, ihPal, 8)
2183 }
2184
2185 static void test_pack_EMRSETARCDIRECTION(void)
2186 {
2187     /* EMRSETARCDIRECTION */
2188     TEST_TYPE_SIZE   (EMRSETARCDIRECTION, 12)
2189     TEST_TYPE_ALIGN  (EMRSETARCDIRECTION, 4)
2190     TEST_FIELD_SIZE  (EMRSETARCDIRECTION, emr, 8)
2191     TEST_FIELD_ALIGN (EMRSETARCDIRECTION, emr, 4)
2192     TEST_FIELD_OFFSET(EMRSETARCDIRECTION, emr, 0)
2193     TEST_FIELD_SIZE  (EMRSETARCDIRECTION, iArcDirection, 4)
2194     TEST_FIELD_ALIGN (EMRSETARCDIRECTION, iArcDirection, 4)
2195     TEST_FIELD_OFFSET(EMRSETARCDIRECTION, iArcDirection, 8)
2196 }
2197
2198 static void test_pack_EMRSETBKCOLOR(void)
2199 {
2200     /* EMRSETBKCOLOR */
2201     TEST_TYPE_SIZE   (EMRSETBKCOLOR, 12)
2202     TEST_TYPE_ALIGN  (EMRSETBKCOLOR, 4)
2203     TEST_FIELD_SIZE  (EMRSETBKCOLOR, emr, 8)
2204     TEST_FIELD_ALIGN (EMRSETBKCOLOR, emr, 4)
2205     TEST_FIELD_OFFSET(EMRSETBKCOLOR, emr, 0)
2206     TEST_FIELD_SIZE  (EMRSETBKCOLOR, crColor, 4)
2207     TEST_FIELD_ALIGN (EMRSETBKCOLOR, crColor, 4)
2208     TEST_FIELD_OFFSET(EMRSETBKCOLOR, crColor, 8)
2209 }
2210
2211 static void test_pack_EMRSETBKMODE(void)
2212 {
2213     /* EMRSETBKMODE */
2214     TEST_TYPE_SIZE   (EMRSETBKMODE, 12)
2215     TEST_TYPE_ALIGN  (EMRSETBKMODE, 4)
2216     TEST_FIELD_SIZE  (EMRSETBKMODE, emr, 8)
2217     TEST_FIELD_ALIGN (EMRSETBKMODE, emr, 4)
2218     TEST_FIELD_OFFSET(EMRSETBKMODE, emr, 0)
2219     TEST_FIELD_SIZE  (EMRSETBKMODE, iMode, 4)
2220     TEST_FIELD_ALIGN (EMRSETBKMODE, iMode, 4)
2221     TEST_FIELD_OFFSET(EMRSETBKMODE, iMode, 8)
2222 }
2223
2224 static void test_pack_EMRSETBRUSHORGEX(void)
2225 {
2226     /* EMRSETBRUSHORGEX */
2227     TEST_TYPE_SIZE   (EMRSETBRUSHORGEX, 16)
2228     TEST_TYPE_ALIGN  (EMRSETBRUSHORGEX, 4)
2229     TEST_FIELD_SIZE  (EMRSETBRUSHORGEX, emr, 8)
2230     TEST_FIELD_ALIGN (EMRSETBRUSHORGEX, emr, 4)
2231     TEST_FIELD_OFFSET(EMRSETBRUSHORGEX, emr, 0)
2232     TEST_FIELD_SIZE  (EMRSETBRUSHORGEX, ptlOrigin, 8)
2233     TEST_FIELD_ALIGN (EMRSETBRUSHORGEX, ptlOrigin, 4)
2234     TEST_FIELD_OFFSET(EMRSETBRUSHORGEX, ptlOrigin, 8)
2235 }
2236
2237 static void test_pack_EMRSETCOLORADJUSTMENT(void)
2238 {
2239     /* EMRSETCOLORADJUSTMENT */
2240     TEST_TYPE_SIZE   (EMRSETCOLORADJUSTMENT, 32)
2241     TEST_TYPE_ALIGN  (EMRSETCOLORADJUSTMENT, 4)
2242     TEST_FIELD_SIZE  (EMRSETCOLORADJUSTMENT, emr, 8)
2243     TEST_FIELD_ALIGN (EMRSETCOLORADJUSTMENT, emr, 4)
2244     TEST_FIELD_OFFSET(EMRSETCOLORADJUSTMENT, emr, 0)
2245     TEST_FIELD_SIZE  (EMRSETCOLORADJUSTMENT, ColorAdjustment, 24)
2246     TEST_FIELD_ALIGN (EMRSETCOLORADJUSTMENT, ColorAdjustment, 2)
2247     TEST_FIELD_OFFSET(EMRSETCOLORADJUSTMENT, ColorAdjustment, 8)
2248 }
2249
2250 static void test_pack_EMRSETCOLORSPACE(void)
2251 {
2252     /* EMRSETCOLORSPACE */
2253     TEST_TYPE_SIZE   (EMRSETCOLORSPACE, 12)
2254     TEST_TYPE_ALIGN  (EMRSETCOLORSPACE, 4)
2255     TEST_FIELD_SIZE  (EMRSETCOLORSPACE, emr, 8)
2256     TEST_FIELD_ALIGN (EMRSETCOLORSPACE, emr, 4)
2257     TEST_FIELD_OFFSET(EMRSETCOLORSPACE, emr, 0)
2258     TEST_FIELD_SIZE  (EMRSETCOLORSPACE, ihCS, 4)
2259     TEST_FIELD_ALIGN (EMRSETCOLORSPACE, ihCS, 4)
2260     TEST_FIELD_OFFSET(EMRSETCOLORSPACE, ihCS, 8)
2261 }
2262
2263 static void test_pack_EMRSETDIBITSTODEVICE(void)
2264 {
2265     /* EMRSETDIBITSTODEVICE */
2266     TEST_TYPE_SIZE   (EMRSETDIBITSTODEVICE, 76)
2267     TEST_TYPE_ALIGN  (EMRSETDIBITSTODEVICE, 4)
2268     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, emr, 8)
2269     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, emr, 4)
2270     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, emr, 0)
2271     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, rclBounds, 16)
2272     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, rclBounds, 4)
2273     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, rclBounds, 8)
2274     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, xDest, 4)
2275     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, xDest, 4)
2276     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, xDest, 24)
2277     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, yDest, 4)
2278     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, yDest, 4)
2279     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, yDest, 28)
2280     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, xSrc, 4)
2281     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, xSrc, 4)
2282     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, xSrc, 32)
2283     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, ySrc, 4)
2284     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, ySrc, 4)
2285     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, ySrc, 36)
2286     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, cxSrc, 4)
2287     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cxSrc, 4)
2288     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cxSrc, 40)
2289     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, cySrc, 4)
2290     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cySrc, 4)
2291     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cySrc, 44)
2292     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, offBmiSrc, 4)
2293     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBmiSrc, 4)
2294     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBmiSrc, 48)
2295     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, cbBmiSrc, 4)
2296     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBmiSrc, 4)
2297     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cbBmiSrc, 52)
2298     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, offBitsSrc, 4)
2299     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBitsSrc, 4)
2300     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBitsSrc, 56)
2301     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, cbBitsSrc, 4)
2302     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBitsSrc, 4)
2303     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cbBitsSrc, 60)
2304     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, iUsageSrc, 4)
2305     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, iUsageSrc, 4)
2306     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, iUsageSrc, 64)
2307     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, iStartScan, 4)
2308     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, iStartScan, 4)
2309     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, iStartScan, 68)
2310     TEST_FIELD_SIZE  (EMRSETDIBITSTODEVICE, cScans, 4)
2311     TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cScans, 4)
2312     TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cScans, 72)
2313 }
2314
2315 static void test_pack_EMRSETICMMODE(void)
2316 {
2317     /* EMRSETICMMODE */
2318     TEST_TYPE_SIZE   (EMRSETICMMODE, 12)
2319     TEST_TYPE_ALIGN  (EMRSETICMMODE, 4)
2320     TEST_FIELD_SIZE  (EMRSETICMMODE, emr, 8)
2321     TEST_FIELD_ALIGN (EMRSETICMMODE, emr, 4)
2322     TEST_FIELD_OFFSET(EMRSETICMMODE, emr, 0)
2323     TEST_FIELD_SIZE  (EMRSETICMMODE, iMode, 4)
2324     TEST_FIELD_ALIGN (EMRSETICMMODE, iMode, 4)
2325     TEST_FIELD_OFFSET(EMRSETICMMODE, iMode, 8)
2326 }
2327
2328 static void test_pack_EMRSETLAYOUT(void)
2329 {
2330     /* EMRSETLAYOUT */
2331     TEST_TYPE_SIZE   (EMRSETLAYOUT, 12)
2332     TEST_TYPE_ALIGN  (EMRSETLAYOUT, 4)
2333     TEST_FIELD_SIZE  (EMRSETLAYOUT, emr, 8)
2334     TEST_FIELD_ALIGN (EMRSETLAYOUT, emr, 4)
2335     TEST_FIELD_OFFSET(EMRSETLAYOUT, emr, 0)
2336     TEST_FIELD_SIZE  (EMRSETLAYOUT, iMode, 4)
2337     TEST_FIELD_ALIGN (EMRSETLAYOUT, iMode, 4)
2338     TEST_FIELD_OFFSET(EMRSETLAYOUT, iMode, 8)
2339 }
2340
2341 static void test_pack_EMRSETMAPMODE(void)
2342 {
2343     /* EMRSETMAPMODE */
2344     TEST_TYPE_SIZE   (EMRSETMAPMODE, 12)
2345     TEST_TYPE_ALIGN  (EMRSETMAPMODE, 4)
2346     TEST_FIELD_SIZE  (EMRSETMAPMODE, emr, 8)
2347     TEST_FIELD_ALIGN (EMRSETMAPMODE, emr, 4)
2348     TEST_FIELD_OFFSET(EMRSETMAPMODE, emr, 0)
2349     TEST_FIELD_SIZE  (EMRSETMAPMODE, iMode, 4)
2350     TEST_FIELD_ALIGN (EMRSETMAPMODE, iMode, 4)
2351     TEST_FIELD_OFFSET(EMRSETMAPMODE, iMode, 8)
2352 }
2353
2354 static void test_pack_EMRSETMAPPERFLAGS(void)
2355 {
2356     /* EMRSETMAPPERFLAGS */
2357     TEST_TYPE_SIZE   (EMRSETMAPPERFLAGS, 12)
2358     TEST_TYPE_ALIGN  (EMRSETMAPPERFLAGS, 4)
2359     TEST_FIELD_SIZE  (EMRSETMAPPERFLAGS, emr, 8)
2360     TEST_FIELD_ALIGN (EMRSETMAPPERFLAGS, emr, 4)
2361     TEST_FIELD_OFFSET(EMRSETMAPPERFLAGS, emr, 0)
2362     TEST_FIELD_SIZE  (EMRSETMAPPERFLAGS, dwFlags, 4)
2363     TEST_FIELD_ALIGN (EMRSETMAPPERFLAGS, dwFlags, 4)
2364     TEST_FIELD_OFFSET(EMRSETMAPPERFLAGS, dwFlags, 8)
2365 }
2366
2367 static void test_pack_EMRSETMETARGN(void)
2368 {
2369     /* EMRSETMETARGN */
2370     TEST_TYPE_SIZE   (EMRSETMETARGN, 8)
2371     TEST_TYPE_ALIGN  (EMRSETMETARGN, 4)
2372     TEST_FIELD_SIZE  (EMRSETMETARGN, emr, 8)
2373     TEST_FIELD_ALIGN (EMRSETMETARGN, emr, 4)
2374     TEST_FIELD_OFFSET(EMRSETMETARGN, emr, 0)
2375 }
2376
2377 static void test_pack_EMRSETMITERLIMIT(void)
2378 {
2379     /* EMRSETMITERLIMIT */
2380     TEST_TYPE_SIZE   (EMRSETMITERLIMIT, 12)
2381     TEST_TYPE_ALIGN  (EMRSETMITERLIMIT, 4)
2382     TEST_FIELD_SIZE  (EMRSETMITERLIMIT, emr, 8)
2383     TEST_FIELD_ALIGN (EMRSETMITERLIMIT, emr, 4)
2384     TEST_FIELD_OFFSET(EMRSETMITERLIMIT, emr, 0)
2385     TEST_FIELD_SIZE  (EMRSETMITERLIMIT, eMiterLimit, 4)
2386     TEST_FIELD_ALIGN (EMRSETMITERLIMIT, eMiterLimit, 4)
2387     TEST_FIELD_OFFSET(EMRSETMITERLIMIT, eMiterLimit, 8)
2388 }
2389
2390 static void test_pack_EMRSETPIXELV(void)
2391 {
2392     /* EMRSETPIXELV */
2393     TEST_TYPE_SIZE   (EMRSETPIXELV, 20)
2394     TEST_TYPE_ALIGN  (EMRSETPIXELV, 4)
2395     TEST_FIELD_SIZE  (EMRSETPIXELV, emr, 8)
2396     TEST_FIELD_ALIGN (EMRSETPIXELV, emr, 4)
2397     TEST_FIELD_OFFSET(EMRSETPIXELV, emr, 0)
2398     TEST_FIELD_SIZE  (EMRSETPIXELV, ptlPixel, 8)
2399     TEST_FIELD_ALIGN (EMRSETPIXELV, ptlPixel, 4)
2400     TEST_FIELD_OFFSET(EMRSETPIXELV, ptlPixel, 8)
2401     TEST_FIELD_SIZE  (EMRSETPIXELV, crColor, 4)
2402     TEST_FIELD_ALIGN (EMRSETPIXELV, crColor, 4)
2403     TEST_FIELD_OFFSET(EMRSETPIXELV, crColor, 16)
2404 }
2405
2406 static void test_pack_EMRSETPOLYFILLMODE(void)
2407 {
2408     /* EMRSETPOLYFILLMODE */
2409     TEST_TYPE_SIZE   (EMRSETPOLYFILLMODE, 12)
2410     TEST_TYPE_ALIGN  (EMRSETPOLYFILLMODE, 4)
2411     TEST_FIELD_SIZE  (EMRSETPOLYFILLMODE, emr, 8)
2412     TEST_FIELD_ALIGN (EMRSETPOLYFILLMODE, emr, 4)
2413     TEST_FIELD_OFFSET(EMRSETPOLYFILLMODE, emr, 0)
2414     TEST_FIELD_SIZE  (EMRSETPOLYFILLMODE, iMode, 4)
2415     TEST_FIELD_ALIGN (EMRSETPOLYFILLMODE, iMode, 4)
2416     TEST_FIELD_OFFSET(EMRSETPOLYFILLMODE, iMode, 8)
2417 }
2418
2419 static void test_pack_EMRSETROP2(void)
2420 {
2421     /* EMRSETROP2 */
2422     TEST_TYPE_SIZE   (EMRSETROP2, 12)
2423     TEST_TYPE_ALIGN  (EMRSETROP2, 4)
2424     TEST_FIELD_SIZE  (EMRSETROP2, emr, 8)
2425     TEST_FIELD_ALIGN (EMRSETROP2, emr, 4)
2426     TEST_FIELD_OFFSET(EMRSETROP2, emr, 0)
2427     TEST_FIELD_SIZE  (EMRSETROP2, iMode, 4)
2428     TEST_FIELD_ALIGN (EMRSETROP2, iMode, 4)
2429     TEST_FIELD_OFFSET(EMRSETROP2, iMode, 8)
2430 }
2431
2432 static void test_pack_EMRSETSTRETCHBLTMODE(void)
2433 {
2434     /* EMRSETSTRETCHBLTMODE */
2435     TEST_TYPE_SIZE   (EMRSETSTRETCHBLTMODE, 12)
2436     TEST_TYPE_ALIGN  (EMRSETSTRETCHBLTMODE, 4)
2437     TEST_FIELD_SIZE  (EMRSETSTRETCHBLTMODE, emr, 8)
2438     TEST_FIELD_ALIGN (EMRSETSTRETCHBLTMODE, emr, 4)
2439     TEST_FIELD_OFFSET(EMRSETSTRETCHBLTMODE, emr, 0)
2440     TEST_FIELD_SIZE  (EMRSETSTRETCHBLTMODE, iMode, 4)
2441     TEST_FIELD_ALIGN (EMRSETSTRETCHBLTMODE, iMode, 4)
2442     TEST_FIELD_OFFSET(EMRSETSTRETCHBLTMODE, iMode, 8)
2443 }
2444
2445 static void test_pack_EMRSETTEXTALIGN(void)
2446 {
2447     /* EMRSETTEXTALIGN */
2448     TEST_TYPE_SIZE   (EMRSETTEXTALIGN, 12)
2449     TEST_TYPE_ALIGN  (EMRSETTEXTALIGN, 4)
2450     TEST_FIELD_SIZE  (EMRSETTEXTALIGN, emr, 8)
2451     TEST_FIELD_ALIGN (EMRSETTEXTALIGN, emr, 4)
2452     TEST_FIELD_OFFSET(EMRSETTEXTALIGN, emr, 0)
2453     TEST_FIELD_SIZE  (EMRSETTEXTALIGN, iMode, 4)
2454     TEST_FIELD_ALIGN (EMRSETTEXTALIGN, iMode, 4)
2455     TEST_FIELD_OFFSET(EMRSETTEXTALIGN, iMode, 8)
2456 }
2457
2458 static void test_pack_EMRSETTEXTCOLOR(void)
2459 {
2460     /* EMRSETTEXTCOLOR */
2461     TEST_TYPE_SIZE   (EMRSETTEXTCOLOR, 12)
2462     TEST_TYPE_ALIGN  (EMRSETTEXTCOLOR, 4)
2463     TEST_FIELD_SIZE  (EMRSETTEXTCOLOR, emr, 8)
2464     TEST_FIELD_ALIGN (EMRSETTEXTCOLOR, emr, 4)
2465     TEST_FIELD_OFFSET(EMRSETTEXTCOLOR, emr, 0)
2466     TEST_FIELD_SIZE  (EMRSETTEXTCOLOR, crColor, 4)
2467     TEST_FIELD_ALIGN (EMRSETTEXTCOLOR, crColor, 4)
2468     TEST_FIELD_OFFSET(EMRSETTEXTCOLOR, crColor, 8)
2469 }
2470
2471 static void test_pack_EMRSETVIEWPORTEXTEX(void)
2472 {
2473     /* EMRSETVIEWPORTEXTEX */
2474     TEST_TYPE_SIZE   (EMRSETVIEWPORTEXTEX, 16)
2475     TEST_TYPE_ALIGN  (EMRSETVIEWPORTEXTEX, 4)
2476     TEST_FIELD_SIZE  (EMRSETVIEWPORTEXTEX, emr, 8)
2477     TEST_FIELD_ALIGN (EMRSETVIEWPORTEXTEX, emr, 4)
2478     TEST_FIELD_OFFSET(EMRSETVIEWPORTEXTEX, emr, 0)
2479     TEST_FIELD_SIZE  (EMRSETVIEWPORTEXTEX, szlExtent, 8)
2480     TEST_FIELD_ALIGN (EMRSETVIEWPORTEXTEX, szlExtent, 4)
2481     TEST_FIELD_OFFSET(EMRSETVIEWPORTEXTEX, szlExtent, 8)
2482 }
2483
2484 static void test_pack_EMRSETVIEWPORTORGEX(void)
2485 {
2486     /* EMRSETVIEWPORTORGEX */
2487     TEST_TYPE_SIZE   (EMRSETVIEWPORTORGEX, 16)
2488     TEST_TYPE_ALIGN  (EMRSETVIEWPORTORGEX, 4)
2489     TEST_FIELD_SIZE  (EMRSETVIEWPORTORGEX, emr, 8)
2490     TEST_FIELD_ALIGN (EMRSETVIEWPORTORGEX, emr, 4)
2491     TEST_FIELD_OFFSET(EMRSETVIEWPORTORGEX, emr, 0)
2492     TEST_FIELD_SIZE  (EMRSETVIEWPORTORGEX, ptlOrigin, 8)
2493     TEST_FIELD_ALIGN (EMRSETVIEWPORTORGEX, ptlOrigin, 4)
2494     TEST_FIELD_OFFSET(EMRSETVIEWPORTORGEX, ptlOrigin, 8)
2495 }
2496
2497 static void test_pack_EMRSETWINDOWEXTEX(void)
2498 {
2499     /* EMRSETWINDOWEXTEX */
2500     TEST_TYPE_SIZE   (EMRSETWINDOWEXTEX, 16)
2501     TEST_TYPE_ALIGN  (EMRSETWINDOWEXTEX, 4)
2502     TEST_FIELD_SIZE  (EMRSETWINDOWEXTEX, emr, 8)
2503     TEST_FIELD_ALIGN (EMRSETWINDOWEXTEX, emr, 4)
2504     TEST_FIELD_OFFSET(EMRSETWINDOWEXTEX, emr, 0)
2505     TEST_FIELD_SIZE  (EMRSETWINDOWEXTEX, szlExtent, 8)
2506     TEST_FIELD_ALIGN (EMRSETWINDOWEXTEX, szlExtent, 4)
2507     TEST_FIELD_OFFSET(EMRSETWINDOWEXTEX, szlExtent, 8)
2508 }
2509
2510 static void test_pack_EMRSETWINDOWORGEX(void)
2511 {
2512     /* EMRSETWINDOWORGEX */
2513     TEST_TYPE_SIZE   (EMRSETWINDOWORGEX, 16)
2514     TEST_TYPE_ALIGN  (EMRSETWINDOWORGEX, 4)
2515     TEST_FIELD_SIZE  (EMRSETWINDOWORGEX, emr, 8)
2516     TEST_FIELD_ALIGN (EMRSETWINDOWORGEX, emr, 4)
2517     TEST_FIELD_OFFSET(EMRSETWINDOWORGEX, emr, 0)
2518     TEST_FIELD_SIZE  (EMRSETWINDOWORGEX, ptlOrigin, 8)
2519     TEST_FIELD_ALIGN (EMRSETWINDOWORGEX, ptlOrigin, 4)
2520     TEST_FIELD_OFFSET(EMRSETWINDOWORGEX, ptlOrigin, 8)
2521 }
2522
2523 static void test_pack_EMRSETWORLDTRANSFORM(void)
2524 {
2525     /* EMRSETWORLDTRANSFORM */
2526     TEST_TYPE_SIZE   (EMRSETWORLDTRANSFORM, 32)
2527     TEST_TYPE_ALIGN  (EMRSETWORLDTRANSFORM, 4)
2528     TEST_FIELD_SIZE  (EMRSETWORLDTRANSFORM, emr, 8)
2529     TEST_FIELD_ALIGN (EMRSETWORLDTRANSFORM, emr, 4)
2530     TEST_FIELD_OFFSET(EMRSETWORLDTRANSFORM, emr, 0)
2531     TEST_FIELD_SIZE  (EMRSETWORLDTRANSFORM, xform, 24)
2532     TEST_FIELD_ALIGN (EMRSETWORLDTRANSFORM, xform, 4)
2533     TEST_FIELD_OFFSET(EMRSETWORLDTRANSFORM, xform, 8)
2534 }
2535
2536 static void test_pack_EMRSTRETCHBLT(void)
2537 {
2538     /* EMRSTRETCHBLT */
2539     TEST_TYPE_SIZE   (EMRSTRETCHBLT, 108)
2540     TEST_TYPE_ALIGN  (EMRSTRETCHBLT, 4)
2541     TEST_FIELD_SIZE  (EMRSTRETCHBLT, emr, 8)
2542     TEST_FIELD_ALIGN (EMRSTRETCHBLT, emr, 4)
2543     TEST_FIELD_OFFSET(EMRSTRETCHBLT, emr, 0)
2544     TEST_FIELD_SIZE  (EMRSTRETCHBLT, rclBounds, 16)
2545     TEST_FIELD_ALIGN (EMRSTRETCHBLT, rclBounds, 4)
2546     TEST_FIELD_OFFSET(EMRSTRETCHBLT, rclBounds, 8)
2547     TEST_FIELD_SIZE  (EMRSTRETCHBLT, xDest, 4)
2548     TEST_FIELD_ALIGN (EMRSTRETCHBLT, xDest, 4)
2549     TEST_FIELD_OFFSET(EMRSTRETCHBLT, xDest, 24)
2550     TEST_FIELD_SIZE  (EMRSTRETCHBLT, yDest, 4)
2551     TEST_FIELD_ALIGN (EMRSTRETCHBLT, yDest, 4)
2552     TEST_FIELD_OFFSET(EMRSTRETCHBLT, yDest, 28)
2553     TEST_FIELD_SIZE  (EMRSTRETCHBLT, cxDest, 4)
2554     TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxDest, 4)
2555     TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxDest, 32)
2556     TEST_FIELD_SIZE  (EMRSTRETCHBLT, cyDest, 4)
2557     TEST_FIELD_ALIGN (EMRSTRETCHBLT, cyDest, 4)
2558     TEST_FIELD_OFFSET(EMRSTRETCHBLT, cyDest, 36)
2559     TEST_FIELD_SIZE  (EMRSTRETCHBLT, dwRop, 4)
2560     TEST_FIELD_ALIGN (EMRSTRETCHBLT, dwRop, 4)
2561     TEST_FIELD_OFFSET(EMRSTRETCHBLT, dwRop, 40)
2562     TEST_FIELD_SIZE  (EMRSTRETCHBLT, xSrc, 4)
2563     TEST_FIELD_ALIGN (EMRSTRETCHBLT, xSrc, 4)
2564     TEST_FIELD_OFFSET(EMRSTRETCHBLT, xSrc, 44)
2565     TEST_FIELD_SIZE  (EMRSTRETCHBLT, ySrc, 4)
2566     TEST_FIELD_ALIGN (EMRSTRETCHBLT, ySrc, 4)
2567     TEST_FIELD_OFFSET(EMRSTRETCHBLT, ySrc, 48)
2568     TEST_FIELD_SIZE  (EMRSTRETCHBLT, xformSrc, 24)
2569     TEST_FIELD_ALIGN (EMRSTRETCHBLT, xformSrc, 4)
2570     TEST_FIELD_OFFSET(EMRSTRETCHBLT, xformSrc, 52)
2571     TEST_FIELD_SIZE  (EMRSTRETCHBLT, crBkColorSrc, 4)
2572     TEST_FIELD_ALIGN (EMRSTRETCHBLT, crBkColorSrc, 4)
2573     TEST_FIELD_OFFSET(EMRSTRETCHBLT, crBkColorSrc, 76)
2574     TEST_FIELD_SIZE  (EMRSTRETCHBLT, iUsageSrc, 4)
2575     TEST_FIELD_ALIGN (EMRSTRETCHBLT, iUsageSrc, 4)
2576     TEST_FIELD_OFFSET(EMRSTRETCHBLT, iUsageSrc, 80)
2577     TEST_FIELD_SIZE  (EMRSTRETCHBLT, offBmiSrc, 4)
2578     TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBmiSrc, 4)
2579     TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBmiSrc, 84)
2580     TEST_FIELD_SIZE  (EMRSTRETCHBLT, cbBmiSrc, 4)
2581     TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBmiSrc, 4)
2582     TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBmiSrc, 88)
2583     TEST_FIELD_SIZE  (EMRSTRETCHBLT, offBitsSrc, 4)
2584     TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBitsSrc, 4)
2585     TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBitsSrc, 92)
2586     TEST_FIELD_SIZE  (EMRSTRETCHBLT, cbBitsSrc, 4)
2587     TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBitsSrc, 4)
2588     TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBitsSrc, 96)
2589     TEST_FIELD_SIZE  (EMRSTRETCHBLT, cxSrc, 4)
2590     TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxSrc, 4)
2591     TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxSrc, 100)
2592     TEST_FIELD_SIZE  (EMRSTRETCHBLT, cySrc, 4)
2593     TEST_FIELD_ALIGN (EMRSTRETCHBLT, cySrc, 4)
2594     TEST_FIELD_OFFSET(EMRSTRETCHBLT, cySrc, 104)
2595 }
2596
2597 static void test_pack_EMRSTRETCHDIBITS(void)
2598 {
2599     /* EMRSTRETCHDIBITS */
2600     TEST_TYPE_SIZE   (EMRSTRETCHDIBITS, 80)
2601     TEST_TYPE_ALIGN  (EMRSTRETCHDIBITS, 4)
2602     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, emr, 8)
2603     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, emr, 4)
2604     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, emr, 0)
2605     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, rclBounds, 16)
2606     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, rclBounds, 4)
2607     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, rclBounds, 8)
2608     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, xDest, 4)
2609     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, xDest, 4)
2610     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, xDest, 24)
2611     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, yDest, 4)
2612     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, yDest, 4)
2613     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, yDest, 28)
2614     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, xSrc, 4)
2615     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, xSrc, 4)
2616     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, xSrc, 32)
2617     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, ySrc, 4)
2618     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, ySrc, 4)
2619     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, ySrc, 36)
2620     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, cxSrc, 4)
2621     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cxSrc, 4)
2622     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cxSrc, 40)
2623     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, cySrc, 4)
2624     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cySrc, 4)
2625     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cySrc, 44)
2626     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, offBmiSrc, 4)
2627     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBmiSrc, 4)
2628     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBmiSrc, 48)
2629     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, cbBmiSrc, 4)
2630     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBmiSrc, 4)
2631     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBmiSrc, 52)
2632     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, offBitsSrc, 4)
2633     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBitsSrc, 4)
2634     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBitsSrc, 56)
2635     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, cbBitsSrc, 4)
2636     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBitsSrc, 4)
2637     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBitsSrc, 60)
2638     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, iUsageSrc, 4)
2639     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, iUsageSrc, 4)
2640     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, iUsageSrc, 64)
2641     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, dwRop, 4)
2642     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, dwRop, 4)
2643     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, dwRop, 68)
2644     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, cxDest, 4)
2645     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cxDest, 4)
2646     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cxDest, 72)
2647     TEST_FIELD_SIZE  (EMRSTRETCHDIBITS, cyDest, 4)
2648     TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cyDest, 4)
2649     TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cyDest, 76)
2650 }
2651
2652 static void test_pack_EMRSTROKEANDFILLPATH(void)
2653 {
2654     /* EMRSTROKEANDFILLPATH */
2655     TEST_TYPE_SIZE   (EMRSTROKEANDFILLPATH, 24)
2656     TEST_TYPE_ALIGN  (EMRSTROKEANDFILLPATH, 4)
2657     TEST_FIELD_SIZE  (EMRSTROKEANDFILLPATH, emr, 8)
2658     TEST_FIELD_ALIGN (EMRSTROKEANDFILLPATH, emr, 4)
2659     TEST_FIELD_OFFSET(EMRSTROKEANDFILLPATH, emr, 0)
2660     TEST_FIELD_SIZE  (EMRSTROKEANDFILLPATH, rclBounds, 16)
2661     TEST_FIELD_ALIGN (EMRSTROKEANDFILLPATH, rclBounds, 4)
2662     TEST_FIELD_OFFSET(EMRSTROKEANDFILLPATH, rclBounds, 8)
2663 }
2664
2665 static void test_pack_EMRSTROKEPATH(void)
2666 {
2667     /* EMRSTROKEPATH */
2668     TEST_TYPE_SIZE   (EMRSTROKEPATH, 24)
2669     TEST_TYPE_ALIGN  (EMRSTROKEPATH, 4)
2670     TEST_FIELD_SIZE  (EMRSTROKEPATH, emr, 8)
2671     TEST_FIELD_ALIGN (EMRSTROKEPATH, emr, 4)
2672     TEST_FIELD_OFFSET(EMRSTROKEPATH, emr, 0)
2673     TEST_FIELD_SIZE  (EMRSTROKEPATH, rclBounds, 16)
2674     TEST_FIELD_ALIGN (EMRSTROKEPATH, rclBounds, 4)
2675     TEST_FIELD_OFFSET(EMRSTROKEPATH, rclBounds, 8)
2676 }
2677
2678 static void test_pack_EMRTEXT(void)
2679 {
2680     /* EMRTEXT */
2681     TEST_TYPE_SIZE   (EMRTEXT, 40)
2682     TEST_TYPE_ALIGN  (EMRTEXT, 4)
2683     TEST_FIELD_SIZE  (EMRTEXT, ptlReference, 8)
2684     TEST_FIELD_ALIGN (EMRTEXT, ptlReference, 4)
2685     TEST_FIELD_OFFSET(EMRTEXT, ptlReference, 0)
2686     TEST_FIELD_SIZE  (EMRTEXT, nChars, 4)
2687     TEST_FIELD_ALIGN (EMRTEXT, nChars, 4)
2688     TEST_FIELD_OFFSET(EMRTEXT, nChars, 8)
2689     TEST_FIELD_SIZE  (EMRTEXT, offString, 4)
2690     TEST_FIELD_ALIGN (EMRTEXT, offString, 4)
2691     TEST_FIELD_OFFSET(EMRTEXT, offString, 12)
2692     TEST_FIELD_SIZE  (EMRTEXT, fOptions, 4)
2693     TEST_FIELD_ALIGN (EMRTEXT, fOptions, 4)
2694     TEST_FIELD_OFFSET(EMRTEXT, fOptions, 16)
2695     TEST_FIELD_SIZE  (EMRTEXT, rcl, 16)
2696     TEST_FIELD_ALIGN (EMRTEXT, rcl, 4)
2697     TEST_FIELD_OFFSET(EMRTEXT, rcl, 20)
2698     TEST_FIELD_SIZE  (EMRTEXT, offDx, 4)
2699     TEST_FIELD_ALIGN (EMRTEXT, offDx, 4)
2700     TEST_FIELD_OFFSET(EMRTEXT, offDx, 36)
2701 }
2702
2703 static void test_pack_EMRWIDENPATH(void)
2704 {
2705     /* EMRWIDENPATH */
2706     TEST_TYPE_SIZE   (EMRWIDENPATH, 8)
2707     TEST_TYPE_ALIGN  (EMRWIDENPATH, 4)
2708     TEST_FIELD_SIZE  (EMRWIDENPATH, emr, 8)
2709     TEST_FIELD_ALIGN (EMRWIDENPATH, emr, 4)
2710     TEST_FIELD_OFFSET(EMRWIDENPATH, emr, 0)
2711 }
2712
2713 static void test_pack_ENHMETAHEADER(void)
2714 {
2715     /* ENHMETAHEADER */
2716     TEST_TYPE_SIZE   (ENHMETAHEADER, 108)
2717     TEST_TYPE_ALIGN  (ENHMETAHEADER, 4)
2718     TEST_FIELD_SIZE  (ENHMETAHEADER, iType, 4)
2719     TEST_FIELD_ALIGN (ENHMETAHEADER, iType, 4)
2720     TEST_FIELD_OFFSET(ENHMETAHEADER, iType, 0)
2721     TEST_FIELD_SIZE  (ENHMETAHEADER, nSize, 4)
2722     TEST_FIELD_ALIGN (ENHMETAHEADER, nSize, 4)
2723     TEST_FIELD_OFFSET(ENHMETAHEADER, nSize, 4)
2724     TEST_FIELD_SIZE  (ENHMETAHEADER, rclBounds, 16)
2725     TEST_FIELD_ALIGN (ENHMETAHEADER, rclBounds, 4)
2726     TEST_FIELD_OFFSET(ENHMETAHEADER, rclBounds, 8)
2727     TEST_FIELD_SIZE  (ENHMETAHEADER, rclFrame, 16)
2728     TEST_FIELD_ALIGN (ENHMETAHEADER, rclFrame, 4)
2729     TEST_FIELD_OFFSET(ENHMETAHEADER, rclFrame, 24)
2730     TEST_FIELD_SIZE  (ENHMETAHEADER, dSignature, 4)
2731     TEST_FIELD_ALIGN (ENHMETAHEADER, dSignature, 4)
2732     TEST_FIELD_OFFSET(ENHMETAHEADER, dSignature, 40)
2733     TEST_FIELD_SIZE  (ENHMETAHEADER, nVersion, 4)
2734     TEST_FIELD_ALIGN (ENHMETAHEADER, nVersion, 4)
2735     TEST_FIELD_OFFSET(ENHMETAHEADER, nVersion, 44)
2736     TEST_FIELD_SIZE  (ENHMETAHEADER, nBytes, 4)
2737     TEST_FIELD_ALIGN (ENHMETAHEADER, nBytes, 4)
2738     TEST_FIELD_OFFSET(ENHMETAHEADER, nBytes, 48)
2739     TEST_FIELD_SIZE  (ENHMETAHEADER, nRecords, 4)
2740     TEST_FIELD_ALIGN (ENHMETAHEADER, nRecords, 4)
2741     TEST_FIELD_OFFSET(ENHMETAHEADER, nRecords, 52)
2742     TEST_FIELD_SIZE  (ENHMETAHEADER, nHandles, 2)
2743     TEST_FIELD_ALIGN (ENHMETAHEADER, nHandles, 2)
2744     TEST_FIELD_OFFSET(ENHMETAHEADER, nHandles, 56)
2745     TEST_FIELD_SIZE  (ENHMETAHEADER, sReserved, 2)
2746     TEST_FIELD_ALIGN (ENHMETAHEADER, sReserved, 2)
2747     TEST_FIELD_OFFSET(ENHMETAHEADER, sReserved, 58)
2748     TEST_FIELD_SIZE  (ENHMETAHEADER, nDescription, 4)
2749     TEST_FIELD_ALIGN (ENHMETAHEADER, nDescription, 4)
2750     TEST_FIELD_OFFSET(ENHMETAHEADER, nDescription, 60)
2751     TEST_FIELD_SIZE  (ENHMETAHEADER, offDescription, 4)
2752     TEST_FIELD_ALIGN (ENHMETAHEADER, offDescription, 4)
2753     TEST_FIELD_OFFSET(ENHMETAHEADER, offDescription, 64)
2754     TEST_FIELD_SIZE  (ENHMETAHEADER, nPalEntries, 4)
2755     TEST_FIELD_ALIGN (ENHMETAHEADER, nPalEntries, 4)
2756     TEST_FIELD_OFFSET(ENHMETAHEADER, nPalEntries, 68)
2757     TEST_FIELD_SIZE  (ENHMETAHEADER, szlDevice, 8)
2758     TEST_FIELD_ALIGN (ENHMETAHEADER, szlDevice, 4)
2759     TEST_FIELD_OFFSET(ENHMETAHEADER, szlDevice, 72)
2760     TEST_FIELD_SIZE  (ENHMETAHEADER, szlMillimeters, 8)
2761     TEST_FIELD_ALIGN (ENHMETAHEADER, szlMillimeters, 4)
2762     TEST_FIELD_OFFSET(ENHMETAHEADER, szlMillimeters, 80)
2763     TEST_FIELD_SIZE  (ENHMETAHEADER, cbPixelFormat, 4)
2764     TEST_FIELD_ALIGN (ENHMETAHEADER, cbPixelFormat, 4)
2765     TEST_FIELD_OFFSET(ENHMETAHEADER, cbPixelFormat, 88)
2766     TEST_FIELD_SIZE  (ENHMETAHEADER, offPixelFormat, 4)
2767     TEST_FIELD_ALIGN (ENHMETAHEADER, offPixelFormat, 4)
2768     TEST_FIELD_OFFSET(ENHMETAHEADER, offPixelFormat, 92)
2769     TEST_FIELD_SIZE  (ENHMETAHEADER, bOpenGL, 4)
2770     TEST_FIELD_ALIGN (ENHMETAHEADER, bOpenGL, 4)
2771     TEST_FIELD_OFFSET(ENHMETAHEADER, bOpenGL, 96)
2772     TEST_FIELD_SIZE  (ENHMETAHEADER, szlMicrometers, 8)
2773     TEST_FIELD_ALIGN (ENHMETAHEADER, szlMicrometers, 4)
2774     TEST_FIELD_OFFSET(ENHMETAHEADER, szlMicrometers, 100)
2775 }
2776
2777 static void test_pack_ENHMETARECORD(void)
2778 {
2779     /* ENHMETARECORD */
2780     TEST_TYPE_SIZE   (ENHMETARECORD, 12)
2781     TEST_TYPE_ALIGN  (ENHMETARECORD, 4)
2782     TEST_FIELD_SIZE  (ENHMETARECORD, iType, 4)
2783     TEST_FIELD_ALIGN (ENHMETARECORD, iType, 4)
2784     TEST_FIELD_OFFSET(ENHMETARECORD, iType, 0)
2785     TEST_FIELD_SIZE  (ENHMETARECORD, nSize, 4)
2786     TEST_FIELD_ALIGN (ENHMETARECORD, nSize, 4)
2787     TEST_FIELD_OFFSET(ENHMETARECORD, nSize, 4)
2788     TEST_FIELD_SIZE  (ENHMETARECORD, dParm, 4)
2789     TEST_FIELD_ALIGN (ENHMETARECORD, dParm, 4)
2790     TEST_FIELD_OFFSET(ENHMETARECORD, dParm, 8)
2791 }
2792
2793 static void test_pack_ENHMFENUMPROC(void)
2794 {
2795     /* ENHMFENUMPROC */
2796     TEST_TYPE_SIZE   (ENHMFENUMPROC, 8)
2797     TEST_TYPE_ALIGN  (ENHMFENUMPROC, 8)
2798 }
2799
2800 static void test_pack_ENUMLOGFONTA(void)
2801 {
2802     /* ENUMLOGFONTA */
2803     TEST_TYPE_SIZE   (ENUMLOGFONTA, 156)
2804     TEST_TYPE_ALIGN  (ENUMLOGFONTA, 4)
2805     TEST_FIELD_SIZE  (ENUMLOGFONTA, elfLogFont, 60)
2806     TEST_FIELD_ALIGN (ENUMLOGFONTA, elfLogFont, 4)
2807     TEST_FIELD_OFFSET(ENUMLOGFONTA, elfLogFont, 0)
2808     TEST_FIELD_SIZE  (ENUMLOGFONTA, elfFullName, 64)
2809     TEST_FIELD_ALIGN (ENUMLOGFONTA, elfFullName, 1)
2810     TEST_FIELD_OFFSET(ENUMLOGFONTA, elfFullName, 60)
2811     TEST_FIELD_SIZE  (ENUMLOGFONTA, elfStyle, 32)
2812     TEST_FIELD_ALIGN (ENUMLOGFONTA, elfStyle, 1)
2813     TEST_FIELD_OFFSET(ENUMLOGFONTA, elfStyle, 124)
2814 }
2815
2816 static void test_pack_ENUMLOGFONTEXA(void)
2817 {
2818     /* ENUMLOGFONTEXA */
2819     TEST_TYPE_SIZE   (ENUMLOGFONTEXA, 188)
2820     TEST_TYPE_ALIGN  (ENUMLOGFONTEXA, 4)
2821     TEST_FIELD_SIZE  (ENUMLOGFONTEXA, elfLogFont, 60)
2822     TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfLogFont, 4)
2823     TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfLogFont, 0)
2824     TEST_FIELD_SIZE  (ENUMLOGFONTEXA, elfFullName, 64)
2825     TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfFullName, 1)
2826     TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfFullName, 60)
2827     TEST_FIELD_SIZE  (ENUMLOGFONTEXA, elfStyle, 32)
2828     TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfStyle, 1)
2829     TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfStyle, 124)
2830     TEST_FIELD_SIZE  (ENUMLOGFONTEXA, elfScript, 32)
2831     TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfScript, 1)
2832     TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfScript, 156)
2833 }
2834
2835 static void test_pack_ENUMLOGFONTEXW(void)
2836 {
2837     /* ENUMLOGFONTEXW */
2838     TEST_TYPE_SIZE   (ENUMLOGFONTEXW, 348)
2839     TEST_TYPE_ALIGN  (ENUMLOGFONTEXW, 4)
2840     TEST_FIELD_SIZE  (ENUMLOGFONTEXW, elfLogFont, 92)
2841     TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfLogFont, 4)
2842     TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfLogFont, 0)
2843     TEST_FIELD_SIZE  (ENUMLOGFONTEXW, elfFullName, 128)
2844     TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfFullName, 2)
2845     TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfFullName, 92)
2846     TEST_FIELD_SIZE  (ENUMLOGFONTEXW, elfStyle, 64)
2847     TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfStyle, 2)
2848     TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfStyle, 220)