| /* File generated automatically from tools/winapi/tests.dat; do not edit! */ |
| /* This file can be copied, modified and distributed without restriction. */ |
| |
| /* |
| * Unit tests for data structure packing |
| */ |
| |
| #define WINVER 0x0501 |
| #define _WIN32_IE 0x0501 |
| #define _WIN32_WINNT 0x0501 |
| |
| #define WINE_NOWINSOCK |
| |
| #include "windows.h" |
| |
| #include "wine/test.h" |
| |
| /*********************************************************************** |
| * Compatibility macros |
| */ |
| |
| #define DWORD_PTR UINT_PTR |
| #define LONG_PTR INT_PTR |
| #define ULONG_PTR UINT_PTR |
| |
| /*********************************************************************** |
| * Windows API extension |
| */ |
| |
| #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus) |
| # define _TYPE_ALIGNMENT(type) __alignof(type) |
| #elif defined(__GNUC__) |
| # define _TYPE_ALIGNMENT(type) __alignof__(type) |
| #else |
| /* |
| * FIXME: May not be possible without a compiler extension |
| * (if type is not just a name that is, otherwise the normal |
| * TYPE_ALIGNMENT can be used) |
| */ |
| #endif |
| |
| #if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus) |
| #pragma warning(disable:4116) |
| #endif |
| |
| #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT) |
| # define TYPE_ALIGNMENT _TYPE_ALIGNMENT |
| #endif |
| |
| /*********************************************************************** |
| * Test helper macros |
| */ |
| |
| #define TEST_TYPE_SIZE(type, size) C_ASSERT(sizeof(type) == size); |
| |
| #ifdef TYPE_ALIGNMENT |
| # define TEST_TYPE_ALIGN(type, align) C_ASSERT(TYPE_ALIGNMENT(type) == align); |
| #else |
| # define TEST_TYPE_ALIGN(type, align) |
| #endif |
| |
| #ifdef _TYPE_ALIGNMENT |
| # define TEST_TARGET_ALIGN(type, align) C_ASSERT(_TYPE_ALIGNMENT(*(type)0) == align); |
| # define TEST_FIELD_ALIGN(type, field, align) C_ASSERT(_TYPE_ALIGNMENT(((type*)0)->field) == align); |
| #else |
| # define TEST_TARGET_ALIGN(type, align) |
| # define TEST_FIELD_ALIGN(type, field, align) |
| #endif |
| |
| #define TEST_FIELD_OFFSET(type, field, offset) C_ASSERT(FIELD_OFFSET(type, field) == offset); |
| |
| #define TEST_TARGET_SIZE(type, size) TEST_TYPE_SIZE(*(type)0, size) |
| #define TEST_FIELD_SIZE(type, field, size) TEST_TYPE_SIZE((((type*)0)->field), size) |
| #define TEST_TYPE_SIGNED(type) C_ASSERT((type) -1 < 0); |
| #define TEST_TYPE_UNSIGNED(type) C_ASSERT((type) -1 > 0); |
| |
| |
| #ifdef _WIN64 |
| |
| static void test_pack_ABC(void) |
| { |
| /* ABC */ |
| TEST_TYPE_SIZE (ABC, 12) |
| TEST_TYPE_ALIGN (ABC, 4) |
| TEST_FIELD_SIZE (ABC, abcA, 4) |
| TEST_FIELD_ALIGN (ABC, abcA, 4) |
| TEST_FIELD_OFFSET(ABC, abcA, 0) |
| TEST_FIELD_SIZE (ABC, abcB, 4) |
| TEST_FIELD_ALIGN (ABC, abcB, 4) |
| TEST_FIELD_OFFSET(ABC, abcB, 4) |
| TEST_FIELD_SIZE (ABC, abcC, 4) |
| TEST_FIELD_ALIGN (ABC, abcC, 4) |
| TEST_FIELD_OFFSET(ABC, abcC, 8) |
| } |
| |
| static void test_pack_ABCFLOAT(void) |
| { |
| /* ABCFLOAT */ |
| TEST_TYPE_SIZE (ABCFLOAT, 12) |
| TEST_TYPE_ALIGN (ABCFLOAT, 4) |
| TEST_FIELD_SIZE (ABCFLOAT, abcfA, 4) |
| TEST_FIELD_ALIGN (ABCFLOAT, abcfA, 4) |
| TEST_FIELD_OFFSET(ABCFLOAT, abcfA, 0) |
| TEST_FIELD_SIZE (ABCFLOAT, abcfB, 4) |
| TEST_FIELD_ALIGN (ABCFLOAT, abcfB, 4) |
| TEST_FIELD_OFFSET(ABCFLOAT, abcfB, 4) |
| TEST_FIELD_SIZE (ABCFLOAT, abcfC, 4) |
| TEST_FIELD_ALIGN (ABCFLOAT, abcfC, 4) |
| TEST_FIELD_OFFSET(ABCFLOAT, abcfC, 8) |
| } |
| |
| static void test_pack_ABORTPROC(void) |
| { |
| /* ABORTPROC */ |
| TEST_TYPE_SIZE (ABORTPROC, 8) |
| TEST_TYPE_ALIGN (ABORTPROC, 8) |
| } |
| |
| static void test_pack_BITMAP(void) |
| { |
| /* BITMAP */ |
| TEST_TYPE_SIZE (BITMAP, 32) |
| TEST_TYPE_ALIGN (BITMAP, 8) |
| TEST_FIELD_SIZE (BITMAP, bmType, 4) |
| TEST_FIELD_ALIGN (BITMAP, bmType, 4) |
| TEST_FIELD_OFFSET(BITMAP, bmType, 0) |
| TEST_FIELD_SIZE (BITMAP, bmWidth, 4) |
| TEST_FIELD_ALIGN (BITMAP, bmWidth, 4) |
| TEST_FIELD_OFFSET(BITMAP, bmWidth, 4) |
| TEST_FIELD_SIZE (BITMAP, bmHeight, 4) |
| TEST_FIELD_ALIGN (BITMAP, bmHeight, 4) |
| TEST_FIELD_OFFSET(BITMAP, bmHeight, 8) |
| TEST_FIELD_SIZE (BITMAP, bmWidthBytes, 4) |
| TEST_FIELD_ALIGN (BITMAP, bmWidthBytes, 4) |
| TEST_FIELD_OFFSET(BITMAP, bmWidthBytes, 12) |
| TEST_FIELD_SIZE (BITMAP, bmPlanes, 2) |
| TEST_FIELD_ALIGN (BITMAP, bmPlanes, 2) |
| TEST_FIELD_OFFSET(BITMAP, bmPlanes, 16) |
| TEST_FIELD_SIZE (BITMAP, bmBitsPixel, 2) |
| TEST_FIELD_ALIGN (BITMAP, bmBitsPixel, 2) |
| TEST_FIELD_OFFSET(BITMAP, bmBitsPixel, 18) |
| TEST_FIELD_SIZE (BITMAP, bmBits, 8) |
| TEST_FIELD_ALIGN (BITMAP, bmBits, 8) |
| TEST_FIELD_OFFSET(BITMAP, bmBits, 24) |
| } |
| |
| static void test_pack_BITMAPCOREHEADER(void) |
| { |
| /* BITMAPCOREHEADER */ |
| TEST_TYPE_SIZE (BITMAPCOREHEADER, 12) |
| TEST_TYPE_ALIGN (BITMAPCOREHEADER, 4) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcSize, 4) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcSize, 4) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcSize, 0) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcWidth, 2) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcWidth, 2) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcWidth, 4) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcHeight, 2) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcHeight, 2) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcHeight, 6) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcPlanes, 2) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcPlanes, 2) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcPlanes, 8) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcBitCount, 2) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcBitCount, 2) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcBitCount, 10) |
| } |
| |
| static void test_pack_BITMAPCOREINFO(void) |
| { |
| /* BITMAPCOREINFO */ |
| TEST_TYPE_SIZE (BITMAPCOREINFO, 16) |
| TEST_TYPE_ALIGN (BITMAPCOREINFO, 4) |
| TEST_FIELD_SIZE (BITMAPCOREINFO, bmciHeader, 12) |
| TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciHeader, 4) |
| TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciHeader, 0) |
| TEST_FIELD_SIZE (BITMAPCOREINFO, bmciColors, 3) |
| TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciColors, 1) |
| TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciColors, 12) |
| } |
| |
| static void test_pack_BITMAPFILEHEADER(void) |
| { |
| /* BITMAPFILEHEADER (pack 2) */ |
| TEST_TYPE_SIZE (BITMAPFILEHEADER, 14) |
| TEST_TYPE_ALIGN (BITMAPFILEHEADER, 2) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfType, 2) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfType, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfType, 0) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfSize, 4) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfSize, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfSize, 2) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfReserved1, 2) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved1, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved1, 6) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfReserved2, 2) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved2, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved2, 8) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfOffBits, 4) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfOffBits, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfOffBits, 10) |
| } |
| |
| static void test_pack_BITMAPINFO(void) |
| { |
| /* BITMAPINFO */ |
| TEST_TYPE_SIZE (BITMAPINFO, 44) |
| TEST_TYPE_ALIGN (BITMAPINFO, 4) |
| TEST_FIELD_SIZE (BITMAPINFO, bmiHeader, 40) |
| TEST_FIELD_ALIGN (BITMAPINFO, bmiHeader, 4) |
| TEST_FIELD_OFFSET(BITMAPINFO, bmiHeader, 0) |
| TEST_FIELD_SIZE (BITMAPINFO, bmiColors, 4) |
| TEST_FIELD_ALIGN (BITMAPINFO, bmiColors, 1) |
| TEST_FIELD_OFFSET(BITMAPINFO, bmiColors, 40) |
| } |
| |
| static void test_pack_BITMAPINFOHEADER(void) |
| { |
| /* BITMAPINFOHEADER */ |
| TEST_TYPE_SIZE (BITMAPINFOHEADER, 40) |
| TEST_TYPE_ALIGN (BITMAPINFOHEADER, 4) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biSize, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biSize, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biSize, 0) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biWidth, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biWidth, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biWidth, 4) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biHeight, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biHeight, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biHeight, 8) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biPlanes, 2) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biPlanes, 2) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biPlanes, 12) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biBitCount, 2) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biBitCount, 2) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biBitCount, 14) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biCompression, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biCompression, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biCompression, 16) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biSizeImage, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biSizeImage, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biSizeImage, 20) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biXPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biXPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biXPelsPerMeter, 24) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biYPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biYPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biYPelsPerMeter, 28) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biClrUsed, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrUsed, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrUsed, 32) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biClrImportant, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrImportant, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrImportant, 36) |
| } |
| |
| static void test_pack_BITMAPV4HEADER(void) |
| { |
| /* BITMAPV4HEADER */ |
| TEST_TYPE_SIZE (BITMAPV4HEADER, 108) |
| TEST_TYPE_ALIGN (BITMAPV4HEADER, 4) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Size, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Size, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Size, 0) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Width, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Width, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Width, 4) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Height, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Height, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Height, 8) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Planes, 2) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Planes, 2) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Planes, 12) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4BitCount, 2) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BitCount, 2) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BitCount, 14) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4V4Compression, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4V4Compression, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4V4Compression, 16) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4SizeImage, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4SizeImage, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4SizeImage, 20) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4XPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4XPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4XPelsPerMeter, 24) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4YPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4YPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4YPelsPerMeter, 28) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4ClrUsed, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrUsed, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrUsed, 32) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4ClrImportant, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrImportant, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrImportant, 36) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4RedMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4RedMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4RedMask, 40) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GreenMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GreenMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GreenMask, 44) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4BlueMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BlueMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BlueMask, 48) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4AlphaMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4AlphaMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4AlphaMask, 52) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4CSType, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4CSType, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4CSType, 56) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Endpoints, 36) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Endpoints, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Endpoints, 60) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaRed, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaRed, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaRed, 96) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaGreen, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaGreen, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaGreen, 100) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaBlue, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaBlue, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaBlue, 104) |
| } |
| |
| static void test_pack_BITMAPV5HEADER(void) |
| { |
| /* BITMAPV5HEADER */ |
| TEST_TYPE_SIZE (BITMAPV5HEADER, 124) |
| TEST_TYPE_ALIGN (BITMAPV5HEADER, 4) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Size, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Size, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Size, 0) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Width, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Width, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Width, 4) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Height, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Height, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Height, 8) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Planes, 2) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Planes, 2) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Planes, 12) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5BitCount, 2) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BitCount, 2) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BitCount, 14) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Compression, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Compression, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Compression, 16) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5SizeImage, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5SizeImage, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5SizeImage, 20) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5XPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5XPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5XPelsPerMeter, 24) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5YPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5YPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5YPelsPerMeter, 28) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ClrUsed, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrUsed, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrUsed, 32) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ClrImportant, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrImportant, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrImportant, 36) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5RedMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5RedMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5RedMask, 40) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GreenMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GreenMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GreenMask, 44) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5BlueMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BlueMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BlueMask, 48) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5AlphaMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5AlphaMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5AlphaMask, 52) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5CSType, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5CSType, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5CSType, 56) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Endpoints, 36) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Endpoints, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Endpoints, 60) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaRed, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaRed, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaRed, 96) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaGreen, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaGreen, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaGreen, 100) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaBlue, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaBlue, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaBlue, 104) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Intent, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Intent, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Intent, 108) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ProfileData, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileData, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileData, 112) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ProfileSize, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileSize, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileSize, 116) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Reserved, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Reserved, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Reserved, 120) |
| } |
| |
| static void test_pack_BLENDFUNCTION(void) |
| { |
| /* BLENDFUNCTION */ |
| TEST_TYPE_SIZE (BLENDFUNCTION, 4) |
| TEST_TYPE_ALIGN (BLENDFUNCTION, 1) |
| TEST_FIELD_SIZE (BLENDFUNCTION, BlendOp, 1) |
| TEST_FIELD_ALIGN (BLENDFUNCTION, BlendOp, 1) |
| TEST_FIELD_OFFSET(BLENDFUNCTION, BlendOp, 0) |
| TEST_FIELD_SIZE (BLENDFUNCTION, BlendFlags, 1) |
| TEST_FIELD_ALIGN (BLENDFUNCTION, BlendFlags, 1) |
| TEST_FIELD_OFFSET(BLENDFUNCTION, BlendFlags, 1) |
| TEST_FIELD_SIZE (BLENDFUNCTION, SourceConstantAlpha, 1) |
| TEST_FIELD_ALIGN (BLENDFUNCTION, SourceConstantAlpha, 1) |
| TEST_FIELD_OFFSET(BLENDFUNCTION, SourceConstantAlpha, 2) |
| TEST_FIELD_SIZE (BLENDFUNCTION, AlphaFormat, 1) |
| TEST_FIELD_ALIGN (BLENDFUNCTION, AlphaFormat, 1) |
| TEST_FIELD_OFFSET(BLENDFUNCTION, AlphaFormat, 3) |
| } |
| |
| static void test_pack_CHARSETINFO(void) |
| { |
| /* CHARSETINFO */ |
| TEST_TYPE_SIZE (CHARSETINFO, 32) |
| TEST_TYPE_ALIGN (CHARSETINFO, 4) |
| TEST_FIELD_SIZE (CHARSETINFO, ciCharset, 4) |
| TEST_FIELD_ALIGN (CHARSETINFO, ciCharset, 4) |
| TEST_FIELD_OFFSET(CHARSETINFO, ciCharset, 0) |
| TEST_FIELD_SIZE (CHARSETINFO, ciACP, 4) |
| TEST_FIELD_ALIGN (CHARSETINFO, ciACP, 4) |
| TEST_FIELD_OFFSET(CHARSETINFO, ciACP, 4) |
| TEST_FIELD_SIZE (CHARSETINFO, fs, 24) |
| TEST_FIELD_ALIGN (CHARSETINFO, fs, 4) |
| TEST_FIELD_OFFSET(CHARSETINFO, fs, 8) |
| } |
| |
| static void test_pack_CIEXYZ(void) |
| { |
| /* CIEXYZ */ |
| TEST_TYPE_SIZE (CIEXYZ, 12) |
| TEST_TYPE_ALIGN (CIEXYZ, 4) |
| TEST_FIELD_SIZE (CIEXYZ, ciexyzX, 4) |
| TEST_FIELD_ALIGN (CIEXYZ, ciexyzX, 4) |
| TEST_FIELD_OFFSET(CIEXYZ, ciexyzX, 0) |
| TEST_FIELD_SIZE (CIEXYZ, ciexyzY, 4) |
| TEST_FIELD_ALIGN (CIEXYZ, ciexyzY, 4) |
| TEST_FIELD_OFFSET(CIEXYZ, ciexyzY, 4) |
| TEST_FIELD_SIZE (CIEXYZ, ciexyzZ, 4) |
| TEST_FIELD_ALIGN (CIEXYZ, ciexyzZ, 4) |
| TEST_FIELD_OFFSET(CIEXYZ, ciexyzZ, 8) |
| } |
| |
| static void test_pack_CIEXYZTRIPLE(void) |
| { |
| /* CIEXYZTRIPLE */ |
| TEST_TYPE_SIZE (CIEXYZTRIPLE, 36) |
| TEST_TYPE_ALIGN (CIEXYZTRIPLE, 4) |
| TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzRed, 12) |
| TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzRed, 4) |
| TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzRed, 0) |
| TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzGreen, 12) |
| TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzGreen, 4) |
| TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzGreen, 12) |
| TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzBlue, 12) |
| TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzBlue, 4) |
| TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzBlue, 24) |
| } |
| |
| static void test_pack_COLOR16(void) |
| { |
| /* COLOR16 */ |
| TEST_TYPE_SIZE (COLOR16, 2) |
| TEST_TYPE_ALIGN (COLOR16, 2) |
| } |
| |
| static void test_pack_COLORADJUSTMENT(void) |
| { |
| /* COLORADJUSTMENT */ |
| TEST_TYPE_SIZE (COLORADJUSTMENT, 24) |
| TEST_TYPE_ALIGN (COLORADJUSTMENT, 2) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caSize, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caSize, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caSize, 0) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caFlags, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caFlags, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caFlags, 2) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caIlluminantIndex, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caIlluminantIndex, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caIlluminantIndex, 4) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caRedGamma, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGamma, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGamma, 6) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caGreenGamma, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caGreenGamma, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caGreenGamma, 8) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caBlueGamma, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caBlueGamma, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caBlueGamma, 10) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caReferenceBlack, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceBlack, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceBlack, 12) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caReferenceWhite, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceWhite, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceWhite, 14) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caContrast, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caContrast, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caContrast, 16) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caBrightness, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caBrightness, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caBrightness, 18) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caColorfulness, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caColorfulness, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caColorfulness, 20) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caRedGreenTint, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGreenTint, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGreenTint, 22) |
| } |
| |
| static void test_pack_DEVMODEA(void) |
| { |
| /* DEVMODEA */ |
| TEST_FIELD_SIZE (DEVMODEA, dmDeviceName, 32) |
| TEST_FIELD_ALIGN (DEVMODEA, dmDeviceName, 1) |
| TEST_FIELD_OFFSET(DEVMODEA, dmDeviceName, 0) |
| TEST_FIELD_SIZE (DEVMODEA, dmSpecVersion, 2) |
| TEST_FIELD_ALIGN (DEVMODEA, dmSpecVersion, 2) |
| TEST_FIELD_OFFSET(DEVMODEA, dmSpecVersion, 32) |
| TEST_FIELD_SIZE (DEVMODEA, dmDriverVersion, 2) |
| TEST_FIELD_ALIGN (DEVMODEA, dmDriverVersion, 2) |
| TEST_FIELD_OFFSET(DEVMODEA, dmDriverVersion, 34) |
| TEST_FIELD_SIZE (DEVMODEA, dmSize, 2) |
| TEST_FIELD_ALIGN (DEVMODEA, dmSize, 2) |
| TEST_FIELD_OFFSET(DEVMODEA, dmSize, 36) |
| TEST_FIELD_SIZE (DEVMODEA, dmDriverExtra, 2) |
| TEST_FIELD_ALIGN (DEVMODEA, dmDriverExtra, 2) |
| TEST_FIELD_OFFSET(DEVMODEA, dmDriverExtra, 38) |
| TEST_FIELD_SIZE (DEVMODEA, dmFields, 4) |
| TEST_FIELD_ALIGN (DEVMODEA, dmFields, 4) |
| TEST_FIELD_OFFSET(DEVMODEA, dmFields, 40) |
| } |
| |
| static void test_pack_DEVMODEW(void) |
| { |
| /* DEVMODEW */ |
| TEST_FIELD_SIZE (DEVMODEW, dmDeviceName, 64) |
| TEST_FIELD_ALIGN (DEVMODEW, dmDeviceName, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmDeviceName, 0) |
| TEST_FIELD_SIZE (DEVMODEW, dmSpecVersion, 2) |
| TEST_FIELD_ALIGN (DEVMODEW, dmSpecVersion, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmSpecVersion, 64) |
| TEST_FIELD_SIZE (DEVMODEW, dmDriverVersion, 2) |
| TEST_FIELD_ALIGN (DEVMODEW, dmDriverVersion, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmDriverVersion, 66) |
| TEST_FIELD_SIZE (DEVMODEW, dmSize, 2) |
| TEST_FIELD_ALIGN (DEVMODEW, dmSize, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmSize, 68) |
| TEST_FIELD_SIZE (DEVMODEW, dmDriverExtra, 2) |
| TEST_FIELD_ALIGN (DEVMODEW, dmDriverExtra, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmDriverExtra, 70) |
| TEST_FIELD_SIZE (DEVMODEW, dmFields, 4) |
| TEST_FIELD_ALIGN (DEVMODEW, dmFields, 4) |
| TEST_FIELD_OFFSET(DEVMODEW, dmFields, 72) |
| } |
| |
| static void test_pack_DIBSECTION(void) |
| { |
| /* DIBSECTION */ |
| TEST_TYPE_SIZE (DIBSECTION, 104) |
| TEST_TYPE_ALIGN (DIBSECTION, 8) |
| TEST_FIELD_SIZE (DIBSECTION, dsBm, 32) |
| TEST_FIELD_ALIGN (DIBSECTION, dsBm, 8) |
| TEST_FIELD_OFFSET(DIBSECTION, dsBm, 0) |
| TEST_FIELD_SIZE (DIBSECTION, dsBmih, 40) |
| TEST_FIELD_ALIGN (DIBSECTION, dsBmih, 4) |
| TEST_FIELD_OFFSET(DIBSECTION, dsBmih, 32) |
| TEST_FIELD_SIZE (DIBSECTION, dsBitfields, 12) |
| TEST_FIELD_ALIGN (DIBSECTION, dsBitfields, 4) |
| TEST_FIELD_OFFSET(DIBSECTION, dsBitfields, 72) |
| TEST_FIELD_SIZE (DIBSECTION, dshSection, 8) |
| TEST_FIELD_ALIGN (DIBSECTION, dshSection, 8) |
| TEST_FIELD_OFFSET(DIBSECTION, dshSection, 88) |
| TEST_FIELD_SIZE (DIBSECTION, dsOffset, 4) |
| TEST_FIELD_ALIGN (DIBSECTION, dsOffset, 4) |
| TEST_FIELD_OFFSET(DIBSECTION, dsOffset, 96) |
| } |
| |
| static void test_pack_DISPLAY_DEVICEA(void) |
| { |
| /* DISPLAY_DEVICEA */ |
| TEST_TYPE_SIZE (DISPLAY_DEVICEA, 424) |
| TEST_TYPE_ALIGN (DISPLAY_DEVICEA, 4) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, cb, 4) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, cb, 4) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, cb, 0) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceName, 32) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceName, 1) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceName, 4) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceString, 128) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceString, 1) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceString, 36) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, StateFlags, 4) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, StateFlags, 4) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, StateFlags, 164) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceID, 128) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceID, 1) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceID, 168) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceKey, 128) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceKey, 1) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceKey, 296) |
| } |
| |
| static void test_pack_DISPLAY_DEVICEW(void) |
| { |
| /* DISPLAY_DEVICEW */ |
| TEST_TYPE_SIZE (DISPLAY_DEVICEW, 840) |
| TEST_TYPE_ALIGN (DISPLAY_DEVICEW, 4) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, cb, 4) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, cb, 4) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, cb, 0) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceName, 64) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceName, 2) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceName, 4) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceString, 256) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceString, 2) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceString, 68) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, StateFlags, 4) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, StateFlags, 4) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, StateFlags, 324) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceID, 256) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceID, 2) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceID, 328) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceKey, 256) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceKey, 2) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceKey, 584) |
| } |
| |
| static void test_pack_DOCINFOA(void) |
| { |
| /* DOCINFOA */ |
| TEST_TYPE_SIZE (DOCINFOA, 40) |
| TEST_TYPE_ALIGN (DOCINFOA, 8) |
| TEST_FIELD_SIZE (DOCINFOA, cbSize, 4) |
| TEST_FIELD_ALIGN (DOCINFOA, cbSize, 4) |
| TEST_FIELD_OFFSET(DOCINFOA, cbSize, 0) |
| TEST_FIELD_SIZE (DOCINFOA, lpszDocName, 8) |
| TEST_FIELD_ALIGN (DOCINFOA, lpszDocName, 8) |
| TEST_FIELD_OFFSET(DOCINFOA, lpszDocName, 8) |
| TEST_FIELD_SIZE (DOCINFOA, lpszOutput, 8) |
| TEST_FIELD_ALIGN (DOCINFOA, lpszOutput, 8) |
| TEST_FIELD_OFFSET(DOCINFOA, lpszOutput, 16) |
| TEST_FIELD_SIZE (DOCINFOA, lpszDatatype, 8) |
| TEST_FIELD_ALIGN (DOCINFOA, lpszDatatype, 8) |
| TEST_FIELD_OFFSET(DOCINFOA, lpszDatatype, 24) |
| TEST_FIELD_SIZE (DOCINFOA, fwType, 4) |
| TEST_FIELD_ALIGN (DOCINFOA, fwType, 4) |
| TEST_FIELD_OFFSET(DOCINFOA, fwType, 32) |
| } |
| |
| static void test_pack_DOCINFOW(void) |
| { |
| /* DOCINFOW */ |
| TEST_TYPE_SIZE (DOCINFOW, 40) |
| TEST_TYPE_ALIGN (DOCINFOW, 8) |
| TEST_FIELD_SIZE (DOCINFOW, cbSize, 4) |
| TEST_FIELD_ALIGN (DOCINFOW, cbSize, 4) |
| TEST_FIELD_OFFSET(DOCINFOW, cbSize, 0) |
| TEST_FIELD_SIZE (DOCINFOW, lpszDocName, 8) |
| TEST_FIELD_ALIGN (DOCINFOW, lpszDocName, 8) |
| TEST_FIELD_OFFSET(DOCINFOW, lpszDocName, 8) |
| TEST_FIELD_SIZE (DOCINFOW, lpszOutput, 8) |
| TEST_FIELD_ALIGN (DOCINFOW, lpszOutput, 8) |
| TEST_FIELD_OFFSET(DOCINFOW, lpszOutput, 16) |
| TEST_FIELD_SIZE (DOCINFOW, lpszDatatype, 8) |
| TEST_FIELD_ALIGN (DOCINFOW, lpszDatatype, 8) |
| TEST_FIELD_OFFSET(DOCINFOW, lpszDatatype, 24) |
| TEST_FIELD_SIZE (DOCINFOW, fwType, 4) |
| TEST_FIELD_ALIGN (DOCINFOW, fwType, 4) |
| TEST_FIELD_OFFSET(DOCINFOW, fwType, 32) |
| } |
| |
| static void test_pack_EMR(void) |
| { |
| /* EMR */ |
| TEST_TYPE_SIZE (EMR, 8) |
| TEST_TYPE_ALIGN (EMR, 4) |
| TEST_FIELD_SIZE (EMR, iType, 4) |
| TEST_FIELD_ALIGN (EMR, iType, 4) |
| TEST_FIELD_OFFSET(EMR, iType, 0) |
| TEST_FIELD_SIZE (EMR, nSize, 4) |
| TEST_FIELD_ALIGN (EMR, nSize, 4) |
| TEST_FIELD_OFFSET(EMR, nSize, 4) |
| } |
| |
| static void test_pack_EMRABORTPATH(void) |
| { |
| /* EMRABORTPATH */ |
| TEST_TYPE_SIZE (EMRABORTPATH, 8) |
| TEST_TYPE_ALIGN (EMRABORTPATH, 4) |
| TEST_FIELD_SIZE (EMRABORTPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRABORTPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRABORTPATH, emr, 0) |
| } |
| |
| static void test_pack_EMRANGLEARC(void) |
| { |
| /* EMRANGLEARC */ |
| TEST_TYPE_SIZE (EMRANGLEARC, 28) |
| TEST_TYPE_ALIGN (EMRANGLEARC, 4) |
| TEST_FIELD_SIZE (EMRANGLEARC, emr, 8) |
| TEST_FIELD_ALIGN (EMRANGLEARC, emr, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, emr, 0) |
| TEST_FIELD_SIZE (EMRANGLEARC, ptlCenter, 8) |
| TEST_FIELD_ALIGN (EMRANGLEARC, ptlCenter, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, ptlCenter, 8) |
| TEST_FIELD_SIZE (EMRANGLEARC, nRadius, 4) |
| TEST_FIELD_ALIGN (EMRANGLEARC, nRadius, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, nRadius, 16) |
| TEST_FIELD_SIZE (EMRANGLEARC, eStartAngle, 4) |
| TEST_FIELD_ALIGN (EMRANGLEARC, eStartAngle, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, eStartAngle, 20) |
| TEST_FIELD_SIZE (EMRANGLEARC, eSweepAngle, 4) |
| TEST_FIELD_ALIGN (EMRANGLEARC, eSweepAngle, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, eSweepAngle, 24) |
| } |
| |
| static void test_pack_EMRARC(void) |
| { |
| /* EMRARC */ |
| TEST_TYPE_SIZE (EMRARC, 40) |
| TEST_TYPE_ALIGN (EMRARC, 4) |
| TEST_FIELD_SIZE (EMRARC, emr, 8) |
| TEST_FIELD_ALIGN (EMRARC, emr, 4) |
| TEST_FIELD_OFFSET(EMRARC, emr, 0) |
| TEST_FIELD_SIZE (EMRARC, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRARC, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRARC, rclBox, 8) |
| TEST_FIELD_SIZE (EMRARC, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMRARC, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMRARC, ptlStart, 24) |
| TEST_FIELD_SIZE (EMRARC, ptlEnd, 8) |
| TEST_FIELD_ALIGN (EMRARC, ptlEnd, 4) |
| TEST_FIELD_OFFSET(EMRARC, ptlEnd, 32) |
| } |
| |
| static void test_pack_EMRARCTO(void) |
| { |
| /* EMRARCTO */ |
| TEST_TYPE_SIZE (EMRARCTO, 40) |
| TEST_TYPE_ALIGN (EMRARCTO, 4) |
| TEST_FIELD_SIZE (EMRARCTO, emr, 8) |
| TEST_FIELD_ALIGN (EMRARCTO, emr, 4) |
| TEST_FIELD_OFFSET(EMRARCTO, emr, 0) |
| TEST_FIELD_SIZE (EMRARCTO, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRARCTO, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRARCTO, rclBox, 8) |
| TEST_FIELD_SIZE (EMRARCTO, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMRARCTO, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMRARCTO, ptlStart, 24) |
| TEST_FIELD_SIZE (EMRARCTO, ptlEnd, 8) |
| TEST_FIELD_ALIGN (EMRARCTO, ptlEnd, 4) |
| TEST_FIELD_OFFSET(EMRARCTO, ptlEnd, 32) |
| } |
| |
| static void test_pack_EMRBEGINPATH(void) |
| { |
| /* EMRBEGINPATH */ |
| TEST_TYPE_SIZE (EMRBEGINPATH, 8) |
| TEST_TYPE_ALIGN (EMRBEGINPATH, 4) |
| TEST_FIELD_SIZE (EMRBEGINPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRBEGINPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRBEGINPATH, emr, 0) |
| } |
| |
| static void test_pack_EMRBITBLT(void) |
| { |
| /* EMRBITBLT */ |
| TEST_TYPE_SIZE (EMRBITBLT, 100) |
| TEST_TYPE_ALIGN (EMRBITBLT, 4) |
| TEST_FIELD_SIZE (EMRBITBLT, emr, 8) |
| TEST_FIELD_ALIGN (EMRBITBLT, emr, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, emr, 0) |
| TEST_FIELD_SIZE (EMRBITBLT, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRBITBLT, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRBITBLT, xDest, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, xDest, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, xDest, 24) |
| TEST_FIELD_SIZE (EMRBITBLT, yDest, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, yDest, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, yDest, 28) |
| TEST_FIELD_SIZE (EMRBITBLT, cxDest, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, cxDest, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, cxDest, 32) |
| TEST_FIELD_SIZE (EMRBITBLT, cyDest, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, cyDest, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, cyDest, 36) |
| TEST_FIELD_SIZE (EMRBITBLT, dwRop, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, dwRop, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, dwRop, 40) |
| TEST_FIELD_SIZE (EMRBITBLT, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, xSrc, 44) |
| TEST_FIELD_SIZE (EMRBITBLT, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, ySrc, 48) |
| TEST_FIELD_SIZE (EMRBITBLT, xformSrc, 24) |
| TEST_FIELD_ALIGN (EMRBITBLT, xformSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, xformSrc, 52) |
| TEST_FIELD_SIZE (EMRBITBLT, crBkColorSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, crBkColorSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, crBkColorSrc, 76) |
| TEST_FIELD_SIZE (EMRBITBLT, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, iUsageSrc, 80) |
| TEST_FIELD_SIZE (EMRBITBLT, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, offBmiSrc, 84) |
| TEST_FIELD_SIZE (EMRBITBLT, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, cbBmiSrc, 88) |
| TEST_FIELD_SIZE (EMRBITBLT, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, offBitsSrc, 92) |
| TEST_FIELD_SIZE (EMRBITBLT, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, cbBitsSrc, 96) |
| } |
| |
| static void test_pack_EMRCHORD(void) |
| { |
| /* EMRCHORD */ |
| TEST_TYPE_SIZE (EMRCHORD, 40) |
| TEST_TYPE_ALIGN (EMRCHORD, 4) |
| TEST_FIELD_SIZE (EMRCHORD, emr, 8) |
| TEST_FIELD_ALIGN (EMRCHORD, emr, 4) |
| TEST_FIELD_OFFSET(EMRCHORD, emr, 0) |
| TEST_FIELD_SIZE (EMRCHORD, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRCHORD, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRCHORD, rclBox, 8) |
| TEST_FIELD_SIZE (EMRCHORD, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMRCHORD, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMRCHORD, ptlStart, 24) |
| TEST_FIELD_SIZE (EMRCHORD, ptlEnd, 8) |
| TEST_FIELD_ALIGN (EMRCHORD, ptlEnd, 4) |
| TEST_FIELD_OFFSET(EMRCHORD, ptlEnd, 32) |
| } |
| |
| static void test_pack_EMRCLOSEFIGURE(void) |
| { |
| /* EMRCLOSEFIGURE */ |
| TEST_TYPE_SIZE (EMRCLOSEFIGURE, 8) |
| TEST_TYPE_ALIGN (EMRCLOSEFIGURE, 4) |
| TEST_FIELD_SIZE (EMRCLOSEFIGURE, emr, 8) |
| TEST_FIELD_ALIGN (EMRCLOSEFIGURE, emr, 4) |
| TEST_FIELD_OFFSET(EMRCLOSEFIGURE, emr, 0) |
| } |
| |
| static void test_pack_EMRCREATEBRUSHINDIRECT(void) |
| { |
| /* EMRCREATEBRUSHINDIRECT */ |
| TEST_TYPE_SIZE (EMRCREATEBRUSHINDIRECT, 24) |
| TEST_TYPE_ALIGN (EMRCREATEBRUSHINDIRECT, 4) |
| TEST_FIELD_SIZE (EMRCREATEBRUSHINDIRECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATEBRUSHINDIRECT, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, ihBrush, 8) |
| TEST_FIELD_SIZE (EMRCREATEBRUSHINDIRECT, lb, 12) |
| TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, lb, 4) |
| TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, lb, 12) |
| } |
| |
| static void test_pack_EMRCREATECOLORSPACE(void) |
| { |
| /* EMRCREATECOLORSPACE */ |
| TEST_TYPE_SIZE (EMRCREATECOLORSPACE, 340) |
| TEST_TYPE_ALIGN (EMRCREATECOLORSPACE, 4) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACE, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACE, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, ihCS, 8) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACE, lcs, 328) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, lcs, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, lcs, 12) |
| } |
| |
| static void test_pack_EMRCREATECOLORSPACEW(void) |
| { |
| /* EMRCREATECOLORSPACEW */ |
| TEST_TYPE_SIZE (EMRCREATECOLORSPACEW, 612) |
| TEST_TYPE_ALIGN (EMRCREATECOLORSPACEW, 4) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, ihCS, 8) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, lcs, 588) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, lcs, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, lcs, 12) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, dwFlags, 4) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, dwFlags, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, dwFlags, 600) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, cbData, 4) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, cbData, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, cbData, 604) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, Data, 1) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, Data, 1) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, Data, 608) |
| } |
| |
| static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void) |
| { |
| /* EMRCREATEDIBPATTERNBRUSHPT */ |
| TEST_TYPE_SIZE (EMRCREATEDIBPATTERNBRUSHPT, 32) |
| TEST_TYPE_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, 4) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 8) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, iUsage, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, iUsage, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, iUsage, 12) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, offBmi, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, offBmi, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, offBmi, 16) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 20) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, offBits, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, offBits, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, offBits, 24) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, cbBits, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, cbBits, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, cbBits, 28) |
| } |
| |
| static void test_pack_EMRCREATEMONOBRUSH(void) |
| { |
| /* EMRCREATEMONOBRUSH */ |
| TEST_TYPE_SIZE (EMRCREATEMONOBRUSH, 32) |
| TEST_TYPE_ALIGN (EMRCREATEMONOBRUSH, 4) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, ihBrush, 8) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, iUsage, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, iUsage, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, iUsage, 12) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, offBmi, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, offBmi, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, offBmi, 16) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, cbBmi, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, cbBmi, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, cbBmi, 20) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, offBits, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, offBits, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, offBits, 24) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, cbBits, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, cbBits, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, cbBits, 28) |
| } |
| |
| static void test_pack_EMRCREATEPEN(void) |
| { |
| /* EMRCREATEPEN */ |
| TEST_TYPE_SIZE (EMRCREATEPEN, 28) |
| TEST_TYPE_ALIGN (EMRCREATEPEN, 4) |
| TEST_FIELD_SIZE (EMRCREATEPEN, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATEPEN, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATEPEN, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATEPEN, ihPen, 4) |
| TEST_FIELD_ALIGN (EMRCREATEPEN, ihPen, 4) |
| TEST_FIELD_OFFSET(EMRCREATEPEN, ihPen, 8) |
| TEST_FIELD_SIZE (EMRCREATEPEN, lopn, 16) |
| TEST_FIELD_ALIGN (EMRCREATEPEN, lopn, 4) |
| TEST_FIELD_OFFSET(EMRCREATEPEN, lopn, 12) |
| } |
| |
| static void test_pack_EMRDELETECOLORSPACE(void) |
| { |
| /* EMRDELETECOLORSPACE */ |
| TEST_TYPE_SIZE (EMRDELETECOLORSPACE, 12) |
| TEST_TYPE_ALIGN (EMRDELETECOLORSPACE, 4) |
| TEST_FIELD_SIZE (EMRDELETECOLORSPACE, emr, 8) |
| TEST_FIELD_ALIGN (EMRDELETECOLORSPACE, emr, 4) |
| TEST_FIELD_OFFSET(EMRDELETECOLORSPACE, emr, 0) |
| TEST_FIELD_SIZE (EMRDELETECOLORSPACE, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRDELETECOLORSPACE, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRDELETECOLORSPACE, ihCS, 8) |
| } |
| |
| static void test_pack_EMRDELETEOBJECT(void) |
| { |
| /* EMRDELETEOBJECT */ |
| TEST_TYPE_SIZE (EMRDELETEOBJECT, 12) |
| TEST_TYPE_ALIGN (EMRDELETEOBJECT, 4) |
| TEST_FIELD_SIZE (EMRDELETEOBJECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRDELETEOBJECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRDELETEOBJECT, emr, 0) |
| TEST_FIELD_SIZE (EMRDELETEOBJECT, ihObject, 4) |
| TEST_FIELD_ALIGN (EMRDELETEOBJECT, ihObject, 4) |
| TEST_FIELD_OFFSET(EMRDELETEOBJECT, ihObject, 8) |
| } |
| |
| static void test_pack_EMRELLIPSE(void) |
| { |
| /* EMRELLIPSE */ |
| TEST_TYPE_SIZE (EMRELLIPSE, 24) |
| TEST_TYPE_ALIGN (EMRELLIPSE, 4) |
| TEST_FIELD_SIZE (EMRELLIPSE, emr, 8) |
| TEST_FIELD_ALIGN (EMRELLIPSE, emr, 4) |
| TEST_FIELD_OFFSET(EMRELLIPSE, emr, 0) |
| TEST_FIELD_SIZE (EMRELLIPSE, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRELLIPSE, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRELLIPSE, rclBox, 8) |
| } |
| |
| static void test_pack_EMRENDPATH(void) |
| { |
| /* EMRENDPATH */ |
| TEST_TYPE_SIZE (EMRENDPATH, 8) |
| TEST_TYPE_ALIGN (EMRENDPATH, 4) |
| TEST_FIELD_SIZE (EMRENDPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRENDPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRENDPATH, emr, 0) |
| } |
| |
| static void test_pack_EMREOF(void) |
| { |
| /* EMREOF */ |
| TEST_TYPE_SIZE (EMREOF, 20) |
| TEST_TYPE_ALIGN (EMREOF, 4) |
| TEST_FIELD_SIZE (EMREOF, emr, 8) |
| TEST_FIELD_ALIGN (EMREOF, emr, 4) |
| TEST_FIELD_OFFSET(EMREOF, emr, 0) |
| TEST_FIELD_SIZE (EMREOF, nPalEntries, 4) |
| TEST_FIELD_ALIGN (EMREOF, nPalEntries, 4) |
| TEST_FIELD_OFFSET(EMREOF, nPalEntries, 8) |
| TEST_FIELD_SIZE (EMREOF, offPalEntries, 4) |
| TEST_FIELD_ALIGN (EMREOF, offPalEntries, 4) |
| TEST_FIELD_OFFSET(EMREOF, offPalEntries, 12) |
| TEST_FIELD_SIZE (EMREOF, nSizeLast, 4) |
| TEST_FIELD_ALIGN (EMREOF, nSizeLast, 4) |
| TEST_FIELD_OFFSET(EMREOF, nSizeLast, 16) |
| } |
| |
| static void test_pack_EMREXCLUDECLIPRECT(void) |
| { |
| /* EMREXCLUDECLIPRECT */ |
| TEST_TYPE_SIZE (EMREXCLUDECLIPRECT, 24) |
| TEST_TYPE_ALIGN (EMREXCLUDECLIPRECT, 4) |
| TEST_FIELD_SIZE (EMREXCLUDECLIPRECT, emr, 8) |
| TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, emr, 4) |
| TEST_FIELD_OFFSET(EMREXCLUDECLIPRECT, emr, 0) |
| TEST_FIELD_SIZE (EMREXCLUDECLIPRECT, rclClip, 16) |
| TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, rclClip, 4) |
| TEST_FIELD_OFFSET(EMREXCLUDECLIPRECT, rclClip, 8) |
| } |
| |
| static void test_pack_EMREXTCREATEFONTINDIRECTW(void) |
| { |
| /* EMREXTCREATEFONTINDIRECTW */ |
| TEST_TYPE_SIZE (EMREXTCREATEFONTINDIRECTW, 332) |
| TEST_TYPE_ALIGN (EMREXTCREATEFONTINDIRECTW, 4) |
| TEST_FIELD_SIZE (EMREXTCREATEFONTINDIRECTW, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, emr, 0) |
| TEST_FIELD_SIZE (EMREXTCREATEFONTINDIRECTW, ihFont, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, ihFont, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, ihFont, 8) |
| TEST_FIELD_SIZE (EMREXTCREATEFONTINDIRECTW, elfw, 320) |
| TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, elfw, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, elfw, 12) |
| } |
| |
| static void test_pack_EMREXTCREATEPEN(void) |
| { |
| /* EMREXTCREATEPEN */ |
| TEST_TYPE_SIZE (EMREXTCREATEPEN, 64) |
| TEST_TYPE_ALIGN (EMREXTCREATEPEN, 8) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, emr, 0) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, ihPen, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, ihPen, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, ihPen, 8) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, offBmi, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBmi, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBmi, 12) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, cbBmi, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBmi, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, cbBmi, 16) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, offBits, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBits, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBits, 20) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, cbBits, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBits, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, cbBits, 24) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, elp, 32) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, elp, 8) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, elp, 32) |
| } |
| |
| static void test_pack_EMREXTFLOODFILL(void) |
| { |
| /* EMREXTFLOODFILL */ |
| TEST_TYPE_SIZE (EMREXTFLOODFILL, 24) |
| TEST_TYPE_ALIGN (EMREXTFLOODFILL, 4) |
| TEST_FIELD_SIZE (EMREXTFLOODFILL, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTFLOODFILL, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTFLOODFILL, emr, 0) |
| TEST_FIELD_SIZE (EMREXTFLOODFILL, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMREXTFLOODFILL, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMREXTFLOODFILL, ptlStart, 8) |
| TEST_FIELD_SIZE (EMREXTFLOODFILL, crColor, 4) |
| TEST_FIELD_ALIGN (EMREXTFLOODFILL, crColor, 4) |
| TEST_FIELD_OFFSET(EMREXTFLOODFILL, crColor, 16) |
| TEST_FIELD_SIZE (EMREXTFLOODFILL, iMode, 4) |
| TEST_FIELD_ALIGN (EMREXTFLOODFILL, iMode, 4) |
| TEST_FIELD_OFFSET(EMREXTFLOODFILL, iMode, 20) |
| } |
| |
| static void test_pack_EMREXTSELECTCLIPRGN(void) |
| { |
| /* EMREXTSELECTCLIPRGN */ |
| TEST_TYPE_SIZE (EMREXTSELECTCLIPRGN, 20) |
| TEST_TYPE_ALIGN (EMREXTSELECTCLIPRGN, 4) |
| TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, emr, 0) |
| TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, cbRgnData, 8) |
| TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, iMode, 4) |
| TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, iMode, 4) |
| TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, iMode, 12) |
| TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, RgnData, 16) |
| } |
| |
| static void test_pack_EMREXTTEXTOUTA(void) |
| { |
| /* EMREXTTEXTOUTA */ |
| TEST_TYPE_SIZE (EMREXTTEXTOUTA, 76) |
| TEST_TYPE_ALIGN (EMREXTTEXTOUTA, 4) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, emr, 0) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, rclBounds, 8) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, iGraphicsMode, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, iGraphicsMode, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, iGraphicsMode, 24) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, exScale, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, exScale, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, exScale, 28) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, eyScale, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, eyScale, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, eyScale, 32) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, emrtext, 40) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, emrtext, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, emrtext, 36) |
| } |
| |
| static void test_pack_EMREXTTEXTOUTW(void) |
| { |
| /* EMREXTTEXTOUTW */ |
| TEST_TYPE_SIZE (EMREXTTEXTOUTW, 76) |
| TEST_TYPE_ALIGN (EMREXTTEXTOUTW, 4) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, emr, 0) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, rclBounds, 8) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, iGraphicsMode, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, iGraphicsMode, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, iGraphicsMode, 24) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, exScale, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, exScale, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, exScale, 28) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, eyScale, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, eyScale, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, eyScale, 32) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, emrtext, 40) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, emrtext, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, emrtext, 36) |
| } |
| |
| static void test_pack_EMRFILLPATH(void) |
| { |
| /* EMRFILLPATH */ |
| TEST_TYPE_SIZE (EMRFILLPATH, 24) |
| TEST_TYPE_ALIGN (EMRFILLPATH, 4) |
| TEST_FIELD_SIZE (EMRFILLPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRFILLPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRFILLPATH, emr, 0) |
| TEST_FIELD_SIZE (EMRFILLPATH, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRFILLPATH, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRFILLPATH, rclBounds, 8) |
| } |
| |
| static void test_pack_EMRFILLRGN(void) |
| { |
| /* EMRFILLRGN */ |
| TEST_TYPE_SIZE (EMRFILLRGN, 36) |
| TEST_TYPE_ALIGN (EMRFILLRGN, 4) |
| TEST_FIELD_SIZE (EMRFILLRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRFILLRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRFILLRGN, emr, 0) |
| TEST_FIELD_SIZE (EMRFILLRGN, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRFILLRGN, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRFILLRGN, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRFILLRGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMRFILLRGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMRFILLRGN, cbRgnData, 24) |
| TEST_FIELD_SIZE (EMRFILLRGN, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRFILLRGN, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRFILLRGN, ihBrush, 28) |
| TEST_FIELD_SIZE (EMRFILLRGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMRFILLRGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMRFILLRGN, RgnData, 32) |
| } |
| |
| static void test_pack_EMRFLATTENPATH(void) |
| { |
| /* EMRFLATTENPATH */ |
| TEST_TYPE_SIZE (EMRFLATTENPATH, 8) |
| TEST_TYPE_ALIGN (EMRFLATTENPATH, 4) |
| TEST_FIELD_SIZE (EMRFLATTENPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRFLATTENPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRFLATTENPATH, emr, 0) |
| } |
| |
| static void test_pack_EMRFORMAT(void) |
| { |
| /* EMRFORMAT */ |
| TEST_TYPE_SIZE (EMRFORMAT, 16) |
| TEST_TYPE_ALIGN (EMRFORMAT, 4) |
| TEST_FIELD_SIZE (EMRFORMAT, dSignature, 4) |
| TEST_FIELD_ALIGN (EMRFORMAT, dSignature, 4) |
| TEST_FIELD_OFFSET(EMRFORMAT, dSignature, 0) |
| TEST_FIELD_SIZE (EMRFORMAT, nVersion, 4) |
| TEST_FIELD_ALIGN (EMRFORMAT, nVersion, 4) |
| TEST_FIELD_OFFSET(EMRFORMAT, nVersion, 4) |
| TEST_FIELD_SIZE (EMRFORMAT, cbData, 4) |
| TEST_FIELD_ALIGN (EMRFORMAT, cbData, 4) |
| TEST_FIELD_OFFSET(EMRFORMAT, cbData, 8) |
| TEST_FIELD_SIZE (EMRFORMAT, offData, 4) |
| TEST_FIELD_ALIGN (EMRFORMAT, offData, 4) |
| TEST_FIELD_OFFSET(EMRFORMAT, offData, 12) |
| } |
| |
| static void test_pack_EMRFRAMERGN(void) |
| { |
| /* EMRFRAMERGN */ |
| TEST_TYPE_SIZE (EMRFRAMERGN, 44) |
| TEST_TYPE_ALIGN (EMRFRAMERGN, 4) |
| TEST_FIELD_SIZE (EMRFRAMERGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, emr, 0) |
| TEST_FIELD_SIZE (EMRFRAMERGN, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRFRAMERGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, cbRgnData, 24) |
| TEST_FIELD_SIZE (EMRFRAMERGN, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, ihBrush, 28) |
| TEST_FIELD_SIZE (EMRFRAMERGN, szlStroke, 8) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, szlStroke, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, szlStroke, 32) |
| TEST_FIELD_SIZE (EMRFRAMERGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, RgnData, 40) |
| } |
| |
| static void test_pack_EMRGDICOMMENT(void) |
| { |
| /* EMRGDICOMMENT */ |
| TEST_TYPE_SIZE (EMRGDICOMMENT, 16) |
| TEST_TYPE_ALIGN (EMRGDICOMMENT, 4) |
| TEST_FIELD_SIZE (EMRGDICOMMENT, emr, 8) |
| TEST_FIELD_ALIGN (EMRGDICOMMENT, emr, 4) |
| TEST_FIELD_OFFSET(EMRGDICOMMENT, emr, 0) |
| TEST_FIELD_SIZE (EMRGDICOMMENT, cbData, 4) |
| TEST_FIELD_ALIGN (EMRGDICOMMENT, cbData, 4) |
| TEST_FIELD_OFFSET(EMRGDICOMMENT, cbData, 8) |
| TEST_FIELD_SIZE (EMRGDICOMMENT, Data, 1) |
| TEST_FIELD_ALIGN (EMRGDICOMMENT, Data, 1) |
| TEST_FIELD_OFFSET(EMRGDICOMMENT, Data, 12) |
| } |
| |
| static void test_pack_EMRGLSBOUNDEDRECORD(void) |
| { |
| /* EMRGLSBOUNDEDRECORD */ |
| TEST_TYPE_SIZE (EMRGLSBOUNDEDRECORD, 32) |
| TEST_TYPE_ALIGN (EMRGLSBOUNDEDRECORD, 4) |
| TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, emr, 8) |
| TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, emr, 4) |
| TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, emr, 0) |
| TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, cbData, 4) |
| TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, cbData, 4) |
| TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, cbData, 24) |
| TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, Data, 1) |
| TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, Data, 1) |
| TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, Data, 28) |
| } |
| |
| static void test_pack_EMRGLSRECORD(void) |
| { |
| /* EMRGLSRECORD */ |
| TEST_TYPE_SIZE (EMRGLSRECORD, 16) |
| TEST_TYPE_ALIGN (EMRGLSRECORD, 4) |
| TEST_FIELD_SIZE (EMRGLSRECORD, emr, 8) |
| TEST_FIELD_ALIGN (EMRGLSRECORD, emr, 4) |
| TEST_FIELD_OFFSET(EMRGLSRECORD, emr, 0) |
| TEST_FIELD_SIZE (EMRGLSRECORD, cbData, 4) |
| TEST_FIELD_ALIGN (EMRGLSRECORD, cbData, 4) |
| TEST_FIELD_OFFSET(EMRGLSRECORD, cbData, 8) |
| TEST_FIELD_SIZE (EMRGLSRECORD, Data, 1) |
| TEST_FIELD_ALIGN (EMRGLSRECORD, Data, 1) |
| TEST_FIELD_OFFSET(EMRGLSRECORD, Data, 12) |
| } |
| |
| static void test_pack_EMRINTERSECTCLIPRECT(void) |
| { |
| /* EMRINTERSECTCLIPRECT */ |
| TEST_TYPE_SIZE (EMRINTERSECTCLIPRECT, 24) |
| TEST_TYPE_ALIGN (EMRINTERSECTCLIPRECT, 4) |
| TEST_FIELD_SIZE (EMRINTERSECTCLIPRECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRINTERSECTCLIPRECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRINTERSECTCLIPRECT, emr, 0) |
| TEST_FIELD_SIZE (EMRINTERSECTCLIPRECT, rclClip, 16) |
| TEST_FIELD_ALIGN (EMRINTERSECTCLIPRECT, rclClip, 4) |
| TEST_FIELD_OFFSET(EMRINTERSECTCLIPRECT, rclClip, 8) |
| } |
| |
| static void test_pack_EMRINVERTRGN(void) |
| { |
| /* EMRINVERTRGN */ |
| TEST_TYPE_SIZE (EMRINVERTRGN, 32) |
| TEST_TYPE_ALIGN (EMRINVERTRGN, 4) |
| TEST_FIELD_SIZE (EMRINVERTRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRINVERTRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRINVERTRGN, emr, 0) |
| TEST_FIELD_SIZE (EMRINVERTRGN, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRINVERTRGN, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRINVERTRGN, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRINVERTRGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMRINVERTRGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMRINVERTRGN, cbRgnData, 24) |
| TEST_FIELD_SIZE (EMRINVERTRGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMRINVERTRGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMRINVERTRGN, RgnData, 28) |
| } |
| |
| static void test_pack_EMRLINETO(void) |
| { |
| /* EMRLINETO */ |
| TEST_TYPE_SIZE (EMRLINETO, 16) |
| TEST_TYPE_ALIGN (EMRLINETO, 4) |
| TEST_FIELD_SIZE (EMRLINETO, emr, 8) |
| TEST_FIELD_ALIGN (EMRLINETO, emr, 4) |
| TEST_FIELD_OFFSET(EMRLINETO, emr, 0) |
| TEST_FIELD_SIZE (EMRLINETO, ptl, 8) |
| TEST_FIELD_ALIGN (EMRLINETO, ptl, 4) |
| TEST_FIELD_OFFSET(EMRLINETO, ptl, 8) |
| } |
| |
| static void test_pack_EMRMASKBLT(void) |
| { |
| /* EMRMASKBLT */ |
| TEST_TYPE_SIZE (EMRMASKBLT, 128) |
| TEST_TYPE_ALIGN (EMRMASKBLT, 4) |
| TEST_FIELD_SIZE (EMRMASKBLT, emr, 8) |
| TEST_FIELD_ALIGN (EMRMASKBLT, emr, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, emr, 0) |
| TEST_FIELD_SIZE (EMRMASKBLT, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRMASKBLT, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRMASKBLT, xDest, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, xDest, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, xDest, 24) |
| TEST_FIELD_SIZE (EMRMASKBLT, yDest, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, yDest, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, yDest, 28) |
| TEST_FIELD_SIZE (EMRMASKBLT, cxDest, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cxDest, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cxDest, 32) |
| TEST_FIELD_SIZE (EMRMASKBLT, cyDest, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cyDest, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cyDest, 36) |
| TEST_FIELD_SIZE (EMRMASKBLT, dwRop, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, dwRop, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, dwRop, 40) |
| TEST_FIELD_SIZE (EMRMASKBLT, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, xSrc, 44) |
| TEST_FIELD_SIZE (EMRMASKBLT, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, ySrc, 48) |
| TEST_FIELD_SIZE (EMRMASKBLT, xformSrc, 24) |
| TEST_FIELD_ALIGN (EMRMASKBLT, xformSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, xformSrc, 52) |
| TEST_FIELD_SIZE (EMRMASKBLT, crBkColorSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, crBkColorSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, crBkColorSrc, 76) |
| TEST_FIELD_SIZE (EMRMASKBLT, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, iUsageSrc, 80) |
| TEST_FIELD_SIZE (EMRMASKBLT, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, offBmiSrc, 84) |
| TEST_FIELD_SIZE (EMRMASKBLT, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiSrc, 88) |
| TEST_FIELD_SIZE (EMRMASKBLT, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, offBitsSrc, 92) |
| TEST_FIELD_SIZE (EMRMASKBLT, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsSrc, 96) |
| TEST_FIELD_SIZE (EMRMASKBLT, xMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, xMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, xMask, 100) |
| TEST_FIELD_SIZE (EMRMASKBLT, yMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, yMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, yMask, 104) |
| TEST_FIELD_SIZE (EMRMASKBLT, iUsageMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, iUsageMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, iUsageMask, 108) |
| TEST_FIELD_SIZE (EMRMASKBLT, offBmiMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, offBmiMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, offBmiMask, 112) |
| TEST_FIELD_SIZE (EMRMASKBLT, cbBmiMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiMask, 116) |
| TEST_FIELD_SIZE (EMRMASKBLT, offBitsMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, offBitsMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, offBitsMask, 120) |
| TEST_FIELD_SIZE (EMRMASKBLT, cbBitsMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsMask, 124) |
| } |
| |
| static void test_pack_EMRMODIFYWORLDTRANSFORM(void) |
| { |
| /* EMRMODIFYWORLDTRANSFORM */ |
| TEST_TYPE_SIZE (EMRMODIFYWORLDTRANSFORM, 36) |
| TEST_TYPE_ALIGN (EMRMODIFYWORLDTRANSFORM, 4) |
| TEST_FIELD_SIZE (EMRMODIFYWORLDTRANSFORM, emr, 8) |
| TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, emr, 4) |
| TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, emr, 0) |
| TEST_FIELD_SIZE (EMRMODIFYWORLDTRANSFORM, xform, 24) |
| TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, xform, 4) |
| TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, xform, 8) |
| TEST_FIELD_SIZE (EMRMODIFYWORLDTRANSFORM, iMode, 4) |
| TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, iMode, 4) |
| TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, iMode, 32) |
| } |
| |
| static void test_pack_EMRMOVETOEX(void) |
| { |
| /* EMRMOVETOEX */ |
| TEST_TYPE_SIZE (EMRMOVETOEX, 16) |
| TEST_TYPE_ALIGN (EMRMOVETOEX, 4) |
| TEST_FIELD_SIZE (EMRMOVETOEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRMOVETOEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRMOVETOEX, emr, 0) |
| TEST_FIELD_SIZE (EMRMOVETOEX, ptl, 8) |
| TEST_FIELD_ALIGN (EMRMOVETOEX, ptl, 4) |
| TEST_FIELD_OFFSET(EMRMOVETOEX, ptl, 8) |
| } |
| |
| static void test_pack_EMROFFSETCLIPRGN(void) |
| { |
| /* EMROFFSETCLIPRGN */ |
| TEST_TYPE_SIZE (EMROFFSETCLIPRGN, 16) |
| TEST_TYPE_ALIGN (EMROFFSETCLIPRGN, 4) |
| TEST_FIELD_SIZE (EMROFFSETCLIPRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMROFFSETCLIPRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMROFFSETCLIPRGN, emr, 0) |
| TEST_FIELD_SIZE (EMROFFSETCLIPRGN, ptlOffset, 8) |
| TEST_FIELD_ALIGN (EMROFFSETCLIPRGN, ptlOffset, 4) |
| TEST_FIELD_OFFSET(EMROFFSETCLIPRGN, ptlOffset, 8) |
| } |
| |
| static void test_pack_EMRPAINTRGN(void) |
| { |
| /* EMRPAINTRGN */ |
| TEST_TYPE_SIZE (EMRPAINTRGN, 32) |
| TEST_TYPE_ALIGN (EMRPAINTRGN, 4) |
| TEST_FIELD_SIZE (EMRPAINTRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRPAINTRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRPAINTRGN, emr, 0) |
| TEST_FIELD_SIZE (EMRPAINTRGN, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPAINTRGN, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPAINTRGN, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPAINTRGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMRPAINTRGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMRPAINTRGN, cbRgnData, 24) |
| TEST_FIELD_SIZE (EMRPAINTRGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMRPAINTRGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMRPAINTRGN, RgnData, 28) |
| } |
| |
| static void test_pack_EMRPIE(void) |
| { |
| /* EMRPIE */ |
| TEST_TYPE_SIZE (EMRPIE, 40) |
| TEST_TYPE_ALIGN (EMRPIE, 4) |
| TEST_FIELD_SIZE (EMRPIE, emr, 8) |
| TEST_FIELD_ALIGN (EMRPIE, emr, 4) |
| TEST_FIELD_OFFSET(EMRPIE, emr, 0) |
| TEST_FIELD_SIZE (EMRPIE, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRPIE, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRPIE, rclBox, 8) |
| TEST_FIELD_SIZE (EMRPIE, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMRPIE, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMRPIE, ptlStart, 24) |
| TEST_FIELD_SIZE (EMRPIE, ptlEnd, 8) |
| TEST_FIELD_ALIGN (EMRPIE, ptlEnd, 4) |
| TEST_FIELD_OFFSET(EMRPIE, ptlEnd, 32) |
| } |
| |
| static void test_pack_EMRPIXELFORMAT(void) |
| { |
| /* EMRPIXELFORMAT */ |
| TEST_TYPE_SIZE (EMRPIXELFORMAT, 48) |
| TEST_TYPE_ALIGN (EMRPIXELFORMAT, 4) |
| TEST_FIELD_SIZE (EMRPIXELFORMAT, emr, 8) |
| TEST_FIELD_ALIGN (EMRPIXELFORMAT, emr, 4) |
| TEST_FIELD_OFFSET(EMRPIXELFORMAT, emr, 0) |
| TEST_FIELD_SIZE (EMRPIXELFORMAT, pfd, 40) |
| TEST_FIELD_ALIGN (EMRPIXELFORMAT, pfd, 4) |
| TEST_FIELD_OFFSET(EMRPIXELFORMAT, pfd, 8) |
| } |
| |
| static void test_pack_EMRPLGBLT(void) |
| { |
| /* EMRPLGBLT */ |
| TEST_TYPE_SIZE (EMRPLGBLT, 140) |
| TEST_TYPE_ALIGN (EMRPLGBLT, 4) |
| TEST_FIELD_SIZE (EMRPLGBLT, emr, 8) |
| TEST_FIELD_ALIGN (EMRPLGBLT, emr, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, emr, 0) |
| TEST_FIELD_SIZE (EMRPLGBLT, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPLGBLT, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPLGBLT, aptlDest, 24) |
| TEST_FIELD_ALIGN (EMRPLGBLT, aptlDest, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, aptlDest, 24) |
| TEST_FIELD_SIZE (EMRPLGBLT, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, xSrc, 48) |
| TEST_FIELD_SIZE (EMRPLGBLT, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, ySrc, 52) |
| TEST_FIELD_SIZE (EMRPLGBLT, cxSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cxSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cxSrc, 56) |
| TEST_FIELD_SIZE (EMRPLGBLT, cySrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cySrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cySrc, 60) |
| TEST_FIELD_SIZE (EMRPLGBLT, xformSrc, 24) |
| TEST_FIELD_ALIGN (EMRPLGBLT, xformSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, xformSrc, 64) |
| TEST_FIELD_SIZE (EMRPLGBLT, crBkColorSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, crBkColorSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, crBkColorSrc, 88) |
| TEST_FIELD_SIZE (EMRPLGBLT, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, iUsageSrc, 92) |
| TEST_FIELD_SIZE (EMRPLGBLT, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, offBmiSrc, 96) |
| TEST_FIELD_SIZE (EMRPLGBLT, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiSrc, 100) |
| TEST_FIELD_SIZE (EMRPLGBLT, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, offBitsSrc, 104) |
| TEST_FIELD_SIZE (EMRPLGBLT, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsSrc, 108) |
| TEST_FIELD_SIZE (EMRPLGBLT, xMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, xMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, xMask, 112) |
| TEST_FIELD_SIZE (EMRPLGBLT, yMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, yMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, yMask, 116) |
| TEST_FIELD_SIZE (EMRPLGBLT, iUsageMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, iUsageMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, iUsageMask, 120) |
| TEST_FIELD_SIZE (EMRPLGBLT, offBmiMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, offBmiMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, offBmiMask, 124) |
| TEST_FIELD_SIZE (EMRPLGBLT, cbBmiMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiMask, 128) |
| TEST_FIELD_SIZE (EMRPLGBLT, offBitsMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, offBitsMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, offBitsMask, 132) |
| TEST_FIELD_SIZE (EMRPLGBLT, cbBitsMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsMask, 136) |
| } |
| |
| static void test_pack_EMRPOLYBEZIER(void) |
| { |
| /* EMRPOLYBEZIER */ |
| TEST_TYPE_SIZE (EMRPOLYBEZIER, 36) |
| TEST_TYPE_ALIGN (EMRPOLYBEZIER, 4) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYBEZIER16(void) |
| { |
| /* EMRPOLYBEZIER16 */ |
| TEST_TYPE_SIZE (EMRPOLYBEZIER16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYBEZIER16, 4) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYBEZIERTO(void) |
| { |
| /* EMRPOLYBEZIERTO */ |
| TEST_TYPE_SIZE (EMRPOLYBEZIERTO, 36) |
| TEST_TYPE_ALIGN (EMRPOLYBEZIERTO, 4) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYBEZIERTO16(void) |
| { |
| /* EMRPOLYBEZIERTO16 */ |
| TEST_TYPE_SIZE (EMRPOLYBEZIERTO16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYBEZIERTO16, 4) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYDRAW(void) |
| { |
| /* EMRPOLYDRAW */ |
| TEST_TYPE_SIZE (EMRPOLYDRAW, 40) |
| TEST_TYPE_ALIGN (EMRPOLYDRAW, 4) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, aptl, 28) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, abTypes, 1) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, abTypes, 1) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, abTypes, 36) |
| } |
| |
| static void test_pack_EMRPOLYDRAW16(void) |
| { |
| /* EMRPOLYDRAW16 */ |
| TEST_TYPE_SIZE (EMRPOLYDRAW16, 36) |
| TEST_TYPE_ALIGN (EMRPOLYDRAW16, 4) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, apts, 28) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, abTypes, 1) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, abTypes, 1) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, abTypes, 32) |
| } |
| |
| static void test_pack_EMRPOLYGON(void) |
| { |
| /* EMRPOLYGON */ |
| TEST_TYPE_SIZE (EMRPOLYGON, 36) |
| TEST_TYPE_ALIGN (EMRPOLYGON, 4) |
| TEST_FIELD_SIZE (EMRPOLYGON, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYGON, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYGON, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYGON, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYGON, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYGON, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYGON, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYGON, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYGON16(void) |
| { |
| /* EMRPOLYGON16 */ |
| TEST_TYPE_SIZE (EMRPOLYGON16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYGON16, 4) |
| TEST_FIELD_SIZE (EMRPOLYGON16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYGON16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYGON16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYGON16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYGON16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYGON16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYGON16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYGON16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYGON16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYLINE(void) |
| { |
| /* EMRPOLYLINE */ |
| TEST_TYPE_SIZE (EMRPOLYLINE, 36) |
| TEST_TYPE_ALIGN (EMRPOLYLINE, 4) |
| TEST_FIELD_SIZE (EMRPOLYLINE, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINE, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYLINE, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYLINE, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYLINE, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINE, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYLINE, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINE, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYLINE16(void) |
| { |
| /* EMRPOLYLINE16 */ |
| TEST_TYPE_SIZE (EMRPOLYLINE16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYLINE16, 4) |
| TEST_FIELD_SIZE (EMRPOLYLINE16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINE16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYLINE16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYLINE16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYLINE16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINE16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYLINE16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINE16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYLINE16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYLINETO(void) |
| { |
| /* EMRPOLYLINETO */ |
| TEST_TYPE_SIZE (EMRPOLYLINETO, 36) |
| TEST_TYPE_ALIGN (EMRPOLYLINETO, 4) |
| TEST_FIELD_SIZE (EMRPOLYLINETO, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYLINETO, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYLINETO, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYLINETO, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYLINETO16(void) |
| { |
| /* EMRPOLYLINETO16 */ |
| TEST_TYPE_SIZE (EMRPOLYLINETO16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYLINETO16, 4) |
| TEST_FIELD_SIZE (EMRPOLYLINETO16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYLINETO16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYLINETO16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYLINETO16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYPOLYGON(void) |
| { |
| /* EMRPOLYPOLYGON */ |
| TEST_TYPE_SIZE (EMRPOLYPOLYGON, 44) |
| TEST_TYPE_ALIGN (EMRPOLYPOLYGON, 4) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, nPolys, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, nPolys, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, nPolys, 24) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, cptl, 28) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, aPolyCounts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aPolyCounts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, aPolyCounts, 32) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, aptl, 36) |
| } |
| |
| static void test_pack_EMRPOLYPOLYGON16(void) |
| { |
| /* EMRPOLYPOLYGON16 */ |
| TEST_TYPE_SIZE (EMRPOLYPOLYGON16, 40) |
| TEST_TYPE_ALIGN (EMRPOLYPOLYGON16, 4) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, nPolys, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, nPolys, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, nPolys, 24) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, cpts, 28) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, aPolyCounts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, aPolyCounts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, aPolyCounts, 32) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, apts, 36) |
| } |
| |
| static void test_pack_EMRPOLYPOLYLINE(void) |
| { |
| /* EMRPOLYPOLYLINE */ |
| TEST_TYPE_SIZE (EMRPOLYPOLYLINE, 44) |
| TEST_TYPE_ALIGN (EMRPOLYPOLYLINE, 4) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, nPolys, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, nPolys, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, nPolys, 24) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, cptl, 28) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, aPolyCounts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, aPolyCounts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, aPolyCounts, 32) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, aptl, 36) |
| } |
| |
| static void test_pack_EMRPOLYPOLYLINE16(void) |
| { |
| /* EMRPOLYPOLYLINE16 */ |
| TEST_TYPE_SIZE (EMRPOLYPOLYLINE16, 40) |
| TEST_TYPE_ALIGN (EMRPOLYPOLYLINE16, 4) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, nPolys, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, nPolys, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, nPolys, 24) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, cpts, 28) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, aPolyCounts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, aPolyCounts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, aPolyCounts, 32) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, apts, 36) |
| } |
| |
| static void test_pack_EMRPOLYTEXTOUTA(void) |
| { |
| /* EMRPOLYTEXTOUTA */ |
| TEST_TYPE_SIZE (EMRPOLYTEXTOUTA, 80) |
| TEST_TYPE_ALIGN (EMRPOLYTEXTOUTA, 4) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, iGraphicsMode, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, iGraphicsMode, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, iGraphicsMode, 24) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, exScale, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, exScale, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, exScale, 28) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, eyScale, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, eyScale, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, eyScale, 32) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, cStrings, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, cStrings, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, cStrings, 36) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, aemrtext, 40) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, aemrtext, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, aemrtext, 40) |
| } |
| |
| static void test_pack_EMRPOLYTEXTOUTW(void) |
| { |
| /* EMRPOLYTEXTOUTW */ |
| TEST_TYPE_SIZE (EMRPOLYTEXTOUTW, 80) |
| TEST_TYPE_ALIGN (EMRPOLYTEXTOUTW, 4) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, iGraphicsMode, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, iGraphicsMode, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, iGraphicsMode, 24) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, exScale, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, exScale, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, exScale, 28) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, eyScale, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, eyScale, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, eyScale, 32) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, cStrings, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, cStrings, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, cStrings, 36) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, aemrtext, 40) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, aemrtext, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, aemrtext, 40) |
| } |
| |
| static void test_pack_EMRREALIZEPALETTE(void) |
| { |
| /* EMRREALIZEPALETTE */ |
| TEST_TYPE_SIZE (EMRREALIZEPALETTE, 8) |
| TEST_TYPE_ALIGN (EMRREALIZEPALETTE, 4) |
| TEST_FIELD_SIZE (EMRREALIZEPALETTE, emr, 8) |
| TEST_FIELD_ALIGN (EMRREALIZEPALETTE, emr, 4) |
| TEST_FIELD_OFFSET(EMRREALIZEPALETTE, emr, 0) |
| } |
| |
| static void test_pack_EMRRECTANGLE(void) |
| { |
| /* EMRRECTANGLE */ |
| TEST_TYPE_SIZE (EMRRECTANGLE, 24) |
| TEST_TYPE_ALIGN (EMRRECTANGLE, 4) |
| TEST_FIELD_SIZE (EMRRECTANGLE, emr, 8) |
| TEST_FIELD_ALIGN (EMRRECTANGLE, emr, 4) |
| TEST_FIELD_OFFSET(EMRRECTANGLE, emr, 0) |
| TEST_FIELD_SIZE (EMRRECTANGLE, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRRECTANGLE, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRRECTANGLE, rclBox, 8) |
| } |
| |
| static void test_pack_EMRRESIZEPALETTE(void) |
| { |
| /* EMRRESIZEPALETTE */ |
| TEST_TYPE_SIZE (EMRRESIZEPALETTE, 16) |
| TEST_TYPE_ALIGN (EMRRESIZEPALETTE, 4) |
| TEST_FIELD_SIZE (EMRRESIZEPALETTE, emr, 8) |
| TEST_FIELD_ALIGN (EMRRESIZEPALETTE, emr, 4) |
| TEST_FIELD_OFFSET(EMRRESIZEPALETTE, emr, 0) |
| TEST_FIELD_SIZE (EMRRESIZEPALETTE, ihPal, 4) |
| TEST_FIELD_ALIGN (EMRRESIZEPALETTE, ihPal, 4) |
| TEST_FIELD_OFFSET(EMRRESIZEPALETTE, ihPal, 8) |
| TEST_FIELD_SIZE (EMRRESIZEPALETTE, cEntries, 4) |
| TEST_FIELD_ALIGN (EMRRESIZEPALETTE, cEntries, 4) |
| TEST_FIELD_OFFSET(EMRRESIZEPALETTE, cEntries, 12) |
| } |
| |
| static void test_pack_EMRRESTOREDC(void) |
| { |
| /* EMRRESTOREDC */ |
| TEST_TYPE_SIZE (EMRRESTOREDC, 12) |
| TEST_TYPE_ALIGN (EMRRESTOREDC, 4) |
| TEST_FIELD_SIZE (EMRRESTOREDC, emr, 8) |
| TEST_FIELD_ALIGN (EMRRESTOREDC, emr, 4) |
| TEST_FIELD_OFFSET(EMRRESTOREDC, emr, 0) |
| TEST_FIELD_SIZE (EMRRESTOREDC, iRelative, 4) |
| TEST_FIELD_ALIGN (EMRRESTOREDC, iRelative, 4) |
| TEST_FIELD_OFFSET(EMRRESTOREDC, iRelative, 8) |
| } |
| |
| static void test_pack_EMRROUNDRECT(void) |
| { |
| /* EMRROUNDRECT */ |
| TEST_TYPE_SIZE (EMRROUNDRECT, 32) |
| TEST_TYPE_ALIGN (EMRROUNDRECT, 4) |
| TEST_FIELD_SIZE (EMRROUNDRECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRROUNDRECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRROUNDRECT, emr, 0) |
| TEST_FIELD_SIZE (EMRROUNDRECT, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRROUNDRECT, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRROUNDRECT, rclBox, 8) |
| TEST_FIELD_SIZE (EMRROUNDRECT, szlCorner, 8) |
| TEST_FIELD_ALIGN (EMRROUNDRECT, szlCorner, 4) |
| TEST_FIELD_OFFSET(EMRROUNDRECT, szlCorner, 24) |
| } |
| |
| static void test_pack_EMRSAVEDC(void) |
| { |
| /* EMRSAVEDC */ |
| TEST_TYPE_SIZE (EMRSAVEDC, 8) |
| TEST_TYPE_ALIGN (EMRSAVEDC, 4) |
| TEST_FIELD_SIZE (EMRSAVEDC, emr, 8) |
| TEST_FIELD_ALIGN (EMRSAVEDC, emr, 4) |
| TEST_FIELD_OFFSET(EMRSAVEDC, emr, 0) |
| } |
| |
| static void test_pack_EMRSCALEVIEWPORTEXTEX(void) |
| { |
| /* EMRSCALEVIEWPORTEXTEX */ |
| TEST_TYPE_SIZE (EMRSCALEVIEWPORTEXTEX, 24) |
| TEST_TYPE_ALIGN (EMRSCALEVIEWPORTEXTEX, 4) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, xNum, 4) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, xNum, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, xNum, 8) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, xDenom, 4) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, xDenom, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, xDenom, 12) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, yNum, 4) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, yNum, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, yNum, 16) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, yDenom, 4) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, yDenom, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, yDenom, 20) |
| } |
| |
| static void test_pack_EMRSCALEWINDOWEXTEX(void) |
| { |
| /* EMRSCALEWINDOWEXTEX */ |
| TEST_TYPE_SIZE (EMRSCALEWINDOWEXTEX, 24) |
| TEST_TYPE_ALIGN (EMRSCALEWINDOWEXTEX, 4) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, xNum, 4) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, xNum, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, xNum, 8) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, xDenom, 4) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, xDenom, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, xDenom, 12) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, yNum, 4) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, yNum, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, yNum, 16) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, yDenom, 4) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, yDenom, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, yDenom, 20) |
| } |
| |
| static void test_pack_EMRSELECTCLIPPATH(void) |
| { |
| /* EMRSELECTCLIPPATH */ |
| TEST_TYPE_SIZE (EMRSELECTCLIPPATH, 12) |
| TEST_TYPE_ALIGN (EMRSELECTCLIPPATH, 4) |
| TEST_FIELD_SIZE (EMRSELECTCLIPPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRSELECTCLIPPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRSELECTCLIPPATH, emr, 0) |
| TEST_FIELD_SIZE (EMRSELECTCLIPPATH, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSELECTCLIPPATH, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSELECTCLIPPATH, iMode, 8) |
| } |
| |
| static void test_pack_EMRSELECTCOLORSPACE(void) |
| { |
| /* EMRSELECTCOLORSPACE */ |
| TEST_TYPE_SIZE (EMRSELECTCOLORSPACE, 12) |
| TEST_TYPE_ALIGN (EMRSELECTCOLORSPACE, 4) |
| TEST_FIELD_SIZE (EMRSELECTCOLORSPACE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSELECTCOLORSPACE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSELECTCOLORSPACE, emr, 0) |
| TEST_FIELD_SIZE (EMRSELECTCOLORSPACE, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRSELECTCOLORSPACE, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRSELECTCOLORSPACE, ihCS, 8) |
| } |
| |
| static void test_pack_EMRSELECTOBJECT(void) |
| { |
| /* EMRSELECTOBJECT */ |
| TEST_TYPE_SIZE (EMRSELECTOBJECT, 12) |
| TEST_TYPE_ALIGN (EMRSELECTOBJECT, 4) |
| TEST_FIELD_SIZE (EMRSELECTOBJECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSELECTOBJECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSELECTOBJECT, emr, 0) |
| TEST_FIELD_SIZE (EMRSELECTOBJECT, ihObject, 4) |
| TEST_FIELD_ALIGN (EMRSELECTOBJECT, ihObject, 4) |
| TEST_FIELD_OFFSET(EMRSELECTOBJECT, ihObject, 8) |
| } |
| |
| static void test_pack_EMRSELECTPALETTE(void) |
| { |
| /* EMRSELECTPALETTE */ |
| TEST_TYPE_SIZE (EMRSELECTPALETTE, 12) |
| TEST_TYPE_ALIGN (EMRSELECTPALETTE, 4) |
| TEST_FIELD_SIZE (EMRSELECTPALETTE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSELECTPALETTE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSELECTPALETTE, emr, 0) |
| TEST_FIELD_SIZE (EMRSELECTPALETTE, ihPal, 4) |
| TEST_FIELD_ALIGN (EMRSELECTPALETTE, ihPal, 4) |
| TEST_FIELD_OFFSET(EMRSELECTPALETTE, ihPal, 8) |
| } |
| |
| static void test_pack_EMRSETARCDIRECTION(void) |
| { |
| /* EMRSETARCDIRECTION */ |
| TEST_TYPE_SIZE (EMRSETARCDIRECTION, 12) |
| TEST_TYPE_ALIGN (EMRSETARCDIRECTION, 4) |
| TEST_FIELD_SIZE (EMRSETARCDIRECTION, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETARCDIRECTION, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETARCDIRECTION, emr, 0) |
| TEST_FIELD_SIZE (EMRSETARCDIRECTION, iArcDirection, 4) |
| TEST_FIELD_ALIGN (EMRSETARCDIRECTION, iArcDirection, 4) |
| TEST_FIELD_OFFSET(EMRSETARCDIRECTION, iArcDirection, 8) |
| } |
| |
| static void test_pack_EMRSETBKCOLOR(void) |
| { |
| /* EMRSETBKCOLOR */ |
| TEST_TYPE_SIZE (EMRSETBKCOLOR, 12) |
| TEST_TYPE_ALIGN (EMRSETBKCOLOR, 4) |
| TEST_FIELD_SIZE (EMRSETBKCOLOR, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETBKCOLOR, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETBKCOLOR, emr, 0) |
| TEST_FIELD_SIZE (EMRSETBKCOLOR, crColor, 4) |
| TEST_FIELD_ALIGN (EMRSETBKCOLOR, crColor, 4) |
| TEST_FIELD_OFFSET(EMRSETBKCOLOR, crColor, 8) |
| } |
| |
| static void test_pack_EMRSETBKMODE(void) |
| { |
| /* EMRSETBKMODE */ |
| TEST_TYPE_SIZE (EMRSETBKMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETBKMODE, 4) |
| TEST_FIELD_SIZE (EMRSETBKMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETBKMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETBKMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETBKMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETBKMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETBKMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETBRUSHORGEX(void) |
| { |
| /* EMRSETBRUSHORGEX */ |
| TEST_TYPE_SIZE (EMRSETBRUSHORGEX, 16) |
| TEST_TYPE_ALIGN (EMRSETBRUSHORGEX, 4) |
| TEST_FIELD_SIZE (EMRSETBRUSHORGEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETBRUSHORGEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETBRUSHORGEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETBRUSHORGEX, ptlOrigin, 8) |
| TEST_FIELD_ALIGN (EMRSETBRUSHORGEX, ptlOrigin, 4) |
| TEST_FIELD_OFFSET(EMRSETBRUSHORGEX, ptlOrigin, 8) |
| } |
| |
| static void test_pack_EMRSETCOLORADJUSTMENT(void) |
| { |
| /* EMRSETCOLORADJUSTMENT */ |
| TEST_TYPE_SIZE (EMRSETCOLORADJUSTMENT, 32) |
| TEST_TYPE_ALIGN (EMRSETCOLORADJUSTMENT, 4) |
| TEST_FIELD_SIZE (EMRSETCOLORADJUSTMENT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETCOLORADJUSTMENT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETCOLORADJUSTMENT, emr, 0) |
| TEST_FIELD_SIZE (EMRSETCOLORADJUSTMENT, ColorAdjustment, 24) |
| TEST_FIELD_ALIGN (EMRSETCOLORADJUSTMENT, ColorAdjustment, 2) |
| TEST_FIELD_OFFSET(EMRSETCOLORADJUSTMENT, ColorAdjustment, 8) |
| } |
| |
| static void test_pack_EMRSETCOLORSPACE(void) |
| { |
| /* EMRSETCOLORSPACE */ |
| TEST_TYPE_SIZE (EMRSETCOLORSPACE, 12) |
| TEST_TYPE_ALIGN (EMRSETCOLORSPACE, 4) |
| TEST_FIELD_SIZE (EMRSETCOLORSPACE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETCOLORSPACE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETCOLORSPACE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETCOLORSPACE, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRSETCOLORSPACE, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRSETCOLORSPACE, ihCS, 8) |
| } |
| |
| static void test_pack_EMRSETDIBITSTODEVICE(void) |
| { |
| /* EMRSETDIBITSTODEVICE */ |
| TEST_TYPE_SIZE (EMRSETDIBITSTODEVICE, 76) |
| TEST_TYPE_ALIGN (EMRSETDIBITSTODEVICE, 4) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, xDest, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, xDest, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, xDest, 24) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, yDest, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, yDest, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, yDest, 28) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, xSrc, 32) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, ySrc, 36) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cxSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cxSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cxSrc, 40) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cySrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cySrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cySrc, 44) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBmiSrc, 48) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cbBmiSrc, 52) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBitsSrc, 56) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cbBitsSrc, 60) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, iUsageSrc, 64) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, iStartScan, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, iStartScan, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, iStartScan, 68) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cScans, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cScans, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cScans, 72) |
| } |
| |
| static void test_pack_EMRSETICMMODE(void) |
| { |
| /* EMRSETICMMODE */ |
| TEST_TYPE_SIZE (EMRSETICMMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETICMMODE, 4) |
| TEST_FIELD_SIZE (EMRSETICMMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETICMMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETICMMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETICMMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETICMMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETICMMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETLAYOUT(void) |
| { |
| /* EMRSETLAYOUT */ |
| TEST_TYPE_SIZE (EMRSETLAYOUT, 12) |
| TEST_TYPE_ALIGN (EMRSETLAYOUT, 4) |
| TEST_FIELD_SIZE (EMRSETLAYOUT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETLAYOUT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETLAYOUT, emr, 0) |
| TEST_FIELD_SIZE (EMRSETLAYOUT, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETLAYOUT, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETLAYOUT, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETMAPMODE(void) |
| { |
| /* EMRSETMAPMODE */ |
| TEST_TYPE_SIZE (EMRSETMAPMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETMAPMODE, 4) |
| TEST_FIELD_SIZE (EMRSETMAPMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETMAPMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETMAPMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETMAPMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETMAPMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETMAPMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETMAPPERFLAGS(void) |
| { |
| /* EMRSETMAPPERFLAGS */ |
| TEST_TYPE_SIZE (EMRSETMAPPERFLAGS, 12) |
| TEST_TYPE_ALIGN (EMRSETMAPPERFLAGS, 4) |
| TEST_FIELD_SIZE (EMRSETMAPPERFLAGS, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETMAPPERFLAGS, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETMAPPERFLAGS, emr, 0) |
| TEST_FIELD_SIZE (EMRSETMAPPERFLAGS, dwFlags, 4) |
| TEST_FIELD_ALIGN (EMRSETMAPPERFLAGS, dwFlags, 4) |
| TEST_FIELD_OFFSET(EMRSETMAPPERFLAGS, dwFlags, 8) |
| } |
| |
| static void test_pack_EMRSETMETARGN(void) |
| { |
| /* EMRSETMETARGN */ |
| TEST_TYPE_SIZE (EMRSETMETARGN, 8) |
| TEST_TYPE_ALIGN (EMRSETMETARGN, 4) |
| TEST_FIELD_SIZE (EMRSETMETARGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETMETARGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETMETARGN, emr, 0) |
| } |
| |
| static void test_pack_EMRSETMITERLIMIT(void) |
| { |
| /* EMRSETMITERLIMIT */ |
| TEST_TYPE_SIZE (EMRSETMITERLIMIT, 12) |
| TEST_TYPE_ALIGN (EMRSETMITERLIMIT, 4) |
| TEST_FIELD_SIZE (EMRSETMITERLIMIT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETMITERLIMIT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETMITERLIMIT, emr, 0) |
| TEST_FIELD_SIZE (EMRSETMITERLIMIT, eMiterLimit, 4) |
| TEST_FIELD_ALIGN (EMRSETMITERLIMIT, eMiterLimit, 4) |
| TEST_FIELD_OFFSET(EMRSETMITERLIMIT, eMiterLimit, 8) |
| } |
| |
| static void test_pack_EMRSETPIXELV(void) |
| { |
| /* EMRSETPIXELV */ |
| TEST_TYPE_SIZE (EMRSETPIXELV, 20) |
| TEST_TYPE_ALIGN (EMRSETPIXELV, 4) |
| TEST_FIELD_SIZE (EMRSETPIXELV, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETPIXELV, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETPIXELV, emr, 0) |
| TEST_FIELD_SIZE (EMRSETPIXELV, ptlPixel, 8) |
| TEST_FIELD_ALIGN (EMRSETPIXELV, ptlPixel, 4) |
| TEST_FIELD_OFFSET(EMRSETPIXELV, ptlPixel, 8) |
| TEST_FIELD_SIZE (EMRSETPIXELV, crColor, 4) |
| TEST_FIELD_ALIGN (EMRSETPIXELV, crColor, 4) |
| TEST_FIELD_OFFSET(EMRSETPIXELV, crColor, 16) |
| } |
| |
| static void test_pack_EMRSETPOLYFILLMODE(void) |
| { |
| /* EMRSETPOLYFILLMODE */ |
| TEST_TYPE_SIZE (EMRSETPOLYFILLMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETPOLYFILLMODE, 4) |
| TEST_FIELD_SIZE (EMRSETPOLYFILLMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETPOLYFILLMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETPOLYFILLMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETPOLYFILLMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETPOLYFILLMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETPOLYFILLMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETROP2(void) |
| { |
| /* EMRSETROP2 */ |
| TEST_TYPE_SIZE (EMRSETROP2, 12) |
| TEST_TYPE_ALIGN (EMRSETROP2, 4) |
| TEST_FIELD_SIZE (EMRSETROP2, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETROP2, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETROP2, emr, 0) |
| TEST_FIELD_SIZE (EMRSETROP2, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETROP2, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETROP2, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETSTRETCHBLTMODE(void) |
| { |
| /* EMRSETSTRETCHBLTMODE */ |
| TEST_TYPE_SIZE (EMRSETSTRETCHBLTMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETSTRETCHBLTMODE, 4) |
| TEST_FIELD_SIZE (EMRSETSTRETCHBLTMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETSTRETCHBLTMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETSTRETCHBLTMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETSTRETCHBLTMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETSTRETCHBLTMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETSTRETCHBLTMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETTEXTALIGN(void) |
| { |
| /* EMRSETTEXTALIGN */ |
| TEST_TYPE_SIZE (EMRSETTEXTALIGN, 12) |
| TEST_TYPE_ALIGN (EMRSETTEXTALIGN, 4) |
| TEST_FIELD_SIZE (EMRSETTEXTALIGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETTEXTALIGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETTEXTALIGN, emr, 0) |
| TEST_FIELD_SIZE (EMRSETTEXTALIGN, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETTEXTALIGN, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETTEXTALIGN, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETTEXTCOLOR(void) |
| { |
| /* EMRSETTEXTCOLOR */ |
| TEST_TYPE_SIZE (EMRSETTEXTCOLOR, 12) |
| TEST_TYPE_ALIGN (EMRSETTEXTCOLOR, 4) |
| TEST_FIELD_SIZE (EMRSETTEXTCOLOR, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETTEXTCOLOR, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETTEXTCOLOR, emr, 0) |
| TEST_FIELD_SIZE (EMRSETTEXTCOLOR, crColor, 4) |
| TEST_FIELD_ALIGN (EMRSETTEXTCOLOR, crColor, 4) |
| TEST_FIELD_OFFSET(EMRSETTEXTCOLOR, crColor, 8) |
| } |
| |
| static void test_pack_EMRSETVIEWPORTEXTEX(void) |
| { |
| /* EMRSETVIEWPORTEXTEX */ |
| TEST_TYPE_SIZE (EMRSETVIEWPORTEXTEX, 16) |
| TEST_TYPE_ALIGN (EMRSETVIEWPORTEXTEX, 4) |
| TEST_FIELD_SIZE (EMRSETVIEWPORTEXTEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETVIEWPORTEXTEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETVIEWPORTEXTEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETVIEWPORTEXTEX, szlExtent, 8) |
| TEST_FIELD_ALIGN (EMRSETVIEWPORTEXTEX, szlExtent, 4) |
| TEST_FIELD_OFFSET(EMRSETVIEWPORTEXTEX, szlExtent, 8) |
| } |
| |
| static void test_pack_EMRSETVIEWPORTORGEX(void) |
| { |
| /* EMRSETVIEWPORTORGEX */ |
| TEST_TYPE_SIZE (EMRSETVIEWPORTORGEX, 16) |
| TEST_TYPE_ALIGN (EMRSETVIEWPORTORGEX, 4) |
| TEST_FIELD_SIZE (EMRSETVIEWPORTORGEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETVIEWPORTORGEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETVIEWPORTORGEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETVIEWPORTORGEX, ptlOrigin, 8) |
| TEST_FIELD_ALIGN (EMRSETVIEWPORTORGEX, ptlOrigin, 4) |
| TEST_FIELD_OFFSET(EMRSETVIEWPORTORGEX, ptlOrigin, 8) |
| } |
| |
| static void test_pack_EMRSETWINDOWEXTEX(void) |
| { |
| /* EMRSETWINDOWEXTEX */ |
| TEST_TYPE_SIZE (EMRSETWINDOWEXTEX, 16) |
| TEST_TYPE_ALIGN (EMRSETWINDOWEXTEX, 4) |
| TEST_FIELD_SIZE (EMRSETWINDOWEXTEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETWINDOWEXTEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETWINDOWEXTEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETWINDOWEXTEX, szlExtent, 8) |
| TEST_FIELD_ALIGN (EMRSETWINDOWEXTEX, szlExtent, 4) |
| TEST_FIELD_OFFSET(EMRSETWINDOWEXTEX, szlExtent, 8) |
| } |
| |
| static void test_pack_EMRSETWINDOWORGEX(void) |
| { |
| /* EMRSETWINDOWORGEX */ |
| TEST_TYPE_SIZE (EMRSETWINDOWORGEX, 16) |
| TEST_TYPE_ALIGN (EMRSETWINDOWORGEX, 4) |
| TEST_FIELD_SIZE (EMRSETWINDOWORGEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETWINDOWORGEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETWINDOWORGEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETWINDOWORGEX, ptlOrigin, 8) |
| TEST_FIELD_ALIGN (EMRSETWINDOWORGEX, ptlOrigin, 4) |
| TEST_FIELD_OFFSET(EMRSETWINDOWORGEX, ptlOrigin, 8) |
| } |
| |
| static void test_pack_EMRSETWORLDTRANSFORM(void) |
| { |
| /* EMRSETWORLDTRANSFORM */ |
| TEST_TYPE_SIZE (EMRSETWORLDTRANSFORM, 32) |
| TEST_TYPE_ALIGN (EMRSETWORLDTRANSFORM, 4) |
| TEST_FIELD_SIZE (EMRSETWORLDTRANSFORM, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETWORLDTRANSFORM, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETWORLDTRANSFORM, emr, 0) |
| TEST_FIELD_SIZE (EMRSETWORLDTRANSFORM, xform, 24) |
| TEST_FIELD_ALIGN (EMRSETWORLDTRANSFORM, xform, 4) |
| TEST_FIELD_OFFSET(EMRSETWORLDTRANSFORM, xform, 8) |
| } |
| |
| static void test_pack_EMRSTRETCHBLT(void) |
| { |
| /* EMRSTRETCHBLT */ |
| TEST_TYPE_SIZE (EMRSTRETCHBLT, 108) |
| TEST_TYPE_ALIGN (EMRSTRETCHBLT, 4) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, emr, 0) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, xDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, xDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, xDest, 24) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, yDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, yDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, yDest, 28) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cxDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxDest, 32) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cyDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cyDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cyDest, 36) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, dwRop, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, dwRop, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, dwRop, 40) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, xSrc, 44) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, ySrc, 48) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, xformSrc, 24) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, xformSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, xformSrc, 52) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, crBkColorSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, crBkColorSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, crBkColorSrc, 76) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, iUsageSrc, 80) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBmiSrc, 84) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBmiSrc, 88) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBitsSrc, 92) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBitsSrc, 96) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cxSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxSrc, 100) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cySrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cySrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cySrc, 104) |
| } |
| |
| static void test_pack_EMRSTRETCHDIBITS(void) |
| { |
| /* EMRSTRETCHDIBITS */ |
| TEST_TYPE_SIZE (EMRSTRETCHDIBITS, 80) |
| TEST_TYPE_ALIGN (EMRSTRETCHDIBITS, 4) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, emr, 8) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, emr, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, emr, 0) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, xDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, xDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, xDest, 24) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, yDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, yDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, yDest, 28) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, xSrc, 32) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, ySrc, 36) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cxSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cxSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cxSrc, 40) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cySrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cySrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cySrc, 44) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBmiSrc, 48) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBmiSrc, 52) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBitsSrc, 56) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBitsSrc, 60) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, iUsageSrc, 64) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, dwRop, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, dwRop, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, dwRop, 68) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cxDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cxDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cxDest, 72) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cyDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cyDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cyDest, 76) |
| } |
| |
| static void test_pack_EMRSTROKEANDFILLPATH(void) |
| { |
| /* EMRSTROKEANDFILLPATH */ |
| TEST_TYPE_SIZE (EMRSTROKEANDFILLPATH, 24) |
| TEST_TYPE_ALIGN (EMRSTROKEANDFILLPATH, 4) |
| TEST_FIELD_SIZE (EMRSTROKEANDFILLPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRSTROKEANDFILLPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRSTROKEANDFILLPATH, emr, 0) |
| TEST_FIELD_SIZE (EMRSTROKEANDFILLPATH, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSTROKEANDFILLPATH, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSTROKEANDFILLPATH, rclBounds, 8) |
| } |
| |
| static void test_pack_EMRSTROKEPATH(void) |
| { |
| /* EMRSTROKEPATH */ |
| TEST_TYPE_SIZE (EMRSTROKEPATH, 24) |
| TEST_TYPE_ALIGN (EMRSTROKEPATH, 4) |
| TEST_FIELD_SIZE (EMRSTROKEPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRSTROKEPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRSTROKEPATH, emr, 0) |
| TEST_FIELD_SIZE (EMRSTROKEPATH, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSTROKEPATH, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSTROKEPATH, rclBounds, 8) |
| } |
| |
| static void test_pack_EMRTEXT(void) |
| { |
| /* EMRTEXT */ |
| TEST_TYPE_SIZE (EMRTEXT, 40) |
| TEST_TYPE_ALIGN (EMRTEXT, 4) |
| TEST_FIELD_SIZE (EMRTEXT, ptlReference, 8) |
| TEST_FIELD_ALIGN (EMRTEXT, ptlReference, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, ptlReference, 0) |
| TEST_FIELD_SIZE (EMRTEXT, nChars, 4) |
| TEST_FIELD_ALIGN (EMRTEXT, nChars, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, nChars, 8) |
| TEST_FIELD_SIZE (EMRTEXT, offString, 4) |
| TEST_FIELD_ALIGN (EMRTEXT, offString, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, offString, 12) |
| TEST_FIELD_SIZE (EMRTEXT, fOptions, 4) |
| TEST_FIELD_ALIGN (EMRTEXT, fOptions, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, fOptions, 16) |
| TEST_FIELD_SIZE (EMRTEXT, rcl, 16) |
| TEST_FIELD_ALIGN (EMRTEXT, rcl, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, rcl, 20) |
| TEST_FIELD_SIZE (EMRTEXT, offDx, 4) |
| TEST_FIELD_ALIGN (EMRTEXT, offDx, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, offDx, 36) |
| } |
| |
| static void test_pack_EMRWIDENPATH(void) |
| { |
| /* EMRWIDENPATH */ |
| TEST_TYPE_SIZE (EMRWIDENPATH, 8) |
| TEST_TYPE_ALIGN (EMRWIDENPATH, 4) |
| TEST_FIELD_SIZE (EMRWIDENPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRWIDENPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRWIDENPATH, emr, 0) |
| } |
| |
| static void test_pack_ENHMETAHEADER(void) |
| { |
| /* ENHMETAHEADER */ |
| TEST_TYPE_SIZE (ENHMETAHEADER, 108) |
| TEST_TYPE_ALIGN (ENHMETAHEADER, 4) |
| TEST_FIELD_SIZE (ENHMETAHEADER, iType, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, iType, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, iType, 0) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nSize, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nSize, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nSize, 4) |
| TEST_FIELD_SIZE (ENHMETAHEADER, rclBounds, 16) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, rclBounds, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, rclBounds, 8) |
| TEST_FIELD_SIZE (ENHMETAHEADER, rclFrame, 16) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, rclFrame, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, rclFrame, 24) |
| TEST_FIELD_SIZE (ENHMETAHEADER, dSignature, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, dSignature, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, dSignature, 40) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nVersion, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nVersion, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nVersion, 44) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nBytes, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nBytes, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nBytes, 48) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nRecords, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nRecords, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nRecords, 52) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nHandles, 2) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nHandles, 2) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nHandles, 56) |
| TEST_FIELD_SIZE (ENHMETAHEADER, sReserved, 2) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, sReserved, 2) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, sReserved, 58) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nDescription, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nDescription, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nDescription, 60) |
| TEST_FIELD_SIZE (ENHMETAHEADER, offDescription, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, offDescription, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, offDescription, 64) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nPalEntries, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nPalEntries, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nPalEntries, 68) |
| TEST_FIELD_SIZE (ENHMETAHEADER, szlDevice, 8) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, szlDevice, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, szlDevice, 72) |
| TEST_FIELD_SIZE (ENHMETAHEADER, szlMillimeters, 8) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, szlMillimeters, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, szlMillimeters, 80) |
| TEST_FIELD_SIZE (ENHMETAHEADER, cbPixelFormat, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, cbPixelFormat, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, cbPixelFormat, 88) |
| TEST_FIELD_SIZE (ENHMETAHEADER, offPixelFormat, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, offPixelFormat, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, offPixelFormat, 92) |
| TEST_FIELD_SIZE (ENHMETAHEADER, bOpenGL, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, bOpenGL, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, bOpenGL, 96) |
| TEST_FIELD_SIZE (ENHMETAHEADER, szlMicrometers, 8) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, szlMicrometers, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, szlMicrometers, 100) |
| } |
| |
| static void test_pack_ENHMETARECORD(void) |
| { |
| /* ENHMETARECORD */ |
| TEST_TYPE_SIZE (ENHMETARECORD, 12) |
| TEST_TYPE_ALIGN (ENHMETARECORD, 4) |
| TEST_FIELD_SIZE (ENHMETARECORD, iType, 4) |
| TEST_FIELD_ALIGN (ENHMETARECORD, iType, 4) |
| TEST_FIELD_OFFSET(ENHMETARECORD, iType, 0) |
| TEST_FIELD_SIZE (ENHMETARECORD, nSize, 4) |
| TEST_FIELD_ALIGN (ENHMETARECORD, nSize, 4) |
| TEST_FIELD_OFFSET(ENHMETARECORD, nSize, 4) |
| TEST_FIELD_SIZE (ENHMETARECORD, dParm, 4) |
| TEST_FIELD_ALIGN (ENHMETARECORD, dParm, 4) |
| TEST_FIELD_OFFSET(ENHMETARECORD, dParm, 8) |
| } |
| |
| static void test_pack_ENHMFENUMPROC(void) |
| { |
| /* ENHMFENUMPROC */ |
| TEST_TYPE_SIZE (ENHMFENUMPROC, 8) |
| TEST_TYPE_ALIGN (ENHMFENUMPROC, 8) |
| } |
| |
| static void test_pack_ENUMLOGFONTA(void) |
| { |
| /* ENUMLOGFONTA */ |
| TEST_TYPE_SIZE (ENUMLOGFONTA, 156) |
| TEST_TYPE_ALIGN (ENUMLOGFONTA, 4) |
| TEST_FIELD_SIZE (ENUMLOGFONTA, elfLogFont, 60) |
| TEST_FIELD_ALIGN (ENUMLOGFONTA, elfLogFont, 4) |
| TEST_FIELD_OFFSET(ENUMLOGFONTA, elfLogFont, 0) |
| TEST_FIELD_SIZE (ENUMLOGFONTA, elfFullName, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTA, elfFullName, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTA, elfFullName, 60) |
| TEST_FIELD_SIZE (ENUMLOGFONTA, elfStyle, 32) |
| TEST_FIELD_ALIGN (ENUMLOGFONTA, elfStyle, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTA, elfStyle, 124) |
| } |
| |
| static void test_pack_ENUMLOGFONTEXA(void) |
| { |
| /* ENUMLOGFONTEXA */ |
| TEST_TYPE_SIZE (ENUMLOGFONTEXA, 188) |
| TEST_TYPE_ALIGN (ENUMLOGFONTEXA, 4) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfLogFont, 60) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfLogFont, 4) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfLogFont, 0) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfFullName, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfFullName, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfFullName, 60) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfStyle, 32) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfStyle, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfStyle, 124) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfScript, 32) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfScript, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfScript, 156) |
| } |
| |
| static void test_pack_ENUMLOGFONTEXW(void) |
| { |
| /* ENUMLOGFONTEXW */ |
| TEST_TYPE_SIZE (ENUMLOGFONTEXW, 348) |
| TEST_TYPE_ALIGN (ENUMLOGFONTEXW, 4) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfLogFont, 92) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfLogFont, 4) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfLogFont, 0) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfFullName, 128) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfFullName, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfFullName, 92) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfStyle, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfStyle, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfStyle, 220) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfScript, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfScript, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfScript, 284) |
| } |
| |
| static void test_pack_ENUMLOGFONTW(void) |
| { |
| /* ENUMLOGFONTW */ |
| TEST_TYPE_SIZE (ENUMLOGFONTW, 284) |
| TEST_TYPE_ALIGN (ENUMLOGFONTW, 4) |
| TEST_FIELD_SIZE (ENUMLOGFONTW, elfLogFont, 92) |
| TEST_FIELD_ALIGN (ENUMLOGFONTW, elfLogFont, 4) |
| TEST_FIELD_OFFSET(ENUMLOGFONTW, elfLogFont, 0) |
| TEST_FIELD_SIZE (ENUMLOGFONTW, elfFullName, 128) |
| TEST_FIELD_ALIGN (ENUMLOGFONTW, elfFullName, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTW, elfFullName, 92) |
| TEST_FIELD_SIZE (ENUMLOGFONTW, elfStyle, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTW, elfStyle, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTW, elfStyle, 220) |
| } |
| |
| static void test_pack_EXTLOGFONTA(void) |
| { |
| /* EXTLOGFONTA */ |
| TEST_TYPE_SIZE (EXTLOGFONTA, 192) |
| TEST_TYPE_ALIGN (EXTLOGFONTA, 4) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfLogFont, 60) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfLogFont, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfLogFont, 0) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfFullName, 64) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfFullName, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfFullName, 60) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfStyle, 32) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfStyle, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfStyle, 124) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfVersion, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfVersion, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfVersion, 156) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfStyleSize, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfStyleSize, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfStyleSize, 160) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfMatch, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfMatch, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfMatch, 164) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfReserved, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfReserved, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfReserved, 168) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfVendorId, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfVendorId, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfVendorId, 172) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfCulture, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfCulture, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfCulture, 176) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfPanose, 10) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfPanose, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfPanose, 180) |
| } |
| |
| static void test_pack_EXTLOGFONTW(void) |
| { |
| /* EXTLOGFONTW */ |
| TEST_TYPE_SIZE (EXTLOGFONTW, 320) |
| TEST_TYPE_ALIGN (EXTLOGFONTW, 4) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfLogFont, 92) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfLogFont, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfLogFont, 0) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfFullName, 128) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfFullName, 2) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfFullName, 92) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfStyle, 64) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfStyle, 2) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfStyle, 220) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfVersion, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfVersion, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfVersion, 284) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfStyleSize, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfStyleSize, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfStyleSize, 288) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfMatch, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfMatch, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfMatch, 292) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfReserved, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfReserved, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfReserved, 296) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfVendorId, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfVendorId, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfVendorId, 300) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfCulture, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfCulture, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfCulture, 304) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfPanose, 10) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfPanose, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfPanose, 308) |
| } |
| |
| static void test_pack_EXTLOGPEN(void) |
| { |
| /* EXTLOGPEN */ |
| TEST_TYPE_SIZE (EXTLOGPEN, 32) |
| TEST_TYPE_ALIGN (EXTLOGPEN, 8) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpPenStyle, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpPenStyle, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpPenStyle, 0) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpWidth, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpWidth, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpWidth, 4) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpBrushStyle, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpBrushStyle, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpBrushStyle, 8) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpColor, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpColor, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpColor, 12) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpHatch, 8) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpHatch, 8) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpHatch, 16) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpNumEntries, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpNumEntries, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpNumEntries, 24) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpStyleEntry, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpStyleEntry, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpStyleEntry, 28) |
| } |
| |
| static void test_pack_FIXED(void) |
| { |
| /* FIXED */ |
| TEST_TYPE_SIZE (FIXED, 4) |
| TEST_TYPE_ALIGN (FIXED, 2) |
| TEST_FIELD_SIZE (FIXED, fract, 2) |
| TEST_FIELD_ALIGN (FIXED, fract, 2) |
| TEST_FIELD_OFFSET(FIXED, fract, 0) |
| TEST_FIELD_SIZE (FIXED, value, 2) |
| TEST_FIELD_ALIGN (FIXED, value, 2) |
| TEST_FIELD_OFFSET(FIXED, value, 2) |
| } |
| |
| static void test_pack_FONTENUMPROCA(void) |
| { |
| /* FONTENUMPROCA */ |
| TEST_TYPE_SIZE (FONTENUMPROCA, 8) |
| TEST_TYPE_ALIGN (FONTENUMPROCA, 8) |
| } |
| |
| static void test_pack_FONTENUMPROCW(void) |
| { |
| /* FONTENUMPROCW */ |
| TEST_TYPE_SIZE (FONTENUMPROCW, 8) |
| TEST_TYPE_ALIGN (FONTENUMPROCW, 8) |
| } |
| |
| static void test_pack_FONTSIGNATURE(void) |
| { |
| /* FONTSIGNATURE */ |
| TEST_TYPE_SIZE (FONTSIGNATURE, 24) |
| TEST_TYPE_ALIGN (FONTSIGNATURE, 4) |
| TEST_FIELD_SIZE (FONTSIGNATURE, fsUsb, 16) |
| TEST_FIELD_ALIGN (FONTSIGNATURE, fsUsb, 4) |
| TEST_FIELD_OFFSET(FONTSIGNATURE, fsUsb, 0) |
| TEST_FIELD_SIZE (FONTSIGNATURE, fsCsb, 8) |
| TEST_FIELD_ALIGN (FONTSIGNATURE, fsCsb, 4) |
| TEST_FIELD_OFFSET(FONTSIGNATURE, fsCsb, 16) |
| } |
| |
| static void test_pack_FXPT16DOT16(void) |
| { |
| /* FXPT16DOT16 */ |
| TEST_TYPE_SIZE (FXPT16DOT16, 4) |
| TEST_TYPE_ALIGN (FXPT16DOT16, 4) |
| } |
| |
| static void test_pack_FXPT2DOT30(void) |
| { |
| /* FXPT2DOT30 */ |
| TEST_TYPE_SIZE (FXPT2DOT30, 4) |
| TEST_TYPE_ALIGN (FXPT2DOT30, 4) |
| } |
| |
| static void test_pack_GCP_RESULTSA(void) |
| { |
| /* GCP_RESULTSA */ |
| TEST_TYPE_SIZE (GCP_RESULTSA, 64) |
| TEST_TYPE_ALIGN (GCP_RESULTSA, 8) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lStructSize, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lStructSize, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lStructSize, 0) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpOutString, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpOutString, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpOutString, 8) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpOrder, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpOrder, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpOrder, 16) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpDx, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpDx, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpDx, 24) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpCaretPos, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpCaretPos, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpCaretPos, 32) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpClass, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpClass, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpClass, 40) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpGlyphs, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpGlyphs, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpGlyphs, 48) |
| TEST_FIELD_SIZE (GCP_RESULTSA, nGlyphs, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, nGlyphs, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, nGlyphs, 56) |
| TEST_FIELD_SIZE (GCP_RESULTSA, nMaxFit, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, nMaxFit, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, nMaxFit, 60) |
| } |
| |
| static void test_pack_GCP_RESULTSW(void) |
| { |
| /* GCP_RESULTSW */ |
| TEST_TYPE_SIZE (GCP_RESULTSW, 64) |
| TEST_TYPE_ALIGN (GCP_RESULTSW, 8) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lStructSize, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lStructSize, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lStructSize, 0) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpOutString, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpOutString, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpOutString, 8) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpOrder, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpOrder, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpOrder, 16) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpDx, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpDx, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpDx, 24) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpCaretPos, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpCaretPos, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpCaretPos, 32) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpClass, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpClass, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpClass, 40) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpGlyphs, 8) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpGlyphs, 8) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpGlyphs, 48) |
| TEST_FIELD_SIZE (GCP_RESULTSW, nGlyphs, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, nGlyphs, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, nGlyphs, 56) |
| TEST_FIELD_SIZE (GCP_RESULTSW, nMaxFit, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, nMaxFit, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, nMaxFit, 60) |
| } |
| |
| static void test_pack_GLYPHMETRICS(void) |
| { |
| /* GLYPHMETRICS */ |
| TEST_TYPE_SIZE (GLYPHMETRICS, 20) |
| TEST_TYPE_ALIGN (GLYPHMETRICS, 4) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmBlackBoxX, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmBlackBoxX, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmBlackBoxX, 0) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmBlackBoxY, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmBlackBoxY, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmBlackBoxY, 4) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmptGlyphOrigin, 8) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmptGlyphOrigin, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmptGlyphOrigin, 8) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmCellIncX, 2) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmCellIncX, 2) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmCellIncX, 16) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmCellIncY, 2) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmCellIncY, 2) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmCellIncY, 18) |
| } |
| |
| static void test_pack_GLYPHMETRICSFLOAT(void) |
| { |
| /* GLYPHMETRICSFLOAT */ |
| TEST_TYPE_SIZE (GLYPHMETRICSFLOAT, 24) |
| TEST_TYPE_ALIGN (GLYPHMETRICSFLOAT, 4) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfBlackBoxX, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfBlackBoxX, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfBlackBoxX, 0) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfBlackBoxY, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfBlackBoxY, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfBlackBoxY, 4) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 8) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 8) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfCellIncX, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfCellIncX, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfCellIncX, 16) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfCellIncY, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfCellIncY, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfCellIncY, 20) |
| } |
| |
| static void test_pack_GOBJENUMPROC(void) |
| { |
| /* GOBJENUMPROC */ |
| TEST_TYPE_SIZE (GOBJENUMPROC, 8) |
| TEST_TYPE_ALIGN (GOBJENUMPROC, 8) |
| } |
| |
| static void test_pack_GRADIENT_RECT(void) |
| { |
| /* GRADIENT_RECT */ |
| TEST_TYPE_SIZE (GRADIENT_RECT, 8) |
| TEST_TYPE_ALIGN (GRADIENT_RECT, 4) |
| TEST_FIELD_SIZE (GRADIENT_RECT, UpperLeft, 4) |
| TEST_FIELD_ALIGN (GRADIENT_RECT, UpperLeft, 4) |
| TEST_FIELD_OFFSET(GRADIENT_RECT, UpperLeft, 0) |
| TEST_FIELD_SIZE (GRADIENT_RECT, LowerRight, 4) |
| TEST_FIELD_ALIGN (GRADIENT_RECT, LowerRight, 4) |
| TEST_FIELD_OFFSET(GRADIENT_RECT, LowerRight, 4) |
| } |
| |
| static void test_pack_GRADIENT_TRIANGLE(void) |
| { |
| /* GRADIENT_TRIANGLE */ |
| TEST_TYPE_SIZE (GRADIENT_TRIANGLE, 12) |
| TEST_TYPE_ALIGN (GRADIENT_TRIANGLE, 4) |
| TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex1, 4) |
| TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex1, 4) |
| TEST_FIELD_OFFSET(GRADIENT_TRIANGLE, Vertex1, 0) |
| TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex2, 4) |
| TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex2, 4) |
| TEST_FIELD_OFFSET(GRADIENT_TRIANGLE, Vertex2, 4) |
| TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex3, 4) |
| TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex3, 4) |
| TEST_FIELD_OFFSET(GRADIENT_TRIANGLE, Vertex3, 8) |
| } |
| |
| static void test_pack_HANDLETABLE(void) |
| { |
| /* HANDLETABLE */ |
| TEST_TYPE_SIZE (HANDLETABLE, 8) |
| TEST_TYPE_ALIGN (HANDLETABLE, 8) |
| TEST_FIELD_SIZE (HANDLETABLE, objectHandle, 8) |
| TEST_FIELD_ALIGN (HANDLETABLE, objectHandle, 8) |
| TEST_FIELD_OFFSET(HANDLETABLE, objectHandle, 0) |
| } |
| |
| static void test_pack_ICMENUMPROCA(void) |
| { |
| /* ICMENUMPROCA */ |
| TEST_TYPE_SIZE (ICMENUMPROCA, 8) |
| TEST_TYPE_ALIGN (ICMENUMPROCA, 8) |
| } |
| |
| static void test_pack_ICMENUMPROCW(void) |
| { |
| /* ICMENUMPROCW */ |
| TEST_TYPE_SIZE (ICMENUMPROCW, 8) |
| TEST_TYPE_ALIGN (ICMENUMPROCW, 8) |
| } |
| |
| static void test_pack_KERNINGPAIR(void) |
| { |
| /* KERNINGPAIR */ |
| TEST_TYPE_SIZE (KERNINGPAIR, 8) |
| TEST_TYPE_ALIGN (KERNINGPAIR, 4) |
| TEST_FIELD_SIZE (KERNINGPAIR, wFirst, 2) |
| TEST_FIELD_ALIGN (KERNINGPAIR, wFirst, 2) |
| TEST_FIELD_OFFSET(KERNINGPAIR, wFirst, 0) |
| TEST_FIELD_SIZE (KERNINGPAIR, wSecond, 2) |
| TEST_FIELD_ALIGN (KERNINGPAIR, wSecond, 2) |
| TEST_FIELD_OFFSET(KERNINGPAIR, wSecond, 2) |
| TEST_FIELD_SIZE (KERNINGPAIR, iKernAmount, 4) |
| TEST_FIELD_ALIGN (KERNINGPAIR, iKernAmount, 4) |
| TEST_FIELD_OFFSET(KERNINGPAIR, iKernAmount, 4) |
| } |
| |
| static void test_pack_LAYERPLANEDESCRIPTOR(void) |
| { |
| /* LAYERPLANEDESCRIPTOR */ |
| TEST_TYPE_SIZE (LAYERPLANEDESCRIPTOR, 32) |
| TEST_TYPE_ALIGN (LAYERPLANEDESCRIPTOR, 4) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, nSize, 2) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, nSize, 2) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, nSize, 0) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, iPixelType, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, iPixelType, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, iPixelType, 8) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cColorBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cColorBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cColorBits, 9) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cRedBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cRedBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cRedBits, 10) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cRedShift, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cRedShift, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cRedShift, 11) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cGreenBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cGreenBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cGreenBits, 12) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cGreenShift, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cGreenShift, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cGreenShift, 13) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cBlueBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cBlueBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cBlueBits, 14) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cBlueShift, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cBlueShift, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cBlueShift, 15) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAlphaBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAlphaBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAlphaBits, 16) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAlphaShift, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAlphaShift, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAlphaShift, 17) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumBits, 18) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumRedBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumRedBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumRedBits, 19) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumGreenBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumGreenBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumGreenBits, 20) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumBlueBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumBlueBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumBlueBits, 21) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 22) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cDepthBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cDepthBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cDepthBits, 23) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cStencilBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cStencilBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cStencilBits, 24) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAuxBuffers, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAuxBuffers, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAuxBuffers, 25) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, iLayerPlane, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, iLayerPlane, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, iLayerPlane, 26) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, bReserved, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, bReserved, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, bReserved, 27) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, crTransparent, 4) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, crTransparent, 4) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, crTransparent, 28) |
| } |
| |
| static void test_pack_LCSCSTYPE(void) |
| { |
| /* LCSCSTYPE */ |
| TEST_TYPE_SIZE (LCSCSTYPE, 4) |
| TEST_TYPE_ALIGN (LCSCSTYPE, 4) |
| } |
| |
| static void test_pack_LCSGAMUTMATCH(void) |
| { |
| /* LCSGAMUTMATCH */ |
| TEST_TYPE_SIZE (LCSGAMUTMATCH, 4) |
| TEST_TYPE_ALIGN (LCSGAMUTMATCH, 4) |
| } |
| |
| static void test_pack_LINEDDAPROC(void) |
| { |
| /* LINEDDAPROC */ |
| TEST_TYPE_SIZE (LINEDDAPROC, 8) |
| TEST_TYPE_ALIGN (LINEDDAPROC, 8) |
| } |
| |
| static void test_pack_LOCALESIGNATURE(void) |
| { |
| /* LOCALESIGNATURE */ |
| TEST_TYPE_SIZE (LOCALESIGNATURE, 32) |
| TEST_TYPE_ALIGN (LOCALESIGNATURE, 4) |
| TEST_FIELD_SIZE (LOCALESIGNATURE, lsUsb, 16) |
| TEST_FIELD_ALIGN (LOCALESIGNATURE, lsUsb, 4) |
| TEST_FIELD_OFFSET(LOCALESIGNATURE, lsUsb, 0) |
| TEST_FIELD_SIZE (LOCALESIGNATURE, lsCsbDefault, 8) |
| TEST_FIELD_ALIGN (LOCALESIGNATURE, lsCsbDefault, 4) |
| TEST_FIELD_OFFSET(LOCALESIGNATURE, lsCsbDefault, 16) |
| TEST_FIELD_SIZE (LOCALESIGNATURE, lsCsbSupported, 8) |
| TEST_FIELD_ALIGN (LOCALESIGNATURE, lsCsbSupported, 4) |
| TEST_FIELD_OFFSET(LOCALESIGNATURE, lsCsbSupported, 24) |
| } |
| |
| static void test_pack_LOGBRUSH(void) |
| { |
| /* LOGBRUSH */ |
| TEST_TYPE_SIZE (LOGBRUSH, 16) |
| TEST_TYPE_ALIGN (LOGBRUSH, 8) |
| TEST_FIELD_SIZE (LOGBRUSH, lbStyle, 4) |
| TEST_FIELD_ALIGN (LOGBRUSH, lbStyle, 4) |
| TEST_FIELD_OFFSET(LOGBRUSH, lbStyle, 0) |
| TEST_FIELD_SIZE (LOGBRUSH, lbColor, 4) |
| TEST_FIELD_ALIGN (LOGBRUSH, lbColor, 4) |
| TEST_FIELD_OFFSET(LOGBRUSH, lbColor, 4) |
| TEST_FIELD_SIZE (LOGBRUSH, lbHatch, 8) |
| TEST_FIELD_ALIGN (LOGBRUSH, lbHatch, 8) |
| TEST_FIELD_OFFSET(LOGBRUSH, lbHatch, 8) |
| } |
| |
| static void test_pack_LOGCOLORSPACEA(void) |
| { |
| /* LOGCOLORSPACEA */ |
| TEST_TYPE_SIZE (LOGCOLORSPACEA, 328) |
| TEST_TYPE_ALIGN (LOGCOLORSPACEA, 4) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsSignature, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsSignature, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsSignature, 0) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsVersion, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsVersion, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsVersion, 4) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsSize, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsSize, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsSize, 8) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsCSType, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsCSType, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsCSType, 12) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsIntent, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsIntent, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsIntent, 16) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsEndpoints, 36) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsEndpoints, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsEndpoints, 20) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaRed, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaRed, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaRed, 56) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaGreen, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaGreen, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaGreen, 60) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaBlue, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaBlue, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaBlue, 64) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsFilename, 260) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsFilename, 1) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsFilename, 68) |
| } |
| |
| static void test_pack_LOGCOLORSPACEW(void) |
| { |
| /* LOGCOLORSPACEW */ |
| TEST_TYPE_SIZE (LOGCOLORSPACEW, 588) |
| TEST_TYPE_ALIGN (LOGCOLORSPACEW, 4) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsSignature, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsSignature, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsSignature, 0) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsVersion, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsVersion, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsVersion, 4) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsSize, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsSize, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsSize, 8) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsCSType, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsCSType, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsCSType, 12) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsIntent, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsIntent, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsIntent, 16) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsEndpoints, 36) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsEndpoints, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsEndpoints, 20) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaRed, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaRed, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaRed, 56) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaGreen, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaGreen, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaGreen, 60) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaBlue, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaBlue, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaBlue, 64) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsFilename, 520) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsFilename, 2) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsFilename, 68) |
| } |
| |
| static void test_pack_LOGFONTA(void) |
| { |
| /* LOGFONTA */ |
| TEST_TYPE_SIZE (LOGFONTA, 60) |
| TEST_TYPE_ALIGN (LOGFONTA, 4) |
| TEST_FIELD_SIZE (LOGFONTA, lfHeight, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfHeight, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfHeight, 0) |
| TEST_FIELD_SIZE (LOGFONTA, lfWidth, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfWidth, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfWidth, 4) |
| TEST_FIELD_SIZE (LOGFONTA, lfEscapement, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfEscapement, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfEscapement, 8) |
| TEST_FIELD_SIZE (LOGFONTA, lfOrientation, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfOrientation, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfOrientation, 12) |
| TEST_FIELD_SIZE (LOGFONTA, lfWeight, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfWeight, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfWeight, 16) |
| TEST_FIELD_SIZE (LOGFONTA, lfItalic, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfItalic, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfItalic, 20) |
| TEST_FIELD_SIZE (LOGFONTA, lfUnderline, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfUnderline, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfUnderline, 21) |
| TEST_FIELD_SIZE (LOGFONTA, lfStrikeOut, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfStrikeOut, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfStrikeOut, 22) |
| TEST_FIELD_SIZE (LOGFONTA, lfCharSet, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfCharSet, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfCharSet, 23) |
| TEST_FIELD_SIZE (LOGFONTA, lfOutPrecision, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfOutPrecision, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfOutPrecision, 24) |
| TEST_FIELD_SIZE (LOGFONTA, lfClipPrecision, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfClipPrecision, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfClipPrecision, 25) |
| TEST_FIELD_SIZE (LOGFONTA, lfQuality, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfQuality, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfQuality, 26) |
| TEST_FIELD_SIZE (LOGFONTA, lfPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfPitchAndFamily, 27) |
| TEST_FIELD_SIZE (LOGFONTA, lfFaceName, 32) |
| TEST_FIELD_ALIGN (LOGFONTA, lfFaceName, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfFaceName, 28) |
| } |
| |
| static void test_pack_LOGFONTW(void) |
| { |
| /* LOGFONTW */ |
| TEST_TYPE_SIZE (LOGFONTW, 92) |
| TEST_TYPE_ALIGN (LOGFONTW, 4) |
| TEST_FIELD_SIZE (LOGFONTW, lfHeight, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfHeight, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfHeight, 0) |
| TEST_FIELD_SIZE (LOGFONTW, lfWidth, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfWidth, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfWidth, 4) |
| TEST_FIELD_SIZE (LOGFONTW, lfEscapement, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfEscapement, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfEscapement, 8) |
| TEST_FIELD_SIZE (LOGFONTW, lfOrientation, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfOrientation, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfOrientation, 12) |
| TEST_FIELD_SIZE (LOGFONTW, lfWeight, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfWeight, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfWeight, 16) |
| TEST_FIELD_SIZE (LOGFONTW, lfItalic, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfItalic, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfItalic, 20) |
| TEST_FIELD_SIZE (LOGFONTW, lfUnderline, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfUnderline, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfUnderline, 21) |
| TEST_FIELD_SIZE (LOGFONTW, lfStrikeOut, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfStrikeOut, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfStrikeOut, 22) |
| TEST_FIELD_SIZE (LOGFONTW, lfCharSet, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfCharSet, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfCharSet, 23) |
| TEST_FIELD_SIZE (LOGFONTW, lfOutPrecision, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfOutPrecision, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfOutPrecision, 24) |
| TEST_FIELD_SIZE (LOGFONTW, lfClipPrecision, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfClipPrecision, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfClipPrecision, 25) |
| TEST_FIELD_SIZE (LOGFONTW, lfQuality, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfQuality, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfQuality, 26) |
| TEST_FIELD_SIZE (LOGFONTW, lfPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfPitchAndFamily, 27) |
| TEST_FIELD_SIZE (LOGFONTW, lfFaceName, 64) |
| TEST_FIELD_ALIGN (LOGFONTW, lfFaceName, 2) |
| TEST_FIELD_OFFSET(LOGFONTW, lfFaceName, 28) |
| } |
| |
| static void test_pack_LOGPEN(void) |
| { |
| /* LOGPEN */ |
| TEST_TYPE_SIZE (LOGPEN, 16) |
| TEST_TYPE_ALIGN (LOGPEN, 4) |
| TEST_FIELD_SIZE (LOGPEN, lopnStyle, 4) |
| TEST_FIELD_ALIGN (LOGPEN, lopnStyle, 4) |
| TEST_FIELD_OFFSET(LOGPEN, lopnStyle, 0) |
| TEST_FIELD_SIZE (LOGPEN, lopnWidth, 8) |
| TEST_FIELD_ALIGN (LOGPEN, lopnWidth, 4) |
| TEST_FIELD_OFFSET(LOGPEN, lopnWidth, 4) |
| TEST_FIELD_SIZE (LOGPEN, lopnColor, 4) |
| TEST_FIELD_ALIGN (LOGPEN, lopnColor, 4) |
| TEST_FIELD_OFFSET(LOGPEN, lopnColor, 12) |
| } |
| |
| static void test_pack_LPABC(void) |
| { |
| /* LPABC */ |
| TEST_TYPE_SIZE (LPABC, 8) |
| TEST_TYPE_ALIGN (LPABC, 8) |
| TEST_TARGET_SIZE (LPABC, 12) |
| TEST_TARGET_ALIGN(LPABC, 4) |
| } |
| |
| static void test_pack_LPABCFLOAT(void) |
| { |
| /* LPABCFLOAT */ |
| TEST_TYPE_SIZE (LPABCFLOAT, 8) |
| TEST_TYPE_ALIGN (LPABCFLOAT, 8) |
| TEST_TARGET_SIZE (LPABCFLOAT, 12) |
| TEST_TARGET_ALIGN(LPABCFLOAT, 4) |
| } |
| |
| static void test_pack_LPBITMAP(void) |
| { |
| /* LPBITMAP */ |
| TEST_TYPE_SIZE (LPBITMAP, 8) |
| TEST_TYPE_ALIGN (LPBITMAP, 8) |
| TEST_TARGET_SIZE (LPBITMAP, 32) |
| TEST_TARGET_ALIGN(LPBITMAP, 8) |
| } |
| |
| static void test_pack_LPBITMAPCOREHEADER(void) |
| { |
| /* LPBITMAPCOREHEADER */ |
| TEST_TYPE_SIZE (LPBITMAPCOREHEADER, 8) |
| TEST_TYPE_ALIGN (LPBITMAPCOREHEADER, 8) |
| TEST_TARGET_SIZE (LPBITMAPCOREHEADER, 12) |
| TEST_TARGET_ALIGN(LPBITMAPCOREHEADER, 4) |
| } |
| |
| static void test_pack_LPBITMAPCOREINFO(void) |
| { |
| /* LPBITMAPCOREINFO */ |
| TEST_TYPE_SIZE (LPBITMAPCOREINFO, 8) |
| TEST_TYPE_ALIGN (LPBITMAPCOREINFO, 8) |
| TEST_TARGET_SIZE (LPBITMAPCOREINFO, 16) |
| TEST_TARGET_ALIGN(LPBITMAPCOREINFO, 4) |
| } |
| |
| static void test_pack_LPBITMAPFILEHEADER(void) |
| { |
| /* LPBITMAPFILEHEADER */ |
| TEST_TYPE_SIZE (LPBITMAPFILEHEADER, 8) |
| TEST_TYPE_ALIGN (LPBITMAPFILEHEADER, 8) |
| TEST_TARGET_SIZE (LPBITMAPFILEHEADER, 14) |
| TEST_TARGET_ALIGN(LPBITMAPFILEHEADER, 2) |
| } |
| |
| static void test_pack_LPBITMAPINFO(void) |
| { |
| /* LPBITMAPINFO */ |
| TEST_TYPE_SIZE (LPBITMAPINFO, 8) |
| TEST_TYPE_ALIGN (LPBITMAPINFO, 8) |
| TEST_TARGET_SIZE (LPBITMAPINFO, 44) |
| TEST_TARGET_ALIGN(LPBITMAPINFO, 4) |
| } |
| |
| static void test_pack_LPBITMAPINFOHEADER(void) |
| { |
| /* LPBITMAPINFOHEADER */ |
| TEST_TYPE_SIZE (LPBITMAPINFOHEADER, 8) |
| TEST_TYPE_ALIGN (LPBITMAPINFOHEADER, 8) |
| TEST_TARGET_SIZE (LPBITMAPINFOHEADER, 40) |
| TEST_TARGET_ALIGN(LPBITMAPINFOHEADER, 4) |
| } |
| |
| static void test_pack_LPBITMAPV5HEADER(void) |
| { |
| /* LPBITMAPV5HEADER */ |
| TEST_TYPE_SIZE (LPBITMAPV5HEADER, 8) |
| TEST_TYPE_ALIGN (LPBITMAPV5HEADER, 8) |
| TEST_TARGET_SIZE (LPBITMAPV5HEADER, 124) |
| TEST_TARGET_ALIGN(LPBITMAPV5HEADER, 4) |
| } |
| |
| static void test_pack_LPCHARSETINFO(void) |
| { |
| /* LPCHARSETINFO */ |
| TEST_TYPE_SIZE (LPCHARSETINFO, 8) |
| TEST_TYPE_ALIGN (LPCHARSETINFO, 8) |
| TEST_TARGET_SIZE (LPCHARSETINFO, 32) |
| TEST_TARGET_ALIGN(LPCHARSETINFO, 4) |
| } |
| |
| static void test_pack_LPCIEXYZ(void) |
| { |
| /* LPCIEXYZ */ |
| TEST_TYPE_SIZE (LPCIEXYZ, 8) |
| TEST_TYPE_ALIGN (LPCIEXYZ, 8) |
| TEST_TARGET_SIZE (LPCIEXYZ, 12) |
| TEST_TARGET_ALIGN(LPCIEXYZ, 4) |
| } |
| |
| static void test_pack_LPCIEXYZTRIPLE(void) |
| { |
| /* LPCIEXYZTRIPLE */ |
| TEST_TYPE_SIZE (LPCIEXYZTRIPLE, 8) |
| TEST_TYPE_ALIGN (LPCIEXYZTRIPLE, 8) |
| TEST_TARGET_SIZE (LPCIEXYZTRIPLE, 36) |
| TEST_TARGET_ALIGN(LPCIEXYZTRIPLE, 4) |
| } |
| |
| static void test_pack_LPCOLORADJUSTMENT(void) |
| { |
| /* LPCOLORADJUSTMENT */ |
| TEST_TYPE_SIZE (LPCOLORADJUSTMENT, 8) |
| TEST_TYPE_ALIGN (LPCOLORADJUSTMENT, 8) |
| TEST_TARGET_SIZE (LPCOLORADJUSTMENT, 24) |
| TEST_TARGET_ALIGN(LPCOLORADJUSTMENT, 2) |
| } |
| |
| static void test_pack_LPDEVMODEA(void) |
| { |
| /* LPDEVMODEA */ |
| TEST_TYPE_SIZE (LPDEVMODEA, 8) |
| TEST_TYPE_ALIGN (LPDEVMODEA, 8) |
| } |
| |
| static void test_pack_LPDEVMODEW(void) |
| { |
| /* LPDEVMODEW */ |
| TEST_TYPE_SIZE (LPDEVMODEW, 8) |
| TEST_TYPE_ALIGN (LPDEVMODEW, 8) |
| } |
| |
| static void test_pack_LPDIBSECTION(void) |
| { |
| /* LPDIBSECTION */ |
| TEST_TYPE_SIZE (LPDIBSECTION, 8) |
| TEST_TYPE_ALIGN (LPDIBSECTION, 8) |
| TEST_TARGET_SIZE (LPDIBSECTION, 104) |
| TEST_TARGET_ALIGN(LPDIBSECTION, 8) |
| } |
| |
| static void test_pack_LPDISPLAY_DEVICEA(void) |
| { |
| /* LPDISPLAY_DEVICEA */ |
| TEST_TYPE_SIZE (LPDISPLAY_DEVICEA, 8) |
| TEST_TYPE_ALIGN (LPDISPLAY_DEVICEA, 8) |
| TEST_TARGET_SIZE (LPDISPLAY_DEVICEA, 424) |
| TEST_TARGET_ALIGN(LPDISPLAY_DEVICEA, 4) |
| } |
| |
| static void test_pack_LPDISPLAY_DEVICEW(void) |
| { |
| /* LPDISPLAY_DEVICEW */ |
| TEST_TYPE_SIZE (LPDISPLAY_DEVICEW, 8) |
| TEST_TYPE_ALIGN (LPDISPLAY_DEVICEW, 8) |
| TEST_TARGET_SIZE (LPDISPLAY_DEVICEW, 840) |
| TEST_TARGET_ALIGN(LPDISPLAY_DEVICEW, 4) |
| } |
| |
| static void test_pack_LPDOCINFOA(void) |
| { |
| /* LPDOCINFOA */ |
| TEST_TYPE_SIZE (LPDOCINFOA, 8) |
| TEST_TYPE_ALIGN (LPDOCINFOA, 8) |
| TEST_TARGET_SIZE (LPDOCINFOA, 40) |
| TEST_TARGET_ALIGN(LPDOCINFOA, 8) |
| } |
| |
| static void test_pack_LPDOCINFOW(void) |
| { |
| /* LPDOCINFOW */ |
| TEST_TYPE_SIZE (LPDOCINFOW, 8) |
| TEST_TYPE_ALIGN (LPDOCINFOW, 8) |
| TEST_TARGET_SIZE (LPDOCINFOW, 40) |
| TEST_TARGET_ALIGN(LPDOCINFOW, 8) |
| } |
| |
| static void test_pack_LPENHMETAHEADER(void) |
| { |
| /* LPENHMETAHEADER */ |
| TEST_TYPE_SIZE (LPENHMETAHEADER, 8) |
| TEST_TYPE_ALIGN (LPENHMETAHEADER, 8) |
| TEST_TARGET_SIZE (LPENHMETAHEADER, 108) |
| TEST_TARGET_ALIGN(LPENHMETAHEADER, 4) |
| } |
| |
| static void test_pack_LPENHMETARECORD(void) |
| { |
| /* LPENHMETARECORD */ |
| TEST_TYPE_SIZE (LPENHMETARECORD, 8) |
| TEST_TYPE_ALIGN (LPENHMETARECORD, 8) |
| TEST_TARGET_SIZE (LPENHMETARECORD, 12) |
| TEST_TARGET_ALIGN(LPENHMETARECORD, 4) |
| } |
| |
| static void test_pack_LPENUMLOGFONTA(void) |
| { |
| /* LPENUMLOGFONTA */ |
| TEST_TYPE_SIZE (LPENUMLOGFONTA, 8) |
| TEST_TYPE_ALIGN (LPENUMLOGFONTA, 8) |
| TEST_TARGET_SIZE (LPENUMLOGFONTA, 156) |
| TEST_TARGET_ALIGN(LPENUMLOGFONTA, 4) |
| } |
| |
| static void test_pack_LPENUMLOGFONTEXA(void) |
| { |
| /* LPENUMLOGFONTEXA */ |
| TEST_TYPE_SIZE (LPENUMLOGFONTEXA, 8) |
| TEST_TYPE_ALIGN (LPENUMLOGFONTEXA, 8) |
| TEST_TARGET_SIZE (LPENUMLOGFONTEXA, 188) |
| TEST_TARGET_ALIGN(LPENUMLOGFONTEXA, 4) |
| } |
| |
| static void test_pack_LPENUMLOGFONTEXW(void) |
| { |
| /* LPENUMLOGFONTEXW */ |
| TEST_TYPE_SIZE (LPENUMLOGFONTEXW, 8) |
| TEST_TYPE_ALIGN (LPENUMLOGFONTEXW, 8) |
| TEST_TARGET_SIZE (LPENUMLOGFONTEXW, 348) |
| TEST_TARGET_ALIGN(LPENUMLOGFONTEXW, 4) |
| } |
| |
| static void test_pack_LPENUMLOGFONTW(void) |
| { |
| /* LPENUMLOGFONTW */ |
| TEST_TYPE_SIZE (LPENUMLOGFONTW, 8) |
| TEST_TYPE_ALIGN (LPENUMLOGFONTW, 8) |
| TEST_TARGET_SIZE (LPENUMLOGFONTW, 284) |
| TEST_TARGET_ALIGN(LPENUMLOGFONTW, 4) |
| } |
| |
| static void test_pack_LPEXTLOGFONTA(void) |
| { |
| /* LPEXTLOGFONTA */ |
| TEST_TYPE_SIZE (LPEXTLOGFONTA, 8) |
| TEST_TYPE_ALIGN (LPEXTLOGFONTA, 8) |
| TEST_TARGET_SIZE (LPEXTLOGFONTA, 192) |
| TEST_TARGET_ALIGN(LPEXTLOGFONTA, 4) |
| } |
| |
| static void test_pack_LPEXTLOGFONTW(void) |
| { |
| /* LPEXTLOGFONTW */ |
| TEST_TYPE_SIZE (LPEXTLOGFONTW, 8) |
| TEST_TYPE_ALIGN (LPEXTLOGFONTW, 8) |
| TEST_TARGET_SIZE (LPEXTLOGFONTW, 320) |
| TEST_TARGET_ALIGN(LPEXTLOGFONTW, 4) |
| } |
| |
| static void test_pack_LPEXTLOGPEN(void) |
| { |
| /* LPEXTLOGPEN */ |
| TEST_TYPE_SIZE (LPEXTLOGPEN, 8) |
| TEST_TYPE_ALIGN (LPEXTLOGPEN, 8) |
| TEST_TARGET_SIZE (LPEXTLOGPEN, 32) |
| TEST_TARGET_ALIGN(LPEXTLOGPEN, 8) |
| } |
| |
| static void test_pack_LPFONTSIGNATURE(void) |
| { |
| /* LPFONTSIGNATURE */ |
| TEST_TYPE_SIZE (LPFONTSIGNATURE, 8) |
| TEST_TYPE_ALIGN (LPFONTSIGNATURE, 8) |
| TEST_TARGET_SIZE (LPFONTSIGNATURE, 24) |
| TEST_TARGET_ALIGN(LPFONTSIGNATURE, 4) |
| } |
| |
| static void test_pack_LPGCP_RESULTSA(void) |
| { |
| /* LPGCP_RESULTSA */ |
| TEST_TYPE_SIZE (LPGCP_RESULTSA, 8) |
| TEST_TYPE_ALIGN (LPGCP_RESULTSA, 8) |
| TEST_TARGET_SIZE (LPGCP_RESULTSA, 64) |
| TEST_TARGET_ALIGN(LPGCP_RESULTSA, 8) |
| } |
| |
| static void test_pack_LPGCP_RESULTSW(void) |
| { |
| /* LPGCP_RESULTSW */ |
| TEST_TYPE_SIZE (LPGCP_RESULTSW, 8) |
| TEST_TYPE_ALIGN (LPGCP_RESULTSW, 8) |
| TEST_TARGET_SIZE (LPGCP_RESULTSW, 64) |
| TEST_TARGET_ALIGN(LPGCP_RESULTSW, 8) |
| } |
| |
| static void test_pack_LPGLYPHMETRICS(void) |
| { |
| /* LPGLYPHMETRICS */ |
| TEST_TYPE_SIZE (LPGLYPHMETRICS, 8) |
| TEST_TYPE_ALIGN (LPGLYPHMETRICS, 8) |
| TEST_TARGET_SIZE (LPGLYPHMETRICS, 20) |
| TEST_TARGET_ALIGN(LPGLYPHMETRICS, 4) |
| } |
| |
| static void test_pack_LPGLYPHMETRICSFLOAT(void) |
| { |
| /* LPGLYPHMETRICSFLOAT */ |
| TEST_TYPE_SIZE (LPGLYPHMETRICSFLOAT, 8) |
| TEST_TYPE_ALIGN (LPGLYPHMETRICSFLOAT, 8) |
| TEST_TARGET_SIZE (LPGLYPHMETRICSFLOAT, 24) |
| TEST_TARGET_ALIGN(LPGLYPHMETRICSFLOAT, 4) |
| } |
| |
| static void test_pack_LPGRADIENT_RECT(void) |
| { |
| /* LPGRADIENT_RECT */ |
| TEST_TYPE_SIZE (LPGRADIENT_RECT, 8) |
| TEST_TYPE_ALIGN (LPGRADIENT_RECT, 8) |
| TEST_TARGET_SIZE (LPGRADIENT_RECT, 8) |
| TEST_TARGET_ALIGN(LPGRADIENT_RECT, 4) |
| } |
| |
| static void test_pack_LPGRADIENT_TRIANGLE(void) |
| { |
| /* LPGRADIENT_TRIANGLE */ |
| TEST_TYPE_SIZE (LPGRADIENT_TRIANGLE, 8) |
| TEST_TYPE_ALIGN (LPGRADIENT_TRIANGLE, 8) |
| TEST_TARGET_SIZE (LPGRADIENT_TRIANGLE, 12) |
| TEST_TARGET_ALIGN(LPGRADIENT_TRIANGLE, 4) |
| } |
| |
| static void test_pack_LPHANDLETABLE(void) |
| { |
| /* LPHANDLETABLE */ |
| TEST_TYPE_SIZE (LPHANDLETABLE, 8) |
| TEST_TYPE_ALIGN (LPHANDLETABLE, 8) |
| TEST_TARGET_SIZE (LPHANDLETABLE, 8) |
| TEST_TARGET_ALIGN(LPHANDLETABLE, 8) |
| } |
| |
| static void test_pack_LPKERNINGPAIR(void) |
| { |
| /* LPKERNINGPAIR */ |
| TEST_TYPE_SIZE (LPKERNINGPAIR, 8) |
| TEST_TYPE_ALIGN (LPKERNINGPAIR, 8) |
| TEST_TARGET_SIZE (LPKERNINGPAIR, 8) |
| TEST_TARGET_ALIGN(LPKERNINGPAIR, 4) |
| } |
| |
| static void test_pack_LPLAYERPLANEDESCRIPTOR(void) |
| { |
| /* LPLAYERPLANEDESCRIPTOR */ |
| TEST_TYPE_SIZE (LPLAYERPLANEDESCRIPTOR, 8) |
| TEST_TYPE_ALIGN (LPLAYERPLANEDESCRIPTOR, 8) |
| TEST_TARGET_SIZE (LPLAYERPLANEDESCRIPTOR, 32) |
| TEST_TARGET_ALIGN(LPLAYERPLANEDESCRIPTOR, 4) |
| } |
| |
| static void test_pack_LPLOCALESIGNATURE(void) |
| { |
| /* LPLOCALESIGNATURE */ |
| TEST_TYPE_SIZE (LPLOCALESIGNATURE, 8) |
| TEST_TYPE_ALIGN (LPLOCALESIGNATURE, 8) |
| TEST_TARGET_SIZE (LPLOCALESIGNATURE, 32) |
| TEST_TARGET_ALIGN(LPLOCALESIGNATURE, 4) |
| } |
| |
| static void test_pack_LPLOGBRUSH(void) |
| { |
| /* LPLOGBRUSH */ |
| TEST_TYPE_SIZE (LPLOGBRUSH, 8) |
| TEST_TYPE_ALIGN (LPLOGBRUSH, 8) |
| TEST_TARGET_SIZE (LPLOGBRUSH, 16) |
| TEST_TARGET_ALIGN(LPLOGBRUSH, 8) |
| } |
| |
| static void test_pack_LPLOGCOLORSPACEA(void) |
| { |
| /* LPLOGCOLORSPACEA */ |
| TEST_TYPE_SIZE (LPLOGCOLORSPACEA, 8) |
| TEST_TYPE_ALIGN (LPLOGCOLORSPACEA, 8) |
| TEST_TARGET_SIZE (LPLOGCOLORSPACEA, 328) |
| TEST_TARGET_ALIGN(LPLOGCOLORSPACEA, 4) |
| } |
| |
| static void test_pack_LPLOGCOLORSPACEW(void) |
| { |
| /* LPLOGCOLORSPACEW */ |
| TEST_TYPE_SIZE (LPLOGCOLORSPACEW, 8) |
| TEST_TYPE_ALIGN (LPLOGCOLORSPACEW, 8) |
| TEST_TARGET_SIZE (LPLOGCOLORSPACEW, 588) |
| TEST_TARGET_ALIGN(LPLOGCOLORSPACEW, 4) |
| } |
| |
| static void test_pack_LPLOGFONTA(void) |
| { |
| /* LPLOGFONTA */ |
| TEST_TYPE_SIZE (LPLOGFONTA, 8) |
| TEST_TYPE_ALIGN (LPLOGFONTA, 8) |
| TEST_TARGET_SIZE (LPLOGFONTA, 60) |
| TEST_TARGET_ALIGN(LPLOGFONTA, 4) |
| } |
| |
| static void test_pack_LPLOGFONTW(void) |
| { |
| /* LPLOGFONTW */ |
| TEST_TYPE_SIZE (LPLOGFONTW, 8) |
| TEST_TYPE_ALIGN (LPLOGFONTW, 8) |
| TEST_TARGET_SIZE (LPLOGFONTW, 92) |
| TEST_TARGET_ALIGN(LPLOGFONTW, 4) |
| } |
| |
| static void test_pack_LPLOGPEN(void) |
| { |
| /* LPLOGPEN */ |
| TEST_TYPE_SIZE (LPLOGPEN, 8) |
| TEST_TYPE_ALIGN (LPLOGPEN, 8) |
| TEST_TARGET_SIZE (LPLOGPEN, 16) |
| TEST_TARGET_ALIGN(LPLOGPEN, 4) |
| } |
| |
| static void test_pack_LPMAT2(void) |
| { |
| /* LPMAT2 */ |
| TEST_TYPE_SIZE (LPMAT2, 8) |
| TEST_TYPE_ALIGN (LPMAT2, 8) |
| TEST_TARGET_SIZE (LPMAT2, 16) |
| TEST_TARGET_ALIGN(LPMAT2, 2) |
| } |
| |
| static void test_pack_LPMETAFILEPICT(void) |
| { |
| /* LPMETAFILEPICT */ |
| TEST_TYPE_SIZE (LPMETAFILEPICT, 8) |
| TEST_TYPE_ALIGN (LPMETAFILEPICT, 8) |
| TEST_TARGET_SIZE (LPMETAFILEPICT, 24) |
| TEST_TARGET_ALIGN(LPMETAFILEPICT, 8) |
| } |
| |
| static void test_pack_LPMETAHEADER(void) |
| { |
| /* LPMETAHEADER */ |
| TEST_TYPE_SIZE (LPMETAHEADER, 8) |
| TEST_TYPE_ALIGN (LPMETAHEADER, 8) |
| TEST_TARGET_SIZE (LPMETAHEADER, 18) |
| TEST_TARGET_ALIGN(LPMETAHEADER, 2) |
| } |
| |
| static void test_pack_LPMETARECORD(void) |
| { |
| /* LPMETARECORD */ |
| TEST_TYPE_SIZE (LPMETARECORD, 8) |
| TEST_TYPE_ALIGN (LPMETARECORD, 8) |
| TEST_TARGET_SIZE (LPMETARECORD, 8) |
| TEST_TARGET_ALIGN(LPMETARECORD, 4) |
| } |
| |
| static void test_pack_LPNEWTEXTMETRICA(void) |
| { |
| /* LPNEWTEXTMETRICA */ |
| TEST_TYPE_SIZE (LPNEWTEXTMETRICA, 8) |
| TEST_TYPE_ALIGN (LPNEWTEXTMETRICA, 8) |
| TEST_TARGET_SIZE (LPNEWTEXTMETRICA, 72) |
| TEST_TARGET_ALIGN(LPNEWTEXTMETRICA, 4) |
| } |
| |
| static void test_pack_LPNEWTEXTMETRICW(void) |
| { |
| /* LPNEWTEXTMETRICW */ |
| TEST_TYPE_SIZE (LPNEWTEXTMETRICW, 8) |
| TEST_TYPE_ALIGN (LPNEWTEXTMETRICW, 8) |
| TEST_TARGET_SIZE (LPNEWTEXTMETRICW, 76) |
| TEST_TARGET_ALIGN(LPNEWTEXTMETRICW, 4) |
| } |
| |
| static void test_pack_LPOUTLINETEXTMETRICA(void) |
| { |
| /* LPOUTLINETEXTMETRICA */ |
| TEST_TYPE_SIZE (LPOUTLINETEXTMETRICA, 8) |
| TEST_TYPE_ALIGN (LPOUTLINETEXTMETRICA, 8) |
| TEST_TARGET_SIZE (LPOUTLINETEXTMETRICA, 232) |
| TEST_TARGET_ALIGN(LPOUTLINETEXTMETRICA, 8) |
| } |
| |
| static void test_pack_LPOUTLINETEXTMETRICW(void) |
| { |
| /* LPOUTLINETEXTMETRICW */ |
| TEST_TYPE_SIZE (LPOUTLINETEXTMETRICW, 8) |
| TEST_TYPE_ALIGN (LPOUTLINETEXTMETRICW, 8) |
| TEST_TARGET_SIZE (LPOUTLINETEXTMETRICW, 232) |
| TEST_TARGET_ALIGN(LPOUTLINETEXTMETRICW, 8) |
| } |
| |
| static void test_pack_LPPANOSE(void) |
| { |
| /* LPPANOSE */ |
| TEST_TYPE_SIZE (LPPANOSE, 8) |
| TEST_TYPE_ALIGN (LPPANOSE, 8) |
| TEST_TARGET_SIZE (LPPANOSE, 10) |
| TEST_TARGET_ALIGN(LPPANOSE, 1) |
| } |
| |
| static void test_pack_LPPELARRAY(void) |
| { |
| /* LPPELARRAY */ |
| TEST_TYPE_SIZE (LPPELARRAY, 8) |
| TEST_TYPE_ALIGN (LPPELARRAY, 8) |
| TEST_TARGET_SIZE (LPPELARRAY, 20) |
| TEST_TARGET_ALIGN(LPPELARRAY, 4) |
| } |
| |
| static void test_pack_LPPIXELFORMATDESCRIPTOR(void) |
| { |
| /* LPPIXELFORMATDESCRIPTOR */ |
| TEST_TYPE_SIZE (LPPIXELFORMATDESCRIPTOR, 8) |
| TEST_TYPE_ALIGN (LPPIXELFORMATDESCRIPTOR, 8) |
| TEST_TARGET_SIZE (LPPIXELFORMATDESCRIPTOR, 40) |
| TEST_TARGET_ALIGN(LPPIXELFORMATDESCRIPTOR, 4) |
| } |
| |
| static void test_pack_LPPOINTFX(void) |
| { |
| /* LPPOINTFX */ |
| TEST_TYPE_SIZE (LPPOINTFX, 8) |
| TEST_TYPE_ALIGN (LPPOINTFX, 8) |
| TEST_TARGET_SIZE (LPPOINTFX, 8) |
| TEST_TARGET_ALIGN(LPPOINTFX, 2) |
| } |
| |
| static void test_pack_LPPOLYTEXTA(void) |
| { |
| /* LPPOLYTEXTA */ |
| TEST_TYPE_SIZE (LPPOLYTEXTA, 8) |
| TEST_TYPE_ALIGN (LPPOLYTEXTA, 8) |
| TEST_TARGET_SIZE (LPPOLYTEXTA, 56) |
| TEST_TARGET_ALIGN(LPPOLYTEXTA, 8) |
| } |
| |
| static void test_pack_LPPOLYTEXTW(void) |
| { |
| /* LPPOLYTEXTW */ |
| TEST_TYPE_SIZE (LPPOLYTEXTW, 8) |
| TEST_TYPE_ALIGN (LPPOLYTEXTW, 8) |
| TEST_TARGET_SIZE (LPPOLYTEXTW, 56) |
| TEST_TARGET_ALIGN(LPPOLYTEXTW, 8) |
| } |
| |
| static void test_pack_LPRASTERIZER_STATUS(void) |
| { |
| /* LPRASTERIZER_STATUS */ |
| TEST_TYPE_SIZE (LPRASTERIZER_STATUS, 8) |
| TEST_TYPE_ALIGN (LPRASTERIZER_STATUS, 8) |
| TEST_TARGET_SIZE (LPRASTERIZER_STATUS, 6) |
| TEST_TARGET_ALIGN(LPRASTERIZER_STATUS, 2) |
| } |
| |
| static void test_pack_LPRGBQUAD(void) |
| { |
| /* LPRGBQUAD */ |
| TEST_TYPE_SIZE (LPRGBQUAD, 8) |
| TEST_TYPE_ALIGN (LPRGBQUAD, 8) |
| TEST_TARGET_SIZE (LPRGBQUAD, 4) |
| TEST_TARGET_ALIGN(LPRGBQUAD, 1) |
| } |
| |
| static void test_pack_LPRGNDATA(void) |
| { |
| /* LPRGNDATA */ |
| TEST_TYPE_SIZE (LPRGNDATA, 8) |
| TEST_TYPE_ALIGN (LPRGNDATA, 8) |
| TEST_TARGET_SIZE (LPRGNDATA, 36) |
| TEST_TARGET_ALIGN(LPRGNDATA, 4) |
| } |
| |
| static void test_pack_LPTEXTMETRICA(void) |
| { |
| /* LPTEXTMETRICA */ |
| TEST_TYPE_SIZE (LPTEXTMETRICA, 8) |
| TEST_TYPE_ALIGN (LPTEXTMETRICA, 8) |
| TEST_TARGET_SIZE (LPTEXTMETRICA, 56) |
| TEST_TARGET_ALIGN(LPTEXTMETRICA, 4) |
| } |
| |
| static void test_pack_LPTEXTMETRICW(void) |
| { |
| /* LPTEXTMETRICW */ |
| TEST_TYPE_SIZE (LPTEXTMETRICW, 8) |
| TEST_TYPE_ALIGN (LPTEXTMETRICW, 8) |
| TEST_TARGET_SIZE (LPTEXTMETRICW, 60) |
| TEST_TARGET_ALIGN(LPTEXTMETRICW, 4) |
| } |
| |
| static void test_pack_LPTRIVERTEX(void) |
| { |
| /* LPTRIVERTEX */ |
| TEST_TYPE_SIZE (LPTRIVERTEX, 8) |
| TEST_TYPE_ALIGN (LPTRIVERTEX, 8) |
| TEST_TARGET_SIZE (LPTRIVERTEX, 16) |
| TEST_TARGET_ALIGN(LPTRIVERTEX, 4) |
| } |
| |
| static void test_pack_LPTTPOLYCURVE(void) |
| { |
| /* LPTTPOLYCURVE */ |
| TEST_TYPE_SIZE (LPTTPOLYCURVE, 8) |
| TEST_TYPE_ALIGN (LPTTPOLYCURVE, 8) |
| TEST_TARGET_SIZE (LPTTPOLYCURVE, 12) |
| TEST_TARGET_ALIGN(LPTTPOLYCURVE, 2) |
| } |
| |
| static void test_pack_LPTTPOLYGONHEADER(void) |
| { |
| /* LPTTPOLYGONHEADER */ |
| TEST_TYPE_SIZE (LPTTPOLYGONHEADER, 8) |
| TEST_TYPE_ALIGN (LPTTPOLYGONHEADER, 8) |
| TEST_TARGET_SIZE (LPTTPOLYGONHEADER, 16) |
| TEST_TARGET_ALIGN(LPTTPOLYGONHEADER, 4) |
| } |
| |
| static void test_pack_LPXFORM(void) |
| { |
| /* LPXFORM */ |
| TEST_TYPE_SIZE (LPXFORM, 8) |
| TEST_TYPE_ALIGN (LPXFORM, 8) |
| TEST_TARGET_SIZE (LPXFORM, 24) |
| TEST_TARGET_ALIGN(LPXFORM, 4) |
| } |
| |
| static void test_pack_MAT2(void) |
| { |
| /* MAT2 */ |
| TEST_TYPE_SIZE (MAT2, 16) |
| TEST_TYPE_ALIGN (MAT2, 2) |
| TEST_FIELD_SIZE (MAT2, eM11, 4) |
| TEST_FIELD_ALIGN (MAT2, eM11, 2) |
| TEST_FIELD_OFFSET(MAT2, eM11, 0) |
| TEST_FIELD_SIZE (MAT2, eM12, 4) |
| TEST_FIELD_ALIGN (MAT2, eM12, 2) |
| TEST_FIELD_OFFSET(MAT2, eM12, 4) |
| TEST_FIELD_SIZE (MAT2, eM21, 4) |
| TEST_FIELD_ALIGN (MAT2, eM21, 2) |
| TEST_FIELD_OFFSET(MAT2, eM21, 8) |
| TEST_FIELD_SIZE (MAT2, eM22, 4) |
| TEST_FIELD_ALIGN (MAT2, eM22, 2) |
| TEST_FIELD_OFFSET(MAT2, eM22, 12) |
| } |
| |
| static void test_pack_METAFILEPICT(void) |
| { |
| /* METAFILEPICT */ |
| TEST_TYPE_SIZE (METAFILEPICT, 24) |
| TEST_TYPE_ALIGN (METAFILEPICT, 8) |
| TEST_FIELD_SIZE (METAFILEPICT, mm, 4) |
| TEST_FIELD_ALIGN (METAFILEPICT, mm, 4) |
| TEST_FIELD_OFFSET(METAFILEPICT, mm, 0) |
| TEST_FIELD_SIZE (METAFILEPICT, xExt, 4) |
| TEST_FIELD_ALIGN (METAFILEPICT, xExt, 4) |
| TEST_FIELD_OFFSET(METAFILEPICT, xExt, 4) |
| TEST_FIELD_SIZE (METAFILEPICT, yExt, 4) |
| TEST_FIELD_ALIGN (METAFILEPICT, yExt, 4) |
| TEST_FIELD_OFFSET(METAFILEPICT, yExt, 8) |
| TEST_FIELD_SIZE (METAFILEPICT, hMF, 8) |
| TEST_FIELD_ALIGN (METAFILEPICT, hMF, 8) |
| TEST_FIELD_OFFSET(METAFILEPICT, hMF, 16) |
| } |
| |
| static void test_pack_METAHEADER(void) |
| { |
| /* METAHEADER (pack 2) */ |
| TEST_TYPE_SIZE (METAHEADER, 18) |
| TEST_TYPE_ALIGN (METAHEADER, 2) |
| TEST_FIELD_SIZE (METAHEADER, mtType, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtType, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtType, 0) |
| TEST_FIELD_SIZE (METAHEADER, mtHeaderSize, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtHeaderSize, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtHeaderSize, 2) |
| TEST_FIELD_SIZE (METAHEADER, mtVersion, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtVersion, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtVersion, 4) |
| TEST_FIELD_SIZE (METAHEADER, mtSize, 4) |
| TEST_FIELD_ALIGN (METAHEADER, mtSize, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtSize, 6) |
| TEST_FIELD_SIZE (METAHEADER, mtNoObjects, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtNoObjects, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtNoObjects, 10) |
| TEST_FIELD_SIZE (METAHEADER, mtMaxRecord, 4) |
| TEST_FIELD_ALIGN (METAHEADER, mtMaxRecord, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtMaxRecord, 12) |
| TEST_FIELD_SIZE (METAHEADER, mtNoParameters, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtNoParameters, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtNoParameters, 16) |
| } |
| |
| static void test_pack_METARECORD(void) |
| { |
| /* METARECORD */ |
| TEST_TYPE_SIZE (METARECORD, 8) |
| TEST_TYPE_ALIGN (METARECORD, 4) |
| TEST_FIELD_SIZE (METARECORD, rdSize, 4) |
| TEST_FIELD_ALIGN (METARECORD, rdSize, 4) |
| TEST_FIELD_OFFSET(METARECORD, rdSize, 0) |
| TEST_FIELD_SIZE (METARECORD, rdFunction, 2) |
| TEST_FIELD_ALIGN (METARECORD, rdFunction, 2) |
| TEST_FIELD_OFFSET(METARECORD, rdFunction, 4) |
| TEST_FIELD_SIZE (METARECORD, rdParm, 2) |
| TEST_FIELD_ALIGN (METARECORD, rdParm, 2) |
| TEST_FIELD_OFFSET(METARECORD, rdParm, 6) |
| } |
| |
| static void test_pack_MFENUMPROC(void) |
| { |
| /* MFENUMPROC */ |
| TEST_TYPE_SIZE (MFENUMPROC, 8) |
| TEST_TYPE_ALIGN (MFENUMPROC, 8) |
| } |
| |
| static void test_pack_NEWTEXTMETRICA(void) |
| { |
| /* NEWTEXTMETRICA */ |
| TEST_TYPE_SIZE (NEWTEXTMETRICA, 72) |
| TEST_TYPE_ALIGN (NEWTEXTMETRICA, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmHeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmHeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmHeight, 0) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmDescent, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmDescent, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmDescent, 8) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmInternalLeading, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmInternalLeading, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmInternalLeading, 12) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmExternalLeading, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmExternalLeading, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmExternalLeading, 16) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmAveCharWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmAveCharWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmAveCharWidth, 20) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmMaxCharWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmMaxCharWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmMaxCharWidth, 24) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmWeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmWeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmWeight, 28) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmOverhang, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmOverhang, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmOverhang, 32) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmDigitizedAspectX, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmDigitizedAspectX, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmDigitizedAspectX, 36) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmDigitizedAspectY, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmDigitizedAspectY, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmDigitizedAspectY, 40) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmFirstChar, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmFirstChar, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmFirstChar, 44) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmLastChar, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmLastChar, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmLastChar, 45) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmDefaultChar, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmDefaultChar, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmDefaultChar, 46) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmBreakChar, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmBreakChar, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmBreakChar, 47) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmItalic, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmItalic, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmItalic, 48) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmUnderlined, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmUnderlined, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmUnderlined, 49) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmStruckOut, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmStruckOut, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmStruckOut, 50) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmPitchAndFamily, 51) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmCharSet, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmCharSet, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmCharSet, 52) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, ntmFlags, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, ntmFlags, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, ntmFlags, 56) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, ntmSizeEM, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, ntmSizeEM, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, ntmSizeEM, 60) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, ntmCellHeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, ntmCellHeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, ntmCellHeight, 64) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, ntmAvgWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, ntmAvgWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, ntmAvgWidth, 68) |
| } |
| |
| static void test_pack_NEWTEXTMETRICEXA(void) |
| { |
| /* NEWTEXTMETRICEXA */ |
| TEST_TYPE_SIZE (NEWTEXTMETRICEXA, 96) |
| TEST_TYPE_ALIGN (NEWTEXTMETRICEXA, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICEXA, ntmTm, 72) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICEXA, ntmTm, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICEXA, ntmTm, 0) |
| TEST_FIELD_SIZE (NEWTEXTMETRICEXA, ntmFontSig, 24) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICEXA, ntmFontSig, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICEXA, ntmFontSig, 72) |
| } |
| |
| static void test_pack_NEWTEXTMETRICEXW(void) |
| { |
| /* NEWTEXTMETRICEXW */ |
| TEST_TYPE_SIZE (NEWTEXTMETRICEXW, 100) |
| TEST_TYPE_ALIGN (NEWTEXTMETRICEXW, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICEXW, ntmTm, 76) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICEXW, ntmTm, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICEXW, ntmTm, 0) |
| TEST_FIELD_SIZE (NEWTEXTMETRICEXW, ntmFontSig, 24) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICEXW, ntmFontSig, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICEXW, ntmFontSig, 76) |
| } |
| |
| static void test_pack_NEWTEXTMETRICW(void) |
| { |
| /* NEWTEXTMETRICW */ |
| TEST_TYPE_SIZE (NEWTEXTMETRICW, 76) |
| TEST_TYPE_ALIGN (NEWTEXTMETRICW, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmHeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmHeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmHeight, 0) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmDescent, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmDescent, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmDescent, 8) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmInternalLeading, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmInternalLeading, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmInternalLeading, 12) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmExternalLeading, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmExternalLeading, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmExternalLeading, 16) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmAveCharWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmAveCharWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmAveCharWidth, 20) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmMaxCharWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmMaxCharWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmMaxCharWidth, 24) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmWeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmWeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmWeight, 28) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmOverhang, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmOverhang, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmOverhang, 32) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmDigitizedAspectX, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmDigitizedAspectX, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmDigitizedAspectX, 36) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmDigitizedAspectY, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmDigitizedAspectY, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmDigitizedAspectY, 40) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmFirstChar, 2) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmFirstChar, 2) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmFirstChar, 44) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmLastChar, 2) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmLastChar, 2) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmLastChar, 46) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmDefaultChar, 2) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmDefaultChar, 2) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmDefaultChar, 48) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmBreakChar, 2) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmBreakChar, 2) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmBreakChar, 50) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmItalic, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmItalic, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmItalic, 52) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmUnderlined, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmUnderlined, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmUnderlined, 53) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmStruckOut, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmStruckOut, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmStruckOut, 54) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmPitchAndFamily, 55) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmCharSet, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmCharSet, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmCharSet, 56) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, ntmFlags, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, ntmFlags, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, ntmFlags, 60) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, ntmSizeEM, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, ntmSizeEM, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, ntmSizeEM, 64) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, ntmCellHeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, ntmCellHeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, ntmCellHeight, 68) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, ntmAvgWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, ntmAvgWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, ntmAvgWidth, 72) |
| } |
| |
| static void test_pack_NPEXTLOGPEN(void) |
| { |
| /* NPEXTLOGPEN */ |
| TEST_TYPE_SIZE (NPEXTLOGPEN, 8) |
| TEST_TYPE_ALIGN (NPEXTLOGPEN, 8) |
| TEST_TARGET_SIZE (NPEXTLOGPEN, 32) |
| TEST_TARGET_ALIGN(NPEXTLOGPEN, 8) |
| } |
| |
| static void test_pack_OLDFONTENUMPROCA(void) |
| { |
| /* OLDFONTENUMPROCA */ |
| TEST_TYPE_SIZE (OLDFONTENUMPROCA, 8) |
| TEST_TYPE_ALIGN (OLDFONTENUMPROCA, 8) |
| } |
| |
| static void test_pack_OLDFONTENUMPROCW(void) |
| { |
| /* OLDFONTENUMPROCW */ |
| TEST_TYPE_SIZE (OLDFONTENUMPROCW, 8) |
| TEST_TYPE_ALIGN (OLDFONTENUMPROCW, 8) |
| } |
| |
| static void test_pack_OUTLINETEXTMETRICA(void) |
| { |
| /* OUTLINETEXTMETRICA */ |
| TEST_TYPE_SIZE (OUTLINETEXTMETRICA, 232) |
| TEST_TYPE_ALIGN (OUTLINETEXTMETRICA, 8) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmSize, 0) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmTextMetrics, 56) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmTextMetrics, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmTextMetrics, 4) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmFiller, 1) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmFiller, 1) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmFiller, 60) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmPanoseNumber, 10) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmPanoseNumber, 1) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmPanoseNumber, 61) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmfsSelection, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmfsSelection, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmfsSelection, 72) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmfsType, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmfsType, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmfsType, 76) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsCharSlopeRise, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsCharSlopeRise, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsCharSlopeRise, 80) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsCharSlopeRun, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsCharSlopeRun, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsCharSlopeRun, 84) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmItalicAngle, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmItalicAngle, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmItalicAngle, 88) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmEMSquare, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmEMSquare, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmEMSquare, 92) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmAscent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmAscent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmAscent, 96) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmDescent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmDescent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmDescent, 100) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmLineGap, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmLineGap, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmLineGap, 104) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsCapEmHeight, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsCapEmHeight, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsCapEmHeight, 108) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsXHeight, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsXHeight, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsXHeight, 112) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmrcFontBox, 16) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmrcFontBox, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmrcFontBox, 116) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmMacAscent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmMacAscent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmMacAscent, 132) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmMacDescent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmMacDescent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmMacDescent, 136) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmMacLineGap, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmMacLineGap, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmMacLineGap, 140) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmusMinimumPPEM, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmusMinimumPPEM, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmusMinimumPPEM, 144) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmptSubscriptSize, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmptSubscriptSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmptSubscriptSize, 148) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmptSubscriptOffset, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmptSubscriptOffset, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmptSubscriptOffset, 156) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmptSuperscriptSize, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmptSuperscriptSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmptSuperscriptSize, 164) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmptSuperscriptOffset, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmptSuperscriptOffset, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmptSuperscriptOffset, 172) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsStrikeoutSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsStrikeoutSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsStrikeoutSize, 180) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsStrikeoutPosition, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsStrikeoutPosition, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsStrikeoutPosition, 184) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsUnderscoreSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsUnderscoreSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsUnderscoreSize, 188) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsUnderscorePosition, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsUnderscorePosition, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsUnderscorePosition, 192) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmpFamilyName, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmpFamilyName, 8) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFamilyName, 200) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmpFaceName, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmpFaceName, 8) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFaceName, 208) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmpStyleName, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmpStyleName, 8) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmpStyleName, 216) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmpFullName, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmpFullName, 8) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFullName, 224) |
| } |
| |
| static void test_pack_OUTLINETEXTMETRICW(void) |
| { |
| /* OUTLINETEXTMETRICW */ |
| TEST_TYPE_SIZE (OUTLINETEXTMETRICW, 232) |
| TEST_TYPE_ALIGN (OUTLINETEXTMETRICW, 8) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmSize, 0) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmTextMetrics, 60) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmTextMetrics, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmTextMetrics, 4) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmFiller, 1) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmFiller, 1) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmFiller, 64) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmPanoseNumber, 10) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmPanoseNumber, 1) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmPanoseNumber, 65) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmfsSelection, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmfsSelection, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmfsSelection, 76) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmfsType, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmfsType, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmfsType, 80) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsCharSlopeRise, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsCharSlopeRise, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsCharSlopeRise, 84) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsCharSlopeRun, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsCharSlopeRun, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsCharSlopeRun, 88) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmItalicAngle, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmItalicAngle, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmItalicAngle, 92) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmEMSquare, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmEMSquare, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmEMSquare, 96) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmAscent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmAscent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmAscent, 100) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmDescent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmDescent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmDescent, 104) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmLineGap, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmLineGap, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmLineGap, 108) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsCapEmHeight, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsCapEmHeight, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsCapEmHeight, 112) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsXHeight, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsXHeight, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsXHeight, 116) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmrcFontBox, 16) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmrcFontBox, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmrcFontBox, 120) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmMacAscent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmMacAscent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmMacAscent, 136) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmMacDescent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmMacDescent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmMacDescent, 140) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmMacLineGap, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmMacLineGap, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmMacLineGap, 144) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmusMinimumPPEM, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmusMinimumPPEM, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmusMinimumPPEM, 148) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmptSubscriptSize, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmptSubscriptSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmptSubscriptSize, 152) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmptSubscriptOffset, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmptSubscriptOffset, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmptSubscriptOffset, 160) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmptSuperscriptSize, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmptSuperscriptSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmptSuperscriptSize, 168) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmptSuperscriptOffset, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmptSuperscriptOffset, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmptSuperscriptOffset, 176) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsStrikeoutSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsStrikeoutSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsStrikeoutSize, 184) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsStrikeoutPosition, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsStrikeoutPosition, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsStrikeoutPosition, 188) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsUnderscoreSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsUnderscoreSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsUnderscoreSize, 192) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsUnderscorePosition, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsUnderscorePosition, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsUnderscorePosition, 196) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmpFamilyName, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmpFamilyName, 8) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmpFamilyName, 200) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmpFaceName, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmpFaceName, 8) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmpFaceName, 208) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmpStyleName, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmpStyleName, 8) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmpStyleName, 216) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmpFullName, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmpFullName, 8) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmpFullName, 224) |
| } |
| |
| static void test_pack_PABC(void) |
| { |
| /* PABC */ |
| TEST_TYPE_SIZE (PABC, 8) |
| TEST_TYPE_ALIGN (PABC, 8) |
| TEST_TARGET_SIZE (PABC, 12) |
| TEST_TARGET_ALIGN(PABC, 4) |
| } |
| |
| static void test_pack_PABCFLOAT(void) |
| { |
| /* PABCFLOAT */ |
| TEST_TYPE_SIZE (PABCFLOAT, 8) |
| TEST_TYPE_ALIGN (PABCFLOAT, 8) |
| TEST_TARGET_SIZE (PABCFLOAT, 12) |
| TEST_TARGET_ALIGN(PABCFLOAT, 4) |
| } |
| |
| static void test_pack_PANOSE(void) |
| { |
| /* PANOSE */ |
| TEST_TYPE_SIZE (PANOSE, 10) |
| TEST_TYPE_ALIGN (PANOSE, 1) |
| TEST_FIELD_SIZE (PANOSE, bFamilyType, 1) |
| TEST_FIELD_ALIGN (PANOSE, bFamilyType, 1) |
| TEST_FIELD_OFFSET(PANOSE, bFamilyType, 0) |
| TEST_FIELD_SIZE (PANOSE, bSerifStyle, 1) |
| TEST_FIELD_ALIGN (PANOSE, bSerifStyle, 1) |
| TEST_FIELD_OFFSET(PANOSE, bSerifStyle, 1) |
| TEST_FIELD_SIZE (PANOSE, bWeight, 1) |
| TEST_FIELD_ALIGN (PANOSE, bWeight, 1) |
| TEST_FIELD_OFFSET(PANOSE, bWeight, 2) |
| TEST_FIELD_SIZE (PANOSE, bProportion, 1) |
| TEST_FIELD_ALIGN (PANOSE, bProportion, 1) |
| TEST_FIELD_OFFSET(PANOSE, bProportion, 3) |
| TEST_FIELD_SIZE (PANOSE, bContrast, 1) |
| TEST_FIELD_ALIGN (PANOSE, bContrast, 1) |
| TEST_FIELD_OFFSET(PANOSE, bContrast, 4) |
| TEST_FIELD_SIZE (PANOSE, bStrokeVariation, 1) |
| TEST_FIELD_ALIGN (PANOSE, bStrokeVariation, 1) |
| TEST_FIELD_OFFSET(PANOSE, bStrokeVariation, 5) |
| TEST_FIELD_SIZE (PANOSE, bArmStyle, 1) |
| TEST_FIELD_ALIGN (PANOSE, bArmStyle, 1) |
| TEST_FIELD_OFFSET(PANOSE, bArmStyle, 6) |
| TEST_FIELD_SIZE (PANOSE, bLetterform, 1) |
| TEST_FIELD_ALIGN (PANOSE, bLetterform, 1) |
| TEST_FIELD_OFFSET(PANOSE, bLetterform, 7) |
| TEST_FIELD_SIZE (PANOSE, bMidline, 1) |
| TEST_FIELD_ALIGN (PANOSE, bMidline, 1) |
| TEST_FIELD_OFFSET(PANOSE, bMidline, 8) |
| TEST_FIELD_SIZE (PANOSE, bXHeight, 1) |
| TEST_FIELD_ALIGN (PANOSE, bXHeight, 1) |
| TEST_FIELD_OFFSET(PANOSE, bXHeight, 9) |
| } |
| |
| static void test_pack_PATTERN(void) |
| { |
| /* PATTERN */ |
| TEST_TYPE_SIZE (PATTERN, 16) |
| TEST_TYPE_ALIGN (PATTERN, 8) |
| } |
| |
| static void test_pack_PBITMAP(void) |
| { |
| /* PBITMAP */ |
| TEST_TYPE_SIZE (PBITMAP, 8) |
| TEST_TYPE_ALIGN (PBITMAP, 8) |
| TEST_TARGET_SIZE (PBITMAP, 32) |
| TEST_TARGET_ALIGN(PBITMAP, 8) |
| } |
| |
| static void test_pack_PBITMAPCOREHEADER(void) |
| { |
| /* PBITMAPCOREHEADER */ |
| TEST_TYPE_SIZE (PBITMAPCOREHEADER, 8) |
| TEST_TYPE_ALIGN (PBITMAPCOREHEADER, 8) |
| TEST_TARGET_SIZE (PBITMAPCOREHEADER, 12) |
| TEST_TARGET_ALIGN(PBITMAPCOREHEADER, 4) |
| } |
| |
| static void test_pack_PBITMAPCOREINFO(void) |
| { |
| /* PBITMAPCOREINFO */ |
| TEST_TYPE_SIZE (PBITMAPCOREINFO, 8) |
| TEST_TYPE_ALIGN (PBITMAPCOREINFO, 8) |
| TEST_TARGET_SIZE (PBITMAPCOREINFO, 16) |
| TEST_TARGET_ALIGN(PBITMAPCOREINFO, 4) |
| } |
| |
| static void test_pack_PBITMAPFILEHEADER(void) |
| { |
| /* PBITMAPFILEHEADER */ |
| TEST_TYPE_SIZE (PBITMAPFILEHEADER, 8) |
| TEST_TYPE_ALIGN (PBITMAPFILEHEADER, 8) |
| TEST_TARGET_SIZE (PBITMAPFILEHEADER, 14) |
| TEST_TARGET_ALIGN(PBITMAPFILEHEADER, 2) |
| } |
| |
| static void test_pack_PBITMAPINFO(void) |
| { |
| /* PBITMAPINFO */ |
| TEST_TYPE_SIZE (PBITMAPINFO, 8) |
| TEST_TYPE_ALIGN (PBITMAPINFO, 8) |
| TEST_TARGET_SIZE (PBITMAPINFO, 44) |
| TEST_TARGET_ALIGN(PBITMAPINFO, 4) |
| } |
| |
| static void test_pack_PBITMAPINFOHEADER(void) |
| { |
| /* PBITMAPINFOHEADER */ |
| TEST_TYPE_SIZE (PBITMAPINFOHEADER, 8) |
| TEST_TYPE_ALIGN (PBITMAPINFOHEADER, 8) |
| TEST_TARGET_SIZE (PBITMAPINFOHEADER, 40) |
| TEST_TARGET_ALIGN(PBITMAPINFOHEADER, 4) |
| } |
| |
| static void test_pack_PBITMAPV4HEADER(void) |
| { |
| /* PBITMAPV4HEADER */ |
| TEST_TYPE_SIZE (PBITMAPV4HEADER, 8) |
| TEST_TYPE_ALIGN (PBITMAPV4HEADER, 8) |
| TEST_TARGET_SIZE (PBITMAPV4HEADER, 108) |
| TEST_TARGET_ALIGN(PBITMAPV4HEADER, 4) |
| } |
| |
| static void test_pack_PBITMAPV5HEADER(void) |
| { |
| /* PBITMAPV5HEADER */ |
| TEST_TYPE_SIZE (PBITMAPV5HEADER, 8) |
| TEST_TYPE_ALIGN (PBITMAPV5HEADER, 8) |
| TEST_TARGET_SIZE (PBITMAPV5HEADER, 124) |
| TEST_TARGET_ALIGN(PBITMAPV5HEADER, 4) |
| } |
| |
| static void test_pack_PBLENDFUNCTION(void) |
| { |
| /* PBLENDFUNCTION */ |
| TEST_TYPE_SIZE (PBLENDFUNCTION, 8) |
| TEST_TYPE_ALIGN (PBLENDFUNCTION, 8) |
| TEST_TARGET_SIZE (PBLENDFUNCTION, 4) |
| TEST_TARGET_ALIGN(PBLENDFUNCTION, 1) |
| } |
| |
| static void test_pack_PCHARSETINFO(void) |
| { |
| /* PCHARSETINFO */ |
| TEST_TYPE_SIZE (PCHARSETINFO, 8) |
| TEST_TYPE_ALIGN (PCHARSETINFO, 8) |
| TEST_TARGET_SIZE (PCHARSETINFO, 32) |
| TEST_TARGET_ALIGN(PCHARSETINFO, 4) |
| } |
| |
| static void test_pack_PCOLORADJUSTMENT(void) |
| { |
| /* PCOLORADJUSTMENT */ |
| TEST_TYPE_SIZE (PCOLORADJUSTMENT, 8) |
| TEST_TYPE_ALIGN (PCOLORADJUSTMENT, 8) |
| TEST_TARGET_SIZE (PCOLORADJUSTMENT, 24) |
| TEST_TARGET_ALIGN(PCOLORADJUSTMENT, 2) |
| } |
| |
| static void test_pack_PDEVMODEA(void) |
| { |
| /* PDEVMODEA */ |
| TEST_TYPE_SIZE (PDEVMODEA, 8) |
| TEST_TYPE_ALIGN (PDEVMODEA, 8) |
| } |
| |
| static void test_pack_PDEVMODEW(void) |
| { |
| /* PDEVMODEW */ |
| TEST_TYPE_SIZE (PDEVMODEW, 8) |
| TEST_TYPE_ALIGN (PDEVMODEW, 8) |
| } |
| |
| static void test_pack_PDIBSECTION(void) |
| { |
| /* PDIBSECTION */ |
| TEST_TYPE_SIZE (PDIBSECTION, 8) |
| TEST_TYPE_ALIGN (PDIBSECTION, 8) |
| TEST_TARGET_SIZE (PDIBSECTION, 104) |
| TEST_TARGET_ALIGN(PDIBSECTION, 8) |
| } |
| |
| static void test_pack_PDISPLAY_DEVICEA(void) |
| { |
| /* PDISPLAY_DEVICEA */ |
| TEST_TYPE_SIZE (PDISPLAY_DEVICEA, 8) |
| TEST_TYPE_ALIGN (PDISPLAY_DEVICEA, 8) |
| TEST_TARGET_SIZE (PDISPLAY_DEVICEA, 424) |
| TEST_TARGET_ALIGN(PDISPLAY_DEVICEA, 4) |
| } |
| |
| static void test_pack_PDISPLAY_DEVICEW(void) |
| { |
| /* PDISPLAY_DEVICEW */ |
| TEST_TYPE_SIZE (PDISPLAY_DEVICEW, 8) |
| TEST_TYPE_ALIGN (PDISPLAY_DEVICEW, 8) |
| TEST_TARGET_SIZE (PDISPLAY_DEVICEW, 840) |
| TEST_TARGET_ALIGN(PDISPLAY_DEVICEW, 4) |
| } |
| |
| static void test_pack_PELARRAY(void) |
| { |
| /* PELARRAY */ |
| TEST_TYPE_SIZE (PELARRAY, 20) |
| TEST_TYPE_ALIGN (PELARRAY, 4) |
| TEST_FIELD_SIZE (PELARRAY, paXCount, 4) |
| TEST_FIELD_ALIGN (PELARRAY, paXCount, 4) |
| TEST_FIELD_OFFSET(PELARRAY, paXCount, 0) |
| TEST_FIELD_SIZE (PELARRAY, paYCount, 4) |
| TEST_FIELD_ALIGN (PELARRAY, paYCount, 4) |
| TEST_FIELD_OFFSET(PELARRAY, paYCount, 4) |
| TEST_FIELD_SIZE (PELARRAY, paXExt, 4) |
| TEST_FIELD_ALIGN (PELARRAY, paXExt, 4) |
| TEST_FIELD_OFFSET(PELARRAY, paXExt, 8) |
| TEST_FIELD_SIZE (PELARRAY, paYExt, 4) |
| TEST_FIELD_ALIGN (PELARRAY, paYExt, 4) |
| TEST_FIELD_OFFSET(PELARRAY, paYExt, 12) |
| TEST_FIELD_SIZE (PELARRAY, paRGBs, 1) |
| TEST_FIELD_ALIGN (PELARRAY, paRGBs, 1) |
| TEST_FIELD_OFFSET(PELARRAY, paRGBs, 16) |
| } |
| |
| static void test_pack_PEMR(void) |
| { |
| /* PEMR */ |
| TEST_TYPE_SIZE (PEMR, 8) |
| TEST_TYPE_ALIGN (PEMR, 8) |
| TEST_TARGET_SIZE (PEMR, 8) |
| TEST_TARGET_ALIGN(PEMR, 4) |
| } |
| |
| static void test_pack_PEMRABORTPATH(void) |
| { |
| /* PEMRABORTPATH */ |
| TEST_TYPE_SIZE (PEMRABORTPATH, 8) |
| TEST_TYPE_ALIGN (PEMRABORTPATH, 8) |
| TEST_TARGET_SIZE (PEMRABORTPATH, 8) |
| TEST_TARGET_ALIGN(PEMRABORTPATH, 4) |
| } |
| |
| static void test_pack_PEMRANGLEARC(void) |
| { |
| /* PEMRANGLEARC */ |
| TEST_TYPE_SIZE (PEMRANGLEARC, 8) |
| TEST_TYPE_ALIGN (PEMRANGLEARC, 8) |
| TEST_TARGET_SIZE (PEMRANGLEARC, 28) |
| TEST_TARGET_ALIGN(PEMRANGLEARC, 4) |
| } |
| |
| static void test_pack_PEMRARC(void) |
| { |
| /* PEMRARC */ |
| TEST_TYPE_SIZE (PEMRARC, 8) |
| TEST_TYPE_ALIGN (PEMRARC, 8) |
| TEST_TARGET_SIZE (PEMRARC, 40) |
| TEST_TARGET_ALIGN(PEMRARC, 4) |
| } |
| |
| static void test_pack_PEMRARCTO(void) |
| { |
| /* PEMRARCTO */ |
| TEST_TYPE_SIZE (PEMRARCTO, 8) |
| TEST_TYPE_ALIGN (PEMRARCTO, 8) |
| TEST_TARGET_SIZE (PEMRARCTO, 40) |
| TEST_TARGET_ALIGN(PEMRARCTO, 4) |
| } |
| |
| static void test_pack_PEMRBEGINPATH(void) |
| { |
| /* PEMRBEGINPATH */ |
| TEST_TYPE_SIZE (PEMRBEGINPATH, 8) |
| TEST_TYPE_ALIGN (PEMRBEGINPATH, 8) |
| TEST_TARGET_SIZE (PEMRBEGINPATH, 8) |
| TEST_TARGET_ALIGN(PEMRBEGINPATH, 4) |
| } |
| |
| static void test_pack_PEMRBITBLT(void) |
| { |
| /* PEMRBITBLT */ |
| TEST_TYPE_SIZE (PEMRBITBLT, 8) |
| TEST_TYPE_ALIGN (PEMRBITBLT, 8) |
| TEST_TARGET_SIZE (PEMRBITBLT, 100) |
| TEST_TARGET_ALIGN(PEMRBITBLT, 4) |
| } |
| |
| static void test_pack_PEMRCHORD(void) |
| { |
| /* PEMRCHORD */ |
| TEST_TYPE_SIZE (PEMRCHORD, 8) |
| TEST_TYPE_ALIGN (PEMRCHORD, 8) |
| TEST_TARGET_SIZE (PEMRCHORD, 40) |
| TEST_TARGET_ALIGN(PEMRCHORD, 4) |
| } |
| |
| static void test_pack_PEMRCLOSEFIGURE(void) |
| { |
| /* PEMRCLOSEFIGURE */ |
| TEST_TYPE_SIZE (PEMRCLOSEFIGURE, 8) |
| TEST_TYPE_ALIGN (PEMRCLOSEFIGURE, 8) |
| TEST_TARGET_SIZE (PEMRCLOSEFIGURE, 8) |
| TEST_TARGET_ALIGN(PEMRCLOSEFIGURE, 4) |
| } |
| |
| static void test_pack_PEMRCREATEBRUSHINDIRECT(void) |
| { |
| /* PEMRCREATEBRUSHINDIRECT */ |
| TEST_TYPE_SIZE (PEMRCREATEBRUSHINDIRECT, 8) |
| TEST_TYPE_ALIGN (PEMRCREATEBRUSHINDIRECT, 8) |
| TEST_TARGET_SIZE (PEMRCREATEBRUSHINDIRECT, 24) |
| TEST_TARGET_ALIGN(PEMRCREATEBRUSHINDIRECT, 4) |
| } |
| |
| static void test_pack_PEMRCREATECOLORSPACE(void) |
| { |
| /* PEMRCREATECOLORSPACE */ |
| TEST_TYPE_SIZE (PEMRCREATECOLORSPACE, 8) |
| TEST_TYPE_ALIGN (PEMRCREATECOLORSPACE, 8) |
| TEST_TARGET_SIZE (PEMRCREATECOLORSPACE, 340) |
| TEST_TARGET_ALIGN(PEMRCREATECOLORSPACE, 4) |
| } |
| |
| static void test_pack_PEMRCREATECOLORSPACEW(void) |
| { |
| /* PEMRCREATECOLORSPACEW */ |
| TEST_TYPE_SIZE (PEMRCREATECOLORSPACEW, 8) |
| TEST_TYPE_ALIGN (PEMRCREATECOLORSPACEW, 8) |
| TEST_TARGET_SIZE (PEMRCREATECOLORSPACEW, 612) |
| TEST_TARGET_ALIGN(PEMRCREATECOLORSPACEW, 4) |
| } |
| |
| static void test_pack_PEMRCREATEDIBPATTERNBRUSHPT(void) |
| { |
| /* PEMRCREATEDIBPATTERNBRUSHPT */ |
| TEST_TYPE_SIZE (PEMRCREATEDIBPATTERNBRUSHPT, 8) |
| TEST_TYPE_ALIGN (PEMRCREATEDIBPATTERNBRUSHPT, 8) |
| TEST_TARGET_SIZE (PEMRCREATEDIBPATTERNBRUSHPT, 32) |
| TEST_TARGET_ALIGN(PEMRCREATEDIBPATTERNBRUSHPT, 4) |
| } |
| |
| static void test_pack_PEMRCREATEMONOBRUSH(void) |
| { |
| /* PEMRCREATEMONOBRUSH */ |
| TEST_TYPE_SIZE (PEMRCREATEMONOBRUSH, 8) |
| TEST_TYPE_ALIGN (PEMRCREATEMONOBRUSH, 8) |
| TEST_TARGET_SIZE (PEMRCREATEMONOBRUSH, 32) |
| TEST_TARGET_ALIGN(PEMRCREATEMONOBRUSH, 4) |
| } |
| |
| static void test_pack_PEMRCREATEPALETTE(void) |
| { |
| /* PEMRCREATEPALETTE */ |
| TEST_TYPE_SIZE (PEMRCREATEPALETTE, 8) |
| TEST_TYPE_ALIGN (PEMRCREATEPALETTE, 8) |
| TEST_TARGET_SIZE (PEMRCREATEPALETTE, 20) |
| TEST_TARGET_ALIGN(PEMRCREATEPALETTE, 4) |
| } |
| |
| static void test_pack_PEMRCREATEPEN(void) |
| { |
| /* PEMRCREATEPEN */ |
| TEST_TYPE_SIZE (PEMRCREATEPEN, 8) |
| TEST_TYPE_ALIGN (PEMRCREATEPEN, 8) |
| TEST_TARGET_SIZE (PEMRCREATEPEN, 28) |
| TEST_TARGET_ALIGN(PEMRCREATEPEN, 4) |
| } |
| |
| static void test_pack_PEMRDELETECOLORSPACE(void) |
| { |
| /* PEMRDELETECOLORSPACE */ |
| TEST_TYPE_SIZE (PEMRDELETECOLORSPACE, 8) |
| TEST_TYPE_ALIGN (PEMRDELETECOLORSPACE, 8) |
| TEST_TARGET_SIZE (PEMRDELETECOLORSPACE, 12) |
| TEST_TARGET_ALIGN(PEMRDELETECOLORSPACE, 4) |
| } |
| |
| static void test_pack_PEMRDELETEOBJECT(void) |
| { |
| /* PEMRDELETEOBJECT */ |
| TEST_TYPE_SIZE (PEMRDELETEOBJECT, 8) |
| TEST_TYPE_ALIGN (PEMRDELETEOBJECT, 8) |
| TEST_TARGET_SIZE (PEMRDELETEOBJECT, 12) |
| TEST_TARGET_ALIGN(PEMRDELETEOBJECT, 4) |
| } |
| |
| static void test_pack_PEMRELLIPSE(void) |
| { |
| /* PEMRELLIPSE */ |
| TEST_TYPE_SIZE (PEMRELLIPSE, 8) |
| TEST_TYPE_ALIGN (PEMRELLIPSE, 8) |
| TEST_TARGET_SIZE (PEMRELLIPSE, 24) |
| TEST_TARGET_ALIGN(PEMRELLIPSE, 4) |
| } |
| |
| static void test_pack_PEMRENDPATH(void) |
| { |
| /* PEMRENDPATH */ |
| TEST_TYPE_SIZE (PEMRENDPATH, 8) |
| TEST_TYPE_ALIGN (PEMRENDPATH, 8) |
| TEST_TARGET_SIZE (PEMRENDPATH, 8) |
| TEST_TARGET_ALIGN(PEMRENDPATH, 4) |
| } |
| |
| static void test_pack_PEMREOF(void) |
| { |
| /* PEMREOF */ |
| TEST_TYPE_SIZE (PEMREOF, 8) |
| TEST_TYPE_ALIGN (PEMREOF, 8) |
| TEST_TARGET_SIZE (PEMREOF, 20) |
| TEST_TARGET_ALIGN(PEMREOF, 4) |
| } |
| |
| static void test_pack_PEMREXCLUDECLIPRECT(void) |
| { |
| /* PEMREXCLUDECLIPRECT */ |
| TEST_TYPE_SIZE (PEMREXCLUDECLIPRECT, 8) |
| TEST_TYPE_ALIGN (PEMREXCLUDECLIPRECT, 8) |
| TEST_TARGET_SIZE (PEMREXCLUDECLIPRECT, 24) |
| TEST_TARGET_ALIGN(PEMREXCLUDECLIPRECT, 4) |
| } |
| |
| static void test_pack_PEMREXTCREATEFONTINDIRECTW(void) |
| { |
| /* PEMREXTCREATEFONTINDIRECTW */ |
| TEST_TYPE_SIZE (PEMREXTCREATEFONTINDIRECTW, 8) |
| TEST_TYPE_ALIGN (PEMREXTCREATEFONTINDIRECTW, 8) |
| TEST_TARGET_SIZE (PEMREXTCREATEFONTINDIRECTW, 332) |
| TEST_TARGET_ALIGN(PEMREXTCREATEFONTINDIRECTW, 4) |
| } |
| |
| static void test_pack_PEMREXTCREATEPEN(void) |
| { |
| /* PEMREXTCREATEPEN */ |
| TEST_TYPE_SIZE (PEMREXTCREATEPEN, 8) |
| TEST_TYPE_ALIGN (PEMREXTCREATEPEN, 8) |
| TEST_TARGET_SIZE (PEMREXTCREATEPEN, 64) |
| TEST_TARGET_ALIGN(PEMREXTCREATEPEN, 8) |
| } |
| |
| static void test_pack_PEMREXTFLOODFILL(void) |
| { |
| /* PEMREXTFLOODFILL */ |
| TEST_TYPE_SIZE (PEMREXTFLOODFILL, 8) |
| TEST_TYPE_ALIGN (PEMREXTFLOODFILL, 8) |
| TEST_TARGET_SIZE (PEMREXTFLOODFILL, 24) |
| TEST_TARGET_ALIGN(PEMREXTFLOODFILL, 4) |
| } |
| |
| static void test_pack_PEMREXTSELECTCLIPRGN(void) |
| { |
| /* PEMREXTSELECTCLIPRGN */ |
| TEST_TYPE_SIZE (PEMREXTSELECTCLIPRGN, 8) |
| TEST_TYPE_ALIGN (PEMREXTSELECTCLIPRGN, 8) |
| TEST_TARGET_SIZE (PEMREXTSELECTCLIPRGN, 20) |
| TEST_TARGET_ALIGN(PEMREXTSELECTCLIPRGN, 4) |
| } |
| |
| static void test_pack_PEMREXTTEXTOUTA(void) |
| { |
| /* PEMREXTTEXTOUTA */ |
| TEST_TYPE_SIZE (PEMREXTTEXTOUTA, 8) |
| TEST_TYPE_ALIGN (PEMREXTTEXTOUTA, 8) |
| TEST_TARGET_SIZE (PEMREXTTEXTOUTA, 76) |
| TEST_TARGET_ALIGN(PEMREXTTEXTOUTA, 4) |
| } |
| |
| static void test_pack_PEMREXTTEXTOUTW(void) |
| { |
| /* PEMREXTTEXTOUTW */ |
| TEST_TYPE_SIZE (PEMREXTTEXTOUTW, 8) |
| TEST_TYPE_ALIGN (PEMREXTTEXTOUTW, 8) |
| TEST_TARGET_SIZE (PEMREXTTEXTOUTW, 76) |
| TEST_TARGET_ALIGN(PEMREXTTEXTOUTW, 4) |
| } |
| |
| static void test_pack_PEMRFILLPATH(void) |
| { |
| /* PEMRFILLPATH */ |
| TEST_TYPE_SIZE (PEMRFILLPATH, 8) |
| TEST_TYPE_ALIGN (PEMRFILLPATH, 8) |
| TEST_TARGET_SIZE (PEMRFILLPATH, 24) |
| TEST_TARGET_ALIGN(PEMRFILLPATH, 4) |
| } |
| |
| static void test_pack_PEMRFILLRGN(void) |
| { |
| /* PEMRFILLRGN */ |
| TEST_TYPE_SIZE (PEMRFILLRGN, 8) |
| TEST_TYPE_ALIGN (PEMRFILLRGN, 8) |
| TEST_TARGET_SIZE (PEMRFILLRGN, 36) |
| TEST_TARGET_ALIGN(PEMRFILLRGN, 4) |
| } |
| |
| static void test_pack_PEMRFLATTENPATH(void) |
| { |
| /* PEMRFLATTENPATH */ |
| TEST_TYPE_SIZE (PEMRFLATTENPATH, 8) |
| TEST_TYPE_ALIGN (PEMRFLATTENPATH, 8) |
| TEST_TARGET_SIZE (PEMRFLATTENPATH, 8) |
| TEST_TARGET_ALIGN(PEMRFLATTENPATH, 4) |
| } |
| |
| static void test_pack_PEMRFORMAT(void) |
| { |
| /* PEMRFORMAT */ |
| TEST_TYPE_SIZE (PEMRFORMAT, 8) |
| TEST_TYPE_ALIGN (PEMRFORMAT, 8) |
| TEST_TARGET_SIZE (PEMRFORMAT, 16) |
| TEST_TARGET_ALIGN(PEMRFORMAT, 4) |
| } |
| |
| static void test_pack_PEMRFRAMERGN(void) |
| { |
| /* PEMRFRAMERGN */ |
| TEST_TYPE_SIZE (PEMRFRAMERGN, 8) |
| TEST_TYPE_ALIGN (PEMRFRAMERGN, 8) |
| TEST_TARGET_SIZE (PEMRFRAMERGN, 44) |
| TEST_TARGET_ALIGN(PEMRFRAMERGN, 4) |
| } |
| |
| static void test_pack_PEMRGDICOMMENT(void) |
| { |
| /* PEMRGDICOMMENT */ |
| TEST_TYPE_SIZE (PEMRGDICOMMENT, 8) |
| TEST_TYPE_ALIGN (PEMRGDICOMMENT, 8) |
| TEST_TARGET_SIZE (PEMRGDICOMMENT, 16) |
| TEST_TARGET_ALIGN(PEMRGDICOMMENT, 4) |
| } |
| |
| static void test_pack_PEMRGLSBOUNDEDRECORD(void) |
| { |
| /* PEMRGLSBOUNDEDRECORD */ |
| TEST_TYPE_SIZE (PEMRGLSBOUNDEDRECORD, 8) |
| TEST_TYPE_ALIGN (PEMRGLSBOUNDEDRECORD, 8) |
| TEST_TARGET_SIZE (PEMRGLSBOUNDEDRECORD, 32) |
| TEST_TARGET_ALIGN(PEMRGLSBOUNDEDRECORD, 4) |
| } |
| |
| static void test_pack_PEMRGLSRECORD(void) |
| { |
| /* PEMRGLSRECORD */ |
| TEST_TYPE_SIZE (PEMRGLSRECORD, 8) |
| TEST_TYPE_ALIGN (PEMRGLSRECORD, 8) |
| TEST_TARGET_SIZE (PEMRGLSRECORD, 16) |
| TEST_TARGET_ALIGN(PEMRGLSRECORD, 4) |
| } |
| |
| static void test_pack_PEMRINTERSECTCLIPRECT(void) |
| { |
| /* PEMRINTERSECTCLIPRECT */ |
| TEST_TYPE_SIZE (PEMRINTERSECTCLIPRECT, 8) |
| TEST_TYPE_ALIGN (PEMRINTERSECTCLIPRECT, 8) |
| TEST_TARGET_SIZE (PEMRINTERSECTCLIPRECT, 24) |
| TEST_TARGET_ALIGN(PEMRINTERSECTCLIPRECT, 4) |
| } |
| |
| static void test_pack_PEMRINVERTRGN(void) |
| { |
| /* PEMRINVERTRGN */ |
| TEST_TYPE_SIZE (PEMRINVERTRGN, 8) |
| TEST_TYPE_ALIGN (PEMRINVERTRGN, 8) |
| TEST_TARGET_SIZE (PEMRINVERTRGN, 32) |
| TEST_TARGET_ALIGN(PEMRINVERTRGN, 4) |
| } |
| |
| static void test_pack_PEMRLINETO(void) |
| { |
| /* PEMRLINETO */ |
| TEST_TYPE_SIZE (PEMRLINETO, 8) |
| TEST_TYPE_ALIGN (PEMRLINETO, 8) |
| TEST_TARGET_SIZE (PEMRLINETO, 16) |
| TEST_TARGET_ALIGN(PEMRLINETO, 4) |
| } |
| |
| static void test_pack_PEMRMASKBLT(void) |
| { |
| /* PEMRMASKBLT */ |
| TEST_TYPE_SIZE (PEMRMASKBLT, 8) |
| TEST_TYPE_ALIGN (PEMRMASKBLT, 8) |
| TEST_TARGET_SIZE (PEMRMASKBLT, 128) |
| TEST_TARGET_ALIGN(PEMRMASKBLT, 4) |
| } |
| |
| static void test_pack_PEMRMODIFYWORLDTRANSFORM(void) |
| { |
| /* PEMRMODIFYWORLDTRANSFORM */ |
| TEST_TYPE_SIZE (PEMRMODIFYWORLDTRANSFORM, 8) |
| TEST_TYPE_ALIGN (PEMRMODIFYWORLDTRANSFORM, 8) |
| TEST_TARGET_SIZE (PEMRMODIFYWORLDTRANSFORM, 36) |
| TEST_TARGET_ALIGN(PEMRMODIFYWORLDTRANSFORM, 4) |
| } |
| |
| static void test_pack_PEMRMOVETOEX(void) |
| { |
| /* PEMRMOVETOEX */ |
| TEST_TYPE_SIZE (PEMRMOVETOEX, 8) |
| TEST_TYPE_ALIGN (PEMRMOVETOEX, 8) |
| TEST_TARGET_SIZE (PEMRMOVETOEX, 16) |
| TEST_TARGET_ALIGN(PEMRMOVETOEX, 4) |
| } |
| |
| static void test_pack_PEMROFFSETCLIPRGN(void) |
| { |
| /* PEMROFFSETCLIPRGN */ |
| TEST_TYPE_SIZE (PEMROFFSETCLIPRGN, 8) |
| TEST_TYPE_ALIGN (PEMROFFSETCLIPRGN, 8) |
| TEST_TARGET_SIZE (PEMROFFSETCLIPRGN, 16) |
| TEST_TARGET_ALIGN(PEMROFFSETCLIPRGN, 4) |
| } |
| |
| static void test_pack_PEMRPAINTRGN(void) |
| { |
| /* PEMRPAINTRGN */ |
| TEST_TYPE_SIZE (PEMRPAINTRGN, 8) |
| TEST_TYPE_ALIGN (PEMRPAINTRGN, 8) |
| TEST_TARGET_SIZE (PEMRPAINTRGN, 32) |
| TEST_TARGET_ALIGN(PEMRPAINTRGN, 4) |
| } |
| |
| static void test_pack_PEMRPIE(void) |
| { |
| /* PEMRPIE */ |
| TEST_TYPE_SIZE (PEMRPIE, 8) |
| TEST_TYPE_ALIGN (PEMRPIE, 8) |
| TEST_TARGET_SIZE (PEMRPIE, 40) |
| TEST_TARGET_ALIGN(PEMRPIE, 4) |
| } |
| |
| static void test_pack_PEMRPIXELFORMAT(void) |
| { |
| /* PEMRPIXELFORMAT */ |
| TEST_TYPE_SIZE (PEMRPIXELFORMAT, 8) |
| TEST_TYPE_ALIGN (PEMRPIXELFORMAT, 8) |
| TEST_TARGET_SIZE (PEMRPIXELFORMAT, 48) |
| TEST_TARGET_ALIGN(PEMRPIXELFORMAT, 4) |
| } |
| |
| static void test_pack_PEMRPLGBLT(void) |
| { |
| /* PEMRPLGBLT */ |
| TEST_TYPE_SIZE (PEMRPLGBLT, 8) |
| TEST_TYPE_ALIGN (PEMRPLGBLT, 8) |
| TEST_TARGET_SIZE (PEMRPLGBLT, 140) |
| TEST_TARGET_ALIGN(PEMRPLGBLT, 4) |
| } |
| |
| static void test_pack_PEMRPOLYBEZIER(void) |
| { |
| /* PEMRPOLYBEZIER */ |
| TEST_TYPE_SIZE (PEMRPOLYBEZIER, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYBEZIER, 8) |
| TEST_TARGET_SIZE (PEMRPOLYBEZIER, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYBEZIER, 4) |
| } |
| |
| static void test_pack_PEMRPOLYBEZIER16(void) |
| { |
| /* PEMRPOLYBEZIER16 */ |
| TEST_TYPE_SIZE (PEMRPOLYBEZIER16, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYBEZIER16, 8) |
| TEST_TARGET_SIZE (PEMRPOLYBEZIER16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYBEZIER16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYBEZIERTO(void) |
| { |
| /* PEMRPOLYBEZIERTO */ |
| TEST_TYPE_SIZE (PEMRPOLYBEZIERTO, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYBEZIERTO, 8) |
| TEST_TARGET_SIZE (PEMRPOLYBEZIERTO, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYBEZIERTO, 4) |
| } |
| |
| static void test_pack_PEMRPOLYBEZIERTO16(void) |
| { |
| /* PEMRPOLYBEZIERTO16 */ |
| TEST_TYPE_SIZE (PEMRPOLYBEZIERTO16, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYBEZIERTO16, 8) |
| TEST_TARGET_SIZE (PEMRPOLYBEZIERTO16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYBEZIERTO16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYDRAW(void) |
| { |
| /* PEMRPOLYDRAW */ |
| TEST_TYPE_SIZE (PEMRPOLYDRAW, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYDRAW, 8) |
| TEST_TARGET_SIZE (PEMRPOLYDRAW, 40) |
| TEST_TARGET_ALIGN(PEMRPOLYDRAW, 4) |
| } |
| |
| static void test_pack_PEMRPOLYDRAW16(void) |
| { |
| /* PEMRPOLYDRAW16 */ |
| TEST_TYPE_SIZE (PEMRPOLYDRAW16, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYDRAW16, 8) |
| TEST_TARGET_SIZE (PEMRPOLYDRAW16, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYDRAW16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYGON(void) |
| { |
| /* PEMRPOLYGON */ |
| TEST_TYPE_SIZE (PEMRPOLYGON, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYGON, 8) |
| TEST_TARGET_SIZE (PEMRPOLYGON, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYGON, 4) |
| } |
| |
| static void test_pack_PEMRPOLYGON16(void) |
| { |
| /* PEMRPOLYGON16 */ |
| TEST_TYPE_SIZE (PEMRPOLYGON16, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYGON16, 8) |
| TEST_TARGET_SIZE (PEMRPOLYGON16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYGON16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYLINE(void) |
| { |
| /* PEMRPOLYLINE */ |
| TEST_TYPE_SIZE (PEMRPOLYLINE, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYLINE, 8) |
| TEST_TARGET_SIZE (PEMRPOLYLINE, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYLINE, 4) |
| } |
| |
| static void test_pack_PEMRPOLYLINE16(void) |
| { |
| /* PEMRPOLYLINE16 */ |
| TEST_TYPE_SIZE (PEMRPOLYLINE16, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYLINE16, 8) |
| TEST_TARGET_SIZE (PEMRPOLYLINE16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYLINE16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYLINETO(void) |
| { |
| /* PEMRPOLYLINETO */ |
| TEST_TYPE_SIZE (PEMRPOLYLINETO, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYLINETO, 8) |
| TEST_TARGET_SIZE (PEMRPOLYLINETO, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYLINETO, 4) |
| } |
| |
| static void test_pack_PEMRPOLYLINETO16(void) |
| { |
| /* PEMRPOLYLINETO16 */ |
| TEST_TYPE_SIZE (PEMRPOLYLINETO16, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYLINETO16, 8) |
| TEST_TARGET_SIZE (PEMRPOLYLINETO16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYLINETO16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYPOLYGON(void) |
| { |
| /* PEMRPOLYPOLYGON */ |
| TEST_TYPE_SIZE (PEMRPOLYPOLYGON, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYPOLYGON, 8) |
| TEST_TARGET_SIZE (PEMRPOLYPOLYGON, 44) |
| TEST_TARGET_ALIGN(PEMRPOLYPOLYGON, 4) |
| } |
| |
| static void test_pack_PEMRPOLYPOLYGON16(void) |
| { |
| /* PEMRPOLYPOLYGON16 */ |
| TEST_TYPE_SIZE (PEMRPOLYPOLYGON16, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYPOLYGON16, 8) |
| TEST_TARGET_SIZE (PEMRPOLYPOLYGON16, 40) |
| TEST_TARGET_ALIGN(PEMRPOLYPOLYGON16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYPOLYLINE(void) |
| { |
| /* PEMRPOLYPOLYLINE */ |
| TEST_TYPE_SIZE (PEMRPOLYPOLYLINE, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYPOLYLINE, 8) |
| TEST_TARGET_SIZE (PEMRPOLYPOLYLINE, 44) |
| TEST_TARGET_ALIGN(PEMRPOLYPOLYLINE, 4) |
| } |
| |
| static void test_pack_PEMRPOLYPOLYLINE16(void) |
| { |
| /* PEMRPOLYPOLYLINE16 */ |
| TEST_TYPE_SIZE (PEMRPOLYPOLYLINE16, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYPOLYLINE16, 8) |
| TEST_TARGET_SIZE (PEMRPOLYPOLYLINE16, 40) |
| TEST_TARGET_ALIGN(PEMRPOLYPOLYLINE16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYTEXTOUTA(void) |
| { |
| /* PEMRPOLYTEXTOUTA */ |
| TEST_TYPE_SIZE (PEMRPOLYTEXTOUTA, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYTEXTOUTA, 8) |
| TEST_TARGET_SIZE (PEMRPOLYTEXTOUTA, 80) |
| TEST_TARGET_ALIGN(PEMRPOLYTEXTOUTA, 4) |
| } |
| |
| static void test_pack_PEMRPOLYTEXTOUTW(void) |
| { |
| /* PEMRPOLYTEXTOUTW */ |
| TEST_TYPE_SIZE (PEMRPOLYTEXTOUTW, 8) |
| TEST_TYPE_ALIGN (PEMRPOLYTEXTOUTW, 8) |
| TEST_TARGET_SIZE (PEMRPOLYTEXTOUTW, 80) |
| TEST_TARGET_ALIGN(PEMRPOLYTEXTOUTW, 4) |
| } |
| |
| static void test_pack_PEMRREALIZEPALETTE(void) |
| { |
| /* PEMRREALIZEPALETTE */ |
| TEST_TYPE_SIZE (PEMRREALIZEPALETTE, 8) |
| TEST_TYPE_ALIGN (PEMRREALIZEPALETTE, 8) |
| TEST_TARGET_SIZE (PEMRREALIZEPALETTE, 8) |
| TEST_TARGET_ALIGN(PEMRREALIZEPALETTE, 4) |
| } |
| |
| static void test_pack_PEMRRECTANGLE(void) |
| { |
| /* PEMRRECTANGLE */ |
| TEST_TYPE_SIZE (PEMRRECTANGLE, 8) |
| TEST_TYPE_ALIGN (PEMRRECTANGLE, 8) |
| TEST_TARGET_SIZE (PEMRRECTANGLE, 24) |
| TEST_TARGET_ALIGN(PEMRRECTANGLE, 4) |
| } |
| |
| static void test_pack_PEMRRESIZEPALETTE(void) |
| { |
| /* PEMRRESIZEPALETTE */ |
| TEST_TYPE_SIZE (PEMRRESIZEPALETTE, 8) |
| TEST_TYPE_ALIGN (PEMRRESIZEPALETTE, 8) |
| TEST_TARGET_SIZE (PEMRRESIZEPALETTE, 16) |
| TEST_TARGET_ALIGN(PEMRRESIZEPALETTE, 4) |
| } |
| |
| static void test_pack_PEMRRESTOREDC(void) |
| { |
| /* PEMRRESTOREDC */ |
| TEST_TYPE_SIZE (PEMRRESTOREDC, 8) |
| TEST_TYPE_ALIGN (PEMRRESTOREDC, 8) |
| TEST_TARGET_SIZE (PEMRRESTOREDC, 12) |
| TEST_TARGET_ALIGN(PEMRRESTOREDC, 4) |
| } |
| |
| static void test_pack_PEMRROUNDRECT(void) |
| { |
| /* PEMRROUNDRECT */ |
| TEST_TYPE_SIZE (PEMRROUNDRECT, 8) |
| TEST_TYPE_ALIGN (PEMRROUNDRECT, 8) |
| TEST_TARGET_SIZE (PEMRROUNDRECT, 32) |
| TEST_TARGET_ALIGN(PEMRROUNDRECT, 4) |
| } |
| |
| static void test_pack_PEMRSAVEDC(void) |
| { |
| /* PEMRSAVEDC */ |
| TEST_TYPE_SIZE (PEMRSAVEDC, 8) |
| TEST_TYPE_ALIGN (PEMRSAVEDC, 8) |
| TEST_TARGET_SIZE (PEMRSAVEDC, 8) |
| TEST_TARGET_ALIGN(PEMRSAVEDC, 4) |
| } |
| |
| static void test_pack_PEMRSCALEVIEWPORTEXTEX(void) |
| { |
| /* PEMRSCALEVIEWPORTEXTEX */ |
| TEST_TYPE_SIZE (PEMRSCALEVIEWPORTEXTEX, 8) |
| TEST_TYPE_ALIGN (PEMRSCALEVIEWPORTEXTEX, 8) |
| TEST_TARGET_SIZE (PEMRSCALEVIEWPORTEXTEX, 24) |
| TEST_TARGET_ALIGN(PEMRSCALEVIEWPORTEXTEX, 4) |
| } |
| |
| static void test_pack_PEMRSCALEWINDOWEXTEX(void) |
| { |
| /* PEMRSCALEWINDOWEXTEX */ |
| TEST_TYPE_SIZE (PEMRSCALEWINDOWEXTEX, 8) |
| TEST_TYPE_ALIGN (PEMRSCALEWINDOWEXTEX, 8) |
| TEST_TARGET_SIZE (PEMRSCALEWINDOWEXTEX, 24) |
| TEST_TARGET_ALIGN(PEMRSCALEWINDOWEXTEX, 4) |
| } |
| |
| static void test_pack_PEMRSELECTCLIPPATH(void) |
| { |
| /* PEMRSELECTCLIPPATH */ |
| TEST_TYPE_SIZE (PEMRSELECTCLIPPATH, 8) |
| TEST_TYPE_ALIGN (PEMRSELECTCLIPPATH, 8) |
| TEST_TARGET_SIZE (PEMRSELECTCLIPPATH, 12) |
| TEST_TARGET_ALIGN(PEMRSELECTCLIPPATH, 4) |
| } |
| |
| static void test_pack_PEMRSELECTCOLORSPACE(void) |
| { |
| /* PEMRSELECTCOLORSPACE */ |
| TEST_TYPE_SIZE (PEMRSELECTCOLORSPACE, 8) |
| TEST_TYPE_ALIGN (PEMRSELECTCOLORSPACE, 8) |
| TEST_TARGET_SIZE (PEMRSELECTCOLORSPACE, 12) |
| TEST_TARGET_ALIGN(PEMRSELECTCOLORSPACE, 4) |
| } |
| |
| static void test_pack_PEMRSELECTOBJECT(void) |
| { |
| /* PEMRSELECTOBJECT */ |
| TEST_TYPE_SIZE (PEMRSELECTOBJECT, 8) |
| TEST_TYPE_ALIGN (PEMRSELECTOBJECT, 8) |
| TEST_TARGET_SIZE (PEMRSELECTOBJECT, 12) |
| TEST_TARGET_ALIGN(PEMRSELECTOBJECT, 4) |
| } |
| |
| static void test_pack_PEMRSELECTPALETTE(void) |
| { |
| /* PEMRSELECTPALETTE */ |
| TEST_TYPE_SIZE (PEMRSELECTPALETTE, 8) |
| TEST_TYPE_ALIGN (PEMRSELECTPALETTE, 8) |
| TEST_TARGET_SIZE (PEMRSELECTPALETTE, 12) |
| TEST_TARGET_ALIGN(PEMRSELECTPALETTE, 4) |
| } |
| |
| static void test_pack_PEMRSETARCDIRECTION(void) |
| { |
| /* PEMRSETARCDIRECTION */ |
| TEST_TYPE_SIZE (PEMRSETARCDIRECTION, 8) |
| TEST_TYPE_ALIGN (PEMRSETARCDIRECTION, 8) |
| TEST_TARGET_SIZE (PEMRSETARCDIRECTION, 12) |
| TEST_TARGET_ALIGN(PEMRSETARCDIRECTION, 4) |
| } |
| |
| static void test_pack_PEMRSETBKCOLOR(void) |
| { |
| /* PEMRSETBKCOLOR */ |
| TEST_TYPE_SIZE (PEMRSETBKCOLOR, 8) |
| TEST_TYPE_ALIGN (PEMRSETBKCOLOR, 8) |
| TEST_TARGET_SIZE (PEMRSETBKCOLOR, 12) |
| TEST_TARGET_ALIGN(PEMRSETBKCOLOR, 4) |
| } |
| |
| static void test_pack_PEMRSETBKMODE(void) |
| { |
| /* PEMRSETBKMODE */ |
| TEST_TYPE_SIZE (PEMRSETBKMODE, 8) |
| TEST_TYPE_ALIGN (PEMRSETBKMODE, 8) |
| TEST_TARGET_SIZE (PEMRSETBKMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETBKMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETBRUSHORGEX(void) |
| { |
| /* PEMRSETBRUSHORGEX */ |
| TEST_TYPE_SIZE (PEMRSETBRUSHORGEX, 8) |
| TEST_TYPE_ALIGN (PEMRSETBRUSHORGEX, 8) |
| TEST_TARGET_SIZE (PEMRSETBRUSHORGEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETBRUSHORGEX, 4) |
| } |
| |
| static void test_pack_PEMRSETCOLORADJUSTMENT(void) |
| { |
| /* PEMRSETCOLORADJUSTMENT */ |
| TEST_TYPE_SIZE (PEMRSETCOLORADJUSTMENT, 8) |
| TEST_TYPE_ALIGN (PEMRSETCOLORADJUSTMENT, 8) |
| TEST_TARGET_SIZE (PEMRSETCOLORADJUSTMENT, 32) |
| TEST_TARGET_ALIGN(PEMRSETCOLORADJUSTMENT, 4) |
| } |
| |
| static void test_pack_PEMRSETCOLORSPACE(void) |
| { |
| /* PEMRSETCOLORSPACE */ |
| TEST_TYPE_SIZE (PEMRSETCOLORSPACE, 8) |
| TEST_TYPE_ALIGN (PEMRSETCOLORSPACE, 8) |
| TEST_TARGET_SIZE (PEMRSETCOLORSPACE, 12) |
| TEST_TARGET_ALIGN(PEMRSETCOLORSPACE, 4) |
| } |
| |
| static void test_pack_PEMRSETDIBITSTODEVICE(void) |
| { |
| /* PEMRSETDIBITSTODEVICE */ |
| TEST_TYPE_SIZE (PEMRSETDIBITSTODEVICE, 8) |
| TEST_TYPE_ALIGN (PEMRSETDIBITSTODEVICE, 8) |
| TEST_TARGET_SIZE (PEMRSETDIBITSTODEVICE, 76) |
| TEST_TARGET_ALIGN(PEMRSETDIBITSTODEVICE, 4) |
| } |
| |
| static void test_pack_PEMRSETICMMODE(void) |
| { |
| /* PEMRSETICMMODE */ |
| TEST_TYPE_SIZE (PEMRSETICMMODE, 8) |
| TEST_TYPE_ALIGN (PEMRSETICMMODE, 8) |
| TEST_TARGET_SIZE (PEMRSETICMMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETICMMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETLAYOUT(void) |
| { |
| /* PEMRSETLAYOUT */ |
| TEST_TYPE_SIZE (PEMRSETLAYOUT, 8) |
| TEST_TYPE_ALIGN (PEMRSETLAYOUT, 8) |
| TEST_TARGET_SIZE (PEMRSETLAYOUT, 12) |
| TEST_TARGET_ALIGN(PEMRSETLAYOUT, 4) |
| } |
| |
| static void test_pack_PEMRSETMAPMODE(void) |
| { |
| /* PEMRSETMAPMODE */ |
| TEST_TYPE_SIZE (PEMRSETMAPMODE, 8) |
| TEST_TYPE_ALIGN (PEMRSETMAPMODE, 8) |
| TEST_TARGET_SIZE (PEMRSETMAPMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETMAPMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETMAPPERFLAGS(void) |
| { |
| /* PEMRSETMAPPERFLAGS */ |
| TEST_TYPE_SIZE (PEMRSETMAPPERFLAGS, 8) |
| TEST_TYPE_ALIGN (PEMRSETMAPPERFLAGS, 8) |
| TEST_TARGET_SIZE (PEMRSETMAPPERFLAGS, 12) |
| TEST_TARGET_ALIGN(PEMRSETMAPPERFLAGS, 4) |
| } |
| |
| static void test_pack_PEMRSETMETARGN(void) |
| { |
| /* PEMRSETMETARGN */ |
| TEST_TYPE_SIZE (PEMRSETMETARGN, 8) |
| TEST_TYPE_ALIGN (PEMRSETMETARGN, 8) |
| TEST_TARGET_SIZE (PEMRSETMETARGN, 8) |
| TEST_TARGET_ALIGN(PEMRSETMETARGN, 4) |
| } |
| |
| static void test_pack_PEMRSETMITERLIMIT(void) |
| { |
| /* PEMRSETMITERLIMIT */ |
| TEST_TYPE_SIZE (PEMRSETMITERLIMIT, 8) |
| TEST_TYPE_ALIGN (PEMRSETMITERLIMIT, 8) |
| TEST_TARGET_SIZE (PEMRSETMITERLIMIT, 12) |
| TEST_TARGET_ALIGN(PEMRSETMITERLIMIT, 4) |
| } |
| |
| static void test_pack_PEMRSETPALETTEENTRIES(void) |
| { |
| /* PEMRSETPALETTEENTRIES */ |
| TEST_TYPE_SIZE (PEMRSETPALETTEENTRIES, 8) |
| TEST_TYPE_ALIGN (PEMRSETPALETTEENTRIES, 8) |
| TEST_TARGET_SIZE (PEMRSETPALETTEENTRIES, 24) |
| TEST_TARGET_ALIGN(PEMRSETPALETTEENTRIES, 4) |
| } |
| |
| static void test_pack_PEMRSETPIXELV(void) |
| { |
| /* PEMRSETPIXELV */ |
| TEST_TYPE_SIZE (PEMRSETPIXELV, 8) |
| TEST_TYPE_ALIGN (PEMRSETPIXELV, 8) |
| TEST_TARGET_SIZE (PEMRSETPIXELV, 20) |
| TEST_TARGET_ALIGN(PEMRSETPIXELV, 4) |
| } |
| |
| static void test_pack_PEMRSETPOLYFILLMODE(void) |
| { |
| /* PEMRSETPOLYFILLMODE */ |
| TEST_TYPE_SIZE (PEMRSETPOLYFILLMODE, 8) |
| TEST_TYPE_ALIGN (PEMRSETPOLYFILLMODE, 8) |
| TEST_TARGET_SIZE (PEMRSETPOLYFILLMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETPOLYFILLMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETROP2(void) |
| { |
| /* PEMRSETROP2 */ |
| TEST_TYPE_SIZE (PEMRSETROP2, 8) |
| TEST_TYPE_ALIGN (PEMRSETROP2, 8) |
| TEST_TARGET_SIZE (PEMRSETROP2, 12) |
| TEST_TARGET_ALIGN(PEMRSETROP2, 4) |
| } |
| |
| static void test_pack_PEMRSETSTRETCHBLTMODE(void) |
| { |
| /* PEMRSETSTRETCHBLTMODE */ |
| TEST_TYPE_SIZE (PEMRSETSTRETCHBLTMODE, 8) |
| TEST_TYPE_ALIGN (PEMRSETSTRETCHBLTMODE, 8) |
| TEST_TARGET_SIZE (PEMRSETSTRETCHBLTMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETSTRETCHBLTMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETTEXTALIGN(void) |
| { |
| /* PEMRSETTEXTALIGN */ |
| TEST_TYPE_SIZE (PEMRSETTEXTALIGN, 8) |
| TEST_TYPE_ALIGN (PEMRSETTEXTALIGN, 8) |
| TEST_TARGET_SIZE (PEMRSETTEXTALIGN, 12) |
| TEST_TARGET_ALIGN(PEMRSETTEXTALIGN, 4) |
| } |
| |
| static void test_pack_PEMRSETTEXTCOLOR(void) |
| { |
| /* PEMRSETTEXTCOLOR */ |
| TEST_TYPE_SIZE (PEMRSETTEXTCOLOR, 8) |
| TEST_TYPE_ALIGN (PEMRSETTEXTCOLOR, 8) |
| TEST_TARGET_SIZE (PEMRSETTEXTCOLOR, 12) |
| TEST_TARGET_ALIGN(PEMRSETTEXTCOLOR, 4) |
| } |
| |
| static void test_pack_PEMRSETVIEWPORTEXTEX(void) |
| { |
| /* PEMRSETVIEWPORTEXTEX */ |
| TEST_TYPE_SIZE (PEMRSETVIEWPORTEXTEX, 8) |
| TEST_TYPE_ALIGN (PEMRSETVIEWPORTEXTEX, 8) |
| TEST_TARGET_SIZE (PEMRSETVIEWPORTEXTEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETVIEWPORTEXTEX, 4) |
| } |
| |
| static void test_pack_PEMRSETVIEWPORTORGEX(void) |
| { |
| /* PEMRSETVIEWPORTORGEX */ |
| TEST_TYPE_SIZE (PEMRSETVIEWPORTORGEX, 8) |
| TEST_TYPE_ALIGN (PEMRSETVIEWPORTORGEX, 8) |
| TEST_TARGET_SIZE (PEMRSETVIEWPORTORGEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETVIEWPORTORGEX, 4) |
| } |
| |
| static void test_pack_PEMRSETWINDOWEXTEX(void) |
| { |
| /* PEMRSETWINDOWEXTEX */ |
| TEST_TYPE_SIZE (PEMRSETWINDOWEXTEX, 8) |
| TEST_TYPE_ALIGN (PEMRSETWINDOWEXTEX, 8) |
| TEST_TARGET_SIZE (PEMRSETWINDOWEXTEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETWINDOWEXTEX, 4) |
| } |
| |
| static void test_pack_PEMRSETWINDOWORGEX(void) |
| { |
| /* PEMRSETWINDOWORGEX */ |
| TEST_TYPE_SIZE (PEMRSETWINDOWORGEX, 8) |
| TEST_TYPE_ALIGN (PEMRSETWINDOWORGEX, 8) |
| TEST_TARGET_SIZE (PEMRSETWINDOWORGEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETWINDOWORGEX, 4) |
| } |
| |
| static void test_pack_PEMRSETWORLDTRANSFORM(void) |
| { |
| /* PEMRSETWORLDTRANSFORM */ |
| TEST_TYPE_SIZE (PEMRSETWORLDTRANSFORM, 8) |
| TEST_TYPE_ALIGN (PEMRSETWORLDTRANSFORM, 8) |
| TEST_TARGET_SIZE (PEMRSETWORLDTRANSFORM, 32) |
| TEST_TARGET_ALIGN(PEMRSETWORLDTRANSFORM, 4) |
| } |
| |
| static void test_pack_PEMRSTRETCHBLT(void) |
| { |
| /* PEMRSTRETCHBLT */ |
| TEST_TYPE_SIZE (PEMRSTRETCHBLT, 8) |
| TEST_TYPE_ALIGN (PEMRSTRETCHBLT, 8) |
| TEST_TARGET_SIZE (PEMRSTRETCHBLT, 108) |
| TEST_TARGET_ALIGN(PEMRSTRETCHBLT, 4) |
| } |
| |
| static void test_pack_PEMRSTRETCHDIBITS(void) |
| { |
| /* PEMRSTRETCHDIBITS */ |
| TEST_TYPE_SIZE (PEMRSTRETCHDIBITS, 8) |
| TEST_TYPE_ALIGN (PEMRSTRETCHDIBITS, 8) |
| TEST_TARGET_SIZE (PEMRSTRETCHDIBITS, 80) |
| TEST_TARGET_ALIGN(PEMRSTRETCHDIBITS, 4) |
| } |
| |
| static void test_pack_PEMRSTROKEANDFILLPATH(void) |
| { |
| /* PEMRSTROKEANDFILLPATH */ |
| TEST_TYPE_SIZE (PEMRSTROKEANDFILLPATH, 8) |
| TEST_TYPE_ALIGN (PEMRSTROKEANDFILLPATH, 8) |
| TEST_TARGET_SIZE (PEMRSTROKEANDFILLPATH, 24) |
| TEST_TARGET_ALIGN(PEMRSTROKEANDFILLPATH, 4) |
| } |
| |
| static void test_pack_PEMRSTROKEPATH(void) |
| { |
| /* PEMRSTROKEPATH */ |
| TEST_TYPE_SIZE (PEMRSTROKEPATH, 8) |
| TEST_TYPE_ALIGN (PEMRSTROKEPATH, 8) |
| TEST_TARGET_SIZE (PEMRSTROKEPATH, 24) |
| TEST_TARGET_ALIGN(PEMRSTROKEPATH, 4) |
| } |
| |
| static void test_pack_PEMRTEXT(void) |
| { |
| /* PEMRTEXT */ |
| TEST_TYPE_SIZE (PEMRTEXT, 8) |
| TEST_TYPE_ALIGN (PEMRTEXT, 8) |
| TEST_TARGET_SIZE (PEMRTEXT, 40) |
| TEST_TARGET_ALIGN(PEMRTEXT, 4) |
| } |
| |
| static void test_pack_PEMRWIDENPATH(void) |
| { |
| /* PEMRWIDENPATH */ |
| TEST_TYPE_SIZE (PEMRWIDENPATH, 8) |
| TEST_TYPE_ALIGN (PEMRWIDENPATH, 8) |
| TEST_TARGET_SIZE (PEMRWIDENPATH, 8) |
| TEST_TARGET_ALIGN(PEMRWIDENPATH, 4) |
| } |
| |
| static void test_pack_PENHMETAHEADER(void) |
| { |
| /* PENHMETAHEADER */ |
| TEST_TYPE_SIZE (PENHMETAHEADER, 8) |
| TEST_TYPE_ALIGN (PENHMETAHEADER, 8) |
| TEST_TARGET_SIZE (PENHMETAHEADER, 108) |
| TEST_TARGET_ALIGN(PENHMETAHEADER, 4) |
| } |
| |
| static void test_pack_PEXTLOGFONTA(void) |
| { |
| /* PEXTLOGFONTA */ |
| TEST_TYPE_SIZE (PEXTLOGFONTA, 8) |
| TEST_TYPE_ALIGN (PEXTLOGFONTA, 8) |
| TEST_TARGET_SIZE (PEXTLOGFONTA, 192) |
| TEST_TARGET_ALIGN(PEXTLOGFONTA, 4) |
| } |
| |
| static void test_pack_PEXTLOGFONTW(void) |
| { |
| /* PEXTLOGFONTW */ |
| TEST_TYPE_SIZE (PEXTLOGFONTW, 8) |
| TEST_TYPE_ALIGN (PEXTLOGFONTW, 8) |
| TEST_TARGET_SIZE (PEXTLOGFONTW, 320) |
| TEST_TARGET_ALIGN(PEXTLOGFONTW, 4) |
| } |
| |
| static void test_pack_PEXTLOGPEN(void) |
| { |
| /* PEXTLOGPEN */ |
| TEST_TYPE_SIZE (PEXTLOGPEN, 8) |
| TEST_TYPE_ALIGN (PEXTLOGPEN, 8) |
| TEST_TARGET_SIZE (PEXTLOGPEN, 32) |
| TEST_TARGET_ALIGN(PEXTLOGPEN, 8) |
| } |
| |
| static void test_pack_PFONTSIGNATURE(void) |
| { |
| /* PFONTSIGNATURE */ |
| TEST_TYPE_SIZE (PFONTSIGNATURE, 8) |
| TEST_TYPE_ALIGN (PFONTSIGNATURE, 8) |
| TEST_TARGET_SIZE (PFONTSIGNATURE, 24) |
| TEST_TARGET_ALIGN(PFONTSIGNATURE, 4) |
| } |
| |
| static void test_pack_PGLYPHMETRICSFLOAT(void) |
| { |
| /* PGLYPHMETRICSFLOAT */ |
| TEST_TYPE_SIZE (PGLYPHMETRICSFLOAT, 8) |
| TEST_TYPE_ALIGN (PGLYPHMETRICSFLOAT, 8) |
| TEST_TARGET_SIZE (PGLYPHMETRICSFLOAT, 24) |
| TEST_TARGET_ALIGN(PGLYPHMETRICSFLOAT, 4) |
| } |
| |
| static void test_pack_PGRADIENT_RECT(void) |
| { |
| /* PGRADIENT_RECT */ |
| TEST_TYPE_SIZE (PGRADIENT_RECT, 8) |
| TEST_TYPE_ALIGN (PGRADIENT_RECT, 8) |
| TEST_TARGET_SIZE (PGRADIENT_RECT, 8) |
| TEST_TARGET_ALIGN(PGRADIENT_RECT, 4) |
| } |
| |
| static void test_pack_PGRADIENT_TRIANGLE(void) |
| { |
| /* PGRADIENT_TRIANGLE */ |
| TEST_TYPE_SIZE (PGRADIENT_TRIANGLE, 8) |
| TEST_TYPE_ALIGN (PGRADIENT_TRIANGLE, 8) |
| TEST_TARGET_SIZE (PGRADIENT_TRIANGLE, 12) |
| TEST_TARGET_ALIGN(PGRADIENT_TRIANGLE, 4) |
| } |
| |
| static void test_pack_PHANDLETABLE(void) |
| { |
| /* PHANDLETABLE */ |
| TEST_TYPE_SIZE (PHANDLETABLE, 8) |
| TEST_TYPE_ALIGN (PHANDLETABLE, 8) |
| TEST_TARGET_SIZE (PHANDLETABLE, 8) |
| TEST_TARGET_ALIGN(PHANDLETABLE, 8) |
| } |
| |
| static void test_pack_PIXELFORMATDESCRIPTOR(void) |
| { |
| /* PIXELFORMATDESCRIPTOR */ |
| TEST_TYPE_SIZE (PIXELFORMATDESCRIPTOR, 40) |
| TEST_TYPE_ALIGN (PIXELFORMATDESCRIPTOR, 4) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, nSize, 2) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, nSize, 2) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, nSize, 0) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, iPixelType, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, iPixelType, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, iPixelType, 8) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cColorBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cColorBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cColorBits, 9) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cRedBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cRedBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cRedBits, 10) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cRedShift, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cRedShift, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cRedShift, 11) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cGreenBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cGreenBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cGreenBits, 12) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cGreenShift, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cGreenShift, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cGreenShift, 13) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cBlueBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cBlueBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cBlueBits, 14) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cBlueShift, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cBlueShift, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cBlueShift, 15) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAlphaBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAlphaBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAlphaBits, 16) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAlphaShift, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAlphaShift, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAlphaShift, 17) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumBits, 18) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumRedBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumRedBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumRedBits, 19) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumGreenBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumGreenBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumGreenBits, 20) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumBlueBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumBlueBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumBlueBits, 21) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumAlphaBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumAlphaBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumAlphaBits, 22) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cDepthBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cDepthBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cDepthBits, 23) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cStencilBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cStencilBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cStencilBits, 24) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAuxBuffers, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAuxBuffers, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAuxBuffers, 25) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, iLayerType, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, iLayerType, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, iLayerType, 26) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, bReserved, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, bReserved, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, bReserved, 27) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, dwLayerMask, 4) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, dwLayerMask, 4) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, dwLayerMask, 28) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, dwVisibleMask, 4) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, dwVisibleMask, 4) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, dwVisibleMask, 32) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, dwDamageMask, 4) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, dwDamageMask, 4) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, dwDamageMask, 36) |
| } |
| |
| static void test_pack_PLAYERPLANEDESCRIPTOR(void) |
| { |
| /* PLAYERPLANEDESCRIPTOR */ |
| TEST_TYPE_SIZE (PLAYERPLANEDESCRIPTOR, 8) |
| TEST_TYPE_ALIGN (PLAYERPLANEDESCRIPTOR, 8) |
| TEST_TARGET_SIZE (PLAYERPLANEDESCRIPTOR, 32) |
| TEST_TARGET_ALIGN(PLAYERPLANEDESCRIPTOR, 4) |
| } |
| |
| static void test_pack_PLOCALESIGNATURE(void) |
| { |
| /* PLOCALESIGNATURE */ |
| TEST_TYPE_SIZE (PLOCALESIGNATURE, 8) |
| TEST_TYPE_ALIGN (PLOCALESIGNATURE, 8) |
| TEST_TARGET_SIZE (PLOCALESIGNATURE, 32) |
| TEST_TARGET_ALIGN(PLOCALESIGNATURE, 4) |
| } |
| |
| static void test_pack_PLOGBRUSH(void) |
| { |
| /* PLOGBRUSH */ |
| TEST_TYPE_SIZE (PLOGBRUSH, 8) |
| TEST_TYPE_ALIGN (PLOGBRUSH, 8) |
| TEST_TARGET_SIZE (PLOGBRUSH, 16) |
| TEST_TARGET_ALIGN(PLOGBRUSH, 8) |
| } |
| |
| static void test_pack_PLOGFONTA(void) |
| { |
| /* PLOGFONTA */ |
| TEST_TYPE_SIZE (PLOGFONTA, 8) |
| TEST_TYPE_ALIGN (PLOGFONTA, 8) |
| TEST_TARGET_SIZE (PLOGFONTA, 60) |
| TEST_TARGET_ALIGN(PLOGFONTA, 4) |
| } |
| |
| static void test_pack_PLOGFONTW(void) |
| { |
| /* PLOGFONTW */ |
| TEST_TYPE_SIZE (PLOGFONTW, 8) |
| TEST_TYPE_ALIGN (PLOGFONTW, 8) |
| TEST_TARGET_SIZE (PLOGFONTW, 92) |
| TEST_TARGET_ALIGN(PLOGFONTW, 4) |
| } |
| |
| static void test_pack_PMETAHEADER(void) |
| { |
| /* PMETAHEADER */ |
| TEST_TYPE_SIZE (PMETAHEADER, 8) |
| TEST_TYPE_ALIGN (PMETAHEADER, 8) |
| TEST_TARGET_SIZE (PMETAHEADER, 18) |
| TEST_TARGET_ALIGN(PMETAHEADER, 2) |
| } |
| |
| static void test_pack_PMETARECORD(void) |
| { |
| /* PMETARECORD */ |
| TEST_TYPE_SIZE (PMETARECORD, 8) |
| TEST_TYPE_ALIGN (PMETARECORD, 8) |
| TEST_TARGET_SIZE (PMETARECORD, 8) |
| TEST_TARGET_ALIGN(PMETARECORD, 4) |
| } |
| |
| static void test_pack_PNEWTEXTMETRICA(void) |
| { |
| /* PNEWTEXTMETRICA */ |
| TEST_TYPE_SIZE (PNEWTEXTMETRICA, 8) |
| TEST_TYPE_ALIGN (PNEWTEXTMETRICA, 8) |
| TEST_TARGET_SIZE (PNEWTEXTMETRICA, 72) |
| TEST_TARGET_ALIGN(PNEWTEXTMETRICA, 4) |
| } |
| |
| static void test_pack_PNEWTEXTMETRICW(void) |
| { |
| /* PNEWTEXTMETRICW */ |
| TEST_TYPE_SIZE (PNEWTEXTMETRICW, 8) |
| TEST_TYPE_ALIGN (PNEWTEXTMETRICW, 8) |
| TEST_TARGET_SIZE (PNEWTEXTMETRICW, 76) |
| TEST_TARGET_ALIGN(PNEWTEXTMETRICW, 4) |
| } |
| |
| static void test_pack_POINTFLOAT(void) |
| { |
| /* POINTFLOAT */ |
| TEST_TYPE_SIZE (POINTFLOAT, 8) |
| TEST_TYPE_ALIGN (POINTFLOAT, 4) |
| TEST_FIELD_SIZE (POINTFLOAT, x, 4) |
| TEST_FIELD_ALIGN (POINTFLOAT, x, 4) |
| TEST_FIELD_OFFSET(POINTFLOAT, x, 0) |
| TEST_FIELD_SIZE (POINTFLOAT, y, 4) |
| TEST_FIELD_ALIGN (POINTFLOAT, y, 4) |
| TEST_FIELD_OFFSET(POINTFLOAT, y, 4) |
| } |
| |
| static void test_pack_POINTFX(void) |
| { |
| /* POINTFX */ |
| TEST_TYPE_SIZE (POINTFX, 8) |
| TEST_TYPE_ALIGN (POINTFX, 2) |
| TEST_FIELD_SIZE (POINTFX, x, 4) |
| TEST_FIELD_ALIGN (POINTFX, x, 2) |
| TEST_FIELD_OFFSET(POINTFX, x, 0) |
| TEST_FIELD_SIZE (POINTFX, y, 4) |
| TEST_FIELD_ALIGN (POINTFX, y, 2) |
| TEST_FIELD_OFFSET(POINTFX, y, 4) |
| } |
| |
| static void test_pack_POLYTEXTA(void) |
| { |
| /* POLYTEXTA */ |
| TEST_TYPE_SIZE (POLYTEXTA, 56) |
| TEST_TYPE_ALIGN (POLYTEXTA, 8) |
| TEST_FIELD_SIZE (POLYTEXTA, x, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, x, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, x, 0) |
| TEST_FIELD_SIZE (POLYTEXTA, y, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, y, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, y, 4) |
| TEST_FIELD_SIZE (POLYTEXTA, n, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, n, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, n, 8) |
| TEST_FIELD_SIZE (POLYTEXTA, lpstr, 8) |
| TEST_FIELD_ALIGN (POLYTEXTA, lpstr, 8) |
| TEST_FIELD_OFFSET(POLYTEXTA, lpstr, 16) |
| TEST_FIELD_SIZE (POLYTEXTA, uiFlags, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, uiFlags, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, uiFlags, 24) |
| TEST_FIELD_SIZE (POLYTEXTA, rcl, 16) |
| TEST_FIELD_ALIGN (POLYTEXTA, rcl, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, rcl, 28) |
| TEST_FIELD_SIZE (POLYTEXTA, pdx, 8) |
| TEST_FIELD_ALIGN (POLYTEXTA, pdx, 8) |
| TEST_FIELD_OFFSET(POLYTEXTA, pdx, 48) |
| } |
| |
| static void test_pack_POLYTEXTW(void) |
| { |
| /* POLYTEXTW */ |
| TEST_TYPE_SIZE (POLYTEXTW, 56) |
| TEST_TYPE_ALIGN (POLYTEXTW, 8) |
| TEST_FIELD_SIZE (POLYTEXTW, x, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, x, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, x, 0) |
| TEST_FIELD_SIZE (POLYTEXTW, y, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, y, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, y, 4) |
| TEST_FIELD_SIZE (POLYTEXTW, n, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, n, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, n, 8) |
| TEST_FIELD_SIZE (POLYTEXTW, lpstr, 8) |
| TEST_FIELD_ALIGN (POLYTEXTW, lpstr, 8) |
| TEST_FIELD_OFFSET(POLYTEXTW, lpstr, 16) |
| TEST_FIELD_SIZE (POLYTEXTW, uiFlags, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, uiFlags, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, uiFlags, 24) |
| TEST_FIELD_SIZE (POLYTEXTW, rcl, 16) |
| TEST_FIELD_ALIGN (POLYTEXTW, rcl, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, rcl, 28) |
| TEST_FIELD_SIZE (POLYTEXTW, pdx, 8) |
| TEST_FIELD_ALIGN (POLYTEXTW, pdx, 8) |
| TEST_FIELD_OFFSET(POLYTEXTW, pdx, 48) |
| } |
| |
| static void test_pack_POUTLINETEXTMETRICA(void) |
| { |
| /* POUTLINETEXTMETRICA */ |
| TEST_TYPE_SIZE (POUTLINETEXTMETRICA, 8) |
| TEST_TYPE_ALIGN (POUTLINETEXTMETRICA, 8) |
| TEST_TARGET_SIZE (POUTLINETEXTMETRICA, 232) |
| TEST_TARGET_ALIGN(POUTLINETEXTMETRICA, 8) |
| } |
| |
| static void test_pack_POUTLINETEXTMETRICW(void) |
| { |
| /* POUTLINETEXTMETRICW */ |
| TEST_TYPE_SIZE (POUTLINETEXTMETRICW, 8) |
| TEST_TYPE_ALIGN (POUTLINETEXTMETRICW, 8) |
| TEST_TARGET_SIZE (POUTLINETEXTMETRICW, 232) |
| TEST_TARGET_ALIGN(POUTLINETEXTMETRICW, 8) |
| } |
| |
| static void test_pack_PPELARRAY(void) |
| { |
| /* PPELARRAY */ |
| TEST_TYPE_SIZE (PPELARRAY, 8) |
| TEST_TYPE_ALIGN (PPELARRAY, 8) |
| TEST_TARGET_SIZE (PPELARRAY, 20) |
| TEST_TARGET_ALIGN(PPELARRAY, 4) |
| } |
| |
| static void test_pack_PPIXELFORMATDESCRIPTOR(void) |
| { |
| /* PPIXELFORMATDESCRIPTOR */ |
| TEST_TYPE_SIZE (PPIXELFORMATDESCRIPTOR, 8) |
| TEST_TYPE_ALIGN (PPIXELFORMATDESCRIPTOR, 8) |
| TEST_TARGET_SIZE (PPIXELFORMATDESCRIPTOR, 40) |
| TEST_TARGET_ALIGN(PPIXELFORMATDESCRIPTOR, 4) |
| } |
| |
| static void test_pack_PPOINTFLOAT(void) |
| { |
| /* PPOINTFLOAT */ |
| TEST_TYPE_SIZE (PPOINTFLOAT, 8) |
| TEST_TYPE_ALIGN (PPOINTFLOAT, 8) |
| TEST_TARGET_SIZE (PPOINTFLOAT, 8) |
| TEST_TARGET_ALIGN(PPOINTFLOAT, 4) |
| } |
| |
| static void test_pack_PPOLYTEXTA(void) |
| { |
| /* PPOLYTEXTA */ |
| TEST_TYPE_SIZE (PPOLYTEXTA, 8) |
| TEST_TYPE_ALIGN (PPOLYTEXTA, 8) |
| TEST_TARGET_SIZE (PPOLYTEXTA, 56) |
| TEST_TARGET_ALIGN(PPOLYTEXTA, 8) |
| } |
| |
| static void test_pack_PPOLYTEXTW(void) |
| { |
| /* PPOLYTEXTW */ |
| TEST_TYPE_SIZE (PPOLYTEXTW, 8) |
| TEST_TYPE_ALIGN (PPOLYTEXTW, 8) |
| TEST_TARGET_SIZE (PPOLYTEXTW, 56) |
| TEST_TARGET_ALIGN(PPOLYTEXTW, 8) |
| } |
| |
| static void test_pack_PRGNDATA(void) |
| { |
| /* PRGNDATA */ |
| TEST_TYPE_SIZE (PRGNDATA, 8) |
| TEST_TYPE_ALIGN (PRGNDATA, 8) |
| TEST_TARGET_SIZE (PRGNDATA, 36) |
| TEST_TARGET_ALIGN(PRGNDATA, 4) |
| } |
| |
| static void test_pack_PRGNDATAHEADER(void) |
| { |
| /* PRGNDATAHEADER */ |
| TEST_TYPE_SIZE (PRGNDATAHEADER, 8) |
| TEST_TYPE_ALIGN (PRGNDATAHEADER, 8) |
| TEST_TARGET_SIZE (PRGNDATAHEADER, 32) |
| TEST_TARGET_ALIGN(PRGNDATAHEADER, 4) |
| } |
| |
| static void test_pack_PTEXTMETRICA(void) |
| { |
| /* PTEXTMETRICA */ |
| TEST_TYPE_SIZE (PTEXTMETRICA, 8) |
| TEST_TYPE_ALIGN (PTEXTMETRICA, 8) |
| TEST_TARGET_SIZE (PTEXTMETRICA, 56) |
| TEST_TARGET_ALIGN(PTEXTMETRICA, 4) |
| } |
| |
| static void test_pack_PTEXTMETRICW(void) |
| { |
| /* PTEXTMETRICW */ |
| TEST_TYPE_SIZE (PTEXTMETRICW, 8) |
| TEST_TYPE_ALIGN (PTEXTMETRICW, 8) |
| TEST_TARGET_SIZE (PTEXTMETRICW, 60) |
| TEST_TARGET_ALIGN(PTEXTMETRICW, 4) |
| } |
| |
| static void test_pack_PTRIVERTEX(void) |
| { |
| /* PTRIVERTEX */ |
| TEST_TYPE_SIZE (PTRIVERTEX, 8) |
| TEST_TYPE_ALIGN (PTRIVERTEX, 8) |
| TEST_TARGET_SIZE (PTRIVERTEX, 16) |
| TEST_TARGET_ALIGN(PTRIVERTEX, 4) |
| } |
| |
| static void test_pack_PXFORM(void) |
| { |
| /* PXFORM */ |
| TEST_TYPE_SIZE (PXFORM, 8) |
| TEST_TYPE_ALIGN (PXFORM, 8) |
| TEST_TARGET_SIZE (PXFORM, 24) |
| TEST_TARGET_ALIGN(PXFORM, 4) |
| } |
| |
| static void test_pack_RASTERIZER_STATUS(void) |
| { |
| /* RASTERIZER_STATUS */ |
| TEST_TYPE_SIZE (RASTERIZER_STATUS, 6) |
| TEST_TYPE_ALIGN (RASTERIZER_STATUS, 2) |
| TEST_FIELD_SIZE (RASTERIZER_STATUS, nSize, 2) |
| TEST_FIELD_ALIGN (RASTERIZER_STATUS, nSize, 2) |
| TEST_FIELD_OFFSET(RASTERIZER_STATUS, nSize, 0) |
| TEST_FIELD_SIZE (RASTERIZER_STATUS, wFlags, 2) |
| TEST_FIELD_ALIGN (RASTERIZER_STATUS, wFlags, 2) |
| TEST_FIELD_OFFSET(RASTERIZER_STATUS, wFlags, 2) |
| TEST_FIELD_SIZE (RASTERIZER_STATUS, nLanguageID, 2) |
| TEST_FIELD_ALIGN (RASTERIZER_STATUS, nLanguageID, 2) |
| TEST_FIELD_OFFSET(RASTERIZER_STATUS, nLanguageID, 4) |
| } |
| |
| static void test_pack_RGBQUAD(void) |
| { |
| /* RGBQUAD */ |
| TEST_TYPE_SIZE (RGBQUAD, 4) |
| TEST_TYPE_ALIGN (RGBQUAD, 1) |
| TEST_FIELD_SIZE (RGBQUAD, rgbBlue, 1) |
| TEST_FIELD_ALIGN (RGBQUAD, rgbBlue, 1) |
| TEST_FIELD_OFFSET(RGBQUAD, rgbBlue, 0) |
| TEST_FIELD_SIZE (RGBQUAD, rgbGreen, 1) |
| TEST_FIELD_ALIGN (RGBQUAD, rgbGreen, 1) |
| TEST_FIELD_OFFSET(RGBQUAD, rgbGreen, 1) |
| TEST_FIELD_SIZE (RGBQUAD, rgbRed, 1) |
| TEST_FIELD_ALIGN (RGBQUAD, rgbRed, 1) |
| TEST_FIELD_OFFSET(RGBQUAD, rgbRed, 2) |
| TEST_FIELD_SIZE (RGBQUAD, rgbReserved, 1) |
| TEST_FIELD_ALIGN (RGBQUAD, rgbReserved, 1) |
| TEST_FIELD_OFFSET(RGBQUAD, rgbReserved, 3) |
| } |
| |
| static void test_pack_RGBTRIPLE(void) |
| { |
| /* RGBTRIPLE */ |
| TEST_TYPE_SIZE (RGBTRIPLE, 3) |
| TEST_TYPE_ALIGN (RGBTRIPLE, 1) |
| TEST_FIELD_SIZE (RGBTRIPLE, rgbtBlue, 1) |
| TEST_FIELD_ALIGN (RGBTRIPLE, rgbtBlue, 1) |
| TEST_FIELD_OFFSET(RGBTRIPLE, rgbtBlue, 0) |
| TEST_FIELD_SIZE (RGBTRIPLE, rgbtGreen, 1) |
| TEST_FIELD_ALIGN (RGBTRIPLE, rgbtGreen, 1) |
| TEST_FIELD_OFFSET(RGBTRIPLE, rgbtGreen, 1) |
| TEST_FIELD_SIZE (RGBTRIPLE, rgbtRed, 1) |
| TEST_FIELD_ALIGN (RGBTRIPLE, rgbtRed, 1) |
| TEST_FIELD_OFFSET(RGBTRIPLE, rgbtRed, 2) |
| } |
| |
| static void test_pack_RGNDATA(void) |
| { |
| /* RGNDATA */ |
| TEST_TYPE_SIZE (RGNDATA, 36) |
| TEST_TYPE_ALIGN (RGNDATA, 4) |
| TEST_FIELD_SIZE (RGNDATA, rdh, 32) |
| TEST_FIELD_ALIGN (RGNDATA, rdh, 4) |
| TEST_FIELD_OFFSET(RGNDATA, rdh, 0) |
| TEST_FIELD_SIZE (RGNDATA, Buffer, 1) |
| TEST_FIELD_ALIGN (RGNDATA, Buffer, 1) |
| TEST_FIELD_OFFSET(RGNDATA, Buffer, 32) |
| } |
| |
| static void test_pack_RGNDATAHEADER(void) |
| { |
| /* RGNDATAHEADER */ |
| TEST_TYPE_SIZE (RGNDATAHEADER, 32) |
| TEST_TYPE_ALIGN (RGNDATAHEADER, 4) |
| TEST_FIELD_SIZE (RGNDATAHEADER, dwSize, 4) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, dwSize, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, dwSize, 0) |
| TEST_FIELD_SIZE (RGNDATAHEADER, iType, 4) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, iType, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, iType, 4) |
| TEST_FIELD_SIZE (RGNDATAHEADER, nCount, 4) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, nCount, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, nCount, 8) |
| TEST_FIELD_SIZE (RGNDATAHEADER, nRgnSize, 4) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, nRgnSize, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, nRgnSize, 12) |
| TEST_FIELD_SIZE (RGNDATAHEADER, rcBound, 16) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, rcBound, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, rcBound, 16) |
| } |
| |
| static void test_pack_TEXTMETRICA(void) |
| { |
| /* TEXTMETRICA */ |
| TEST_TYPE_SIZE (TEXTMETRICA, 56) |
| TEST_TYPE_ALIGN (TEXTMETRICA, 4) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmHeight, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmHeight, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmHeight, 0) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmDescent, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmDescent, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmDescent, 8) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmInternalLeading, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmInternalLeading, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmInternalLeading, 12) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmExternalLeading, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmExternalLeading, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmExternalLeading, 16) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmAveCharWidth, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmAveCharWidth, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmAveCharWidth, 20) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmMaxCharWidth, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmMaxCharWidth, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmMaxCharWidth, 24) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmWeight, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmWeight, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmWeight, 28) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmOverhang, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmOverhang, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmOverhang, 32) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmDigitizedAspectX, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmDigitizedAspectX, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmDigitizedAspectX, 36) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmDigitizedAspectY, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmDigitizedAspectY, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmDigitizedAspectY, 40) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmFirstChar, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmFirstChar, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmFirstChar, 44) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmLastChar, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmLastChar, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmLastChar, 45) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmDefaultChar, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmDefaultChar, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmDefaultChar, 46) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmBreakChar, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmBreakChar, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmBreakChar, 47) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmItalic, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmItalic, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmItalic, 48) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmUnderlined, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmUnderlined, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmUnderlined, 49) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmStruckOut, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmStruckOut, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmStruckOut, 50) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmPitchAndFamily, 51) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmCharSet, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmCharSet, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmCharSet, 52) |
| } |
| |
| static void test_pack_TEXTMETRICW(void) |
| { |
| /* TEXTMETRICW */ |
| TEST_TYPE_SIZE (TEXTMETRICW, 60) |
| TEST_TYPE_ALIGN (TEXTMETRICW, 4) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmHeight, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmHeight, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmHeight, 0) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmDescent, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmDescent, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmDescent, 8) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmInternalLeading, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmInternalLeading, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmInternalLeading, 12) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmExternalLeading, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmExternalLeading, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmExternalLeading, 16) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmAveCharWidth, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmAveCharWidth, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmAveCharWidth, 20) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmMaxCharWidth, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmMaxCharWidth, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmMaxCharWidth, 24) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmWeight, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmWeight, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmWeight, 28) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmOverhang, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmOverhang, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmOverhang, 32) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmDigitizedAspectX, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmDigitizedAspectX, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmDigitizedAspectX, 36) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmDigitizedAspectY, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmDigitizedAspectY, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmDigitizedAspectY, 40) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmFirstChar, 2) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmFirstChar, 2) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmFirstChar, 44) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmLastChar, 2) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmLastChar, 2) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmLastChar, 46) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmDefaultChar, 2) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmDefaultChar, 2) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmDefaultChar, 48) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmBreakChar, 2) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmBreakChar, 2) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmBreakChar, 50) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmItalic, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmItalic, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmItalic, 52) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmUnderlined, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmUnderlined, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmUnderlined, 53) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmStruckOut, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmStruckOut, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmStruckOut, 54) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmPitchAndFamily, 55) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmCharSet, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmCharSet, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmCharSet, 56) |
| } |
| |
| static void test_pack_TRIVERTEX(void) |
| { |
| /* TRIVERTEX */ |
| TEST_TYPE_SIZE (TRIVERTEX, 16) |
| TEST_TYPE_ALIGN (TRIVERTEX, 4) |
| TEST_FIELD_SIZE (TRIVERTEX, x, 4) |
| TEST_FIELD_ALIGN (TRIVERTEX, x, 4) |
| TEST_FIELD_OFFSET(TRIVERTEX, x, 0) |
| TEST_FIELD_SIZE (TRIVERTEX, y, 4) |
| TEST_FIELD_ALIGN (TRIVERTEX, y, 4) |
| TEST_FIELD_OFFSET(TRIVERTEX, y, 4) |
| TEST_FIELD_SIZE (TRIVERTEX, Red, 2) |
| TEST_FIELD_ALIGN (TRIVERTEX, Red, 2) |
| TEST_FIELD_OFFSET(TRIVERTEX, Red, 8) |
| TEST_FIELD_SIZE (TRIVERTEX, Green, 2) |
| TEST_FIELD_ALIGN (TRIVERTEX, Green, 2) |
| TEST_FIELD_OFFSET(TRIVERTEX, Green, 10) |
| TEST_FIELD_SIZE (TRIVERTEX, Blue, 2) |
| TEST_FIELD_ALIGN (TRIVERTEX, Blue, 2) |
| TEST_FIELD_OFFSET(TRIVERTEX, Blue, 12) |
| TEST_FIELD_SIZE (TRIVERTEX, Alpha, 2) |
| TEST_FIELD_ALIGN (TRIVERTEX, Alpha, 2) |
| TEST_FIELD_OFFSET(TRIVERTEX, Alpha, 14) |
| } |
| |
| static void test_pack_TTPOLYCURVE(void) |
| { |
| /* TTPOLYCURVE */ |
| TEST_TYPE_SIZE (TTPOLYCURVE, 12) |
| TEST_TYPE_ALIGN (TTPOLYCURVE, 2) |
| TEST_FIELD_SIZE (TTPOLYCURVE, wType, 2) |
| TEST_FIELD_ALIGN (TTPOLYCURVE, wType, 2) |
| TEST_FIELD_OFFSET(TTPOLYCURVE, wType, 0) |
| TEST_FIELD_SIZE (TTPOLYCURVE, cpfx, 2) |
| TEST_FIELD_ALIGN (TTPOLYCURVE, cpfx, 2) |
| TEST_FIELD_OFFSET(TTPOLYCURVE, cpfx, 2) |
| TEST_FIELD_SIZE (TTPOLYCURVE, apfx, 8) |
| TEST_FIELD_ALIGN (TTPOLYCURVE, apfx, 2) |
| TEST_FIELD_OFFSET(TTPOLYCURVE, apfx, 4) |
| } |
| |
| static void test_pack_TTPOLYGONHEADER(void) |
| { |
| /* TTPOLYGONHEADER */ |
| TEST_TYPE_SIZE (TTPOLYGONHEADER, 16) |
| TEST_TYPE_ALIGN (TTPOLYGONHEADER, 4) |
| TEST_FIELD_SIZE (TTPOLYGONHEADER, cb, 4) |
| TEST_FIELD_ALIGN (TTPOLYGONHEADER, cb, 4) |
| TEST_FIELD_OFFSET(TTPOLYGONHEADER, cb, 0) |
| TEST_FIELD_SIZE (TTPOLYGONHEADER, dwType, 4) |
| TEST_FIELD_ALIGN (TTPOLYGONHEADER, dwType, 4) |
| TEST_FIELD_OFFSET(TTPOLYGONHEADER, dwType, 4) |
| TEST_FIELD_SIZE (TTPOLYGONHEADER, pfxStart, 8) |
| TEST_FIELD_ALIGN (TTPOLYGONHEADER, pfxStart, 2) |
| TEST_FIELD_OFFSET(TTPOLYGONHEADER, pfxStart, 8) |
| } |
| |
| static void test_pack_XFORM(void) |
| { |
| /* XFORM */ |
| TEST_TYPE_SIZE (XFORM, 24) |
| TEST_TYPE_ALIGN (XFORM, 4) |
| TEST_FIELD_SIZE (XFORM, eM11, 4) |
| TEST_FIELD_ALIGN (XFORM, eM11, 4) |
| TEST_FIELD_OFFSET(XFORM, eM11, 0) |
| TEST_FIELD_SIZE (XFORM, eM12, 4) |
| TEST_FIELD_ALIGN (XFORM, eM12, 4) |
| TEST_FIELD_OFFSET(XFORM, eM12, 4) |
| TEST_FIELD_SIZE (XFORM, eM21, 4) |
| TEST_FIELD_ALIGN (XFORM, eM21, 4) |
| TEST_FIELD_OFFSET(XFORM, eM21, 8) |
| TEST_FIELD_SIZE (XFORM, eM22, 4) |
| TEST_FIELD_ALIGN (XFORM, eM22, 4) |
| TEST_FIELD_OFFSET(XFORM, eM22, 12) |
| TEST_FIELD_SIZE (XFORM, eDx, 4) |
| TEST_FIELD_ALIGN (XFORM, eDx, 4) |
| TEST_FIELD_OFFSET(XFORM, eDx, 16) |
| TEST_FIELD_SIZE (XFORM, eDy, 4) |
| TEST_FIELD_ALIGN (XFORM, eDy, 4) |
| TEST_FIELD_OFFSET(XFORM, eDy, 20) |
| } |
| |
| #else /* _WIN64 */ |
| |
| static void test_pack_ABC(void) |
| { |
| /* ABC */ |
| TEST_TYPE_SIZE (ABC, 12) |
| TEST_TYPE_ALIGN (ABC, 4) |
| TEST_FIELD_SIZE (ABC, abcA, 4) |
| TEST_FIELD_ALIGN (ABC, abcA, 4) |
| TEST_FIELD_OFFSET(ABC, abcA, 0) |
| TEST_FIELD_SIZE (ABC, abcB, 4) |
| TEST_FIELD_ALIGN (ABC, abcB, 4) |
| TEST_FIELD_OFFSET(ABC, abcB, 4) |
| TEST_FIELD_SIZE (ABC, abcC, 4) |
| TEST_FIELD_ALIGN (ABC, abcC, 4) |
| TEST_FIELD_OFFSET(ABC, abcC, 8) |
| } |
| |
| static void test_pack_ABCFLOAT(void) |
| { |
| /* ABCFLOAT */ |
| TEST_TYPE_SIZE (ABCFLOAT, 12) |
| TEST_TYPE_ALIGN (ABCFLOAT, 4) |
| TEST_FIELD_SIZE (ABCFLOAT, abcfA, 4) |
| TEST_FIELD_ALIGN (ABCFLOAT, abcfA, 4) |
| TEST_FIELD_OFFSET(ABCFLOAT, abcfA, 0) |
| TEST_FIELD_SIZE (ABCFLOAT, abcfB, 4) |
| TEST_FIELD_ALIGN (ABCFLOAT, abcfB, 4) |
| TEST_FIELD_OFFSET(ABCFLOAT, abcfB, 4) |
| TEST_FIELD_SIZE (ABCFLOAT, abcfC, 4) |
| TEST_FIELD_ALIGN (ABCFLOAT, abcfC, 4) |
| TEST_FIELD_OFFSET(ABCFLOAT, abcfC, 8) |
| } |
| |
| static void test_pack_ABORTPROC(void) |
| { |
| /* ABORTPROC */ |
| TEST_TYPE_SIZE (ABORTPROC, 4) |
| TEST_TYPE_ALIGN (ABORTPROC, 4) |
| } |
| |
| static void test_pack_BITMAP(void) |
| { |
| /* BITMAP */ |
| TEST_TYPE_SIZE (BITMAP, 24) |
| TEST_TYPE_ALIGN (BITMAP, 4) |
| TEST_FIELD_SIZE (BITMAP, bmType, 4) |
| TEST_FIELD_ALIGN (BITMAP, bmType, 4) |
| TEST_FIELD_OFFSET(BITMAP, bmType, 0) |
| TEST_FIELD_SIZE (BITMAP, bmWidth, 4) |
| TEST_FIELD_ALIGN (BITMAP, bmWidth, 4) |
| TEST_FIELD_OFFSET(BITMAP, bmWidth, 4) |
| TEST_FIELD_SIZE (BITMAP, bmHeight, 4) |
| TEST_FIELD_ALIGN (BITMAP, bmHeight, 4) |
| TEST_FIELD_OFFSET(BITMAP, bmHeight, 8) |
| TEST_FIELD_SIZE (BITMAP, bmWidthBytes, 4) |
| TEST_FIELD_ALIGN (BITMAP, bmWidthBytes, 4) |
| TEST_FIELD_OFFSET(BITMAP, bmWidthBytes, 12) |
| TEST_FIELD_SIZE (BITMAP, bmPlanes, 2) |
| TEST_FIELD_ALIGN (BITMAP, bmPlanes, 2) |
| TEST_FIELD_OFFSET(BITMAP, bmPlanes, 16) |
| TEST_FIELD_SIZE (BITMAP, bmBitsPixel, 2) |
| TEST_FIELD_ALIGN (BITMAP, bmBitsPixel, 2) |
| TEST_FIELD_OFFSET(BITMAP, bmBitsPixel, 18) |
| TEST_FIELD_SIZE (BITMAP, bmBits, 4) |
| TEST_FIELD_ALIGN (BITMAP, bmBits, 4) |
| TEST_FIELD_OFFSET(BITMAP, bmBits, 20) |
| } |
| |
| static void test_pack_BITMAPCOREHEADER(void) |
| { |
| /* BITMAPCOREHEADER */ |
| TEST_TYPE_SIZE (BITMAPCOREHEADER, 12) |
| TEST_TYPE_ALIGN (BITMAPCOREHEADER, 4) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcSize, 4) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcSize, 4) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcSize, 0) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcWidth, 2) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcWidth, 2) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcWidth, 4) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcHeight, 2) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcHeight, 2) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcHeight, 6) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcPlanes, 2) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcPlanes, 2) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcPlanes, 8) |
| TEST_FIELD_SIZE (BITMAPCOREHEADER, bcBitCount, 2) |
| TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcBitCount, 2) |
| TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcBitCount, 10) |
| } |
| |
| static void test_pack_BITMAPCOREINFO(void) |
| { |
| /* BITMAPCOREINFO */ |
| TEST_TYPE_SIZE (BITMAPCOREINFO, 16) |
| TEST_TYPE_ALIGN (BITMAPCOREINFO, 4) |
| TEST_FIELD_SIZE (BITMAPCOREINFO, bmciHeader, 12) |
| TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciHeader, 4) |
| TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciHeader, 0) |
| TEST_FIELD_SIZE (BITMAPCOREINFO, bmciColors, 3) |
| TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciColors, 1) |
| TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciColors, 12) |
| } |
| |
| static void test_pack_BITMAPFILEHEADER(void) |
| { |
| /* BITMAPFILEHEADER (pack 2) */ |
| TEST_TYPE_SIZE (BITMAPFILEHEADER, 14) |
| TEST_TYPE_ALIGN (BITMAPFILEHEADER, 2) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfType, 2) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfType, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfType, 0) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfSize, 4) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfSize, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfSize, 2) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfReserved1, 2) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved1, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved1, 6) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfReserved2, 2) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved2, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved2, 8) |
| TEST_FIELD_SIZE (BITMAPFILEHEADER, bfOffBits, 4) |
| TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfOffBits, 2) |
| TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfOffBits, 10) |
| } |
| |
| static void test_pack_BITMAPINFO(void) |
| { |
| /* BITMAPINFO */ |
| TEST_TYPE_SIZE (BITMAPINFO, 44) |
| TEST_TYPE_ALIGN (BITMAPINFO, 4) |
| TEST_FIELD_SIZE (BITMAPINFO, bmiHeader, 40) |
| TEST_FIELD_ALIGN (BITMAPINFO, bmiHeader, 4) |
| TEST_FIELD_OFFSET(BITMAPINFO, bmiHeader, 0) |
| TEST_FIELD_SIZE (BITMAPINFO, bmiColors, 4) |
| TEST_FIELD_ALIGN (BITMAPINFO, bmiColors, 1) |
| TEST_FIELD_OFFSET(BITMAPINFO, bmiColors, 40) |
| } |
| |
| static void test_pack_BITMAPINFOHEADER(void) |
| { |
| /* BITMAPINFOHEADER */ |
| TEST_TYPE_SIZE (BITMAPINFOHEADER, 40) |
| TEST_TYPE_ALIGN (BITMAPINFOHEADER, 4) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biSize, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biSize, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biSize, 0) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biWidth, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biWidth, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biWidth, 4) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biHeight, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biHeight, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biHeight, 8) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biPlanes, 2) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biPlanes, 2) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biPlanes, 12) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biBitCount, 2) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biBitCount, 2) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biBitCount, 14) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biCompression, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biCompression, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biCompression, 16) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biSizeImage, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biSizeImage, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biSizeImage, 20) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biXPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biXPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biXPelsPerMeter, 24) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biYPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biYPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biYPelsPerMeter, 28) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biClrUsed, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrUsed, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrUsed, 32) |
| TEST_FIELD_SIZE (BITMAPINFOHEADER, biClrImportant, 4) |
| TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrImportant, 4) |
| TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrImportant, 36) |
| } |
| |
| static void test_pack_BITMAPV4HEADER(void) |
| { |
| /* BITMAPV4HEADER */ |
| TEST_TYPE_SIZE (BITMAPV4HEADER, 108) |
| TEST_TYPE_ALIGN (BITMAPV4HEADER, 4) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Size, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Size, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Size, 0) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Width, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Width, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Width, 4) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Height, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Height, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Height, 8) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Planes, 2) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Planes, 2) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Planes, 12) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4BitCount, 2) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BitCount, 2) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BitCount, 14) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4V4Compression, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4V4Compression, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4V4Compression, 16) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4SizeImage, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4SizeImage, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4SizeImage, 20) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4XPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4XPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4XPelsPerMeter, 24) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4YPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4YPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4YPelsPerMeter, 28) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4ClrUsed, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrUsed, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrUsed, 32) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4ClrImportant, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrImportant, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrImportant, 36) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4RedMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4RedMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4RedMask, 40) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GreenMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GreenMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GreenMask, 44) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4BlueMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BlueMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BlueMask, 48) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4AlphaMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4AlphaMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4AlphaMask, 52) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4CSType, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4CSType, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4CSType, 56) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Endpoints, 36) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Endpoints, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Endpoints, 60) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaRed, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaRed, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaRed, 96) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaGreen, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaGreen, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaGreen, 100) |
| TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaBlue, 4) |
| TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaBlue, 4) |
| TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaBlue, 104) |
| } |
| |
| static void test_pack_BITMAPV5HEADER(void) |
| { |
| /* BITMAPV5HEADER */ |
| TEST_TYPE_SIZE (BITMAPV5HEADER, 124) |
| TEST_TYPE_ALIGN (BITMAPV5HEADER, 4) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Size, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Size, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Size, 0) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Width, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Width, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Width, 4) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Height, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Height, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Height, 8) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Planes, 2) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Planes, 2) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Planes, 12) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5BitCount, 2) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BitCount, 2) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BitCount, 14) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Compression, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Compression, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Compression, 16) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5SizeImage, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5SizeImage, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5SizeImage, 20) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5XPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5XPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5XPelsPerMeter, 24) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5YPelsPerMeter, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5YPelsPerMeter, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5YPelsPerMeter, 28) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ClrUsed, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrUsed, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrUsed, 32) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ClrImportant, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrImportant, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrImportant, 36) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5RedMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5RedMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5RedMask, 40) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GreenMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GreenMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GreenMask, 44) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5BlueMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BlueMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BlueMask, 48) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5AlphaMask, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5AlphaMask, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5AlphaMask, 52) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5CSType, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5CSType, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5CSType, 56) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Endpoints, 36) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Endpoints, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Endpoints, 60) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaRed, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaRed, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaRed, 96) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaGreen, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaGreen, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaGreen, 100) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaBlue, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaBlue, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaBlue, 104) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Intent, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Intent, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Intent, 108) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ProfileData, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileData, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileData, 112) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ProfileSize, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileSize, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileSize, 116) |
| TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Reserved, 4) |
| TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Reserved, 4) |
| TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Reserved, 120) |
| } |
| |
| static void test_pack_BLENDFUNCTION(void) |
| { |
| /* BLENDFUNCTION */ |
| TEST_TYPE_SIZE (BLENDFUNCTION, 4) |
| TEST_TYPE_ALIGN (BLENDFUNCTION, 1) |
| TEST_FIELD_SIZE (BLENDFUNCTION, BlendOp, 1) |
| TEST_FIELD_ALIGN (BLENDFUNCTION, BlendOp, 1) |
| TEST_FIELD_OFFSET(BLENDFUNCTION, BlendOp, 0) |
| TEST_FIELD_SIZE (BLENDFUNCTION, BlendFlags, 1) |
| TEST_FIELD_ALIGN (BLENDFUNCTION, BlendFlags, 1) |
| TEST_FIELD_OFFSET(BLENDFUNCTION, BlendFlags, 1) |
| TEST_FIELD_SIZE (BLENDFUNCTION, SourceConstantAlpha, 1) |
| TEST_FIELD_ALIGN (BLENDFUNCTION, SourceConstantAlpha, 1) |
| TEST_FIELD_OFFSET(BLENDFUNCTION, SourceConstantAlpha, 2) |
| TEST_FIELD_SIZE (BLENDFUNCTION, AlphaFormat, 1) |
| TEST_FIELD_ALIGN (BLENDFUNCTION, AlphaFormat, 1) |
| TEST_FIELD_OFFSET(BLENDFUNCTION, AlphaFormat, 3) |
| } |
| |
| static void test_pack_CHARSETINFO(void) |
| { |
| /* CHARSETINFO */ |
| TEST_TYPE_SIZE (CHARSETINFO, 32) |
| TEST_TYPE_ALIGN (CHARSETINFO, 4) |
| TEST_FIELD_SIZE (CHARSETINFO, ciCharset, 4) |
| TEST_FIELD_ALIGN (CHARSETINFO, ciCharset, 4) |
| TEST_FIELD_OFFSET(CHARSETINFO, ciCharset, 0) |
| TEST_FIELD_SIZE (CHARSETINFO, ciACP, 4) |
| TEST_FIELD_ALIGN (CHARSETINFO, ciACP, 4) |
| TEST_FIELD_OFFSET(CHARSETINFO, ciACP, 4) |
| TEST_FIELD_SIZE (CHARSETINFO, fs, 24) |
| TEST_FIELD_ALIGN (CHARSETINFO, fs, 4) |
| TEST_FIELD_OFFSET(CHARSETINFO, fs, 8) |
| } |
| |
| static void test_pack_CIEXYZ(void) |
| { |
| /* CIEXYZ */ |
| TEST_TYPE_SIZE (CIEXYZ, 12) |
| TEST_TYPE_ALIGN (CIEXYZ, 4) |
| TEST_FIELD_SIZE (CIEXYZ, ciexyzX, 4) |
| TEST_FIELD_ALIGN (CIEXYZ, ciexyzX, 4) |
| TEST_FIELD_OFFSET(CIEXYZ, ciexyzX, 0) |
| TEST_FIELD_SIZE (CIEXYZ, ciexyzY, 4) |
| TEST_FIELD_ALIGN (CIEXYZ, ciexyzY, 4) |
| TEST_FIELD_OFFSET(CIEXYZ, ciexyzY, 4) |
| TEST_FIELD_SIZE (CIEXYZ, ciexyzZ, 4) |
| TEST_FIELD_ALIGN (CIEXYZ, ciexyzZ, 4) |
| TEST_FIELD_OFFSET(CIEXYZ, ciexyzZ, 8) |
| } |
| |
| static void test_pack_CIEXYZTRIPLE(void) |
| { |
| /* CIEXYZTRIPLE */ |
| TEST_TYPE_SIZE (CIEXYZTRIPLE, 36) |
| TEST_TYPE_ALIGN (CIEXYZTRIPLE, 4) |
| TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzRed, 12) |
| TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzRed, 4) |
| TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzRed, 0) |
| TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzGreen, 12) |
| TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzGreen, 4) |
| TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzGreen, 12) |
| TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzBlue, 12) |
| TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzBlue, 4) |
| TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzBlue, 24) |
| } |
| |
| static void test_pack_COLOR16(void) |
| { |
| /* COLOR16 */ |
| TEST_TYPE_SIZE (COLOR16, 2) |
| TEST_TYPE_ALIGN (COLOR16, 2) |
| } |
| |
| static void test_pack_COLORADJUSTMENT(void) |
| { |
| /* COLORADJUSTMENT */ |
| TEST_TYPE_SIZE (COLORADJUSTMENT, 24) |
| TEST_TYPE_ALIGN (COLORADJUSTMENT, 2) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caSize, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caSize, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caSize, 0) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caFlags, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caFlags, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caFlags, 2) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caIlluminantIndex, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caIlluminantIndex, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caIlluminantIndex, 4) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caRedGamma, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGamma, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGamma, 6) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caGreenGamma, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caGreenGamma, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caGreenGamma, 8) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caBlueGamma, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caBlueGamma, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caBlueGamma, 10) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caReferenceBlack, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceBlack, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceBlack, 12) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caReferenceWhite, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceWhite, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceWhite, 14) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caContrast, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caContrast, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caContrast, 16) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caBrightness, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caBrightness, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caBrightness, 18) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caColorfulness, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caColorfulness, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caColorfulness, 20) |
| TEST_FIELD_SIZE (COLORADJUSTMENT, caRedGreenTint, 2) |
| TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGreenTint, 2) |
| TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGreenTint, 22) |
| } |
| |
| static void test_pack_DEVMODEA(void) |
| { |
| /* DEVMODEA */ |
| TEST_FIELD_SIZE (DEVMODEA, dmDeviceName, 32) |
| TEST_FIELD_ALIGN (DEVMODEA, dmDeviceName, 1) |
| TEST_FIELD_OFFSET(DEVMODEA, dmDeviceName, 0) |
| TEST_FIELD_SIZE (DEVMODEA, dmSpecVersion, 2) |
| TEST_FIELD_ALIGN (DEVMODEA, dmSpecVersion, 2) |
| TEST_FIELD_OFFSET(DEVMODEA, dmSpecVersion, 32) |
| TEST_FIELD_SIZE (DEVMODEA, dmDriverVersion, 2) |
| TEST_FIELD_ALIGN (DEVMODEA, dmDriverVersion, 2) |
| TEST_FIELD_OFFSET(DEVMODEA, dmDriverVersion, 34) |
| TEST_FIELD_SIZE (DEVMODEA, dmSize, 2) |
| TEST_FIELD_ALIGN (DEVMODEA, dmSize, 2) |
| TEST_FIELD_OFFSET(DEVMODEA, dmSize, 36) |
| TEST_FIELD_SIZE (DEVMODEA, dmDriverExtra, 2) |
| TEST_FIELD_ALIGN (DEVMODEA, dmDriverExtra, 2) |
| TEST_FIELD_OFFSET(DEVMODEA, dmDriverExtra, 38) |
| TEST_FIELD_SIZE (DEVMODEA, dmFields, 4) |
| TEST_FIELD_ALIGN (DEVMODEA, dmFields, 4) |
| TEST_FIELD_OFFSET(DEVMODEA, dmFields, 40) |
| } |
| |
| static void test_pack_DEVMODEW(void) |
| { |
| /* DEVMODEW */ |
| TEST_FIELD_SIZE (DEVMODEW, dmDeviceName, 64) |
| TEST_FIELD_ALIGN (DEVMODEW, dmDeviceName, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmDeviceName, 0) |
| TEST_FIELD_SIZE (DEVMODEW, dmSpecVersion, 2) |
| TEST_FIELD_ALIGN (DEVMODEW, dmSpecVersion, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmSpecVersion, 64) |
| TEST_FIELD_SIZE (DEVMODEW, dmDriverVersion, 2) |
| TEST_FIELD_ALIGN (DEVMODEW, dmDriverVersion, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmDriverVersion, 66) |
| TEST_FIELD_SIZE (DEVMODEW, dmSize, 2) |
| TEST_FIELD_ALIGN (DEVMODEW, dmSize, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmSize, 68) |
| TEST_FIELD_SIZE (DEVMODEW, dmDriverExtra, 2) |
| TEST_FIELD_ALIGN (DEVMODEW, dmDriverExtra, 2) |
| TEST_FIELD_OFFSET(DEVMODEW, dmDriverExtra, 70) |
| TEST_FIELD_SIZE (DEVMODEW, dmFields, 4) |
| TEST_FIELD_ALIGN (DEVMODEW, dmFields, 4) |
| TEST_FIELD_OFFSET(DEVMODEW, dmFields, 72) |
| } |
| |
| static void test_pack_DIBSECTION(void) |
| { |
| /* DIBSECTION */ |
| TEST_TYPE_SIZE (DIBSECTION, 84) |
| TEST_TYPE_ALIGN (DIBSECTION, 4) |
| TEST_FIELD_SIZE (DIBSECTION, dsBm, 24) |
| TEST_FIELD_ALIGN (DIBSECTION, dsBm, 4) |
| TEST_FIELD_OFFSET(DIBSECTION, dsBm, 0) |
| TEST_FIELD_SIZE (DIBSECTION, dsBmih, 40) |
| TEST_FIELD_ALIGN (DIBSECTION, dsBmih, 4) |
| TEST_FIELD_OFFSET(DIBSECTION, dsBmih, 24) |
| TEST_FIELD_SIZE (DIBSECTION, dsBitfields, 12) |
| TEST_FIELD_ALIGN (DIBSECTION, dsBitfields, 4) |
| TEST_FIELD_OFFSET(DIBSECTION, dsBitfields, 64) |
| TEST_FIELD_SIZE (DIBSECTION, dshSection, 4) |
| TEST_FIELD_ALIGN (DIBSECTION, dshSection, 4) |
| TEST_FIELD_OFFSET(DIBSECTION, dshSection, 76) |
| TEST_FIELD_SIZE (DIBSECTION, dsOffset, 4) |
| TEST_FIELD_ALIGN (DIBSECTION, dsOffset, 4) |
| TEST_FIELD_OFFSET(DIBSECTION, dsOffset, 80) |
| } |
| |
| static void test_pack_DISPLAY_DEVICEA(void) |
| { |
| /* DISPLAY_DEVICEA */ |
| TEST_TYPE_SIZE (DISPLAY_DEVICEA, 424) |
| TEST_TYPE_ALIGN (DISPLAY_DEVICEA, 4) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, cb, 4) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, cb, 4) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, cb, 0) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceName, 32) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceName, 1) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceName, 4) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceString, 128) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceString, 1) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceString, 36) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, StateFlags, 4) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, StateFlags, 4) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, StateFlags, 164) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceID, 128) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceID, 1) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceID, 168) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceKey, 128) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceKey, 1) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceKey, 296) |
| } |
| |
| static void test_pack_DISPLAY_DEVICEW(void) |
| { |
| /* DISPLAY_DEVICEW */ |
| TEST_TYPE_SIZE (DISPLAY_DEVICEW, 840) |
| TEST_TYPE_ALIGN (DISPLAY_DEVICEW, 4) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, cb, 4) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, cb, 4) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, cb, 0) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceName, 64) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceName, 2) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceName, 4) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceString, 256) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceString, 2) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceString, 68) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, StateFlags, 4) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, StateFlags, 4) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, StateFlags, 324) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceID, 256) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceID, 2) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceID, 328) |
| TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceKey, 256) |
| TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceKey, 2) |
| TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceKey, 584) |
| } |
| |
| static void test_pack_DOCINFOA(void) |
| { |
| /* DOCINFOA */ |
| TEST_TYPE_SIZE (DOCINFOA, 20) |
| TEST_TYPE_ALIGN (DOCINFOA, 4) |
| TEST_FIELD_SIZE (DOCINFOA, cbSize, 4) |
| TEST_FIELD_ALIGN (DOCINFOA, cbSize, 4) |
| TEST_FIELD_OFFSET(DOCINFOA, cbSize, 0) |
| TEST_FIELD_SIZE (DOCINFOA, lpszDocName, 4) |
| TEST_FIELD_ALIGN (DOCINFOA, lpszDocName, 4) |
| TEST_FIELD_OFFSET(DOCINFOA, lpszDocName, 4) |
| TEST_FIELD_SIZE (DOCINFOA, lpszOutput, 4) |
| TEST_FIELD_ALIGN (DOCINFOA, lpszOutput, 4) |
| TEST_FIELD_OFFSET(DOCINFOA, lpszOutput, 8) |
| TEST_FIELD_SIZE (DOCINFOA, lpszDatatype, 4) |
| TEST_FIELD_ALIGN (DOCINFOA, lpszDatatype, 4) |
| TEST_FIELD_OFFSET(DOCINFOA, lpszDatatype, 12) |
| TEST_FIELD_SIZE (DOCINFOA, fwType, 4) |
| TEST_FIELD_ALIGN (DOCINFOA, fwType, 4) |
| TEST_FIELD_OFFSET(DOCINFOA, fwType, 16) |
| } |
| |
| static void test_pack_DOCINFOW(void) |
| { |
| /* DOCINFOW */ |
| TEST_TYPE_SIZE (DOCINFOW, 20) |
| TEST_TYPE_ALIGN (DOCINFOW, 4) |
| TEST_FIELD_SIZE (DOCINFOW, cbSize, 4) |
| TEST_FIELD_ALIGN (DOCINFOW, cbSize, 4) |
| TEST_FIELD_OFFSET(DOCINFOW, cbSize, 0) |
| TEST_FIELD_SIZE (DOCINFOW, lpszDocName, 4) |
| TEST_FIELD_ALIGN (DOCINFOW, lpszDocName, 4) |
| TEST_FIELD_OFFSET(DOCINFOW, lpszDocName, 4) |
| TEST_FIELD_SIZE (DOCINFOW, lpszOutput, 4) |
| TEST_FIELD_ALIGN (DOCINFOW, lpszOutput, 4) |
| TEST_FIELD_OFFSET(DOCINFOW, lpszOutput, 8) |
| TEST_FIELD_SIZE (DOCINFOW, lpszDatatype, 4) |
| TEST_FIELD_ALIGN (DOCINFOW, lpszDatatype, 4) |
| TEST_FIELD_OFFSET(DOCINFOW, lpszDatatype, 12) |
| TEST_FIELD_SIZE (DOCINFOW, fwType, 4) |
| TEST_FIELD_ALIGN (DOCINFOW, fwType, 4) |
| TEST_FIELD_OFFSET(DOCINFOW, fwType, 16) |
| } |
| |
| static void test_pack_EMR(void) |
| { |
| /* EMR */ |
| TEST_TYPE_SIZE (EMR, 8) |
| TEST_TYPE_ALIGN (EMR, 4) |
| TEST_FIELD_SIZE (EMR, iType, 4) |
| TEST_FIELD_ALIGN (EMR, iType, 4) |
| TEST_FIELD_OFFSET(EMR, iType, 0) |
| TEST_FIELD_SIZE (EMR, nSize, 4) |
| TEST_FIELD_ALIGN (EMR, nSize, 4) |
| TEST_FIELD_OFFSET(EMR, nSize, 4) |
| } |
| |
| static void test_pack_EMRABORTPATH(void) |
| { |
| /* EMRABORTPATH */ |
| TEST_TYPE_SIZE (EMRABORTPATH, 8) |
| TEST_TYPE_ALIGN (EMRABORTPATH, 4) |
| TEST_FIELD_SIZE (EMRABORTPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRABORTPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRABORTPATH, emr, 0) |
| } |
| |
| static void test_pack_EMRANGLEARC(void) |
| { |
| /* EMRANGLEARC */ |
| TEST_TYPE_SIZE (EMRANGLEARC, 28) |
| TEST_TYPE_ALIGN (EMRANGLEARC, 4) |
| TEST_FIELD_SIZE (EMRANGLEARC, emr, 8) |
| TEST_FIELD_ALIGN (EMRANGLEARC, emr, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, emr, 0) |
| TEST_FIELD_SIZE (EMRANGLEARC, ptlCenter, 8) |
| TEST_FIELD_ALIGN (EMRANGLEARC, ptlCenter, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, ptlCenter, 8) |
| TEST_FIELD_SIZE (EMRANGLEARC, nRadius, 4) |
| TEST_FIELD_ALIGN (EMRANGLEARC, nRadius, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, nRadius, 16) |
| TEST_FIELD_SIZE (EMRANGLEARC, eStartAngle, 4) |
| TEST_FIELD_ALIGN (EMRANGLEARC, eStartAngle, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, eStartAngle, 20) |
| TEST_FIELD_SIZE (EMRANGLEARC, eSweepAngle, 4) |
| TEST_FIELD_ALIGN (EMRANGLEARC, eSweepAngle, 4) |
| TEST_FIELD_OFFSET(EMRANGLEARC, eSweepAngle, 24) |
| } |
| |
| static void test_pack_EMRARC(void) |
| { |
| /* EMRARC */ |
| TEST_TYPE_SIZE (EMRARC, 40) |
| TEST_TYPE_ALIGN (EMRARC, 4) |
| TEST_FIELD_SIZE (EMRARC, emr, 8) |
| TEST_FIELD_ALIGN (EMRARC, emr, 4) |
| TEST_FIELD_OFFSET(EMRARC, emr, 0) |
| TEST_FIELD_SIZE (EMRARC, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRARC, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRARC, rclBox, 8) |
| TEST_FIELD_SIZE (EMRARC, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMRARC, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMRARC, ptlStart, 24) |
| TEST_FIELD_SIZE (EMRARC, ptlEnd, 8) |
| TEST_FIELD_ALIGN (EMRARC, ptlEnd, 4) |
| TEST_FIELD_OFFSET(EMRARC, ptlEnd, 32) |
| } |
| |
| static void test_pack_EMRARCTO(void) |
| { |
| /* EMRARCTO */ |
| TEST_TYPE_SIZE (EMRARCTO, 40) |
| TEST_TYPE_ALIGN (EMRARCTO, 4) |
| TEST_FIELD_SIZE (EMRARCTO, emr, 8) |
| TEST_FIELD_ALIGN (EMRARCTO, emr, 4) |
| TEST_FIELD_OFFSET(EMRARCTO, emr, 0) |
| TEST_FIELD_SIZE (EMRARCTO, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRARCTO, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRARCTO, rclBox, 8) |
| TEST_FIELD_SIZE (EMRARCTO, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMRARCTO, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMRARCTO, ptlStart, 24) |
| TEST_FIELD_SIZE (EMRARCTO, ptlEnd, 8) |
| TEST_FIELD_ALIGN (EMRARCTO, ptlEnd, 4) |
| TEST_FIELD_OFFSET(EMRARCTO, ptlEnd, 32) |
| } |
| |
| static void test_pack_EMRBEGINPATH(void) |
| { |
| /* EMRBEGINPATH */ |
| TEST_TYPE_SIZE (EMRBEGINPATH, 8) |
| TEST_TYPE_ALIGN (EMRBEGINPATH, 4) |
| TEST_FIELD_SIZE (EMRBEGINPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRBEGINPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRBEGINPATH, emr, 0) |
| } |
| |
| static void test_pack_EMRBITBLT(void) |
| { |
| /* EMRBITBLT */ |
| TEST_TYPE_SIZE (EMRBITBLT, 100) |
| TEST_TYPE_ALIGN (EMRBITBLT, 4) |
| TEST_FIELD_SIZE (EMRBITBLT, emr, 8) |
| TEST_FIELD_ALIGN (EMRBITBLT, emr, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, emr, 0) |
| TEST_FIELD_SIZE (EMRBITBLT, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRBITBLT, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRBITBLT, xDest, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, xDest, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, xDest, 24) |
| TEST_FIELD_SIZE (EMRBITBLT, yDest, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, yDest, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, yDest, 28) |
| TEST_FIELD_SIZE (EMRBITBLT, cxDest, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, cxDest, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, cxDest, 32) |
| TEST_FIELD_SIZE (EMRBITBLT, cyDest, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, cyDest, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, cyDest, 36) |
| TEST_FIELD_SIZE (EMRBITBLT, dwRop, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, dwRop, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, dwRop, 40) |
| TEST_FIELD_SIZE (EMRBITBLT, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, xSrc, 44) |
| TEST_FIELD_SIZE (EMRBITBLT, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, ySrc, 48) |
| TEST_FIELD_SIZE (EMRBITBLT, xformSrc, 24) |
| TEST_FIELD_ALIGN (EMRBITBLT, xformSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, xformSrc, 52) |
| TEST_FIELD_SIZE (EMRBITBLT, crBkColorSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, crBkColorSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, crBkColorSrc, 76) |
| TEST_FIELD_SIZE (EMRBITBLT, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, iUsageSrc, 80) |
| TEST_FIELD_SIZE (EMRBITBLT, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, offBmiSrc, 84) |
| TEST_FIELD_SIZE (EMRBITBLT, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, cbBmiSrc, 88) |
| TEST_FIELD_SIZE (EMRBITBLT, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, offBitsSrc, 92) |
| TEST_FIELD_SIZE (EMRBITBLT, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRBITBLT, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRBITBLT, cbBitsSrc, 96) |
| } |
| |
| static void test_pack_EMRCHORD(void) |
| { |
| /* EMRCHORD */ |
| TEST_TYPE_SIZE (EMRCHORD, 40) |
| TEST_TYPE_ALIGN (EMRCHORD, 4) |
| TEST_FIELD_SIZE (EMRCHORD, emr, 8) |
| TEST_FIELD_ALIGN (EMRCHORD, emr, 4) |
| TEST_FIELD_OFFSET(EMRCHORD, emr, 0) |
| TEST_FIELD_SIZE (EMRCHORD, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRCHORD, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRCHORD, rclBox, 8) |
| TEST_FIELD_SIZE (EMRCHORD, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMRCHORD, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMRCHORD, ptlStart, 24) |
| TEST_FIELD_SIZE (EMRCHORD, ptlEnd, 8) |
| TEST_FIELD_ALIGN (EMRCHORD, ptlEnd, 4) |
| TEST_FIELD_OFFSET(EMRCHORD, ptlEnd, 32) |
| } |
| |
| static void test_pack_EMRCLOSEFIGURE(void) |
| { |
| /* EMRCLOSEFIGURE */ |
| TEST_TYPE_SIZE (EMRCLOSEFIGURE, 8) |
| TEST_TYPE_ALIGN (EMRCLOSEFIGURE, 4) |
| TEST_FIELD_SIZE (EMRCLOSEFIGURE, emr, 8) |
| TEST_FIELD_ALIGN (EMRCLOSEFIGURE, emr, 4) |
| TEST_FIELD_OFFSET(EMRCLOSEFIGURE, emr, 0) |
| } |
| |
| static void test_pack_EMRCREATEBRUSHINDIRECT(void) |
| { |
| /* EMRCREATEBRUSHINDIRECT */ |
| TEST_TYPE_SIZE (EMRCREATEBRUSHINDIRECT, 24) |
| TEST_TYPE_ALIGN (EMRCREATEBRUSHINDIRECT, 4) |
| TEST_FIELD_SIZE (EMRCREATEBRUSHINDIRECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATEBRUSHINDIRECT, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, ihBrush, 8) |
| TEST_FIELD_SIZE (EMRCREATEBRUSHINDIRECT, lb, 12) |
| TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, lb, 4) |
| TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, lb, 12) |
| } |
| |
| static void test_pack_EMRCREATECOLORSPACE(void) |
| { |
| /* EMRCREATECOLORSPACE */ |
| TEST_TYPE_SIZE (EMRCREATECOLORSPACE, 340) |
| TEST_TYPE_ALIGN (EMRCREATECOLORSPACE, 4) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACE, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACE, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, ihCS, 8) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACE, lcs, 328) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, lcs, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, lcs, 12) |
| } |
| |
| static void test_pack_EMRCREATECOLORSPACEW(void) |
| { |
| /* EMRCREATECOLORSPACEW */ |
| TEST_TYPE_SIZE (EMRCREATECOLORSPACEW, 612) |
| TEST_TYPE_ALIGN (EMRCREATECOLORSPACEW, 4) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, ihCS, 8) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, lcs, 588) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, lcs, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, lcs, 12) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, dwFlags, 4) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, dwFlags, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, dwFlags, 600) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, cbData, 4) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, cbData, 4) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, cbData, 604) |
| TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, Data, 1) |
| TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, Data, 1) |
| TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, Data, 608) |
| } |
| |
| static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void) |
| { |
| /* EMRCREATEDIBPATTERNBRUSHPT */ |
| TEST_TYPE_SIZE (EMRCREATEDIBPATTERNBRUSHPT, 32) |
| TEST_TYPE_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, 4) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 8) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, iUsage, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, iUsage, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, iUsage, 12) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, offBmi, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, offBmi, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, offBmi, 16) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 20) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, offBits, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, offBits, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, offBits, 24) |
| TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, cbBits, 4) |
| TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, cbBits, 4) |
| TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, cbBits, 28) |
| } |
| |
| static void test_pack_EMRCREATEMONOBRUSH(void) |
| { |
| /* EMRCREATEMONOBRUSH */ |
| TEST_TYPE_SIZE (EMRCREATEMONOBRUSH, 32) |
| TEST_TYPE_ALIGN (EMRCREATEMONOBRUSH, 4) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, ihBrush, 8) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, iUsage, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, iUsage, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, iUsage, 12) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, offBmi, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, offBmi, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, offBmi, 16) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, cbBmi, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, cbBmi, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, cbBmi, 20) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, offBits, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, offBits, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, offBits, 24) |
| TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, cbBits, 4) |
| TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, cbBits, 4) |
| TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, cbBits, 28) |
| } |
| |
| static void test_pack_EMRCREATEPEN(void) |
| { |
| /* EMRCREATEPEN */ |
| TEST_TYPE_SIZE (EMRCREATEPEN, 28) |
| TEST_TYPE_ALIGN (EMRCREATEPEN, 4) |
| TEST_FIELD_SIZE (EMRCREATEPEN, emr, 8) |
| TEST_FIELD_ALIGN (EMRCREATEPEN, emr, 4) |
| TEST_FIELD_OFFSET(EMRCREATEPEN, emr, 0) |
| TEST_FIELD_SIZE (EMRCREATEPEN, ihPen, 4) |
| TEST_FIELD_ALIGN (EMRCREATEPEN, ihPen, 4) |
| TEST_FIELD_OFFSET(EMRCREATEPEN, ihPen, 8) |
| TEST_FIELD_SIZE (EMRCREATEPEN, lopn, 16) |
| TEST_FIELD_ALIGN (EMRCREATEPEN, lopn, 4) |
| TEST_FIELD_OFFSET(EMRCREATEPEN, lopn, 12) |
| } |
| |
| static void test_pack_EMRDELETECOLORSPACE(void) |
| { |
| /* EMRDELETECOLORSPACE */ |
| TEST_TYPE_SIZE (EMRDELETECOLORSPACE, 12) |
| TEST_TYPE_ALIGN (EMRDELETECOLORSPACE, 4) |
| TEST_FIELD_SIZE (EMRDELETECOLORSPACE, emr, 8) |
| TEST_FIELD_ALIGN (EMRDELETECOLORSPACE, emr, 4) |
| TEST_FIELD_OFFSET(EMRDELETECOLORSPACE, emr, 0) |
| TEST_FIELD_SIZE (EMRDELETECOLORSPACE, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRDELETECOLORSPACE, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRDELETECOLORSPACE, ihCS, 8) |
| } |
| |
| static void test_pack_EMRDELETEOBJECT(void) |
| { |
| /* EMRDELETEOBJECT */ |
| TEST_TYPE_SIZE (EMRDELETEOBJECT, 12) |
| TEST_TYPE_ALIGN (EMRDELETEOBJECT, 4) |
| TEST_FIELD_SIZE (EMRDELETEOBJECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRDELETEOBJECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRDELETEOBJECT, emr, 0) |
| TEST_FIELD_SIZE (EMRDELETEOBJECT, ihObject, 4) |
| TEST_FIELD_ALIGN (EMRDELETEOBJECT, ihObject, 4) |
| TEST_FIELD_OFFSET(EMRDELETEOBJECT, ihObject, 8) |
| } |
| |
| static void test_pack_EMRELLIPSE(void) |
| { |
| /* EMRELLIPSE */ |
| TEST_TYPE_SIZE (EMRELLIPSE, 24) |
| TEST_TYPE_ALIGN (EMRELLIPSE, 4) |
| TEST_FIELD_SIZE (EMRELLIPSE, emr, 8) |
| TEST_FIELD_ALIGN (EMRELLIPSE, emr, 4) |
| TEST_FIELD_OFFSET(EMRELLIPSE, emr, 0) |
| TEST_FIELD_SIZE (EMRELLIPSE, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRELLIPSE, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRELLIPSE, rclBox, 8) |
| } |
| |
| static void test_pack_EMRENDPATH(void) |
| { |
| /* EMRENDPATH */ |
| TEST_TYPE_SIZE (EMRENDPATH, 8) |
| TEST_TYPE_ALIGN (EMRENDPATH, 4) |
| TEST_FIELD_SIZE (EMRENDPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRENDPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRENDPATH, emr, 0) |
| } |
| |
| static void test_pack_EMREOF(void) |
| { |
| /* EMREOF */ |
| TEST_TYPE_SIZE (EMREOF, 20) |
| TEST_TYPE_ALIGN (EMREOF, 4) |
| TEST_FIELD_SIZE (EMREOF, emr, 8) |
| TEST_FIELD_ALIGN (EMREOF, emr, 4) |
| TEST_FIELD_OFFSET(EMREOF, emr, 0) |
| TEST_FIELD_SIZE (EMREOF, nPalEntries, 4) |
| TEST_FIELD_ALIGN (EMREOF, nPalEntries, 4) |
| TEST_FIELD_OFFSET(EMREOF, nPalEntries, 8) |
| TEST_FIELD_SIZE (EMREOF, offPalEntries, 4) |
| TEST_FIELD_ALIGN (EMREOF, offPalEntries, 4) |
| TEST_FIELD_OFFSET(EMREOF, offPalEntries, 12) |
| TEST_FIELD_SIZE (EMREOF, nSizeLast, 4) |
| TEST_FIELD_ALIGN (EMREOF, nSizeLast, 4) |
| TEST_FIELD_OFFSET(EMREOF, nSizeLast, 16) |
| } |
| |
| static void test_pack_EMREXCLUDECLIPRECT(void) |
| { |
| /* EMREXCLUDECLIPRECT */ |
| TEST_TYPE_SIZE (EMREXCLUDECLIPRECT, 24) |
| TEST_TYPE_ALIGN (EMREXCLUDECLIPRECT, 4) |
| TEST_FIELD_SIZE (EMREXCLUDECLIPRECT, emr, 8) |
| TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, emr, 4) |
| TEST_FIELD_OFFSET(EMREXCLUDECLIPRECT, emr, 0) |
| TEST_FIELD_SIZE (EMREXCLUDECLIPRECT, rclClip, 16) |
| TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, rclClip, 4) |
| TEST_FIELD_OFFSET(EMREXCLUDECLIPRECT, rclClip, 8) |
| } |
| |
| static void test_pack_EMREXTCREATEFONTINDIRECTW(void) |
| { |
| /* EMREXTCREATEFONTINDIRECTW */ |
| TEST_TYPE_SIZE (EMREXTCREATEFONTINDIRECTW, 332) |
| TEST_TYPE_ALIGN (EMREXTCREATEFONTINDIRECTW, 4) |
| TEST_FIELD_SIZE (EMREXTCREATEFONTINDIRECTW, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, emr, 0) |
| TEST_FIELD_SIZE (EMREXTCREATEFONTINDIRECTW, ihFont, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, ihFont, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, ihFont, 8) |
| TEST_FIELD_SIZE (EMREXTCREATEFONTINDIRECTW, elfw, 320) |
| TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, elfw, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, elfw, 12) |
| } |
| |
| static void test_pack_EMREXTCREATEPEN(void) |
| { |
| /* EMREXTCREATEPEN */ |
| TEST_TYPE_SIZE (EMREXTCREATEPEN, 56) |
| TEST_TYPE_ALIGN (EMREXTCREATEPEN, 4) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, emr, 0) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, ihPen, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, ihPen, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, ihPen, 8) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, offBmi, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBmi, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBmi, 12) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, cbBmi, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBmi, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, cbBmi, 16) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, offBits, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBits, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBits, 20) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, cbBits, 4) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBits, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, cbBits, 24) |
| TEST_FIELD_SIZE (EMREXTCREATEPEN, elp, 28) |
| TEST_FIELD_ALIGN (EMREXTCREATEPEN, elp, 4) |
| TEST_FIELD_OFFSET(EMREXTCREATEPEN, elp, 28) |
| } |
| |
| static void test_pack_EMREXTFLOODFILL(void) |
| { |
| /* EMREXTFLOODFILL */ |
| TEST_TYPE_SIZE (EMREXTFLOODFILL, 24) |
| TEST_TYPE_ALIGN (EMREXTFLOODFILL, 4) |
| TEST_FIELD_SIZE (EMREXTFLOODFILL, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTFLOODFILL, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTFLOODFILL, emr, 0) |
| TEST_FIELD_SIZE (EMREXTFLOODFILL, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMREXTFLOODFILL, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMREXTFLOODFILL, ptlStart, 8) |
| TEST_FIELD_SIZE (EMREXTFLOODFILL, crColor, 4) |
| TEST_FIELD_ALIGN (EMREXTFLOODFILL, crColor, 4) |
| TEST_FIELD_OFFSET(EMREXTFLOODFILL, crColor, 16) |
| TEST_FIELD_SIZE (EMREXTFLOODFILL, iMode, 4) |
| TEST_FIELD_ALIGN (EMREXTFLOODFILL, iMode, 4) |
| TEST_FIELD_OFFSET(EMREXTFLOODFILL, iMode, 20) |
| } |
| |
| static void test_pack_EMREXTSELECTCLIPRGN(void) |
| { |
| /* EMREXTSELECTCLIPRGN */ |
| TEST_TYPE_SIZE (EMREXTSELECTCLIPRGN, 20) |
| TEST_TYPE_ALIGN (EMREXTSELECTCLIPRGN, 4) |
| TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, emr, 0) |
| TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, cbRgnData, 8) |
| TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, iMode, 4) |
| TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, iMode, 4) |
| TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, iMode, 12) |
| TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, RgnData, 16) |
| } |
| |
| static void test_pack_EMREXTTEXTOUTA(void) |
| { |
| /* EMREXTTEXTOUTA */ |
| TEST_TYPE_SIZE (EMREXTTEXTOUTA, 76) |
| TEST_TYPE_ALIGN (EMREXTTEXTOUTA, 4) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, emr, 0) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, rclBounds, 8) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, iGraphicsMode, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, iGraphicsMode, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, iGraphicsMode, 24) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, exScale, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, exScale, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, exScale, 28) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, eyScale, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, eyScale, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, eyScale, 32) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTA, emrtext, 40) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTA, emrtext, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTA, emrtext, 36) |
| } |
| |
| static void test_pack_EMREXTTEXTOUTW(void) |
| { |
| /* EMREXTTEXTOUTW */ |
| TEST_TYPE_SIZE (EMREXTTEXTOUTW, 76) |
| TEST_TYPE_ALIGN (EMREXTTEXTOUTW, 4) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, emr, 8) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, emr, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, emr, 0) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, rclBounds, 8) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, iGraphicsMode, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, iGraphicsMode, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, iGraphicsMode, 24) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, exScale, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, exScale, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, exScale, 28) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, eyScale, 4) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, eyScale, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, eyScale, 32) |
| TEST_FIELD_SIZE (EMREXTTEXTOUTW, emrtext, 40) |
| TEST_FIELD_ALIGN (EMREXTTEXTOUTW, emrtext, 4) |
| TEST_FIELD_OFFSET(EMREXTTEXTOUTW, emrtext, 36) |
| } |
| |
| static void test_pack_EMRFILLPATH(void) |
| { |
| /* EMRFILLPATH */ |
| TEST_TYPE_SIZE (EMRFILLPATH, 24) |
| TEST_TYPE_ALIGN (EMRFILLPATH, 4) |
| TEST_FIELD_SIZE (EMRFILLPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRFILLPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRFILLPATH, emr, 0) |
| TEST_FIELD_SIZE (EMRFILLPATH, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRFILLPATH, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRFILLPATH, rclBounds, 8) |
| } |
| |
| static void test_pack_EMRFILLRGN(void) |
| { |
| /* EMRFILLRGN */ |
| TEST_TYPE_SIZE (EMRFILLRGN, 36) |
| TEST_TYPE_ALIGN (EMRFILLRGN, 4) |
| TEST_FIELD_SIZE (EMRFILLRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRFILLRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRFILLRGN, emr, 0) |
| TEST_FIELD_SIZE (EMRFILLRGN, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRFILLRGN, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRFILLRGN, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRFILLRGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMRFILLRGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMRFILLRGN, cbRgnData, 24) |
| TEST_FIELD_SIZE (EMRFILLRGN, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRFILLRGN, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRFILLRGN, ihBrush, 28) |
| TEST_FIELD_SIZE (EMRFILLRGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMRFILLRGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMRFILLRGN, RgnData, 32) |
| } |
| |
| static void test_pack_EMRFLATTENPATH(void) |
| { |
| /* EMRFLATTENPATH */ |
| TEST_TYPE_SIZE (EMRFLATTENPATH, 8) |
| TEST_TYPE_ALIGN (EMRFLATTENPATH, 4) |
| TEST_FIELD_SIZE (EMRFLATTENPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRFLATTENPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRFLATTENPATH, emr, 0) |
| } |
| |
| static void test_pack_EMRFORMAT(void) |
| { |
| /* EMRFORMAT */ |
| TEST_TYPE_SIZE (EMRFORMAT, 16) |
| TEST_TYPE_ALIGN (EMRFORMAT, 4) |
| TEST_FIELD_SIZE (EMRFORMAT, dSignature, 4) |
| TEST_FIELD_ALIGN (EMRFORMAT, dSignature, 4) |
| TEST_FIELD_OFFSET(EMRFORMAT, dSignature, 0) |
| TEST_FIELD_SIZE (EMRFORMAT, nVersion, 4) |
| TEST_FIELD_ALIGN (EMRFORMAT, nVersion, 4) |
| TEST_FIELD_OFFSET(EMRFORMAT, nVersion, 4) |
| TEST_FIELD_SIZE (EMRFORMAT, cbData, 4) |
| TEST_FIELD_ALIGN (EMRFORMAT, cbData, 4) |
| TEST_FIELD_OFFSET(EMRFORMAT, cbData, 8) |
| TEST_FIELD_SIZE (EMRFORMAT, offData, 4) |
| TEST_FIELD_ALIGN (EMRFORMAT, offData, 4) |
| TEST_FIELD_OFFSET(EMRFORMAT, offData, 12) |
| } |
| |
| static void test_pack_EMRFRAMERGN(void) |
| { |
| /* EMRFRAMERGN */ |
| TEST_TYPE_SIZE (EMRFRAMERGN, 44) |
| TEST_TYPE_ALIGN (EMRFRAMERGN, 4) |
| TEST_FIELD_SIZE (EMRFRAMERGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, emr, 0) |
| TEST_FIELD_SIZE (EMRFRAMERGN, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRFRAMERGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, cbRgnData, 24) |
| TEST_FIELD_SIZE (EMRFRAMERGN, ihBrush, 4) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, ihBrush, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, ihBrush, 28) |
| TEST_FIELD_SIZE (EMRFRAMERGN, szlStroke, 8) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, szlStroke, 4) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, szlStroke, 32) |
| TEST_FIELD_SIZE (EMRFRAMERGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMRFRAMERGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMRFRAMERGN, RgnData, 40) |
| } |
| |
| static void test_pack_EMRGDICOMMENT(void) |
| { |
| /* EMRGDICOMMENT */ |
| TEST_TYPE_SIZE (EMRGDICOMMENT, 16) |
| TEST_TYPE_ALIGN (EMRGDICOMMENT, 4) |
| TEST_FIELD_SIZE (EMRGDICOMMENT, emr, 8) |
| TEST_FIELD_ALIGN (EMRGDICOMMENT, emr, 4) |
| TEST_FIELD_OFFSET(EMRGDICOMMENT, emr, 0) |
| TEST_FIELD_SIZE (EMRGDICOMMENT, cbData, 4) |
| TEST_FIELD_ALIGN (EMRGDICOMMENT, cbData, 4) |
| TEST_FIELD_OFFSET(EMRGDICOMMENT, cbData, 8) |
| TEST_FIELD_SIZE (EMRGDICOMMENT, Data, 1) |
| TEST_FIELD_ALIGN (EMRGDICOMMENT, Data, 1) |
| TEST_FIELD_OFFSET(EMRGDICOMMENT, Data, 12) |
| } |
| |
| static void test_pack_EMRGLSBOUNDEDRECORD(void) |
| { |
| /* EMRGLSBOUNDEDRECORD */ |
| TEST_TYPE_SIZE (EMRGLSBOUNDEDRECORD, 32) |
| TEST_TYPE_ALIGN (EMRGLSBOUNDEDRECORD, 4) |
| TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, emr, 8) |
| TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, emr, 4) |
| TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, emr, 0) |
| TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, cbData, 4) |
| TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, cbData, 4) |
| TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, cbData, 24) |
| TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, Data, 1) |
| TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, Data, 1) |
| TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, Data, 28) |
| } |
| |
| static void test_pack_EMRGLSRECORD(void) |
| { |
| /* EMRGLSRECORD */ |
| TEST_TYPE_SIZE (EMRGLSRECORD, 16) |
| TEST_TYPE_ALIGN (EMRGLSRECORD, 4) |
| TEST_FIELD_SIZE (EMRGLSRECORD, emr, 8) |
| TEST_FIELD_ALIGN (EMRGLSRECORD, emr, 4) |
| TEST_FIELD_OFFSET(EMRGLSRECORD, emr, 0) |
| TEST_FIELD_SIZE (EMRGLSRECORD, cbData, 4) |
| TEST_FIELD_ALIGN (EMRGLSRECORD, cbData, 4) |
| TEST_FIELD_OFFSET(EMRGLSRECORD, cbData, 8) |
| TEST_FIELD_SIZE (EMRGLSRECORD, Data, 1) |
| TEST_FIELD_ALIGN (EMRGLSRECORD, Data, 1) |
| TEST_FIELD_OFFSET(EMRGLSRECORD, Data, 12) |
| } |
| |
| static void test_pack_EMRINTERSECTCLIPRECT(void) |
| { |
| /* EMRINTERSECTCLIPRECT */ |
| TEST_TYPE_SIZE (EMRINTERSECTCLIPRECT, 24) |
| TEST_TYPE_ALIGN (EMRINTERSECTCLIPRECT, 4) |
| TEST_FIELD_SIZE (EMRINTERSECTCLIPRECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRINTERSECTCLIPRECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRINTERSECTCLIPRECT, emr, 0) |
| TEST_FIELD_SIZE (EMRINTERSECTCLIPRECT, rclClip, 16) |
| TEST_FIELD_ALIGN (EMRINTERSECTCLIPRECT, rclClip, 4) |
| TEST_FIELD_OFFSET(EMRINTERSECTCLIPRECT, rclClip, 8) |
| } |
| |
| static void test_pack_EMRINVERTRGN(void) |
| { |
| /* EMRINVERTRGN */ |
| TEST_TYPE_SIZE (EMRINVERTRGN, 32) |
| TEST_TYPE_ALIGN (EMRINVERTRGN, 4) |
| TEST_FIELD_SIZE (EMRINVERTRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRINVERTRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRINVERTRGN, emr, 0) |
| TEST_FIELD_SIZE (EMRINVERTRGN, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRINVERTRGN, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRINVERTRGN, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRINVERTRGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMRINVERTRGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMRINVERTRGN, cbRgnData, 24) |
| TEST_FIELD_SIZE (EMRINVERTRGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMRINVERTRGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMRINVERTRGN, RgnData, 28) |
| } |
| |
| static void test_pack_EMRLINETO(void) |
| { |
| /* EMRLINETO */ |
| TEST_TYPE_SIZE (EMRLINETO, 16) |
| TEST_TYPE_ALIGN (EMRLINETO, 4) |
| TEST_FIELD_SIZE (EMRLINETO, emr, 8) |
| TEST_FIELD_ALIGN (EMRLINETO, emr, 4) |
| TEST_FIELD_OFFSET(EMRLINETO, emr, 0) |
| TEST_FIELD_SIZE (EMRLINETO, ptl, 8) |
| TEST_FIELD_ALIGN (EMRLINETO, ptl, 4) |
| TEST_FIELD_OFFSET(EMRLINETO, ptl, 8) |
| } |
| |
| static void test_pack_EMRMASKBLT(void) |
| { |
| /* EMRMASKBLT */ |
| TEST_TYPE_SIZE (EMRMASKBLT, 128) |
| TEST_TYPE_ALIGN (EMRMASKBLT, 4) |
| TEST_FIELD_SIZE (EMRMASKBLT, emr, 8) |
| TEST_FIELD_ALIGN (EMRMASKBLT, emr, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, emr, 0) |
| TEST_FIELD_SIZE (EMRMASKBLT, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRMASKBLT, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRMASKBLT, xDest, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, xDest, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, xDest, 24) |
| TEST_FIELD_SIZE (EMRMASKBLT, yDest, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, yDest, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, yDest, 28) |
| TEST_FIELD_SIZE (EMRMASKBLT, cxDest, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cxDest, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cxDest, 32) |
| TEST_FIELD_SIZE (EMRMASKBLT, cyDest, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cyDest, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cyDest, 36) |
| TEST_FIELD_SIZE (EMRMASKBLT, dwRop, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, dwRop, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, dwRop, 40) |
| TEST_FIELD_SIZE (EMRMASKBLT, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, xSrc, 44) |
| TEST_FIELD_SIZE (EMRMASKBLT, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, ySrc, 48) |
| TEST_FIELD_SIZE (EMRMASKBLT, xformSrc, 24) |
| TEST_FIELD_ALIGN (EMRMASKBLT, xformSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, xformSrc, 52) |
| TEST_FIELD_SIZE (EMRMASKBLT, crBkColorSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, crBkColorSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, crBkColorSrc, 76) |
| TEST_FIELD_SIZE (EMRMASKBLT, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, iUsageSrc, 80) |
| TEST_FIELD_SIZE (EMRMASKBLT, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, offBmiSrc, 84) |
| TEST_FIELD_SIZE (EMRMASKBLT, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiSrc, 88) |
| TEST_FIELD_SIZE (EMRMASKBLT, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, offBitsSrc, 92) |
| TEST_FIELD_SIZE (EMRMASKBLT, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsSrc, 96) |
| TEST_FIELD_SIZE (EMRMASKBLT, xMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, xMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, xMask, 100) |
| TEST_FIELD_SIZE (EMRMASKBLT, yMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, yMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, yMask, 104) |
| TEST_FIELD_SIZE (EMRMASKBLT, iUsageMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, iUsageMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, iUsageMask, 108) |
| TEST_FIELD_SIZE (EMRMASKBLT, offBmiMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, offBmiMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, offBmiMask, 112) |
| TEST_FIELD_SIZE (EMRMASKBLT, cbBmiMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiMask, 116) |
| TEST_FIELD_SIZE (EMRMASKBLT, offBitsMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, offBitsMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, offBitsMask, 120) |
| TEST_FIELD_SIZE (EMRMASKBLT, cbBitsMask, 4) |
| TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsMask, 4) |
| TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsMask, 124) |
| } |
| |
| static void test_pack_EMRMODIFYWORLDTRANSFORM(void) |
| { |
| /* EMRMODIFYWORLDTRANSFORM */ |
| TEST_TYPE_SIZE (EMRMODIFYWORLDTRANSFORM, 36) |
| TEST_TYPE_ALIGN (EMRMODIFYWORLDTRANSFORM, 4) |
| TEST_FIELD_SIZE (EMRMODIFYWORLDTRANSFORM, emr, 8) |
| TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, emr, 4) |
| TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, emr, 0) |
| TEST_FIELD_SIZE (EMRMODIFYWORLDTRANSFORM, xform, 24) |
| TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, xform, 4) |
| TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, xform, 8) |
| TEST_FIELD_SIZE (EMRMODIFYWORLDTRANSFORM, iMode, 4) |
| TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, iMode, 4) |
| TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, iMode, 32) |
| } |
| |
| static void test_pack_EMRMOVETOEX(void) |
| { |
| /* EMRMOVETOEX */ |
| TEST_TYPE_SIZE (EMRMOVETOEX, 16) |
| TEST_TYPE_ALIGN (EMRMOVETOEX, 4) |
| TEST_FIELD_SIZE (EMRMOVETOEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRMOVETOEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRMOVETOEX, emr, 0) |
| TEST_FIELD_SIZE (EMRMOVETOEX, ptl, 8) |
| TEST_FIELD_ALIGN (EMRMOVETOEX, ptl, 4) |
| TEST_FIELD_OFFSET(EMRMOVETOEX, ptl, 8) |
| } |
| |
| static void test_pack_EMROFFSETCLIPRGN(void) |
| { |
| /* EMROFFSETCLIPRGN */ |
| TEST_TYPE_SIZE (EMROFFSETCLIPRGN, 16) |
| TEST_TYPE_ALIGN (EMROFFSETCLIPRGN, 4) |
| TEST_FIELD_SIZE (EMROFFSETCLIPRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMROFFSETCLIPRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMROFFSETCLIPRGN, emr, 0) |
| TEST_FIELD_SIZE (EMROFFSETCLIPRGN, ptlOffset, 8) |
| TEST_FIELD_ALIGN (EMROFFSETCLIPRGN, ptlOffset, 4) |
| TEST_FIELD_OFFSET(EMROFFSETCLIPRGN, ptlOffset, 8) |
| } |
| |
| static void test_pack_EMRPAINTRGN(void) |
| { |
| /* EMRPAINTRGN */ |
| TEST_TYPE_SIZE (EMRPAINTRGN, 32) |
| TEST_TYPE_ALIGN (EMRPAINTRGN, 4) |
| TEST_FIELD_SIZE (EMRPAINTRGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRPAINTRGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRPAINTRGN, emr, 0) |
| TEST_FIELD_SIZE (EMRPAINTRGN, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPAINTRGN, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPAINTRGN, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPAINTRGN, cbRgnData, 4) |
| TEST_FIELD_ALIGN (EMRPAINTRGN, cbRgnData, 4) |
| TEST_FIELD_OFFSET(EMRPAINTRGN, cbRgnData, 24) |
| TEST_FIELD_SIZE (EMRPAINTRGN, RgnData, 1) |
| TEST_FIELD_ALIGN (EMRPAINTRGN, RgnData, 1) |
| TEST_FIELD_OFFSET(EMRPAINTRGN, RgnData, 28) |
| } |
| |
| static void test_pack_EMRPIE(void) |
| { |
| /* EMRPIE */ |
| TEST_TYPE_SIZE (EMRPIE, 40) |
| TEST_TYPE_ALIGN (EMRPIE, 4) |
| TEST_FIELD_SIZE (EMRPIE, emr, 8) |
| TEST_FIELD_ALIGN (EMRPIE, emr, 4) |
| TEST_FIELD_OFFSET(EMRPIE, emr, 0) |
| TEST_FIELD_SIZE (EMRPIE, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRPIE, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRPIE, rclBox, 8) |
| TEST_FIELD_SIZE (EMRPIE, ptlStart, 8) |
| TEST_FIELD_ALIGN (EMRPIE, ptlStart, 4) |
| TEST_FIELD_OFFSET(EMRPIE, ptlStart, 24) |
| TEST_FIELD_SIZE (EMRPIE, ptlEnd, 8) |
| TEST_FIELD_ALIGN (EMRPIE, ptlEnd, 4) |
| TEST_FIELD_OFFSET(EMRPIE, ptlEnd, 32) |
| } |
| |
| static void test_pack_EMRPIXELFORMAT(void) |
| { |
| /* EMRPIXELFORMAT */ |
| TEST_TYPE_SIZE (EMRPIXELFORMAT, 48) |
| TEST_TYPE_ALIGN (EMRPIXELFORMAT, 4) |
| TEST_FIELD_SIZE (EMRPIXELFORMAT, emr, 8) |
| TEST_FIELD_ALIGN (EMRPIXELFORMAT, emr, 4) |
| TEST_FIELD_OFFSET(EMRPIXELFORMAT, emr, 0) |
| TEST_FIELD_SIZE (EMRPIXELFORMAT, pfd, 40) |
| TEST_FIELD_ALIGN (EMRPIXELFORMAT, pfd, 4) |
| TEST_FIELD_OFFSET(EMRPIXELFORMAT, pfd, 8) |
| } |
| |
| static void test_pack_EMRPLGBLT(void) |
| { |
| /* EMRPLGBLT */ |
| TEST_TYPE_SIZE (EMRPLGBLT, 140) |
| TEST_TYPE_ALIGN (EMRPLGBLT, 4) |
| TEST_FIELD_SIZE (EMRPLGBLT, emr, 8) |
| TEST_FIELD_ALIGN (EMRPLGBLT, emr, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, emr, 0) |
| TEST_FIELD_SIZE (EMRPLGBLT, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPLGBLT, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPLGBLT, aptlDest, 24) |
| TEST_FIELD_ALIGN (EMRPLGBLT, aptlDest, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, aptlDest, 24) |
| TEST_FIELD_SIZE (EMRPLGBLT, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, xSrc, 48) |
| TEST_FIELD_SIZE (EMRPLGBLT, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, ySrc, 52) |
| TEST_FIELD_SIZE (EMRPLGBLT, cxSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cxSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cxSrc, 56) |
| TEST_FIELD_SIZE (EMRPLGBLT, cySrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cySrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cySrc, 60) |
| TEST_FIELD_SIZE (EMRPLGBLT, xformSrc, 24) |
| TEST_FIELD_ALIGN (EMRPLGBLT, xformSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, xformSrc, 64) |
| TEST_FIELD_SIZE (EMRPLGBLT, crBkColorSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, crBkColorSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, crBkColorSrc, 88) |
| TEST_FIELD_SIZE (EMRPLGBLT, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, iUsageSrc, 92) |
| TEST_FIELD_SIZE (EMRPLGBLT, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, offBmiSrc, 96) |
| TEST_FIELD_SIZE (EMRPLGBLT, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiSrc, 100) |
| TEST_FIELD_SIZE (EMRPLGBLT, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, offBitsSrc, 104) |
| TEST_FIELD_SIZE (EMRPLGBLT, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsSrc, 108) |
| TEST_FIELD_SIZE (EMRPLGBLT, xMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, xMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, xMask, 112) |
| TEST_FIELD_SIZE (EMRPLGBLT, yMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, yMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, yMask, 116) |
| TEST_FIELD_SIZE (EMRPLGBLT, iUsageMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, iUsageMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, iUsageMask, 120) |
| TEST_FIELD_SIZE (EMRPLGBLT, offBmiMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, offBmiMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, offBmiMask, 124) |
| TEST_FIELD_SIZE (EMRPLGBLT, cbBmiMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiMask, 128) |
| TEST_FIELD_SIZE (EMRPLGBLT, offBitsMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, offBitsMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, offBitsMask, 132) |
| TEST_FIELD_SIZE (EMRPLGBLT, cbBitsMask, 4) |
| TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsMask, 4) |
| TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsMask, 136) |
| } |
| |
| static void test_pack_EMRPOLYBEZIER(void) |
| { |
| /* EMRPOLYBEZIER */ |
| TEST_TYPE_SIZE (EMRPOLYBEZIER, 36) |
| TEST_TYPE_ALIGN (EMRPOLYBEZIER, 4) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYBEZIER16(void) |
| { |
| /* EMRPOLYBEZIER16 */ |
| TEST_TYPE_SIZE (EMRPOLYBEZIER16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYBEZIER16, 4) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYBEZIER16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIER16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIER16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYBEZIERTO(void) |
| { |
| /* EMRPOLYBEZIERTO */ |
| TEST_TYPE_SIZE (EMRPOLYBEZIERTO, 36) |
| TEST_TYPE_ALIGN (EMRPOLYBEZIERTO, 4) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYBEZIERTO16(void) |
| { |
| /* EMRPOLYBEZIERTO16 */ |
| TEST_TYPE_SIZE (EMRPOLYBEZIERTO16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYBEZIERTO16, 4) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYDRAW(void) |
| { |
| /* EMRPOLYDRAW */ |
| TEST_TYPE_SIZE (EMRPOLYDRAW, 40) |
| TEST_TYPE_ALIGN (EMRPOLYDRAW, 4) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, aptl, 28) |
| TEST_FIELD_SIZE (EMRPOLYDRAW, abTypes, 1) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW, abTypes, 1) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW, abTypes, 36) |
| } |
| |
| static void test_pack_EMRPOLYDRAW16(void) |
| { |
| /* EMRPOLYDRAW16 */ |
| TEST_TYPE_SIZE (EMRPOLYDRAW16, 36) |
| TEST_TYPE_ALIGN (EMRPOLYDRAW16, 4) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, apts, 28) |
| TEST_FIELD_SIZE (EMRPOLYDRAW16, abTypes, 1) |
| TEST_FIELD_ALIGN (EMRPOLYDRAW16, abTypes, 1) |
| TEST_FIELD_OFFSET(EMRPOLYDRAW16, abTypes, 32) |
| } |
| |
| static void test_pack_EMRPOLYGON(void) |
| { |
| /* EMRPOLYGON */ |
| TEST_TYPE_SIZE (EMRPOLYGON, 36) |
| TEST_TYPE_ALIGN (EMRPOLYGON, 4) |
| TEST_FIELD_SIZE (EMRPOLYGON, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYGON, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYGON, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYGON, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYGON, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYGON, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYGON, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYGON, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYGON16(void) |
| { |
| /* EMRPOLYGON16 */ |
| TEST_TYPE_SIZE (EMRPOLYGON16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYGON16, 4) |
| TEST_FIELD_SIZE (EMRPOLYGON16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYGON16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYGON16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYGON16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYGON16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYGON16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYGON16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYGON16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYGON16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYGON16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYLINE(void) |
| { |
| /* EMRPOLYLINE */ |
| TEST_TYPE_SIZE (EMRPOLYLINE, 36) |
| TEST_TYPE_ALIGN (EMRPOLYLINE, 4) |
| TEST_FIELD_SIZE (EMRPOLYLINE, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINE, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYLINE, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYLINE, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYLINE, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINE, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYLINE, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINE, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYLINE16(void) |
| { |
| /* EMRPOLYLINE16 */ |
| TEST_TYPE_SIZE (EMRPOLYLINE16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYLINE16, 4) |
| TEST_FIELD_SIZE (EMRPOLYLINE16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINE16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYLINE16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYLINE16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYLINE16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINE16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINE16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYLINE16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINE16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYLINE16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYLINETO(void) |
| { |
| /* EMRPOLYLINETO */ |
| TEST_TYPE_SIZE (EMRPOLYLINETO, 36) |
| TEST_TYPE_ALIGN (EMRPOLYLINETO, 4) |
| TEST_FIELD_SIZE (EMRPOLYLINETO, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYLINETO, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYLINETO, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO, cptl, 24) |
| TEST_FIELD_SIZE (EMRPOLYLINETO, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO, aptl, 28) |
| } |
| |
| static void test_pack_EMRPOLYLINETO16(void) |
| { |
| /* EMRPOLYLINETO16 */ |
| TEST_TYPE_SIZE (EMRPOLYLINETO16, 32) |
| TEST_TYPE_ALIGN (EMRPOLYLINETO16, 4) |
| TEST_FIELD_SIZE (EMRPOLYLINETO16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYLINETO16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYLINETO16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO16, cpts, 24) |
| TEST_FIELD_SIZE (EMRPOLYLINETO16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYLINETO16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYLINETO16, apts, 28) |
| } |
| |
| static void test_pack_EMRPOLYPOLYGON(void) |
| { |
| /* EMRPOLYPOLYGON */ |
| TEST_TYPE_SIZE (EMRPOLYPOLYGON, 44) |
| TEST_TYPE_ALIGN (EMRPOLYPOLYGON, 4) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, nPolys, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, nPolys, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, nPolys, 24) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, cptl, 28) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, aPolyCounts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aPolyCounts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, aPolyCounts, 32) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON, aptl, 36) |
| } |
| |
| static void test_pack_EMRPOLYPOLYGON16(void) |
| { |
| /* EMRPOLYPOLYGON16 */ |
| TEST_TYPE_SIZE (EMRPOLYPOLYGON16, 40) |
| TEST_TYPE_ALIGN (EMRPOLYPOLYGON16, 4) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, nPolys, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, nPolys, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, nPolys, 24) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, cpts, 28) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, aPolyCounts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, aPolyCounts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, aPolyCounts, 32) |
| TEST_FIELD_SIZE (EMRPOLYPOLYGON16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, apts, 36) |
| } |
| |
| static void test_pack_EMRPOLYPOLYLINE(void) |
| { |
| /* EMRPOLYPOLYLINE */ |
| TEST_TYPE_SIZE (EMRPOLYPOLYLINE, 44) |
| TEST_TYPE_ALIGN (EMRPOLYPOLYLINE, 4) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, nPolys, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, nPolys, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, nPolys, 24) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, cptl, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, cptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, cptl, 28) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, aPolyCounts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, aPolyCounts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, aPolyCounts, 32) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE, aptl, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, aptl, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, aptl, 36) |
| } |
| |
| static void test_pack_EMRPOLYPOLYLINE16(void) |
| { |
| /* EMRPOLYPOLYLINE16 */ |
| TEST_TYPE_SIZE (EMRPOLYPOLYLINE16, 40) |
| TEST_TYPE_ALIGN (EMRPOLYPOLYLINE16, 4) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, nPolys, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, nPolys, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, nPolys, 24) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, cpts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, cpts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, cpts, 28) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, aPolyCounts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, aPolyCounts, 4) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, aPolyCounts, 32) |
| TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, apts, 4) |
| TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, apts, 2) |
| TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, apts, 36) |
| } |
| |
| static void test_pack_EMRPOLYTEXTOUTA(void) |
| { |
| /* EMRPOLYTEXTOUTA */ |
| TEST_TYPE_SIZE (EMRPOLYTEXTOUTA, 80) |
| TEST_TYPE_ALIGN (EMRPOLYTEXTOUTA, 4) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, iGraphicsMode, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, iGraphicsMode, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, iGraphicsMode, 24) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, exScale, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, exScale, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, exScale, 28) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, eyScale, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, eyScale, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, eyScale, 32) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, cStrings, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, cStrings, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, cStrings, 36) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, aemrtext, 40) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, aemrtext, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, aemrtext, 40) |
| } |
| |
| static void test_pack_EMRPOLYTEXTOUTW(void) |
| { |
| /* EMRPOLYTEXTOUTW */ |
| TEST_TYPE_SIZE (EMRPOLYTEXTOUTW, 80) |
| TEST_TYPE_ALIGN (EMRPOLYTEXTOUTW, 4) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, emr, 8) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, emr, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, emr, 0) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, iGraphicsMode, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, iGraphicsMode, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, iGraphicsMode, 24) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, exScale, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, exScale, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, exScale, 28) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, eyScale, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, eyScale, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, eyScale, 32) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, cStrings, 4) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, cStrings, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, cStrings, 36) |
| TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, aemrtext, 40) |
| TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, aemrtext, 4) |
| TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, aemrtext, 40) |
| } |
| |
| static void test_pack_EMRREALIZEPALETTE(void) |
| { |
| /* EMRREALIZEPALETTE */ |
| TEST_TYPE_SIZE (EMRREALIZEPALETTE, 8) |
| TEST_TYPE_ALIGN (EMRREALIZEPALETTE, 4) |
| TEST_FIELD_SIZE (EMRREALIZEPALETTE, emr, 8) |
| TEST_FIELD_ALIGN (EMRREALIZEPALETTE, emr, 4) |
| TEST_FIELD_OFFSET(EMRREALIZEPALETTE, emr, 0) |
| } |
| |
| static void test_pack_EMRRECTANGLE(void) |
| { |
| /* EMRRECTANGLE */ |
| TEST_TYPE_SIZE (EMRRECTANGLE, 24) |
| TEST_TYPE_ALIGN (EMRRECTANGLE, 4) |
| TEST_FIELD_SIZE (EMRRECTANGLE, emr, 8) |
| TEST_FIELD_ALIGN (EMRRECTANGLE, emr, 4) |
| TEST_FIELD_OFFSET(EMRRECTANGLE, emr, 0) |
| TEST_FIELD_SIZE (EMRRECTANGLE, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRRECTANGLE, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRRECTANGLE, rclBox, 8) |
| } |
| |
| static void test_pack_EMRRESIZEPALETTE(void) |
| { |
| /* EMRRESIZEPALETTE */ |
| TEST_TYPE_SIZE (EMRRESIZEPALETTE, 16) |
| TEST_TYPE_ALIGN (EMRRESIZEPALETTE, 4) |
| TEST_FIELD_SIZE (EMRRESIZEPALETTE, emr, 8) |
| TEST_FIELD_ALIGN (EMRRESIZEPALETTE, emr, 4) |
| TEST_FIELD_OFFSET(EMRRESIZEPALETTE, emr, 0) |
| TEST_FIELD_SIZE (EMRRESIZEPALETTE, ihPal, 4) |
| TEST_FIELD_ALIGN (EMRRESIZEPALETTE, ihPal, 4) |
| TEST_FIELD_OFFSET(EMRRESIZEPALETTE, ihPal, 8) |
| TEST_FIELD_SIZE (EMRRESIZEPALETTE, cEntries, 4) |
| TEST_FIELD_ALIGN (EMRRESIZEPALETTE, cEntries, 4) |
| TEST_FIELD_OFFSET(EMRRESIZEPALETTE, cEntries, 12) |
| } |
| |
| static void test_pack_EMRRESTOREDC(void) |
| { |
| /* EMRRESTOREDC */ |
| TEST_TYPE_SIZE (EMRRESTOREDC, 12) |
| TEST_TYPE_ALIGN (EMRRESTOREDC, 4) |
| TEST_FIELD_SIZE (EMRRESTOREDC, emr, 8) |
| TEST_FIELD_ALIGN (EMRRESTOREDC, emr, 4) |
| TEST_FIELD_OFFSET(EMRRESTOREDC, emr, 0) |
| TEST_FIELD_SIZE (EMRRESTOREDC, iRelative, 4) |
| TEST_FIELD_ALIGN (EMRRESTOREDC, iRelative, 4) |
| TEST_FIELD_OFFSET(EMRRESTOREDC, iRelative, 8) |
| } |
| |
| static void test_pack_EMRROUNDRECT(void) |
| { |
| /* EMRROUNDRECT */ |
| TEST_TYPE_SIZE (EMRROUNDRECT, 32) |
| TEST_TYPE_ALIGN (EMRROUNDRECT, 4) |
| TEST_FIELD_SIZE (EMRROUNDRECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRROUNDRECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRROUNDRECT, emr, 0) |
| TEST_FIELD_SIZE (EMRROUNDRECT, rclBox, 16) |
| TEST_FIELD_ALIGN (EMRROUNDRECT, rclBox, 4) |
| TEST_FIELD_OFFSET(EMRROUNDRECT, rclBox, 8) |
| TEST_FIELD_SIZE (EMRROUNDRECT, szlCorner, 8) |
| TEST_FIELD_ALIGN (EMRROUNDRECT, szlCorner, 4) |
| TEST_FIELD_OFFSET(EMRROUNDRECT, szlCorner, 24) |
| } |
| |
| static void test_pack_EMRSAVEDC(void) |
| { |
| /* EMRSAVEDC */ |
| TEST_TYPE_SIZE (EMRSAVEDC, 8) |
| TEST_TYPE_ALIGN (EMRSAVEDC, 4) |
| TEST_FIELD_SIZE (EMRSAVEDC, emr, 8) |
| TEST_FIELD_ALIGN (EMRSAVEDC, emr, 4) |
| TEST_FIELD_OFFSET(EMRSAVEDC, emr, 0) |
| } |
| |
| static void test_pack_EMRSCALEVIEWPORTEXTEX(void) |
| { |
| /* EMRSCALEVIEWPORTEXTEX */ |
| TEST_TYPE_SIZE (EMRSCALEVIEWPORTEXTEX, 24) |
| TEST_TYPE_ALIGN (EMRSCALEVIEWPORTEXTEX, 4) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, xNum, 4) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, xNum, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, xNum, 8) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, xDenom, 4) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, xDenom, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, xDenom, 12) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, yNum, 4) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, yNum, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, yNum, 16) |
| TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, yDenom, 4) |
| TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, yDenom, 4) |
| TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, yDenom, 20) |
| } |
| |
| static void test_pack_EMRSCALEWINDOWEXTEX(void) |
| { |
| /* EMRSCALEWINDOWEXTEX */ |
| TEST_TYPE_SIZE (EMRSCALEWINDOWEXTEX, 24) |
| TEST_TYPE_ALIGN (EMRSCALEWINDOWEXTEX, 4) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, xNum, 4) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, xNum, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, xNum, 8) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, xDenom, 4) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, xDenom, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, xDenom, 12) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, yNum, 4) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, yNum, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, yNum, 16) |
| TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, yDenom, 4) |
| TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, yDenom, 4) |
| TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, yDenom, 20) |
| } |
| |
| static void test_pack_EMRSELECTCLIPPATH(void) |
| { |
| /* EMRSELECTCLIPPATH */ |
| TEST_TYPE_SIZE (EMRSELECTCLIPPATH, 12) |
| TEST_TYPE_ALIGN (EMRSELECTCLIPPATH, 4) |
| TEST_FIELD_SIZE (EMRSELECTCLIPPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRSELECTCLIPPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRSELECTCLIPPATH, emr, 0) |
| TEST_FIELD_SIZE (EMRSELECTCLIPPATH, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSELECTCLIPPATH, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSELECTCLIPPATH, iMode, 8) |
| } |
| |
| static void test_pack_EMRSELECTCOLORSPACE(void) |
| { |
| /* EMRSELECTCOLORSPACE */ |
| TEST_TYPE_SIZE (EMRSELECTCOLORSPACE, 12) |
| TEST_TYPE_ALIGN (EMRSELECTCOLORSPACE, 4) |
| TEST_FIELD_SIZE (EMRSELECTCOLORSPACE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSELECTCOLORSPACE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSELECTCOLORSPACE, emr, 0) |
| TEST_FIELD_SIZE (EMRSELECTCOLORSPACE, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRSELECTCOLORSPACE, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRSELECTCOLORSPACE, ihCS, 8) |
| } |
| |
| static void test_pack_EMRSELECTOBJECT(void) |
| { |
| /* EMRSELECTOBJECT */ |
| TEST_TYPE_SIZE (EMRSELECTOBJECT, 12) |
| TEST_TYPE_ALIGN (EMRSELECTOBJECT, 4) |
| TEST_FIELD_SIZE (EMRSELECTOBJECT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSELECTOBJECT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSELECTOBJECT, emr, 0) |
| TEST_FIELD_SIZE (EMRSELECTOBJECT, ihObject, 4) |
| TEST_FIELD_ALIGN (EMRSELECTOBJECT, ihObject, 4) |
| TEST_FIELD_OFFSET(EMRSELECTOBJECT, ihObject, 8) |
| } |
| |
| static void test_pack_EMRSELECTPALETTE(void) |
| { |
| /* EMRSELECTPALETTE */ |
| TEST_TYPE_SIZE (EMRSELECTPALETTE, 12) |
| TEST_TYPE_ALIGN (EMRSELECTPALETTE, 4) |
| TEST_FIELD_SIZE (EMRSELECTPALETTE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSELECTPALETTE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSELECTPALETTE, emr, 0) |
| TEST_FIELD_SIZE (EMRSELECTPALETTE, ihPal, 4) |
| TEST_FIELD_ALIGN (EMRSELECTPALETTE, ihPal, 4) |
| TEST_FIELD_OFFSET(EMRSELECTPALETTE, ihPal, 8) |
| } |
| |
| static void test_pack_EMRSETARCDIRECTION(void) |
| { |
| /* EMRSETARCDIRECTION */ |
| TEST_TYPE_SIZE (EMRSETARCDIRECTION, 12) |
| TEST_TYPE_ALIGN (EMRSETARCDIRECTION, 4) |
| TEST_FIELD_SIZE (EMRSETARCDIRECTION, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETARCDIRECTION, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETARCDIRECTION, emr, 0) |
| TEST_FIELD_SIZE (EMRSETARCDIRECTION, iArcDirection, 4) |
| TEST_FIELD_ALIGN (EMRSETARCDIRECTION, iArcDirection, 4) |
| TEST_FIELD_OFFSET(EMRSETARCDIRECTION, iArcDirection, 8) |
| } |
| |
| static void test_pack_EMRSETBKCOLOR(void) |
| { |
| /* EMRSETBKCOLOR */ |
| TEST_TYPE_SIZE (EMRSETBKCOLOR, 12) |
| TEST_TYPE_ALIGN (EMRSETBKCOLOR, 4) |
| TEST_FIELD_SIZE (EMRSETBKCOLOR, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETBKCOLOR, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETBKCOLOR, emr, 0) |
| TEST_FIELD_SIZE (EMRSETBKCOLOR, crColor, 4) |
| TEST_FIELD_ALIGN (EMRSETBKCOLOR, crColor, 4) |
| TEST_FIELD_OFFSET(EMRSETBKCOLOR, crColor, 8) |
| } |
| |
| static void test_pack_EMRSETBKMODE(void) |
| { |
| /* EMRSETBKMODE */ |
| TEST_TYPE_SIZE (EMRSETBKMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETBKMODE, 4) |
| TEST_FIELD_SIZE (EMRSETBKMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETBKMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETBKMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETBKMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETBKMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETBKMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETBRUSHORGEX(void) |
| { |
| /* EMRSETBRUSHORGEX */ |
| TEST_TYPE_SIZE (EMRSETBRUSHORGEX, 16) |
| TEST_TYPE_ALIGN (EMRSETBRUSHORGEX, 4) |
| TEST_FIELD_SIZE (EMRSETBRUSHORGEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETBRUSHORGEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETBRUSHORGEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETBRUSHORGEX, ptlOrigin, 8) |
| TEST_FIELD_ALIGN (EMRSETBRUSHORGEX, ptlOrigin, 4) |
| TEST_FIELD_OFFSET(EMRSETBRUSHORGEX, ptlOrigin, 8) |
| } |
| |
| static void test_pack_EMRSETCOLORADJUSTMENT(void) |
| { |
| /* EMRSETCOLORADJUSTMENT */ |
| TEST_TYPE_SIZE (EMRSETCOLORADJUSTMENT, 32) |
| TEST_TYPE_ALIGN (EMRSETCOLORADJUSTMENT, 4) |
| TEST_FIELD_SIZE (EMRSETCOLORADJUSTMENT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETCOLORADJUSTMENT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETCOLORADJUSTMENT, emr, 0) |
| TEST_FIELD_SIZE (EMRSETCOLORADJUSTMENT, ColorAdjustment, 24) |
| TEST_FIELD_ALIGN (EMRSETCOLORADJUSTMENT, ColorAdjustment, 2) |
| TEST_FIELD_OFFSET(EMRSETCOLORADJUSTMENT, ColorAdjustment, 8) |
| } |
| |
| static void test_pack_EMRSETCOLORSPACE(void) |
| { |
| /* EMRSETCOLORSPACE */ |
| TEST_TYPE_SIZE (EMRSETCOLORSPACE, 12) |
| TEST_TYPE_ALIGN (EMRSETCOLORSPACE, 4) |
| TEST_FIELD_SIZE (EMRSETCOLORSPACE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETCOLORSPACE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETCOLORSPACE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETCOLORSPACE, ihCS, 4) |
| TEST_FIELD_ALIGN (EMRSETCOLORSPACE, ihCS, 4) |
| TEST_FIELD_OFFSET(EMRSETCOLORSPACE, ihCS, 8) |
| } |
| |
| static void test_pack_EMRSETDIBITSTODEVICE(void) |
| { |
| /* EMRSETDIBITSTODEVICE */ |
| TEST_TYPE_SIZE (EMRSETDIBITSTODEVICE, 76) |
| TEST_TYPE_ALIGN (EMRSETDIBITSTODEVICE, 4) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, xDest, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, xDest, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, xDest, 24) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, yDest, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, yDest, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, yDest, 28) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, xSrc, 32) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, ySrc, 36) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cxSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cxSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cxSrc, 40) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cySrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cySrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cySrc, 44) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBmiSrc, 48) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cbBmiSrc, 52) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBitsSrc, 56) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cbBitsSrc, 60) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, iUsageSrc, 64) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, iStartScan, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, iStartScan, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, iStartScan, 68) |
| TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cScans, 4) |
| TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cScans, 4) |
| TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cScans, 72) |
| } |
| |
| static void test_pack_EMRSETICMMODE(void) |
| { |
| /* EMRSETICMMODE */ |
| TEST_TYPE_SIZE (EMRSETICMMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETICMMODE, 4) |
| TEST_FIELD_SIZE (EMRSETICMMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETICMMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETICMMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETICMMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETICMMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETICMMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETLAYOUT(void) |
| { |
| /* EMRSETLAYOUT */ |
| TEST_TYPE_SIZE (EMRSETLAYOUT, 12) |
| TEST_TYPE_ALIGN (EMRSETLAYOUT, 4) |
| TEST_FIELD_SIZE (EMRSETLAYOUT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETLAYOUT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETLAYOUT, emr, 0) |
| TEST_FIELD_SIZE (EMRSETLAYOUT, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETLAYOUT, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETLAYOUT, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETMAPMODE(void) |
| { |
| /* EMRSETMAPMODE */ |
| TEST_TYPE_SIZE (EMRSETMAPMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETMAPMODE, 4) |
| TEST_FIELD_SIZE (EMRSETMAPMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETMAPMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETMAPMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETMAPMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETMAPMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETMAPMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETMAPPERFLAGS(void) |
| { |
| /* EMRSETMAPPERFLAGS */ |
| TEST_TYPE_SIZE (EMRSETMAPPERFLAGS, 12) |
| TEST_TYPE_ALIGN (EMRSETMAPPERFLAGS, 4) |
| TEST_FIELD_SIZE (EMRSETMAPPERFLAGS, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETMAPPERFLAGS, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETMAPPERFLAGS, emr, 0) |
| TEST_FIELD_SIZE (EMRSETMAPPERFLAGS, dwFlags, 4) |
| TEST_FIELD_ALIGN (EMRSETMAPPERFLAGS, dwFlags, 4) |
| TEST_FIELD_OFFSET(EMRSETMAPPERFLAGS, dwFlags, 8) |
| } |
| |
| static void test_pack_EMRSETMETARGN(void) |
| { |
| /* EMRSETMETARGN */ |
| TEST_TYPE_SIZE (EMRSETMETARGN, 8) |
| TEST_TYPE_ALIGN (EMRSETMETARGN, 4) |
| TEST_FIELD_SIZE (EMRSETMETARGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETMETARGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETMETARGN, emr, 0) |
| } |
| |
| static void test_pack_EMRSETMITERLIMIT(void) |
| { |
| /* EMRSETMITERLIMIT */ |
| TEST_TYPE_SIZE (EMRSETMITERLIMIT, 12) |
| TEST_TYPE_ALIGN (EMRSETMITERLIMIT, 4) |
| TEST_FIELD_SIZE (EMRSETMITERLIMIT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETMITERLIMIT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETMITERLIMIT, emr, 0) |
| TEST_FIELD_SIZE (EMRSETMITERLIMIT, eMiterLimit, 4) |
| TEST_FIELD_ALIGN (EMRSETMITERLIMIT, eMiterLimit, 4) |
| TEST_FIELD_OFFSET(EMRSETMITERLIMIT, eMiterLimit, 8) |
| } |
| |
| static void test_pack_EMRSETPIXELV(void) |
| { |
| /* EMRSETPIXELV */ |
| TEST_TYPE_SIZE (EMRSETPIXELV, 20) |
| TEST_TYPE_ALIGN (EMRSETPIXELV, 4) |
| TEST_FIELD_SIZE (EMRSETPIXELV, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETPIXELV, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETPIXELV, emr, 0) |
| TEST_FIELD_SIZE (EMRSETPIXELV, ptlPixel, 8) |
| TEST_FIELD_ALIGN (EMRSETPIXELV, ptlPixel, 4) |
| TEST_FIELD_OFFSET(EMRSETPIXELV, ptlPixel, 8) |
| TEST_FIELD_SIZE (EMRSETPIXELV, crColor, 4) |
| TEST_FIELD_ALIGN (EMRSETPIXELV, crColor, 4) |
| TEST_FIELD_OFFSET(EMRSETPIXELV, crColor, 16) |
| } |
| |
| static void test_pack_EMRSETPOLYFILLMODE(void) |
| { |
| /* EMRSETPOLYFILLMODE */ |
| TEST_TYPE_SIZE (EMRSETPOLYFILLMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETPOLYFILLMODE, 4) |
| TEST_FIELD_SIZE (EMRSETPOLYFILLMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETPOLYFILLMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETPOLYFILLMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETPOLYFILLMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETPOLYFILLMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETPOLYFILLMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETROP2(void) |
| { |
| /* EMRSETROP2 */ |
| TEST_TYPE_SIZE (EMRSETROP2, 12) |
| TEST_TYPE_ALIGN (EMRSETROP2, 4) |
| TEST_FIELD_SIZE (EMRSETROP2, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETROP2, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETROP2, emr, 0) |
| TEST_FIELD_SIZE (EMRSETROP2, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETROP2, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETROP2, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETSTRETCHBLTMODE(void) |
| { |
| /* EMRSETSTRETCHBLTMODE */ |
| TEST_TYPE_SIZE (EMRSETSTRETCHBLTMODE, 12) |
| TEST_TYPE_ALIGN (EMRSETSTRETCHBLTMODE, 4) |
| TEST_FIELD_SIZE (EMRSETSTRETCHBLTMODE, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETSTRETCHBLTMODE, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETSTRETCHBLTMODE, emr, 0) |
| TEST_FIELD_SIZE (EMRSETSTRETCHBLTMODE, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETSTRETCHBLTMODE, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETSTRETCHBLTMODE, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETTEXTALIGN(void) |
| { |
| /* EMRSETTEXTALIGN */ |
| TEST_TYPE_SIZE (EMRSETTEXTALIGN, 12) |
| TEST_TYPE_ALIGN (EMRSETTEXTALIGN, 4) |
| TEST_FIELD_SIZE (EMRSETTEXTALIGN, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETTEXTALIGN, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETTEXTALIGN, emr, 0) |
| TEST_FIELD_SIZE (EMRSETTEXTALIGN, iMode, 4) |
| TEST_FIELD_ALIGN (EMRSETTEXTALIGN, iMode, 4) |
| TEST_FIELD_OFFSET(EMRSETTEXTALIGN, iMode, 8) |
| } |
| |
| static void test_pack_EMRSETTEXTCOLOR(void) |
| { |
| /* EMRSETTEXTCOLOR */ |
| TEST_TYPE_SIZE (EMRSETTEXTCOLOR, 12) |
| TEST_TYPE_ALIGN (EMRSETTEXTCOLOR, 4) |
| TEST_FIELD_SIZE (EMRSETTEXTCOLOR, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETTEXTCOLOR, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETTEXTCOLOR, emr, 0) |
| TEST_FIELD_SIZE (EMRSETTEXTCOLOR, crColor, 4) |
| TEST_FIELD_ALIGN (EMRSETTEXTCOLOR, crColor, 4) |
| TEST_FIELD_OFFSET(EMRSETTEXTCOLOR, crColor, 8) |
| } |
| |
| static void test_pack_EMRSETVIEWPORTEXTEX(void) |
| { |
| /* EMRSETVIEWPORTEXTEX */ |
| TEST_TYPE_SIZE (EMRSETVIEWPORTEXTEX, 16) |
| TEST_TYPE_ALIGN (EMRSETVIEWPORTEXTEX, 4) |
| TEST_FIELD_SIZE (EMRSETVIEWPORTEXTEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETVIEWPORTEXTEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETVIEWPORTEXTEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETVIEWPORTEXTEX, szlExtent, 8) |
| TEST_FIELD_ALIGN (EMRSETVIEWPORTEXTEX, szlExtent, 4) |
| TEST_FIELD_OFFSET(EMRSETVIEWPORTEXTEX, szlExtent, 8) |
| } |
| |
| static void test_pack_EMRSETVIEWPORTORGEX(void) |
| { |
| /* EMRSETVIEWPORTORGEX */ |
| TEST_TYPE_SIZE (EMRSETVIEWPORTORGEX, 16) |
| TEST_TYPE_ALIGN (EMRSETVIEWPORTORGEX, 4) |
| TEST_FIELD_SIZE (EMRSETVIEWPORTORGEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETVIEWPORTORGEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETVIEWPORTORGEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETVIEWPORTORGEX, ptlOrigin, 8) |
| TEST_FIELD_ALIGN (EMRSETVIEWPORTORGEX, ptlOrigin, 4) |
| TEST_FIELD_OFFSET(EMRSETVIEWPORTORGEX, ptlOrigin, 8) |
| } |
| |
| static void test_pack_EMRSETWINDOWEXTEX(void) |
| { |
| /* EMRSETWINDOWEXTEX */ |
| TEST_TYPE_SIZE (EMRSETWINDOWEXTEX, 16) |
| TEST_TYPE_ALIGN (EMRSETWINDOWEXTEX, 4) |
| TEST_FIELD_SIZE (EMRSETWINDOWEXTEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETWINDOWEXTEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETWINDOWEXTEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETWINDOWEXTEX, szlExtent, 8) |
| TEST_FIELD_ALIGN (EMRSETWINDOWEXTEX, szlExtent, 4) |
| TEST_FIELD_OFFSET(EMRSETWINDOWEXTEX, szlExtent, 8) |
| } |
| |
| static void test_pack_EMRSETWINDOWORGEX(void) |
| { |
| /* EMRSETWINDOWORGEX */ |
| TEST_TYPE_SIZE (EMRSETWINDOWORGEX, 16) |
| TEST_TYPE_ALIGN (EMRSETWINDOWORGEX, 4) |
| TEST_FIELD_SIZE (EMRSETWINDOWORGEX, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETWINDOWORGEX, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETWINDOWORGEX, emr, 0) |
| TEST_FIELD_SIZE (EMRSETWINDOWORGEX, ptlOrigin, 8) |
| TEST_FIELD_ALIGN (EMRSETWINDOWORGEX, ptlOrigin, 4) |
| TEST_FIELD_OFFSET(EMRSETWINDOWORGEX, ptlOrigin, 8) |
| } |
| |
| static void test_pack_EMRSETWORLDTRANSFORM(void) |
| { |
| /* EMRSETWORLDTRANSFORM */ |
| TEST_TYPE_SIZE (EMRSETWORLDTRANSFORM, 32) |
| TEST_TYPE_ALIGN (EMRSETWORLDTRANSFORM, 4) |
| TEST_FIELD_SIZE (EMRSETWORLDTRANSFORM, emr, 8) |
| TEST_FIELD_ALIGN (EMRSETWORLDTRANSFORM, emr, 4) |
| TEST_FIELD_OFFSET(EMRSETWORLDTRANSFORM, emr, 0) |
| TEST_FIELD_SIZE (EMRSETWORLDTRANSFORM, xform, 24) |
| TEST_FIELD_ALIGN (EMRSETWORLDTRANSFORM, xform, 4) |
| TEST_FIELD_OFFSET(EMRSETWORLDTRANSFORM, xform, 8) |
| } |
| |
| static void test_pack_EMRSTRETCHBLT(void) |
| { |
| /* EMRSTRETCHBLT */ |
| TEST_TYPE_SIZE (EMRSTRETCHBLT, 108) |
| TEST_TYPE_ALIGN (EMRSTRETCHBLT, 4) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, emr, 8) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, emr, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, emr, 0) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, xDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, xDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, xDest, 24) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, yDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, yDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, yDest, 28) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cxDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxDest, 32) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cyDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cyDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cyDest, 36) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, dwRop, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, dwRop, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, dwRop, 40) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, xSrc, 44) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, ySrc, 48) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, xformSrc, 24) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, xformSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, xformSrc, 52) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, crBkColorSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, crBkColorSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, crBkColorSrc, 76) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, iUsageSrc, 80) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBmiSrc, 84) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBmiSrc, 88) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBitsSrc, 92) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBitsSrc, 96) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cxSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxSrc, 100) |
| TEST_FIELD_SIZE (EMRSTRETCHBLT, cySrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHBLT, cySrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHBLT, cySrc, 104) |
| } |
| |
| static void test_pack_EMRSTRETCHDIBITS(void) |
| { |
| /* EMRSTRETCHDIBITS */ |
| TEST_TYPE_SIZE (EMRSTRETCHDIBITS, 80) |
| TEST_TYPE_ALIGN (EMRSTRETCHDIBITS, 4) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, emr, 8) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, emr, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, emr, 0) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, rclBounds, 8) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, xDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, xDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, xDest, 24) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, yDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, yDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, yDest, 28) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, xSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, xSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, xSrc, 32) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, ySrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, ySrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, ySrc, 36) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cxSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cxSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cxSrc, 40) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cySrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cySrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cySrc, 44) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, offBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBmiSrc, 48) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cbBmiSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBmiSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBmiSrc, 52) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, offBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBitsSrc, 56) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cbBitsSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBitsSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBitsSrc, 60) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, iUsageSrc, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, iUsageSrc, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, iUsageSrc, 64) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, dwRop, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, dwRop, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, dwRop, 68) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cxDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cxDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cxDest, 72) |
| TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cyDest, 4) |
| TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cyDest, 4) |
| TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cyDest, 76) |
| } |
| |
| static void test_pack_EMRSTROKEANDFILLPATH(void) |
| { |
| /* EMRSTROKEANDFILLPATH */ |
| TEST_TYPE_SIZE (EMRSTROKEANDFILLPATH, 24) |
| TEST_TYPE_ALIGN (EMRSTROKEANDFILLPATH, 4) |
| TEST_FIELD_SIZE (EMRSTROKEANDFILLPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRSTROKEANDFILLPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRSTROKEANDFILLPATH, emr, 0) |
| TEST_FIELD_SIZE (EMRSTROKEANDFILLPATH, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSTROKEANDFILLPATH, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSTROKEANDFILLPATH, rclBounds, 8) |
| } |
| |
| static void test_pack_EMRSTROKEPATH(void) |
| { |
| /* EMRSTROKEPATH */ |
| TEST_TYPE_SIZE (EMRSTROKEPATH, 24) |
| TEST_TYPE_ALIGN (EMRSTROKEPATH, 4) |
| TEST_FIELD_SIZE (EMRSTROKEPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRSTROKEPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRSTROKEPATH, emr, 0) |
| TEST_FIELD_SIZE (EMRSTROKEPATH, rclBounds, 16) |
| TEST_FIELD_ALIGN (EMRSTROKEPATH, rclBounds, 4) |
| TEST_FIELD_OFFSET(EMRSTROKEPATH, rclBounds, 8) |
| } |
| |
| static void test_pack_EMRTEXT(void) |
| { |
| /* EMRTEXT */ |
| TEST_TYPE_SIZE (EMRTEXT, 40) |
| TEST_TYPE_ALIGN (EMRTEXT, 4) |
| TEST_FIELD_SIZE (EMRTEXT, ptlReference, 8) |
| TEST_FIELD_ALIGN (EMRTEXT, ptlReference, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, ptlReference, 0) |
| TEST_FIELD_SIZE (EMRTEXT, nChars, 4) |
| TEST_FIELD_ALIGN (EMRTEXT, nChars, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, nChars, 8) |
| TEST_FIELD_SIZE (EMRTEXT, offString, 4) |
| TEST_FIELD_ALIGN (EMRTEXT, offString, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, offString, 12) |
| TEST_FIELD_SIZE (EMRTEXT, fOptions, 4) |
| TEST_FIELD_ALIGN (EMRTEXT, fOptions, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, fOptions, 16) |
| TEST_FIELD_SIZE (EMRTEXT, rcl, 16) |
| TEST_FIELD_ALIGN (EMRTEXT, rcl, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, rcl, 20) |
| TEST_FIELD_SIZE (EMRTEXT, offDx, 4) |
| TEST_FIELD_ALIGN (EMRTEXT, offDx, 4) |
| TEST_FIELD_OFFSET(EMRTEXT, offDx, 36) |
| } |
| |
| static void test_pack_EMRWIDENPATH(void) |
| { |
| /* EMRWIDENPATH */ |
| TEST_TYPE_SIZE (EMRWIDENPATH, 8) |
| TEST_TYPE_ALIGN (EMRWIDENPATH, 4) |
| TEST_FIELD_SIZE (EMRWIDENPATH, emr, 8) |
| TEST_FIELD_ALIGN (EMRWIDENPATH, emr, 4) |
| TEST_FIELD_OFFSET(EMRWIDENPATH, emr, 0) |
| } |
| |
| static void test_pack_ENHMETAHEADER(void) |
| { |
| /* ENHMETAHEADER */ |
| TEST_TYPE_SIZE (ENHMETAHEADER, 108) |
| TEST_TYPE_ALIGN (ENHMETAHEADER, 4) |
| TEST_FIELD_SIZE (ENHMETAHEADER, iType, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, iType, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, iType, 0) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nSize, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nSize, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nSize, 4) |
| TEST_FIELD_SIZE (ENHMETAHEADER, rclBounds, 16) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, rclBounds, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, rclBounds, 8) |
| TEST_FIELD_SIZE (ENHMETAHEADER, rclFrame, 16) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, rclFrame, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, rclFrame, 24) |
| TEST_FIELD_SIZE (ENHMETAHEADER, dSignature, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, dSignature, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, dSignature, 40) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nVersion, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nVersion, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nVersion, 44) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nBytes, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nBytes, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nBytes, 48) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nRecords, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nRecords, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nRecords, 52) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nHandles, 2) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nHandles, 2) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nHandles, 56) |
| TEST_FIELD_SIZE (ENHMETAHEADER, sReserved, 2) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, sReserved, 2) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, sReserved, 58) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nDescription, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nDescription, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nDescription, 60) |
| TEST_FIELD_SIZE (ENHMETAHEADER, offDescription, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, offDescription, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, offDescription, 64) |
| TEST_FIELD_SIZE (ENHMETAHEADER, nPalEntries, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, nPalEntries, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, nPalEntries, 68) |
| TEST_FIELD_SIZE (ENHMETAHEADER, szlDevice, 8) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, szlDevice, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, szlDevice, 72) |
| TEST_FIELD_SIZE (ENHMETAHEADER, szlMillimeters, 8) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, szlMillimeters, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, szlMillimeters, 80) |
| TEST_FIELD_SIZE (ENHMETAHEADER, cbPixelFormat, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, cbPixelFormat, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, cbPixelFormat, 88) |
| TEST_FIELD_SIZE (ENHMETAHEADER, offPixelFormat, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, offPixelFormat, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, offPixelFormat, 92) |
| TEST_FIELD_SIZE (ENHMETAHEADER, bOpenGL, 4) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, bOpenGL, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, bOpenGL, 96) |
| TEST_FIELD_SIZE (ENHMETAHEADER, szlMicrometers, 8) |
| TEST_FIELD_ALIGN (ENHMETAHEADER, szlMicrometers, 4) |
| TEST_FIELD_OFFSET(ENHMETAHEADER, szlMicrometers, 100) |
| } |
| |
| static void test_pack_ENHMETARECORD(void) |
| { |
| /* ENHMETARECORD */ |
| TEST_TYPE_SIZE (ENHMETARECORD, 12) |
| TEST_TYPE_ALIGN (ENHMETARECORD, 4) |
| TEST_FIELD_SIZE (ENHMETARECORD, iType, 4) |
| TEST_FIELD_ALIGN (ENHMETARECORD, iType, 4) |
| TEST_FIELD_OFFSET(ENHMETARECORD, iType, 0) |
| TEST_FIELD_SIZE (ENHMETARECORD, nSize, 4) |
| TEST_FIELD_ALIGN (ENHMETARECORD, nSize, 4) |
| TEST_FIELD_OFFSET(ENHMETARECORD, nSize, 4) |
| TEST_FIELD_SIZE (ENHMETARECORD, dParm, 4) |
| TEST_FIELD_ALIGN (ENHMETARECORD, dParm, 4) |
| TEST_FIELD_OFFSET(ENHMETARECORD, dParm, 8) |
| } |
| |
| static void test_pack_ENHMFENUMPROC(void) |
| { |
| /* ENHMFENUMPROC */ |
| TEST_TYPE_SIZE (ENHMFENUMPROC, 4) |
| TEST_TYPE_ALIGN (ENHMFENUMPROC, 4) |
| } |
| |
| static void test_pack_ENUMLOGFONTA(void) |
| { |
| /* ENUMLOGFONTA */ |
| TEST_TYPE_SIZE (ENUMLOGFONTA, 156) |
| TEST_TYPE_ALIGN (ENUMLOGFONTA, 4) |
| TEST_FIELD_SIZE (ENUMLOGFONTA, elfLogFont, 60) |
| TEST_FIELD_ALIGN (ENUMLOGFONTA, elfLogFont, 4) |
| TEST_FIELD_OFFSET(ENUMLOGFONTA, elfLogFont, 0) |
| TEST_FIELD_SIZE (ENUMLOGFONTA, elfFullName, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTA, elfFullName, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTA, elfFullName, 60) |
| TEST_FIELD_SIZE (ENUMLOGFONTA, elfStyle, 32) |
| TEST_FIELD_ALIGN (ENUMLOGFONTA, elfStyle, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTA, elfStyle, 124) |
| } |
| |
| static void test_pack_ENUMLOGFONTEXA(void) |
| { |
| /* ENUMLOGFONTEXA */ |
| TEST_TYPE_SIZE (ENUMLOGFONTEXA, 188) |
| TEST_TYPE_ALIGN (ENUMLOGFONTEXA, 4) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfLogFont, 60) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfLogFont, 4) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfLogFont, 0) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfFullName, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfFullName, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfFullName, 60) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfStyle, 32) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfStyle, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfStyle, 124) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfScript, 32) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfScript, 1) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfScript, 156) |
| } |
| |
| static void test_pack_ENUMLOGFONTEXW(void) |
| { |
| /* ENUMLOGFONTEXW */ |
| TEST_TYPE_SIZE (ENUMLOGFONTEXW, 348) |
| TEST_TYPE_ALIGN (ENUMLOGFONTEXW, 4) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfLogFont, 92) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfLogFont, 4) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfLogFont, 0) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfFullName, 128) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfFullName, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfFullName, 92) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfStyle, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfStyle, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfStyle, 220) |
| TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfScript, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfScript, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfScript, 284) |
| } |
| |
| static void test_pack_ENUMLOGFONTW(void) |
| { |
| /* ENUMLOGFONTW */ |
| TEST_TYPE_SIZE (ENUMLOGFONTW, 284) |
| TEST_TYPE_ALIGN (ENUMLOGFONTW, 4) |
| TEST_FIELD_SIZE (ENUMLOGFONTW, elfLogFont, 92) |
| TEST_FIELD_ALIGN (ENUMLOGFONTW, elfLogFont, 4) |
| TEST_FIELD_OFFSET(ENUMLOGFONTW, elfLogFont, 0) |
| TEST_FIELD_SIZE (ENUMLOGFONTW, elfFullName, 128) |
| TEST_FIELD_ALIGN (ENUMLOGFONTW, elfFullName, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTW, elfFullName, 92) |
| TEST_FIELD_SIZE (ENUMLOGFONTW, elfStyle, 64) |
| TEST_FIELD_ALIGN (ENUMLOGFONTW, elfStyle, 2) |
| TEST_FIELD_OFFSET(ENUMLOGFONTW, elfStyle, 220) |
| } |
| |
| static void test_pack_EXTLOGFONTA(void) |
| { |
| /* EXTLOGFONTA */ |
| TEST_TYPE_SIZE (EXTLOGFONTA, 192) |
| TEST_TYPE_ALIGN (EXTLOGFONTA, 4) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfLogFont, 60) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfLogFont, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfLogFont, 0) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfFullName, 64) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfFullName, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfFullName, 60) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfStyle, 32) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfStyle, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfStyle, 124) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfVersion, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfVersion, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfVersion, 156) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfStyleSize, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfStyleSize, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfStyleSize, 160) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfMatch, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfMatch, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfMatch, 164) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfReserved, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfReserved, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfReserved, 168) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfVendorId, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfVendorId, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfVendorId, 172) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfCulture, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfCulture, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfCulture, 176) |
| TEST_FIELD_SIZE (EXTLOGFONTA, elfPanose, 10) |
| TEST_FIELD_ALIGN (EXTLOGFONTA, elfPanose, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTA, elfPanose, 180) |
| } |
| |
| static void test_pack_EXTLOGFONTW(void) |
| { |
| /* EXTLOGFONTW */ |
| TEST_TYPE_SIZE (EXTLOGFONTW, 320) |
| TEST_TYPE_ALIGN (EXTLOGFONTW, 4) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfLogFont, 92) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfLogFont, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfLogFont, 0) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfFullName, 128) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfFullName, 2) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfFullName, 92) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfStyle, 64) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfStyle, 2) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfStyle, 220) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfVersion, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfVersion, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfVersion, 284) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfStyleSize, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfStyleSize, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfStyleSize, 288) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfMatch, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfMatch, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfMatch, 292) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfReserved, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfReserved, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfReserved, 296) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfVendorId, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfVendorId, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfVendorId, 300) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfCulture, 4) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfCulture, 4) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfCulture, 304) |
| TEST_FIELD_SIZE (EXTLOGFONTW, elfPanose, 10) |
| TEST_FIELD_ALIGN (EXTLOGFONTW, elfPanose, 1) |
| TEST_FIELD_OFFSET(EXTLOGFONTW, elfPanose, 308) |
| } |
| |
| static void test_pack_EXTLOGPEN(void) |
| { |
| /* EXTLOGPEN */ |
| TEST_TYPE_SIZE (EXTLOGPEN, 28) |
| TEST_TYPE_ALIGN (EXTLOGPEN, 4) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpPenStyle, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpPenStyle, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpPenStyle, 0) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpWidth, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpWidth, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpWidth, 4) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpBrushStyle, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpBrushStyle, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpBrushStyle, 8) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpColor, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpColor, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpColor, 12) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpHatch, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpHatch, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpHatch, 16) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpNumEntries, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpNumEntries, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpNumEntries, 20) |
| TEST_FIELD_SIZE (EXTLOGPEN, elpStyleEntry, 4) |
| TEST_FIELD_ALIGN (EXTLOGPEN, elpStyleEntry, 4) |
| TEST_FIELD_OFFSET(EXTLOGPEN, elpStyleEntry, 24) |
| } |
| |
| static void test_pack_FIXED(void) |
| { |
| /* FIXED */ |
| TEST_TYPE_SIZE (FIXED, 4) |
| TEST_TYPE_ALIGN (FIXED, 2) |
| TEST_FIELD_SIZE (FIXED, fract, 2) |
| TEST_FIELD_ALIGN (FIXED, fract, 2) |
| TEST_FIELD_OFFSET(FIXED, fract, 0) |
| TEST_FIELD_SIZE (FIXED, value, 2) |
| TEST_FIELD_ALIGN (FIXED, value, 2) |
| TEST_FIELD_OFFSET(FIXED, value, 2) |
| } |
| |
| static void test_pack_FONTENUMPROCA(void) |
| { |
| /* FONTENUMPROCA */ |
| TEST_TYPE_SIZE (FONTENUMPROCA, 4) |
| TEST_TYPE_ALIGN (FONTENUMPROCA, 4) |
| } |
| |
| static void test_pack_FONTENUMPROCW(void) |
| { |
| /* FONTENUMPROCW */ |
| TEST_TYPE_SIZE (FONTENUMPROCW, 4) |
| TEST_TYPE_ALIGN (FONTENUMPROCW, 4) |
| } |
| |
| static void test_pack_FONTSIGNATURE(void) |
| { |
| /* FONTSIGNATURE */ |
| TEST_TYPE_SIZE (FONTSIGNATURE, 24) |
| TEST_TYPE_ALIGN (FONTSIGNATURE, 4) |
| TEST_FIELD_SIZE (FONTSIGNATURE, fsUsb, 16) |
| TEST_FIELD_ALIGN (FONTSIGNATURE, fsUsb, 4) |
| TEST_FIELD_OFFSET(FONTSIGNATURE, fsUsb, 0) |
| TEST_FIELD_SIZE (FONTSIGNATURE, fsCsb, 8) |
| TEST_FIELD_ALIGN (FONTSIGNATURE, fsCsb, 4) |
| TEST_FIELD_OFFSET(FONTSIGNATURE, fsCsb, 16) |
| } |
| |
| static void test_pack_FXPT16DOT16(void) |
| { |
| /* FXPT16DOT16 */ |
| TEST_TYPE_SIZE (FXPT16DOT16, 4) |
| TEST_TYPE_ALIGN (FXPT16DOT16, 4) |
| } |
| |
| static void test_pack_FXPT2DOT30(void) |
| { |
| /* FXPT2DOT30 */ |
| TEST_TYPE_SIZE (FXPT2DOT30, 4) |
| TEST_TYPE_ALIGN (FXPT2DOT30, 4) |
| } |
| |
| static void test_pack_GCP_RESULTSA(void) |
| { |
| /* GCP_RESULTSA */ |
| TEST_TYPE_SIZE (GCP_RESULTSA, 36) |
| TEST_TYPE_ALIGN (GCP_RESULTSA, 4) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lStructSize, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lStructSize, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lStructSize, 0) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpOutString, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpOutString, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpOutString, 4) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpOrder, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpOrder, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpOrder, 8) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpDx, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpDx, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpDx, 12) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpCaretPos, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpCaretPos, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpCaretPos, 16) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpClass, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpClass, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpClass, 20) |
| TEST_FIELD_SIZE (GCP_RESULTSA, lpGlyphs, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, lpGlyphs, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, lpGlyphs, 24) |
| TEST_FIELD_SIZE (GCP_RESULTSA, nGlyphs, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, nGlyphs, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, nGlyphs, 28) |
| TEST_FIELD_SIZE (GCP_RESULTSA, nMaxFit, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSA, nMaxFit, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSA, nMaxFit, 32) |
| } |
| |
| static void test_pack_GCP_RESULTSW(void) |
| { |
| /* GCP_RESULTSW */ |
| TEST_TYPE_SIZE (GCP_RESULTSW, 36) |
| TEST_TYPE_ALIGN (GCP_RESULTSW, 4) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lStructSize, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lStructSize, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lStructSize, 0) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpOutString, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpOutString, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpOutString, 4) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpOrder, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpOrder, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpOrder, 8) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpDx, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpDx, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpDx, 12) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpCaretPos, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpCaretPos, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpCaretPos, 16) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpClass, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpClass, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpClass, 20) |
| TEST_FIELD_SIZE (GCP_RESULTSW, lpGlyphs, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, lpGlyphs, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, lpGlyphs, 24) |
| TEST_FIELD_SIZE (GCP_RESULTSW, nGlyphs, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, nGlyphs, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, nGlyphs, 28) |
| TEST_FIELD_SIZE (GCP_RESULTSW, nMaxFit, 4) |
| TEST_FIELD_ALIGN (GCP_RESULTSW, nMaxFit, 4) |
| TEST_FIELD_OFFSET(GCP_RESULTSW, nMaxFit, 32) |
| } |
| |
| static void test_pack_GLYPHMETRICS(void) |
| { |
| /* GLYPHMETRICS */ |
| TEST_TYPE_SIZE (GLYPHMETRICS, 20) |
| TEST_TYPE_ALIGN (GLYPHMETRICS, 4) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmBlackBoxX, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmBlackBoxX, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmBlackBoxX, 0) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmBlackBoxY, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmBlackBoxY, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmBlackBoxY, 4) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmptGlyphOrigin, 8) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmptGlyphOrigin, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmptGlyphOrigin, 8) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmCellIncX, 2) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmCellIncX, 2) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmCellIncX, 16) |
| TEST_FIELD_SIZE (GLYPHMETRICS, gmCellIncY, 2) |
| TEST_FIELD_ALIGN (GLYPHMETRICS, gmCellIncY, 2) |
| TEST_FIELD_OFFSET(GLYPHMETRICS, gmCellIncY, 18) |
| } |
| |
| static void test_pack_GLYPHMETRICSFLOAT(void) |
| { |
| /* GLYPHMETRICSFLOAT */ |
| TEST_TYPE_SIZE (GLYPHMETRICSFLOAT, 24) |
| TEST_TYPE_ALIGN (GLYPHMETRICSFLOAT, 4) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfBlackBoxX, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfBlackBoxX, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfBlackBoxX, 0) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfBlackBoxY, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfBlackBoxY, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfBlackBoxY, 4) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 8) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 8) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfCellIncX, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfCellIncX, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfCellIncX, 16) |
| TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfCellIncY, 4) |
| TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfCellIncY, 4) |
| TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfCellIncY, 20) |
| } |
| |
| static void test_pack_GOBJENUMPROC(void) |
| { |
| /* GOBJENUMPROC */ |
| TEST_TYPE_SIZE (GOBJENUMPROC, 4) |
| TEST_TYPE_ALIGN (GOBJENUMPROC, 4) |
| } |
| |
| static void test_pack_GRADIENT_RECT(void) |
| { |
| /* GRADIENT_RECT */ |
| TEST_TYPE_SIZE (GRADIENT_RECT, 8) |
| TEST_TYPE_ALIGN (GRADIENT_RECT, 4) |
| TEST_FIELD_SIZE (GRADIENT_RECT, UpperLeft, 4) |
| TEST_FIELD_ALIGN (GRADIENT_RECT, UpperLeft, 4) |
| TEST_FIELD_OFFSET(GRADIENT_RECT, UpperLeft, 0) |
| TEST_FIELD_SIZE (GRADIENT_RECT, LowerRight, 4) |
| TEST_FIELD_ALIGN (GRADIENT_RECT, LowerRight, 4) |
| TEST_FIELD_OFFSET(GRADIENT_RECT, LowerRight, 4) |
| } |
| |
| static void test_pack_GRADIENT_TRIANGLE(void) |
| { |
| /* GRADIENT_TRIANGLE */ |
| TEST_TYPE_SIZE (GRADIENT_TRIANGLE, 12) |
| TEST_TYPE_ALIGN (GRADIENT_TRIANGLE, 4) |
| TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex1, 4) |
| TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex1, 4) |
| TEST_FIELD_OFFSET(GRADIENT_TRIANGLE, Vertex1, 0) |
| TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex2, 4) |
| TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex2, 4) |
| TEST_FIELD_OFFSET(GRADIENT_TRIANGLE, Vertex2, 4) |
| TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex3, 4) |
| TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex3, 4) |
| TEST_FIELD_OFFSET(GRADIENT_TRIANGLE, Vertex3, 8) |
| } |
| |
| static void test_pack_HANDLETABLE(void) |
| { |
| /* HANDLETABLE */ |
| TEST_TYPE_SIZE (HANDLETABLE, 4) |
| TEST_TYPE_ALIGN (HANDLETABLE, 4) |
| TEST_FIELD_SIZE (HANDLETABLE, objectHandle, 4) |
| TEST_FIELD_ALIGN (HANDLETABLE, objectHandle, 4) |
| TEST_FIELD_OFFSET(HANDLETABLE, objectHandle, 0) |
| } |
| |
| static void test_pack_ICMENUMPROCA(void) |
| { |
| /* ICMENUMPROCA */ |
| TEST_TYPE_SIZE (ICMENUMPROCA, 4) |
| TEST_TYPE_ALIGN (ICMENUMPROCA, 4) |
| } |
| |
| static void test_pack_ICMENUMPROCW(void) |
| { |
| /* ICMENUMPROCW */ |
| TEST_TYPE_SIZE (ICMENUMPROCW, 4) |
| TEST_TYPE_ALIGN (ICMENUMPROCW, 4) |
| } |
| |
| static void test_pack_KERNINGPAIR(void) |
| { |
| /* KERNINGPAIR */ |
| TEST_TYPE_SIZE (KERNINGPAIR, 8) |
| TEST_TYPE_ALIGN (KERNINGPAIR, 4) |
| TEST_FIELD_SIZE (KERNINGPAIR, wFirst, 2) |
| TEST_FIELD_ALIGN (KERNINGPAIR, wFirst, 2) |
| TEST_FIELD_OFFSET(KERNINGPAIR, wFirst, 0) |
| TEST_FIELD_SIZE (KERNINGPAIR, wSecond, 2) |
| TEST_FIELD_ALIGN (KERNINGPAIR, wSecond, 2) |
| TEST_FIELD_OFFSET(KERNINGPAIR, wSecond, 2) |
| TEST_FIELD_SIZE (KERNINGPAIR, iKernAmount, 4) |
| TEST_FIELD_ALIGN (KERNINGPAIR, iKernAmount, 4) |
| TEST_FIELD_OFFSET(KERNINGPAIR, iKernAmount, 4) |
| } |
| |
| static void test_pack_LAYERPLANEDESCRIPTOR(void) |
| { |
| /* LAYERPLANEDESCRIPTOR */ |
| TEST_TYPE_SIZE (LAYERPLANEDESCRIPTOR, 32) |
| TEST_TYPE_ALIGN (LAYERPLANEDESCRIPTOR, 4) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, nSize, 2) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, nSize, 2) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, nSize, 0) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, iPixelType, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, iPixelType, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, iPixelType, 8) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cColorBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cColorBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cColorBits, 9) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cRedBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cRedBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cRedBits, 10) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cRedShift, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cRedShift, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cRedShift, 11) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cGreenBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cGreenBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cGreenBits, 12) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cGreenShift, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cGreenShift, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cGreenShift, 13) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cBlueBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cBlueBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cBlueBits, 14) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cBlueShift, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cBlueShift, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cBlueShift, 15) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAlphaBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAlphaBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAlphaBits, 16) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAlphaShift, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAlphaShift, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAlphaShift, 17) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumBits, 18) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumRedBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumRedBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumRedBits, 19) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumGreenBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumGreenBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumGreenBits, 20) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumBlueBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumBlueBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumBlueBits, 21) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 22) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cDepthBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cDepthBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cDepthBits, 23) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cStencilBits, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cStencilBits, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cStencilBits, 24) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAuxBuffers, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAuxBuffers, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAuxBuffers, 25) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, iLayerPlane, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, iLayerPlane, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, iLayerPlane, 26) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, bReserved, 1) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, bReserved, 1) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, bReserved, 27) |
| TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, crTransparent, 4) |
| TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, crTransparent, 4) |
| TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, crTransparent, 28) |
| } |
| |
| static void test_pack_LCSCSTYPE(void) |
| { |
| /* LCSCSTYPE */ |
| TEST_TYPE_SIZE (LCSCSTYPE, 4) |
| TEST_TYPE_ALIGN (LCSCSTYPE, 4) |
| } |
| |
| static void test_pack_LCSGAMUTMATCH(void) |
| { |
| /* LCSGAMUTMATCH */ |
| TEST_TYPE_SIZE (LCSGAMUTMATCH, 4) |
| TEST_TYPE_ALIGN (LCSGAMUTMATCH, 4) |
| } |
| |
| static void test_pack_LINEDDAPROC(void) |
| { |
| /* LINEDDAPROC */ |
| TEST_TYPE_SIZE (LINEDDAPROC, 4) |
| TEST_TYPE_ALIGN (LINEDDAPROC, 4) |
| } |
| |
| static void test_pack_LOCALESIGNATURE(void) |
| { |
| /* LOCALESIGNATURE */ |
| TEST_TYPE_SIZE (LOCALESIGNATURE, 32) |
| TEST_TYPE_ALIGN (LOCALESIGNATURE, 4) |
| TEST_FIELD_SIZE (LOCALESIGNATURE, lsUsb, 16) |
| TEST_FIELD_ALIGN (LOCALESIGNATURE, lsUsb, 4) |
| TEST_FIELD_OFFSET(LOCALESIGNATURE, lsUsb, 0) |
| TEST_FIELD_SIZE (LOCALESIGNATURE, lsCsbDefault, 8) |
| TEST_FIELD_ALIGN (LOCALESIGNATURE, lsCsbDefault, 4) |
| TEST_FIELD_OFFSET(LOCALESIGNATURE, lsCsbDefault, 16) |
| TEST_FIELD_SIZE (LOCALESIGNATURE, lsCsbSupported, 8) |
| TEST_FIELD_ALIGN (LOCALESIGNATURE, lsCsbSupported, 4) |
| TEST_FIELD_OFFSET(LOCALESIGNATURE, lsCsbSupported, 24) |
| } |
| |
| static void test_pack_LOGBRUSH(void) |
| { |
| /* LOGBRUSH */ |
| TEST_TYPE_SIZE (LOGBRUSH, 12) |
| TEST_TYPE_ALIGN (LOGBRUSH, 4) |
| TEST_FIELD_SIZE (LOGBRUSH, lbStyle, 4) |
| TEST_FIELD_ALIGN (LOGBRUSH, lbStyle, 4) |
| TEST_FIELD_OFFSET(LOGBRUSH, lbStyle, 0) |
| TEST_FIELD_SIZE (LOGBRUSH, lbColor, 4) |
| TEST_FIELD_ALIGN (LOGBRUSH, lbColor, 4) |
| TEST_FIELD_OFFSET(LOGBRUSH, lbColor, 4) |
| TEST_FIELD_SIZE (LOGBRUSH, lbHatch, 4) |
| TEST_FIELD_ALIGN (LOGBRUSH, lbHatch, 4) |
| TEST_FIELD_OFFSET(LOGBRUSH, lbHatch, 8) |
| } |
| |
| static void test_pack_LOGCOLORSPACEA(void) |
| { |
| /* LOGCOLORSPACEA */ |
| TEST_TYPE_SIZE (LOGCOLORSPACEA, 328) |
| TEST_TYPE_ALIGN (LOGCOLORSPACEA, 4) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsSignature, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsSignature, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsSignature, 0) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsVersion, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsVersion, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsVersion, 4) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsSize, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsSize, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsSize, 8) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsCSType, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsCSType, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsCSType, 12) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsIntent, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsIntent, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsIntent, 16) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsEndpoints, 36) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsEndpoints, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsEndpoints, 20) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaRed, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaRed, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaRed, 56) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaGreen, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaGreen, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaGreen, 60) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaBlue, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaBlue, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaBlue, 64) |
| TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsFilename, 260) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsFilename, 1) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsFilename, 68) |
| } |
| |
| static void test_pack_LOGCOLORSPACEW(void) |
| { |
| /* LOGCOLORSPACEW */ |
| TEST_TYPE_SIZE (LOGCOLORSPACEW, 588) |
| TEST_TYPE_ALIGN (LOGCOLORSPACEW, 4) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsSignature, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsSignature, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsSignature, 0) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsVersion, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsVersion, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsVersion, 4) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsSize, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsSize, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsSize, 8) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsCSType, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsCSType, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsCSType, 12) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsIntent, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsIntent, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsIntent, 16) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsEndpoints, 36) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsEndpoints, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsEndpoints, 20) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaRed, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaRed, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaRed, 56) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaGreen, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaGreen, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaGreen, 60) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaBlue, 4) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaBlue, 4) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaBlue, 64) |
| TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsFilename, 520) |
| TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsFilename, 2) |
| TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsFilename, 68) |
| } |
| |
| static void test_pack_LOGFONTA(void) |
| { |
| /* LOGFONTA */ |
| TEST_TYPE_SIZE (LOGFONTA, 60) |
| TEST_TYPE_ALIGN (LOGFONTA, 4) |
| TEST_FIELD_SIZE (LOGFONTA, lfHeight, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfHeight, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfHeight, 0) |
| TEST_FIELD_SIZE (LOGFONTA, lfWidth, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfWidth, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfWidth, 4) |
| TEST_FIELD_SIZE (LOGFONTA, lfEscapement, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfEscapement, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfEscapement, 8) |
| TEST_FIELD_SIZE (LOGFONTA, lfOrientation, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfOrientation, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfOrientation, 12) |
| TEST_FIELD_SIZE (LOGFONTA, lfWeight, 4) |
| TEST_FIELD_ALIGN (LOGFONTA, lfWeight, 4) |
| TEST_FIELD_OFFSET(LOGFONTA, lfWeight, 16) |
| TEST_FIELD_SIZE (LOGFONTA, lfItalic, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfItalic, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfItalic, 20) |
| TEST_FIELD_SIZE (LOGFONTA, lfUnderline, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfUnderline, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfUnderline, 21) |
| TEST_FIELD_SIZE (LOGFONTA, lfStrikeOut, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfStrikeOut, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfStrikeOut, 22) |
| TEST_FIELD_SIZE (LOGFONTA, lfCharSet, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfCharSet, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfCharSet, 23) |
| TEST_FIELD_SIZE (LOGFONTA, lfOutPrecision, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfOutPrecision, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfOutPrecision, 24) |
| TEST_FIELD_SIZE (LOGFONTA, lfClipPrecision, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfClipPrecision, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfClipPrecision, 25) |
| TEST_FIELD_SIZE (LOGFONTA, lfQuality, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfQuality, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfQuality, 26) |
| TEST_FIELD_SIZE (LOGFONTA, lfPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (LOGFONTA, lfPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfPitchAndFamily, 27) |
| TEST_FIELD_SIZE (LOGFONTA, lfFaceName, 32) |
| TEST_FIELD_ALIGN (LOGFONTA, lfFaceName, 1) |
| TEST_FIELD_OFFSET(LOGFONTA, lfFaceName, 28) |
| } |
| |
| static void test_pack_LOGFONTW(void) |
| { |
| /* LOGFONTW */ |
| TEST_TYPE_SIZE (LOGFONTW, 92) |
| TEST_TYPE_ALIGN (LOGFONTW, 4) |
| TEST_FIELD_SIZE (LOGFONTW, lfHeight, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfHeight, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfHeight, 0) |
| TEST_FIELD_SIZE (LOGFONTW, lfWidth, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfWidth, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfWidth, 4) |
| TEST_FIELD_SIZE (LOGFONTW, lfEscapement, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfEscapement, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfEscapement, 8) |
| TEST_FIELD_SIZE (LOGFONTW, lfOrientation, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfOrientation, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfOrientation, 12) |
| TEST_FIELD_SIZE (LOGFONTW, lfWeight, 4) |
| TEST_FIELD_ALIGN (LOGFONTW, lfWeight, 4) |
| TEST_FIELD_OFFSET(LOGFONTW, lfWeight, 16) |
| TEST_FIELD_SIZE (LOGFONTW, lfItalic, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfItalic, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfItalic, 20) |
| TEST_FIELD_SIZE (LOGFONTW, lfUnderline, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfUnderline, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfUnderline, 21) |
| TEST_FIELD_SIZE (LOGFONTW, lfStrikeOut, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfStrikeOut, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfStrikeOut, 22) |
| TEST_FIELD_SIZE (LOGFONTW, lfCharSet, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfCharSet, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfCharSet, 23) |
| TEST_FIELD_SIZE (LOGFONTW, lfOutPrecision, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfOutPrecision, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfOutPrecision, 24) |
| TEST_FIELD_SIZE (LOGFONTW, lfClipPrecision, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfClipPrecision, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfClipPrecision, 25) |
| TEST_FIELD_SIZE (LOGFONTW, lfQuality, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfQuality, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfQuality, 26) |
| TEST_FIELD_SIZE (LOGFONTW, lfPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (LOGFONTW, lfPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(LOGFONTW, lfPitchAndFamily, 27) |
| TEST_FIELD_SIZE (LOGFONTW, lfFaceName, 64) |
| TEST_FIELD_ALIGN (LOGFONTW, lfFaceName, 2) |
| TEST_FIELD_OFFSET(LOGFONTW, lfFaceName, 28) |
| } |
| |
| static void test_pack_LOGPEN(void) |
| { |
| /* LOGPEN */ |
| TEST_TYPE_SIZE (LOGPEN, 16) |
| TEST_TYPE_ALIGN (LOGPEN, 4) |
| TEST_FIELD_SIZE (LOGPEN, lopnStyle, 4) |
| TEST_FIELD_ALIGN (LOGPEN, lopnStyle, 4) |
| TEST_FIELD_OFFSET(LOGPEN, lopnStyle, 0) |
| TEST_FIELD_SIZE (LOGPEN, lopnWidth, 8) |
| TEST_FIELD_ALIGN (LOGPEN, lopnWidth, 4) |
| TEST_FIELD_OFFSET(LOGPEN, lopnWidth, 4) |
| TEST_FIELD_SIZE (LOGPEN, lopnColor, 4) |
| TEST_FIELD_ALIGN (LOGPEN, lopnColor, 4) |
| TEST_FIELD_OFFSET(LOGPEN, lopnColor, 12) |
| } |
| |
| static void test_pack_LPABC(void) |
| { |
| /* LPABC */ |
| TEST_TYPE_SIZE (LPABC, 4) |
| TEST_TYPE_ALIGN (LPABC, 4) |
| TEST_TARGET_SIZE (LPABC, 12) |
| TEST_TARGET_ALIGN(LPABC, 4) |
| } |
| |
| static void test_pack_LPABCFLOAT(void) |
| { |
| /* LPABCFLOAT */ |
| TEST_TYPE_SIZE (LPABCFLOAT, 4) |
| TEST_TYPE_ALIGN (LPABCFLOAT, 4) |
| TEST_TARGET_SIZE (LPABCFLOAT, 12) |
| TEST_TARGET_ALIGN(LPABCFLOAT, 4) |
| } |
| |
| static void test_pack_LPBITMAP(void) |
| { |
| /* LPBITMAP */ |
| TEST_TYPE_SIZE (LPBITMAP, 4) |
| TEST_TYPE_ALIGN (LPBITMAP, 4) |
| TEST_TARGET_SIZE (LPBITMAP, 24) |
| TEST_TARGET_ALIGN(LPBITMAP, 4) |
| } |
| |
| static void test_pack_LPBITMAPCOREHEADER(void) |
| { |
| /* LPBITMAPCOREHEADER */ |
| TEST_TYPE_SIZE (LPBITMAPCOREHEADER, 4) |
| TEST_TYPE_ALIGN (LPBITMAPCOREHEADER, 4) |
| TEST_TARGET_SIZE (LPBITMAPCOREHEADER, 12) |
| TEST_TARGET_ALIGN(LPBITMAPCOREHEADER, 4) |
| } |
| |
| static void test_pack_LPBITMAPCOREINFO(void) |
| { |
| /* LPBITMAPCOREINFO */ |
| TEST_TYPE_SIZE (LPBITMAPCOREINFO, 4) |
| TEST_TYPE_ALIGN (LPBITMAPCOREINFO, 4) |
| TEST_TARGET_SIZE (LPBITMAPCOREINFO, 16) |
| TEST_TARGET_ALIGN(LPBITMAPCOREINFO, 4) |
| } |
| |
| static void test_pack_LPBITMAPFILEHEADER(void) |
| { |
| /* LPBITMAPFILEHEADER */ |
| TEST_TYPE_SIZE (LPBITMAPFILEHEADER, 4) |
| TEST_TYPE_ALIGN (LPBITMAPFILEHEADER, 4) |
| TEST_TARGET_SIZE (LPBITMAPFILEHEADER, 14) |
| TEST_TARGET_ALIGN(LPBITMAPFILEHEADER, 2) |
| } |
| |
| static void test_pack_LPBITMAPINFO(void) |
| { |
| /* LPBITMAPINFO */ |
| TEST_TYPE_SIZE (LPBITMAPINFO, 4) |
| TEST_TYPE_ALIGN (LPBITMAPINFO, 4) |
| TEST_TARGET_SIZE (LPBITMAPINFO, 44) |
| TEST_TARGET_ALIGN(LPBITMAPINFO, 4) |
| } |
| |
| static void test_pack_LPBITMAPINFOHEADER(void) |
| { |
| /* LPBITMAPINFOHEADER */ |
| TEST_TYPE_SIZE (LPBITMAPINFOHEADER, 4) |
| TEST_TYPE_ALIGN (LPBITMAPINFOHEADER, 4) |
| TEST_TARGET_SIZE (LPBITMAPINFOHEADER, 40) |
| TEST_TARGET_ALIGN(LPBITMAPINFOHEADER, 4) |
| } |
| |
| static void test_pack_LPBITMAPV5HEADER(void) |
| { |
| /* LPBITMAPV5HEADER */ |
| TEST_TYPE_SIZE (LPBITMAPV5HEADER, 4) |
| TEST_TYPE_ALIGN (LPBITMAPV5HEADER, 4) |
| TEST_TARGET_SIZE (LPBITMAPV5HEADER, 124) |
| TEST_TARGET_ALIGN(LPBITMAPV5HEADER, 4) |
| } |
| |
| static void test_pack_LPCHARSETINFO(void) |
| { |
| /* LPCHARSETINFO */ |
| TEST_TYPE_SIZE (LPCHARSETINFO, 4) |
| TEST_TYPE_ALIGN (LPCHARSETINFO, 4) |
| TEST_TARGET_SIZE (LPCHARSETINFO, 32) |
| TEST_TARGET_ALIGN(LPCHARSETINFO, 4) |
| } |
| |
| static void test_pack_LPCIEXYZ(void) |
| { |
| /* LPCIEXYZ */ |
| TEST_TYPE_SIZE (LPCIEXYZ, 4) |
| TEST_TYPE_ALIGN (LPCIEXYZ, 4) |
| TEST_TARGET_SIZE (LPCIEXYZ, 12) |
| TEST_TARGET_ALIGN(LPCIEXYZ, 4) |
| } |
| |
| static void test_pack_LPCIEXYZTRIPLE(void) |
| { |
| /* LPCIEXYZTRIPLE */ |
| TEST_TYPE_SIZE (LPCIEXYZTRIPLE, 4) |
| TEST_TYPE_ALIGN (LPCIEXYZTRIPLE, 4) |
| TEST_TARGET_SIZE (LPCIEXYZTRIPLE, 36) |
| TEST_TARGET_ALIGN(LPCIEXYZTRIPLE, 4) |
| } |
| |
| static void test_pack_LPCOLORADJUSTMENT(void) |
| { |
| /* LPCOLORADJUSTMENT */ |
| TEST_TYPE_SIZE (LPCOLORADJUSTMENT, 4) |
| TEST_TYPE_ALIGN (LPCOLORADJUSTMENT, 4) |
| TEST_TARGET_SIZE (LPCOLORADJUSTMENT, 24) |
| TEST_TARGET_ALIGN(LPCOLORADJUSTMENT, 2) |
| } |
| |
| static void test_pack_LPDEVMODEA(void) |
| { |
| /* LPDEVMODEA */ |
| TEST_TYPE_SIZE (LPDEVMODEA, 4) |
| TEST_TYPE_ALIGN (LPDEVMODEA, 4) |
| } |
| |
| static void test_pack_LPDEVMODEW(void) |
| { |
| /* LPDEVMODEW */ |
| TEST_TYPE_SIZE (LPDEVMODEW, 4) |
| TEST_TYPE_ALIGN (LPDEVMODEW, 4) |
| } |
| |
| static void test_pack_LPDIBSECTION(void) |
| { |
| /* LPDIBSECTION */ |
| TEST_TYPE_SIZE (LPDIBSECTION, 4) |
| TEST_TYPE_ALIGN (LPDIBSECTION, 4) |
| TEST_TARGET_SIZE (LPDIBSECTION, 84) |
| TEST_TARGET_ALIGN(LPDIBSECTION, 4) |
| } |
| |
| static void test_pack_LPDISPLAY_DEVICEA(void) |
| { |
| /* LPDISPLAY_DEVICEA */ |
| TEST_TYPE_SIZE (LPDISPLAY_DEVICEA, 4) |
| TEST_TYPE_ALIGN (LPDISPLAY_DEVICEA, 4) |
| TEST_TARGET_SIZE (LPDISPLAY_DEVICEA, 424) |
| TEST_TARGET_ALIGN(LPDISPLAY_DEVICEA, 4) |
| } |
| |
| static void test_pack_LPDISPLAY_DEVICEW(void) |
| { |
| /* LPDISPLAY_DEVICEW */ |
| TEST_TYPE_SIZE (LPDISPLAY_DEVICEW, 4) |
| TEST_TYPE_ALIGN (LPDISPLAY_DEVICEW, 4) |
| TEST_TARGET_SIZE (LPDISPLAY_DEVICEW, 840) |
| TEST_TARGET_ALIGN(LPDISPLAY_DEVICEW, 4) |
| } |
| |
| static void test_pack_LPDOCINFOA(void) |
| { |
| /* LPDOCINFOA */ |
| TEST_TYPE_SIZE (LPDOCINFOA, 4) |
| TEST_TYPE_ALIGN (LPDOCINFOA, 4) |
| TEST_TARGET_SIZE (LPDOCINFOA, 20) |
| TEST_TARGET_ALIGN(LPDOCINFOA, 4) |
| } |
| |
| static void test_pack_LPDOCINFOW(void) |
| { |
| /* LPDOCINFOW */ |
| TEST_TYPE_SIZE (LPDOCINFOW, 4) |
| TEST_TYPE_ALIGN (LPDOCINFOW, 4) |
| TEST_TARGET_SIZE (LPDOCINFOW, 20) |
| TEST_TARGET_ALIGN(LPDOCINFOW, 4) |
| } |
| |
| static void test_pack_LPENHMETAHEADER(void) |
| { |
| /* LPENHMETAHEADER */ |
| TEST_TYPE_SIZE (LPENHMETAHEADER, 4) |
| TEST_TYPE_ALIGN (LPENHMETAHEADER, 4) |
| TEST_TARGET_SIZE (LPENHMETAHEADER, 108) |
| TEST_TARGET_ALIGN(LPENHMETAHEADER, 4) |
| } |
| |
| static void test_pack_LPENHMETARECORD(void) |
| { |
| /* LPENHMETARECORD */ |
| TEST_TYPE_SIZE (LPENHMETARECORD, 4) |
| TEST_TYPE_ALIGN (LPENHMETARECORD, 4) |
| TEST_TARGET_SIZE (LPENHMETARECORD, 12) |
| TEST_TARGET_ALIGN(LPENHMETARECORD, 4) |
| } |
| |
| static void test_pack_LPENUMLOGFONTA(void) |
| { |
| /* LPENUMLOGFONTA */ |
| TEST_TYPE_SIZE (LPENUMLOGFONTA, 4) |
| TEST_TYPE_ALIGN (LPENUMLOGFONTA, 4) |
| TEST_TARGET_SIZE (LPENUMLOGFONTA, 156) |
| TEST_TARGET_ALIGN(LPENUMLOGFONTA, 4) |
| } |
| |
| static void test_pack_LPENUMLOGFONTEXA(void) |
| { |
| /* LPENUMLOGFONTEXA */ |
| TEST_TYPE_SIZE (LPENUMLOGFONTEXA, 4) |
| TEST_TYPE_ALIGN (LPENUMLOGFONTEXA, 4) |
| TEST_TARGET_SIZE (LPENUMLOGFONTEXA, 188) |
| TEST_TARGET_ALIGN(LPENUMLOGFONTEXA, 4) |
| } |
| |
| static void test_pack_LPENUMLOGFONTEXW(void) |
| { |
| /* LPENUMLOGFONTEXW */ |
| TEST_TYPE_SIZE (LPENUMLOGFONTEXW, 4) |
| TEST_TYPE_ALIGN (LPENUMLOGFONTEXW, 4) |
| TEST_TARGET_SIZE (LPENUMLOGFONTEXW, 348) |
| TEST_TARGET_ALIGN(LPENUMLOGFONTEXW, 4) |
| } |
| |
| static void test_pack_LPENUMLOGFONTW(void) |
| { |
| /* LPENUMLOGFONTW */ |
| TEST_TYPE_SIZE (LPENUMLOGFONTW, 4) |
| TEST_TYPE_ALIGN (LPENUMLOGFONTW, 4) |
| TEST_TARGET_SIZE (LPENUMLOGFONTW, 284) |
| TEST_TARGET_ALIGN(LPENUMLOGFONTW, 4) |
| } |
| |
| static void test_pack_LPEXTLOGFONTA(void) |
| { |
| /* LPEXTLOGFONTA */ |
| TEST_TYPE_SIZE (LPEXTLOGFONTA, 4) |
| TEST_TYPE_ALIGN (LPEXTLOGFONTA, 4) |
| TEST_TARGET_SIZE (LPEXTLOGFONTA, 192) |
| TEST_TARGET_ALIGN(LPEXTLOGFONTA, 4) |
| } |
| |
| static void test_pack_LPEXTLOGFONTW(void) |
| { |
| /* LPEXTLOGFONTW */ |
| TEST_TYPE_SIZE (LPEXTLOGFONTW, 4) |
| TEST_TYPE_ALIGN (LPEXTLOGFONTW, 4) |
| TEST_TARGET_SIZE (LPEXTLOGFONTW, 320) |
| TEST_TARGET_ALIGN(LPEXTLOGFONTW, 4) |
| } |
| |
| static void test_pack_LPEXTLOGPEN(void) |
| { |
| /* LPEXTLOGPEN */ |
| TEST_TYPE_SIZE (LPEXTLOGPEN, 4) |
| TEST_TYPE_ALIGN (LPEXTLOGPEN, 4) |
| TEST_TARGET_SIZE (LPEXTLOGPEN, 28) |
| TEST_TARGET_ALIGN(LPEXTLOGPEN, 4) |
| } |
| |
| static void test_pack_LPFONTSIGNATURE(void) |
| { |
| /* LPFONTSIGNATURE */ |
| TEST_TYPE_SIZE (LPFONTSIGNATURE, 4) |
| TEST_TYPE_ALIGN (LPFONTSIGNATURE, 4) |
| TEST_TARGET_SIZE (LPFONTSIGNATURE, 24) |
| TEST_TARGET_ALIGN(LPFONTSIGNATURE, 4) |
| } |
| |
| static void test_pack_LPGCP_RESULTSA(void) |
| { |
| /* LPGCP_RESULTSA */ |
| TEST_TYPE_SIZE (LPGCP_RESULTSA, 4) |
| TEST_TYPE_ALIGN (LPGCP_RESULTSA, 4) |
| TEST_TARGET_SIZE (LPGCP_RESULTSA, 36) |
| TEST_TARGET_ALIGN(LPGCP_RESULTSA, 4) |
| } |
| |
| static void test_pack_LPGCP_RESULTSW(void) |
| { |
| /* LPGCP_RESULTSW */ |
| TEST_TYPE_SIZE (LPGCP_RESULTSW, 4) |
| TEST_TYPE_ALIGN (LPGCP_RESULTSW, 4) |
| TEST_TARGET_SIZE (LPGCP_RESULTSW, 36) |
| TEST_TARGET_ALIGN(LPGCP_RESULTSW, 4) |
| } |
| |
| static void test_pack_LPGLYPHMETRICS(void) |
| { |
| /* LPGLYPHMETRICS */ |
| TEST_TYPE_SIZE (LPGLYPHMETRICS, 4) |
| TEST_TYPE_ALIGN (LPGLYPHMETRICS, 4) |
| TEST_TARGET_SIZE (LPGLYPHMETRICS, 20) |
| TEST_TARGET_ALIGN(LPGLYPHMETRICS, 4) |
| } |
| |
| static void test_pack_LPGLYPHMETRICSFLOAT(void) |
| { |
| /* LPGLYPHMETRICSFLOAT */ |
| TEST_TYPE_SIZE (LPGLYPHMETRICSFLOAT, 4) |
| TEST_TYPE_ALIGN (LPGLYPHMETRICSFLOAT, 4) |
| TEST_TARGET_SIZE (LPGLYPHMETRICSFLOAT, 24) |
| TEST_TARGET_ALIGN(LPGLYPHMETRICSFLOAT, 4) |
| } |
| |
| static void test_pack_LPGRADIENT_RECT(void) |
| { |
| /* LPGRADIENT_RECT */ |
| TEST_TYPE_SIZE (LPGRADIENT_RECT, 4) |
| TEST_TYPE_ALIGN (LPGRADIENT_RECT, 4) |
| TEST_TARGET_SIZE (LPGRADIENT_RECT, 8) |
| TEST_TARGET_ALIGN(LPGRADIENT_RECT, 4) |
| } |
| |
| static void test_pack_LPGRADIENT_TRIANGLE(void) |
| { |
| /* LPGRADIENT_TRIANGLE */ |
| TEST_TYPE_SIZE (LPGRADIENT_TRIANGLE, 4) |
| TEST_TYPE_ALIGN (LPGRADIENT_TRIANGLE, 4) |
| TEST_TARGET_SIZE (LPGRADIENT_TRIANGLE, 12) |
| TEST_TARGET_ALIGN(LPGRADIENT_TRIANGLE, 4) |
| } |
| |
| static void test_pack_LPHANDLETABLE(void) |
| { |
| /* LPHANDLETABLE */ |
| TEST_TYPE_SIZE (LPHANDLETABLE, 4) |
| TEST_TYPE_ALIGN (LPHANDLETABLE, 4) |
| TEST_TARGET_SIZE (LPHANDLETABLE, 4) |
| TEST_TARGET_ALIGN(LPHANDLETABLE, 4) |
| } |
| |
| static void test_pack_LPKERNINGPAIR(void) |
| { |
| /* LPKERNINGPAIR */ |
| TEST_TYPE_SIZE (LPKERNINGPAIR, 4) |
| TEST_TYPE_ALIGN (LPKERNINGPAIR, 4) |
| TEST_TARGET_SIZE (LPKERNINGPAIR, 8) |
| TEST_TARGET_ALIGN(LPKERNINGPAIR, 4) |
| } |
| |
| static void test_pack_LPLAYERPLANEDESCRIPTOR(void) |
| { |
| /* LPLAYERPLANEDESCRIPTOR */ |
| TEST_TYPE_SIZE (LPLAYERPLANEDESCRIPTOR, 4) |
| TEST_TYPE_ALIGN (LPLAYERPLANEDESCRIPTOR, 4) |
| TEST_TARGET_SIZE (LPLAYERPLANEDESCRIPTOR, 32) |
| TEST_TARGET_ALIGN(LPLAYERPLANEDESCRIPTOR, 4) |
| } |
| |
| static void test_pack_LPLOCALESIGNATURE(void) |
| { |
| /* LPLOCALESIGNATURE */ |
| TEST_TYPE_SIZE (LPLOCALESIGNATURE, 4) |
| TEST_TYPE_ALIGN (LPLOCALESIGNATURE, 4) |
| TEST_TARGET_SIZE (LPLOCALESIGNATURE, 32) |
| TEST_TARGET_ALIGN(LPLOCALESIGNATURE, 4) |
| } |
| |
| static void test_pack_LPLOGBRUSH(void) |
| { |
| /* LPLOGBRUSH */ |
| TEST_TYPE_SIZE (LPLOGBRUSH, 4) |
| TEST_TYPE_ALIGN (LPLOGBRUSH, 4) |
| TEST_TARGET_SIZE (LPLOGBRUSH, 12) |
| TEST_TARGET_ALIGN(LPLOGBRUSH, 4) |
| } |
| |
| static void test_pack_LPLOGCOLORSPACEA(void) |
| { |
| /* LPLOGCOLORSPACEA */ |
| TEST_TYPE_SIZE (LPLOGCOLORSPACEA, 4) |
| TEST_TYPE_ALIGN (LPLOGCOLORSPACEA, 4) |
| TEST_TARGET_SIZE (LPLOGCOLORSPACEA, 328) |
| TEST_TARGET_ALIGN(LPLOGCOLORSPACEA, 4) |
| } |
| |
| static void test_pack_LPLOGCOLORSPACEW(void) |
| { |
| /* LPLOGCOLORSPACEW */ |
| TEST_TYPE_SIZE (LPLOGCOLORSPACEW, 4) |
| TEST_TYPE_ALIGN (LPLOGCOLORSPACEW, 4) |
| TEST_TARGET_SIZE (LPLOGCOLORSPACEW, 588) |
| TEST_TARGET_ALIGN(LPLOGCOLORSPACEW, 4) |
| } |
| |
| static void test_pack_LPLOGFONTA(void) |
| { |
| /* LPLOGFONTA */ |
| TEST_TYPE_SIZE (LPLOGFONTA, 4) |
| TEST_TYPE_ALIGN (LPLOGFONTA, 4) |
| TEST_TARGET_SIZE (LPLOGFONTA, 60) |
| TEST_TARGET_ALIGN(LPLOGFONTA, 4) |
| } |
| |
| static void test_pack_LPLOGFONTW(void) |
| { |
| /* LPLOGFONTW */ |
| TEST_TYPE_SIZE (LPLOGFONTW, 4) |
| TEST_TYPE_ALIGN (LPLOGFONTW, 4) |
| TEST_TARGET_SIZE (LPLOGFONTW, 92) |
| TEST_TARGET_ALIGN(LPLOGFONTW, 4) |
| } |
| |
| static void test_pack_LPLOGPEN(void) |
| { |
| /* LPLOGPEN */ |
| TEST_TYPE_SIZE (LPLOGPEN, 4) |
| TEST_TYPE_ALIGN (LPLOGPEN, 4) |
| TEST_TARGET_SIZE (LPLOGPEN, 16) |
| TEST_TARGET_ALIGN(LPLOGPEN, 4) |
| } |
| |
| static void test_pack_LPMAT2(void) |
| { |
| /* LPMAT2 */ |
| TEST_TYPE_SIZE (LPMAT2, 4) |
| TEST_TYPE_ALIGN (LPMAT2, 4) |
| TEST_TARGET_SIZE (LPMAT2, 16) |
| TEST_TARGET_ALIGN(LPMAT2, 2) |
| } |
| |
| static void test_pack_LPMETAFILEPICT(void) |
| { |
| /* LPMETAFILEPICT */ |
| TEST_TYPE_SIZE (LPMETAFILEPICT, 4) |
| TEST_TYPE_ALIGN (LPMETAFILEPICT, 4) |
| TEST_TARGET_SIZE (LPMETAFILEPICT, 16) |
| TEST_TARGET_ALIGN(LPMETAFILEPICT, 4) |
| } |
| |
| static void test_pack_LPMETAHEADER(void) |
| { |
| /* LPMETAHEADER */ |
| TEST_TYPE_SIZE (LPMETAHEADER, 4) |
| TEST_TYPE_ALIGN (LPMETAHEADER, 4) |
| TEST_TARGET_SIZE (LPMETAHEADER, 18) |
| TEST_TARGET_ALIGN(LPMETAHEADER, 2) |
| } |
| |
| static void test_pack_LPMETARECORD(void) |
| { |
| /* LPMETARECORD */ |
| TEST_TYPE_SIZE (LPMETARECORD, 4) |
| TEST_TYPE_ALIGN (LPMETARECORD, 4) |
| TEST_TARGET_SIZE (LPMETARECORD, 8) |
| TEST_TARGET_ALIGN(LPMETARECORD, 4) |
| } |
| |
| static void test_pack_LPNEWTEXTMETRICA(void) |
| { |
| /* LPNEWTEXTMETRICA */ |
| TEST_TYPE_SIZE (LPNEWTEXTMETRICA, 4) |
| TEST_TYPE_ALIGN (LPNEWTEXTMETRICA, 4) |
| TEST_TARGET_SIZE (LPNEWTEXTMETRICA, 72) |
| TEST_TARGET_ALIGN(LPNEWTEXTMETRICA, 4) |
| } |
| |
| static void test_pack_LPNEWTEXTMETRICW(void) |
| { |
| /* LPNEWTEXTMETRICW */ |
| TEST_TYPE_SIZE (LPNEWTEXTMETRICW, 4) |
| TEST_TYPE_ALIGN (LPNEWTEXTMETRICW, 4) |
| TEST_TARGET_SIZE (LPNEWTEXTMETRICW, 76) |
| TEST_TARGET_ALIGN(LPNEWTEXTMETRICW, 4) |
| } |
| |
| static void test_pack_LPOUTLINETEXTMETRICA(void) |
| { |
| /* LPOUTLINETEXTMETRICA */ |
| TEST_TYPE_SIZE (LPOUTLINETEXTMETRICA, 4) |
| TEST_TYPE_ALIGN (LPOUTLINETEXTMETRICA, 4) |
| TEST_TARGET_SIZE (LPOUTLINETEXTMETRICA, 212) |
| TEST_TARGET_ALIGN(LPOUTLINETEXTMETRICA, 4) |
| } |
| |
| static void test_pack_LPOUTLINETEXTMETRICW(void) |
| { |
| /* LPOUTLINETEXTMETRICW */ |
| TEST_TYPE_SIZE (LPOUTLINETEXTMETRICW, 4) |
| TEST_TYPE_ALIGN (LPOUTLINETEXTMETRICW, 4) |
| TEST_TARGET_SIZE (LPOUTLINETEXTMETRICW, 216) |
| TEST_TARGET_ALIGN(LPOUTLINETEXTMETRICW, 4) |
| } |
| |
| static void test_pack_LPPANOSE(void) |
| { |
| /* LPPANOSE */ |
| TEST_TYPE_SIZE (LPPANOSE, 4) |
| TEST_TYPE_ALIGN (LPPANOSE, 4) |
| TEST_TARGET_SIZE (LPPANOSE, 10) |
| TEST_TARGET_ALIGN(LPPANOSE, 1) |
| } |
| |
| static void test_pack_LPPELARRAY(void) |
| { |
| /* LPPELARRAY */ |
| TEST_TYPE_SIZE (LPPELARRAY, 4) |
| TEST_TYPE_ALIGN (LPPELARRAY, 4) |
| TEST_TARGET_SIZE (LPPELARRAY, 20) |
| TEST_TARGET_ALIGN(LPPELARRAY, 4) |
| } |
| |
| static void test_pack_LPPIXELFORMATDESCRIPTOR(void) |
| { |
| /* LPPIXELFORMATDESCRIPTOR */ |
| TEST_TYPE_SIZE (LPPIXELFORMATDESCRIPTOR, 4) |
| TEST_TYPE_ALIGN (LPPIXELFORMATDESCRIPTOR, 4) |
| TEST_TARGET_SIZE (LPPIXELFORMATDESCRIPTOR, 40) |
| TEST_TARGET_ALIGN(LPPIXELFORMATDESCRIPTOR, 4) |
| } |
| |
| static void test_pack_LPPOINTFX(void) |
| { |
| /* LPPOINTFX */ |
| TEST_TYPE_SIZE (LPPOINTFX, 4) |
| TEST_TYPE_ALIGN (LPPOINTFX, 4) |
| TEST_TARGET_SIZE (LPPOINTFX, 8) |
| TEST_TARGET_ALIGN(LPPOINTFX, 2) |
| } |
| |
| static void test_pack_LPPOLYTEXTA(void) |
| { |
| /* LPPOLYTEXTA */ |
| TEST_TYPE_SIZE (LPPOLYTEXTA, 4) |
| TEST_TYPE_ALIGN (LPPOLYTEXTA, 4) |
| TEST_TARGET_SIZE (LPPOLYTEXTA, 40) |
| TEST_TARGET_ALIGN(LPPOLYTEXTA, 4) |
| } |
| |
| static void test_pack_LPPOLYTEXTW(void) |
| { |
| /* LPPOLYTEXTW */ |
| TEST_TYPE_SIZE (LPPOLYTEXTW, 4) |
| TEST_TYPE_ALIGN (LPPOLYTEXTW, 4) |
| TEST_TARGET_SIZE (LPPOLYTEXTW, 40) |
| TEST_TARGET_ALIGN(LPPOLYTEXTW, 4) |
| } |
| |
| static void test_pack_LPRASTERIZER_STATUS(void) |
| { |
| /* LPRASTERIZER_STATUS */ |
| TEST_TYPE_SIZE (LPRASTERIZER_STATUS, 4) |
| TEST_TYPE_ALIGN (LPRASTERIZER_STATUS, 4) |
| TEST_TARGET_SIZE (LPRASTERIZER_STATUS, 6) |
| TEST_TARGET_ALIGN(LPRASTERIZER_STATUS, 2) |
| } |
| |
| static void test_pack_LPRGBQUAD(void) |
| { |
| /* LPRGBQUAD */ |
| TEST_TYPE_SIZE (LPRGBQUAD, 4) |
| TEST_TYPE_ALIGN (LPRGBQUAD, 4) |
| TEST_TARGET_SIZE (LPRGBQUAD, 4) |
| TEST_TARGET_ALIGN(LPRGBQUAD, 1) |
| } |
| |
| static void test_pack_LPRGNDATA(void) |
| { |
| /* LPRGNDATA */ |
| TEST_TYPE_SIZE (LPRGNDATA, 4) |
| TEST_TYPE_ALIGN (LPRGNDATA, 4) |
| TEST_TARGET_SIZE (LPRGNDATA, 36) |
| TEST_TARGET_ALIGN(LPRGNDATA, 4) |
| } |
| |
| static void test_pack_LPTEXTMETRICA(void) |
| { |
| /* LPTEXTMETRICA */ |
| TEST_TYPE_SIZE (LPTEXTMETRICA, 4) |
| TEST_TYPE_ALIGN (LPTEXTMETRICA, 4) |
| TEST_TARGET_SIZE (LPTEXTMETRICA, 56) |
| TEST_TARGET_ALIGN(LPTEXTMETRICA, 4) |
| } |
| |
| static void test_pack_LPTEXTMETRICW(void) |
| { |
| /* LPTEXTMETRICW */ |
| TEST_TYPE_SIZE (LPTEXTMETRICW, 4) |
| TEST_TYPE_ALIGN (LPTEXTMETRICW, 4) |
| TEST_TARGET_SIZE (LPTEXTMETRICW, 60) |
| TEST_TARGET_ALIGN(LPTEXTMETRICW, 4) |
| } |
| |
| static void test_pack_LPTRIVERTEX(void) |
| { |
| /* LPTRIVERTEX */ |
| TEST_TYPE_SIZE (LPTRIVERTEX, 4) |
| TEST_TYPE_ALIGN (LPTRIVERTEX, 4) |
| TEST_TARGET_SIZE (LPTRIVERTEX, 16) |
| TEST_TARGET_ALIGN(LPTRIVERTEX, 4) |
| } |
| |
| static void test_pack_LPTTPOLYCURVE(void) |
| { |
| /* LPTTPOLYCURVE */ |
| TEST_TYPE_SIZE (LPTTPOLYCURVE, 4) |
| TEST_TYPE_ALIGN (LPTTPOLYCURVE, 4) |
| TEST_TARGET_SIZE (LPTTPOLYCURVE, 12) |
| TEST_TARGET_ALIGN(LPTTPOLYCURVE, 2) |
| } |
| |
| static void test_pack_LPTTPOLYGONHEADER(void) |
| { |
| /* LPTTPOLYGONHEADER */ |
| TEST_TYPE_SIZE (LPTTPOLYGONHEADER, 4) |
| TEST_TYPE_ALIGN (LPTTPOLYGONHEADER, 4) |
| TEST_TARGET_SIZE (LPTTPOLYGONHEADER, 16) |
| TEST_TARGET_ALIGN(LPTTPOLYGONHEADER, 4) |
| } |
| |
| static void test_pack_LPXFORM(void) |
| { |
| /* LPXFORM */ |
| TEST_TYPE_SIZE (LPXFORM, 4) |
| TEST_TYPE_ALIGN (LPXFORM, 4) |
| TEST_TARGET_SIZE (LPXFORM, 24) |
| TEST_TARGET_ALIGN(LPXFORM, 4) |
| } |
| |
| static void test_pack_MAT2(void) |
| { |
| /* MAT2 */ |
| TEST_TYPE_SIZE (MAT2, 16) |
| TEST_TYPE_ALIGN (MAT2, 2) |
| TEST_FIELD_SIZE (MAT2, eM11, 4) |
| TEST_FIELD_ALIGN (MAT2, eM11, 2) |
| TEST_FIELD_OFFSET(MAT2, eM11, 0) |
| TEST_FIELD_SIZE (MAT2, eM12, 4) |
| TEST_FIELD_ALIGN (MAT2, eM12, 2) |
| TEST_FIELD_OFFSET(MAT2, eM12, 4) |
| TEST_FIELD_SIZE (MAT2, eM21, 4) |
| TEST_FIELD_ALIGN (MAT2, eM21, 2) |
| TEST_FIELD_OFFSET(MAT2, eM21, 8) |
| TEST_FIELD_SIZE (MAT2, eM22, 4) |
| TEST_FIELD_ALIGN (MAT2, eM22, 2) |
| TEST_FIELD_OFFSET(MAT2, eM22, 12) |
| } |
| |
| static void test_pack_METAFILEPICT(void) |
| { |
| /* METAFILEPICT */ |
| TEST_TYPE_SIZE (METAFILEPICT, 16) |
| TEST_TYPE_ALIGN (METAFILEPICT, 4) |
| TEST_FIELD_SIZE (METAFILEPICT, mm, 4) |
| TEST_FIELD_ALIGN (METAFILEPICT, mm, 4) |
| TEST_FIELD_OFFSET(METAFILEPICT, mm, 0) |
| TEST_FIELD_SIZE (METAFILEPICT, xExt, 4) |
| TEST_FIELD_ALIGN (METAFILEPICT, xExt, 4) |
| TEST_FIELD_OFFSET(METAFILEPICT, xExt, 4) |
| TEST_FIELD_SIZE (METAFILEPICT, yExt, 4) |
| TEST_FIELD_ALIGN (METAFILEPICT, yExt, 4) |
| TEST_FIELD_OFFSET(METAFILEPICT, yExt, 8) |
| TEST_FIELD_SIZE (METAFILEPICT, hMF, 4) |
| TEST_FIELD_ALIGN (METAFILEPICT, hMF, 4) |
| TEST_FIELD_OFFSET(METAFILEPICT, hMF, 12) |
| } |
| |
| static void test_pack_METAHEADER(void) |
| { |
| /* METAHEADER (pack 2) */ |
| TEST_TYPE_SIZE (METAHEADER, 18) |
| TEST_TYPE_ALIGN (METAHEADER, 2) |
| TEST_FIELD_SIZE (METAHEADER, mtType, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtType, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtType, 0) |
| TEST_FIELD_SIZE (METAHEADER, mtHeaderSize, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtHeaderSize, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtHeaderSize, 2) |
| TEST_FIELD_SIZE (METAHEADER, mtVersion, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtVersion, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtVersion, 4) |
| TEST_FIELD_SIZE (METAHEADER, mtSize, 4) |
| TEST_FIELD_ALIGN (METAHEADER, mtSize, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtSize, 6) |
| TEST_FIELD_SIZE (METAHEADER, mtNoObjects, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtNoObjects, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtNoObjects, 10) |
| TEST_FIELD_SIZE (METAHEADER, mtMaxRecord, 4) |
| TEST_FIELD_ALIGN (METAHEADER, mtMaxRecord, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtMaxRecord, 12) |
| TEST_FIELD_SIZE (METAHEADER, mtNoParameters, 2) |
| TEST_FIELD_ALIGN (METAHEADER, mtNoParameters, 2) |
| TEST_FIELD_OFFSET(METAHEADER, mtNoParameters, 16) |
| } |
| |
| static void test_pack_METARECORD(void) |
| { |
| /* METARECORD */ |
| TEST_TYPE_SIZE (METARECORD, 8) |
| TEST_TYPE_ALIGN (METARECORD, 4) |
| TEST_FIELD_SIZE (METARECORD, rdSize, 4) |
| TEST_FIELD_ALIGN (METARECORD, rdSize, 4) |
| TEST_FIELD_OFFSET(METARECORD, rdSize, 0) |
| TEST_FIELD_SIZE (METARECORD, rdFunction, 2) |
| TEST_FIELD_ALIGN (METARECORD, rdFunction, 2) |
| TEST_FIELD_OFFSET(METARECORD, rdFunction, 4) |
| TEST_FIELD_SIZE (METARECORD, rdParm, 2) |
| TEST_FIELD_ALIGN (METARECORD, rdParm, 2) |
| TEST_FIELD_OFFSET(METARECORD, rdParm, 6) |
| } |
| |
| static void test_pack_MFENUMPROC(void) |
| { |
| /* MFENUMPROC */ |
| TEST_TYPE_SIZE (MFENUMPROC, 4) |
| TEST_TYPE_ALIGN (MFENUMPROC, 4) |
| } |
| |
| static void test_pack_NEWTEXTMETRICA(void) |
| { |
| /* NEWTEXTMETRICA */ |
| TEST_TYPE_SIZE (NEWTEXTMETRICA, 72) |
| TEST_TYPE_ALIGN (NEWTEXTMETRICA, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmHeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmHeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmHeight, 0) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmDescent, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmDescent, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmDescent, 8) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmInternalLeading, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmInternalLeading, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmInternalLeading, 12) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmExternalLeading, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmExternalLeading, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmExternalLeading, 16) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmAveCharWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmAveCharWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmAveCharWidth, 20) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmMaxCharWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmMaxCharWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmMaxCharWidth, 24) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmWeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmWeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmWeight, 28) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmOverhang, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmOverhang, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmOverhang, 32) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmDigitizedAspectX, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmDigitizedAspectX, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmDigitizedAspectX, 36) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmDigitizedAspectY, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmDigitizedAspectY, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmDigitizedAspectY, 40) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmFirstChar, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmFirstChar, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmFirstChar, 44) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmLastChar, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmLastChar, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmLastChar, 45) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmDefaultChar, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmDefaultChar, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmDefaultChar, 46) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmBreakChar, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmBreakChar, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmBreakChar, 47) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmItalic, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmItalic, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmItalic, 48) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmUnderlined, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmUnderlined, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmUnderlined, 49) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmStruckOut, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmStruckOut, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmStruckOut, 50) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmPitchAndFamily, 51) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, tmCharSet, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, tmCharSet, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, tmCharSet, 52) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, ntmFlags, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, ntmFlags, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, ntmFlags, 56) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, ntmSizeEM, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, ntmSizeEM, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, ntmSizeEM, 60) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, ntmCellHeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, ntmCellHeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, ntmCellHeight, 64) |
| TEST_FIELD_SIZE (NEWTEXTMETRICA, ntmAvgWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICA, ntmAvgWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICA, ntmAvgWidth, 68) |
| } |
| |
| static void test_pack_NEWTEXTMETRICEXA(void) |
| { |
| /* NEWTEXTMETRICEXA */ |
| TEST_TYPE_SIZE (NEWTEXTMETRICEXA, 96) |
| TEST_TYPE_ALIGN (NEWTEXTMETRICEXA, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICEXA, ntmTm, 72) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICEXA, ntmTm, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICEXA, ntmTm, 0) |
| TEST_FIELD_SIZE (NEWTEXTMETRICEXA, ntmFontSig, 24) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICEXA, ntmFontSig, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICEXA, ntmFontSig, 72) |
| } |
| |
| static void test_pack_NEWTEXTMETRICEXW(void) |
| { |
| /* NEWTEXTMETRICEXW */ |
| TEST_TYPE_SIZE (NEWTEXTMETRICEXW, 100) |
| TEST_TYPE_ALIGN (NEWTEXTMETRICEXW, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICEXW, ntmTm, 76) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICEXW, ntmTm, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICEXW, ntmTm, 0) |
| TEST_FIELD_SIZE (NEWTEXTMETRICEXW, ntmFontSig, 24) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICEXW, ntmFontSig, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICEXW, ntmFontSig, 76) |
| } |
| |
| static void test_pack_NEWTEXTMETRICW(void) |
| { |
| /* NEWTEXTMETRICW */ |
| TEST_TYPE_SIZE (NEWTEXTMETRICW, 76) |
| TEST_TYPE_ALIGN (NEWTEXTMETRICW, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmHeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmHeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmHeight, 0) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmDescent, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmDescent, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmDescent, 8) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmInternalLeading, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmInternalLeading, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmInternalLeading, 12) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmExternalLeading, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmExternalLeading, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmExternalLeading, 16) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmAveCharWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmAveCharWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmAveCharWidth, 20) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmMaxCharWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmMaxCharWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmMaxCharWidth, 24) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmWeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmWeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmWeight, 28) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmOverhang, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmOverhang, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmOverhang, 32) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmDigitizedAspectX, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmDigitizedAspectX, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmDigitizedAspectX, 36) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmDigitizedAspectY, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmDigitizedAspectY, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmDigitizedAspectY, 40) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmFirstChar, 2) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmFirstChar, 2) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmFirstChar, 44) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmLastChar, 2) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmLastChar, 2) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmLastChar, 46) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmDefaultChar, 2) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmDefaultChar, 2) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmDefaultChar, 48) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmBreakChar, 2) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmBreakChar, 2) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmBreakChar, 50) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmItalic, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmItalic, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmItalic, 52) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmUnderlined, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmUnderlined, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmUnderlined, 53) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmStruckOut, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmStruckOut, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmStruckOut, 54) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmPitchAndFamily, 55) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, tmCharSet, 1) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, tmCharSet, 1) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, tmCharSet, 56) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, ntmFlags, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, ntmFlags, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, ntmFlags, 60) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, ntmSizeEM, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, ntmSizeEM, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, ntmSizeEM, 64) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, ntmCellHeight, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, ntmCellHeight, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, ntmCellHeight, 68) |
| TEST_FIELD_SIZE (NEWTEXTMETRICW, ntmAvgWidth, 4) |
| TEST_FIELD_ALIGN (NEWTEXTMETRICW, ntmAvgWidth, 4) |
| TEST_FIELD_OFFSET(NEWTEXTMETRICW, ntmAvgWidth, 72) |
| } |
| |
| static void test_pack_NPEXTLOGPEN(void) |
| { |
| /* NPEXTLOGPEN */ |
| TEST_TYPE_SIZE (NPEXTLOGPEN, 4) |
| TEST_TYPE_ALIGN (NPEXTLOGPEN, 4) |
| TEST_TARGET_SIZE (NPEXTLOGPEN, 28) |
| TEST_TARGET_ALIGN(NPEXTLOGPEN, 4) |
| } |
| |
| static void test_pack_OLDFONTENUMPROCA(void) |
| { |
| /* OLDFONTENUMPROCA */ |
| TEST_TYPE_SIZE (OLDFONTENUMPROCA, 4) |
| TEST_TYPE_ALIGN (OLDFONTENUMPROCA, 4) |
| } |
| |
| static void test_pack_OLDFONTENUMPROCW(void) |
| { |
| /* OLDFONTENUMPROCW */ |
| TEST_TYPE_SIZE (OLDFONTENUMPROCW, 4) |
| TEST_TYPE_ALIGN (OLDFONTENUMPROCW, 4) |
| } |
| |
| static void test_pack_OUTLINETEXTMETRICA(void) |
| { |
| /* OUTLINETEXTMETRICA */ |
| TEST_TYPE_SIZE (OUTLINETEXTMETRICA, 212) |
| TEST_TYPE_ALIGN (OUTLINETEXTMETRICA, 4) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmSize, 0) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmTextMetrics, 56) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmTextMetrics, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmTextMetrics, 4) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmFiller, 1) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmFiller, 1) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmFiller, 60) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmPanoseNumber, 10) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmPanoseNumber, 1) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmPanoseNumber, 61) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmfsSelection, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmfsSelection, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmfsSelection, 72) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmfsType, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmfsType, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmfsType, 76) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsCharSlopeRise, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsCharSlopeRise, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsCharSlopeRise, 80) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsCharSlopeRun, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsCharSlopeRun, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsCharSlopeRun, 84) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmItalicAngle, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmItalicAngle, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmItalicAngle, 88) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmEMSquare, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmEMSquare, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmEMSquare, 92) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmAscent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmAscent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmAscent, 96) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmDescent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmDescent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmDescent, 100) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmLineGap, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmLineGap, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmLineGap, 104) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsCapEmHeight, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsCapEmHeight, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsCapEmHeight, 108) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsXHeight, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsXHeight, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsXHeight, 112) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmrcFontBox, 16) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmrcFontBox, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmrcFontBox, 116) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmMacAscent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmMacAscent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmMacAscent, 132) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmMacDescent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmMacDescent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmMacDescent, 136) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmMacLineGap, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmMacLineGap, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmMacLineGap, 140) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmusMinimumPPEM, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmusMinimumPPEM, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmusMinimumPPEM, 144) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmptSubscriptSize, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmptSubscriptSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmptSubscriptSize, 148) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmptSubscriptOffset, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmptSubscriptOffset, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmptSubscriptOffset, 156) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmptSuperscriptSize, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmptSuperscriptSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmptSuperscriptSize, 164) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmptSuperscriptOffset, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmptSuperscriptOffset, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmptSuperscriptOffset, 172) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsStrikeoutSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsStrikeoutSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsStrikeoutSize, 180) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsStrikeoutPosition, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsStrikeoutPosition, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsStrikeoutPosition, 184) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsUnderscoreSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsUnderscoreSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsUnderscoreSize, 188) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmsUnderscorePosition, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmsUnderscorePosition, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmsUnderscorePosition, 192) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmpFamilyName, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmpFamilyName, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFamilyName, 196) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmpFaceName, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmpFaceName, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFaceName, 200) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmpStyleName, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmpStyleName, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmpStyleName, 204) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICA, otmpFullName, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICA, otmpFullName, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFullName, 208) |
| } |
| |
| static void test_pack_OUTLINETEXTMETRICW(void) |
| { |
| /* OUTLINETEXTMETRICW */ |
| TEST_TYPE_SIZE (OUTLINETEXTMETRICW, 216) |
| TEST_TYPE_ALIGN (OUTLINETEXTMETRICW, 4) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmSize, 0) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmTextMetrics, 60) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmTextMetrics, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmTextMetrics, 4) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmFiller, 1) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmFiller, 1) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmFiller, 64) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmPanoseNumber, 10) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmPanoseNumber, 1) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmPanoseNumber, 65) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmfsSelection, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmfsSelection, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmfsSelection, 76) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmfsType, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmfsType, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmfsType, 80) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsCharSlopeRise, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsCharSlopeRise, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsCharSlopeRise, 84) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsCharSlopeRun, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsCharSlopeRun, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsCharSlopeRun, 88) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmItalicAngle, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmItalicAngle, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmItalicAngle, 92) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmEMSquare, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmEMSquare, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmEMSquare, 96) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmAscent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmAscent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmAscent, 100) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmDescent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmDescent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmDescent, 104) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmLineGap, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmLineGap, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmLineGap, 108) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsCapEmHeight, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsCapEmHeight, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsCapEmHeight, 112) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsXHeight, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsXHeight, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsXHeight, 116) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmrcFontBox, 16) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmrcFontBox, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmrcFontBox, 120) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmMacAscent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmMacAscent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmMacAscent, 136) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmMacDescent, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmMacDescent, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmMacDescent, 140) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmMacLineGap, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmMacLineGap, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmMacLineGap, 144) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmusMinimumPPEM, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmusMinimumPPEM, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmusMinimumPPEM, 148) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmptSubscriptSize, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmptSubscriptSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmptSubscriptSize, 152) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmptSubscriptOffset, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmptSubscriptOffset, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmptSubscriptOffset, 160) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmptSuperscriptSize, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmptSuperscriptSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmptSuperscriptSize, 168) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmptSuperscriptOffset, 8) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmptSuperscriptOffset, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmptSuperscriptOffset, 176) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsStrikeoutSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsStrikeoutSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsStrikeoutSize, 184) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsStrikeoutPosition, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsStrikeoutPosition, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsStrikeoutPosition, 188) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsUnderscoreSize, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsUnderscoreSize, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsUnderscoreSize, 192) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmsUnderscorePosition, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmsUnderscorePosition, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmsUnderscorePosition, 196) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmpFamilyName, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmpFamilyName, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmpFamilyName, 200) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmpFaceName, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmpFaceName, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmpFaceName, 204) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmpStyleName, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmpStyleName, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmpStyleName, 208) |
| TEST_FIELD_SIZE (OUTLINETEXTMETRICW, otmpFullName, 4) |
| TEST_FIELD_ALIGN (OUTLINETEXTMETRICW, otmpFullName, 4) |
| TEST_FIELD_OFFSET(OUTLINETEXTMETRICW, otmpFullName, 212) |
| } |
| |
| static void test_pack_PABC(void) |
| { |
| /* PABC */ |
| TEST_TYPE_SIZE (PABC, 4) |
| TEST_TYPE_ALIGN (PABC, 4) |
| TEST_TARGET_SIZE (PABC, 12) |
| TEST_TARGET_ALIGN(PABC, 4) |
| } |
| |
| static void test_pack_PABCFLOAT(void) |
| { |
| /* PABCFLOAT */ |
| TEST_TYPE_SIZE (PABCFLOAT, 4) |
| TEST_TYPE_ALIGN (PABCFLOAT, 4) |
| TEST_TARGET_SIZE (PABCFLOAT, 12) |
| TEST_TARGET_ALIGN(PABCFLOAT, 4) |
| } |
| |
| static void test_pack_PANOSE(void) |
| { |
| /* PANOSE */ |
| TEST_TYPE_SIZE (PANOSE, 10) |
| TEST_TYPE_ALIGN (PANOSE, 1) |
| TEST_FIELD_SIZE (PANOSE, bFamilyType, 1) |
| TEST_FIELD_ALIGN (PANOSE, bFamilyType, 1) |
| TEST_FIELD_OFFSET(PANOSE, bFamilyType, 0) |
| TEST_FIELD_SIZE (PANOSE, bSerifStyle, 1) |
| TEST_FIELD_ALIGN (PANOSE, bSerifStyle, 1) |
| TEST_FIELD_OFFSET(PANOSE, bSerifStyle, 1) |
| TEST_FIELD_SIZE (PANOSE, bWeight, 1) |
| TEST_FIELD_ALIGN (PANOSE, bWeight, 1) |
| TEST_FIELD_OFFSET(PANOSE, bWeight, 2) |
| TEST_FIELD_SIZE (PANOSE, bProportion, 1) |
| TEST_FIELD_ALIGN (PANOSE, bProportion, 1) |
| TEST_FIELD_OFFSET(PANOSE, bProportion, 3) |
| TEST_FIELD_SIZE (PANOSE, bContrast, 1) |
| TEST_FIELD_ALIGN (PANOSE, bContrast, 1) |
| TEST_FIELD_OFFSET(PANOSE, bContrast, 4) |
| TEST_FIELD_SIZE (PANOSE, bStrokeVariation, 1) |
| TEST_FIELD_ALIGN (PANOSE, bStrokeVariation, 1) |
| TEST_FIELD_OFFSET(PANOSE, bStrokeVariation, 5) |
| TEST_FIELD_SIZE (PANOSE, bArmStyle, 1) |
| TEST_FIELD_ALIGN (PANOSE, bArmStyle, 1) |
| TEST_FIELD_OFFSET(PANOSE, bArmStyle, 6) |
| TEST_FIELD_SIZE (PANOSE, bLetterform, 1) |
| TEST_FIELD_ALIGN (PANOSE, bLetterform, 1) |
| TEST_FIELD_OFFSET(PANOSE, bLetterform, 7) |
| TEST_FIELD_SIZE (PANOSE, bMidline, 1) |
| TEST_FIELD_ALIGN (PANOSE, bMidline, 1) |
| TEST_FIELD_OFFSET(PANOSE, bMidline, 8) |
| TEST_FIELD_SIZE (PANOSE, bXHeight, 1) |
| TEST_FIELD_ALIGN (PANOSE, bXHeight, 1) |
| TEST_FIELD_OFFSET(PANOSE, bXHeight, 9) |
| } |
| |
| static void test_pack_PATTERN(void) |
| { |
| /* PATTERN */ |
| TEST_TYPE_SIZE (PATTERN, 12) |
| TEST_TYPE_ALIGN (PATTERN, 4) |
| } |
| |
| static void test_pack_PBITMAP(void) |
| { |
| /* PBITMAP */ |
| TEST_TYPE_SIZE (PBITMAP, 4) |
| TEST_TYPE_ALIGN (PBITMAP, 4) |
| TEST_TARGET_SIZE (PBITMAP, 24) |
| TEST_TARGET_ALIGN(PBITMAP, 4) |
| } |
| |
| static void test_pack_PBITMAPCOREHEADER(void) |
| { |
| /* PBITMAPCOREHEADER */ |
| TEST_TYPE_SIZE (PBITMAPCOREHEADER, 4) |
| TEST_TYPE_ALIGN (PBITMAPCOREHEADER, 4) |
| TEST_TARGET_SIZE (PBITMAPCOREHEADER, 12) |
| TEST_TARGET_ALIGN(PBITMAPCOREHEADER, 4) |
| } |
| |
| static void test_pack_PBITMAPCOREINFO(void) |
| { |
| /* PBITMAPCOREINFO */ |
| TEST_TYPE_SIZE (PBITMAPCOREINFO, 4) |
| TEST_TYPE_ALIGN (PBITMAPCOREINFO, 4) |
| TEST_TARGET_SIZE (PBITMAPCOREINFO, 16) |
| TEST_TARGET_ALIGN(PBITMAPCOREINFO, 4) |
| } |
| |
| static void test_pack_PBITMAPFILEHEADER(void) |
| { |
| /* PBITMAPFILEHEADER */ |
| TEST_TYPE_SIZE (PBITMAPFILEHEADER, 4) |
| TEST_TYPE_ALIGN (PBITMAPFILEHEADER, 4) |
| TEST_TARGET_SIZE (PBITMAPFILEHEADER, 14) |
| TEST_TARGET_ALIGN(PBITMAPFILEHEADER, 2) |
| } |
| |
| static void test_pack_PBITMAPINFO(void) |
| { |
| /* PBITMAPINFO */ |
| TEST_TYPE_SIZE (PBITMAPINFO, 4) |
| TEST_TYPE_ALIGN (PBITMAPINFO, 4) |
| TEST_TARGET_SIZE (PBITMAPINFO, 44) |
| TEST_TARGET_ALIGN(PBITMAPINFO, 4) |
| } |
| |
| static void test_pack_PBITMAPINFOHEADER(void) |
| { |
| /* PBITMAPINFOHEADER */ |
| TEST_TYPE_SIZE (PBITMAPINFOHEADER, 4) |
| TEST_TYPE_ALIGN (PBITMAPINFOHEADER, 4) |
| TEST_TARGET_SIZE (PBITMAPINFOHEADER, 40) |
| TEST_TARGET_ALIGN(PBITMAPINFOHEADER, 4) |
| } |
| |
| static void test_pack_PBITMAPV4HEADER(void) |
| { |
| /* PBITMAPV4HEADER */ |
| TEST_TYPE_SIZE (PBITMAPV4HEADER, 4) |
| TEST_TYPE_ALIGN (PBITMAPV4HEADER, 4) |
| TEST_TARGET_SIZE (PBITMAPV4HEADER, 108) |
| TEST_TARGET_ALIGN(PBITMAPV4HEADER, 4) |
| } |
| |
| static void test_pack_PBITMAPV5HEADER(void) |
| { |
| /* PBITMAPV5HEADER */ |
| TEST_TYPE_SIZE (PBITMAPV5HEADER, 4) |
| TEST_TYPE_ALIGN (PBITMAPV5HEADER, 4) |
| TEST_TARGET_SIZE (PBITMAPV5HEADER, 124) |
| TEST_TARGET_ALIGN(PBITMAPV5HEADER, 4) |
| } |
| |
| static void test_pack_PBLENDFUNCTION(void) |
| { |
| /* PBLENDFUNCTION */ |
| TEST_TYPE_SIZE (PBLENDFUNCTION, 4) |
| TEST_TYPE_ALIGN (PBLENDFUNCTION, 4) |
| TEST_TARGET_SIZE (PBLENDFUNCTION, 4) |
| TEST_TARGET_ALIGN(PBLENDFUNCTION, 1) |
| } |
| |
| static void test_pack_PCHARSETINFO(void) |
| { |
| /* PCHARSETINFO */ |
| TEST_TYPE_SIZE (PCHARSETINFO, 4) |
| TEST_TYPE_ALIGN (PCHARSETINFO, 4) |
| TEST_TARGET_SIZE (PCHARSETINFO, 32) |
| TEST_TARGET_ALIGN(PCHARSETINFO, 4) |
| } |
| |
| static void test_pack_PCOLORADJUSTMENT(void) |
| { |
| /* PCOLORADJUSTMENT */ |
| TEST_TYPE_SIZE (PCOLORADJUSTMENT, 4) |
| TEST_TYPE_ALIGN (PCOLORADJUSTMENT, 4) |
| TEST_TARGET_SIZE (PCOLORADJUSTMENT, 24) |
| TEST_TARGET_ALIGN(PCOLORADJUSTMENT, 2) |
| } |
| |
| static void test_pack_PDEVMODEA(void) |
| { |
| /* PDEVMODEA */ |
| TEST_TYPE_SIZE (PDEVMODEA, 4) |
| TEST_TYPE_ALIGN (PDEVMODEA, 4) |
| } |
| |
| static void test_pack_PDEVMODEW(void) |
| { |
| /* PDEVMODEW */ |
| TEST_TYPE_SIZE (PDEVMODEW, 4) |
| TEST_TYPE_ALIGN (PDEVMODEW, 4) |
| } |
| |
| static void test_pack_PDIBSECTION(void) |
| { |
| /* PDIBSECTION */ |
| TEST_TYPE_SIZE (PDIBSECTION, 4) |
| TEST_TYPE_ALIGN (PDIBSECTION, 4) |
| TEST_TARGET_SIZE (PDIBSECTION, 84) |
| TEST_TARGET_ALIGN(PDIBSECTION, 4) |
| } |
| |
| static void test_pack_PDISPLAY_DEVICEA(void) |
| { |
| /* PDISPLAY_DEVICEA */ |
| TEST_TYPE_SIZE (PDISPLAY_DEVICEA, 4) |
| TEST_TYPE_ALIGN (PDISPLAY_DEVICEA, 4) |
| TEST_TARGET_SIZE (PDISPLAY_DEVICEA, 424) |
| TEST_TARGET_ALIGN(PDISPLAY_DEVICEA, 4) |
| } |
| |
| static void test_pack_PDISPLAY_DEVICEW(void) |
| { |
| /* PDISPLAY_DEVICEW */ |
| TEST_TYPE_SIZE (PDISPLAY_DEVICEW, 4) |
| TEST_TYPE_ALIGN (PDISPLAY_DEVICEW, 4) |
| TEST_TARGET_SIZE (PDISPLAY_DEVICEW, 840) |
| TEST_TARGET_ALIGN(PDISPLAY_DEVICEW, 4) |
| } |
| |
| static void test_pack_PELARRAY(void) |
| { |
| /* PELARRAY */ |
| TEST_TYPE_SIZE (PELARRAY, 20) |
| TEST_TYPE_ALIGN (PELARRAY, 4) |
| TEST_FIELD_SIZE (PELARRAY, paXCount, 4) |
| TEST_FIELD_ALIGN (PELARRAY, paXCount, 4) |
| TEST_FIELD_OFFSET(PELARRAY, paXCount, 0) |
| TEST_FIELD_SIZE (PELARRAY, paYCount, 4) |
| TEST_FIELD_ALIGN (PELARRAY, paYCount, 4) |
| TEST_FIELD_OFFSET(PELARRAY, paYCount, 4) |
| TEST_FIELD_SIZE (PELARRAY, paXExt, 4) |
| TEST_FIELD_ALIGN (PELARRAY, paXExt, 4) |
| TEST_FIELD_OFFSET(PELARRAY, paXExt, 8) |
| TEST_FIELD_SIZE (PELARRAY, paYExt, 4) |
| TEST_FIELD_ALIGN (PELARRAY, paYExt, 4) |
| TEST_FIELD_OFFSET(PELARRAY, paYExt, 12) |
| TEST_FIELD_SIZE (PELARRAY, paRGBs, 1) |
| TEST_FIELD_ALIGN (PELARRAY, paRGBs, 1) |
| TEST_FIELD_OFFSET(PELARRAY, paRGBs, 16) |
| } |
| |
| static void test_pack_PEMR(void) |
| { |
| /* PEMR */ |
| TEST_TYPE_SIZE (PEMR, 4) |
| TEST_TYPE_ALIGN (PEMR, 4) |
| TEST_TARGET_SIZE (PEMR, 8) |
| TEST_TARGET_ALIGN(PEMR, 4) |
| } |
| |
| static void test_pack_PEMRABORTPATH(void) |
| { |
| /* PEMRABORTPATH */ |
| TEST_TYPE_SIZE (PEMRABORTPATH, 4) |
| TEST_TYPE_ALIGN (PEMRABORTPATH, 4) |
| TEST_TARGET_SIZE (PEMRABORTPATH, 8) |
| TEST_TARGET_ALIGN(PEMRABORTPATH, 4) |
| } |
| |
| static void test_pack_PEMRANGLEARC(void) |
| { |
| /* PEMRANGLEARC */ |
| TEST_TYPE_SIZE (PEMRANGLEARC, 4) |
| TEST_TYPE_ALIGN (PEMRANGLEARC, 4) |
| TEST_TARGET_SIZE (PEMRANGLEARC, 28) |
| TEST_TARGET_ALIGN(PEMRANGLEARC, 4) |
| } |
| |
| static void test_pack_PEMRARC(void) |
| { |
| /* PEMRARC */ |
| TEST_TYPE_SIZE (PEMRARC, 4) |
| TEST_TYPE_ALIGN (PEMRARC, 4) |
| TEST_TARGET_SIZE (PEMRARC, 40) |
| TEST_TARGET_ALIGN(PEMRARC, 4) |
| } |
| |
| static void test_pack_PEMRARCTO(void) |
| { |
| /* PEMRARCTO */ |
| TEST_TYPE_SIZE (PEMRARCTO, 4) |
| TEST_TYPE_ALIGN (PEMRARCTO, 4) |
| TEST_TARGET_SIZE (PEMRARCTO, 40) |
| TEST_TARGET_ALIGN(PEMRARCTO, 4) |
| } |
| |
| static void test_pack_PEMRBEGINPATH(void) |
| { |
| /* PEMRBEGINPATH */ |
| TEST_TYPE_SIZE (PEMRBEGINPATH, 4) |
| TEST_TYPE_ALIGN (PEMRBEGINPATH, 4) |
| TEST_TARGET_SIZE (PEMRBEGINPATH, 8) |
| TEST_TARGET_ALIGN(PEMRBEGINPATH, 4) |
| } |
| |
| static void test_pack_PEMRBITBLT(void) |
| { |
| /* PEMRBITBLT */ |
| TEST_TYPE_SIZE (PEMRBITBLT, 4) |
| TEST_TYPE_ALIGN (PEMRBITBLT, 4) |
| TEST_TARGET_SIZE (PEMRBITBLT, 100) |
| TEST_TARGET_ALIGN(PEMRBITBLT, 4) |
| } |
| |
| static void test_pack_PEMRCHORD(void) |
| { |
| /* PEMRCHORD */ |
| TEST_TYPE_SIZE (PEMRCHORD, 4) |
| TEST_TYPE_ALIGN (PEMRCHORD, 4) |
| TEST_TARGET_SIZE (PEMRCHORD, 40) |
| TEST_TARGET_ALIGN(PEMRCHORD, 4) |
| } |
| |
| static void test_pack_PEMRCLOSEFIGURE(void) |
| { |
| /* PEMRCLOSEFIGURE */ |
| TEST_TYPE_SIZE (PEMRCLOSEFIGURE, 4) |
| TEST_TYPE_ALIGN (PEMRCLOSEFIGURE, 4) |
| TEST_TARGET_SIZE (PEMRCLOSEFIGURE, 8) |
| TEST_TARGET_ALIGN(PEMRCLOSEFIGURE, 4) |
| } |
| |
| static void test_pack_PEMRCREATEBRUSHINDIRECT(void) |
| { |
| /* PEMRCREATEBRUSHINDIRECT */ |
| TEST_TYPE_SIZE (PEMRCREATEBRUSHINDIRECT, 4) |
| TEST_TYPE_ALIGN (PEMRCREATEBRUSHINDIRECT, 4) |
| TEST_TARGET_SIZE (PEMRCREATEBRUSHINDIRECT, 24) |
| TEST_TARGET_ALIGN(PEMRCREATEBRUSHINDIRECT, 4) |
| } |
| |
| static void test_pack_PEMRCREATECOLORSPACE(void) |
| { |
| /* PEMRCREATECOLORSPACE */ |
| TEST_TYPE_SIZE (PEMRCREATECOLORSPACE, 4) |
| TEST_TYPE_ALIGN (PEMRCREATECOLORSPACE, 4) |
| TEST_TARGET_SIZE (PEMRCREATECOLORSPACE, 340) |
| TEST_TARGET_ALIGN(PEMRCREATECOLORSPACE, 4) |
| } |
| |
| static void test_pack_PEMRCREATECOLORSPACEW(void) |
| { |
| /* PEMRCREATECOLORSPACEW */ |
| TEST_TYPE_SIZE (PEMRCREATECOLORSPACEW, 4) |
| TEST_TYPE_ALIGN (PEMRCREATECOLORSPACEW, 4) |
| TEST_TARGET_SIZE (PEMRCREATECOLORSPACEW, 612) |
| TEST_TARGET_ALIGN(PEMRCREATECOLORSPACEW, 4) |
| } |
| |
| static void test_pack_PEMRCREATEDIBPATTERNBRUSHPT(void) |
| { |
| /* PEMRCREATEDIBPATTERNBRUSHPT */ |
| TEST_TYPE_SIZE (PEMRCREATEDIBPATTERNBRUSHPT, 4) |
| TEST_TYPE_ALIGN (PEMRCREATEDIBPATTERNBRUSHPT, 4) |
| TEST_TARGET_SIZE (PEMRCREATEDIBPATTERNBRUSHPT, 32) |
| TEST_TARGET_ALIGN(PEMRCREATEDIBPATTERNBRUSHPT, 4) |
| } |
| |
| static void test_pack_PEMRCREATEMONOBRUSH(void) |
| { |
| /* PEMRCREATEMONOBRUSH */ |
| TEST_TYPE_SIZE (PEMRCREATEMONOBRUSH, 4) |
| TEST_TYPE_ALIGN (PEMRCREATEMONOBRUSH, 4) |
| TEST_TARGET_SIZE (PEMRCREATEMONOBRUSH, 32) |
| TEST_TARGET_ALIGN(PEMRCREATEMONOBRUSH, 4) |
| } |
| |
| static void test_pack_PEMRCREATEPALETTE(void) |
| { |
| /* PEMRCREATEPALETTE */ |
| TEST_TYPE_SIZE (PEMRCREATEPALETTE, 4) |
| TEST_TYPE_ALIGN (PEMRCREATEPALETTE, 4) |
| TEST_TARGET_SIZE (PEMRCREATEPALETTE, 20) |
| TEST_TARGET_ALIGN(PEMRCREATEPALETTE, 4) |
| } |
| |
| static void test_pack_PEMRCREATEPEN(void) |
| { |
| /* PEMRCREATEPEN */ |
| TEST_TYPE_SIZE (PEMRCREATEPEN, 4) |
| TEST_TYPE_ALIGN (PEMRCREATEPEN, 4) |
| TEST_TARGET_SIZE (PEMRCREATEPEN, 28) |
| TEST_TARGET_ALIGN(PEMRCREATEPEN, 4) |
| } |
| |
| static void test_pack_PEMRDELETECOLORSPACE(void) |
| { |
| /* PEMRDELETECOLORSPACE */ |
| TEST_TYPE_SIZE (PEMRDELETECOLORSPACE, 4) |
| TEST_TYPE_ALIGN (PEMRDELETECOLORSPACE, 4) |
| TEST_TARGET_SIZE (PEMRDELETECOLORSPACE, 12) |
| TEST_TARGET_ALIGN(PEMRDELETECOLORSPACE, 4) |
| } |
| |
| static void test_pack_PEMRDELETEOBJECT(void) |
| { |
| /* PEMRDELETEOBJECT */ |
| TEST_TYPE_SIZE (PEMRDELETEOBJECT, 4) |
| TEST_TYPE_ALIGN (PEMRDELETEOBJECT, 4) |
| TEST_TARGET_SIZE (PEMRDELETEOBJECT, 12) |
| TEST_TARGET_ALIGN(PEMRDELETEOBJECT, 4) |
| } |
| |
| static void test_pack_PEMRELLIPSE(void) |
| { |
| /* PEMRELLIPSE */ |
| TEST_TYPE_SIZE (PEMRELLIPSE, 4) |
| TEST_TYPE_ALIGN (PEMRELLIPSE, 4) |
| TEST_TARGET_SIZE (PEMRELLIPSE, 24) |
| TEST_TARGET_ALIGN(PEMRELLIPSE, 4) |
| } |
| |
| static void test_pack_PEMRENDPATH(void) |
| { |
| /* PEMRENDPATH */ |
| TEST_TYPE_SIZE (PEMRENDPATH, 4) |
| TEST_TYPE_ALIGN (PEMRENDPATH, 4) |
| TEST_TARGET_SIZE (PEMRENDPATH, 8) |
| TEST_TARGET_ALIGN(PEMRENDPATH, 4) |
| } |
| |
| static void test_pack_PEMREOF(void) |
| { |
| /* PEMREOF */ |
| TEST_TYPE_SIZE (PEMREOF, 4) |
| TEST_TYPE_ALIGN (PEMREOF, 4) |
| TEST_TARGET_SIZE (PEMREOF, 20) |
| TEST_TARGET_ALIGN(PEMREOF, 4) |
| } |
| |
| static void test_pack_PEMREXCLUDECLIPRECT(void) |
| { |
| /* PEMREXCLUDECLIPRECT */ |
| TEST_TYPE_SIZE (PEMREXCLUDECLIPRECT, 4) |
| TEST_TYPE_ALIGN (PEMREXCLUDECLIPRECT, 4) |
| TEST_TARGET_SIZE (PEMREXCLUDECLIPRECT, 24) |
| TEST_TARGET_ALIGN(PEMREXCLUDECLIPRECT, 4) |
| } |
| |
| static void test_pack_PEMREXTCREATEFONTINDIRECTW(void) |
| { |
| /* PEMREXTCREATEFONTINDIRECTW */ |
| TEST_TYPE_SIZE (PEMREXTCREATEFONTINDIRECTW, 4) |
| TEST_TYPE_ALIGN (PEMREXTCREATEFONTINDIRECTW, 4) |
| TEST_TARGET_SIZE (PEMREXTCREATEFONTINDIRECTW, 332) |
| TEST_TARGET_ALIGN(PEMREXTCREATEFONTINDIRECTW, 4) |
| } |
| |
| static void test_pack_PEMREXTCREATEPEN(void) |
| { |
| /* PEMREXTCREATEPEN */ |
| TEST_TYPE_SIZE (PEMREXTCREATEPEN, 4) |
| TEST_TYPE_ALIGN (PEMREXTCREATEPEN, 4) |
| TEST_TARGET_SIZE (PEMREXTCREATEPEN, 56) |
| TEST_TARGET_ALIGN(PEMREXTCREATEPEN, 4) |
| } |
| |
| static void test_pack_PEMREXTFLOODFILL(void) |
| { |
| /* PEMREXTFLOODFILL */ |
| TEST_TYPE_SIZE (PEMREXTFLOODFILL, 4) |
| TEST_TYPE_ALIGN (PEMREXTFLOODFILL, 4) |
| TEST_TARGET_SIZE (PEMREXTFLOODFILL, 24) |
| TEST_TARGET_ALIGN(PEMREXTFLOODFILL, 4) |
| } |
| |
| static void test_pack_PEMREXTSELECTCLIPRGN(void) |
| { |
| /* PEMREXTSELECTCLIPRGN */ |
| TEST_TYPE_SIZE (PEMREXTSELECTCLIPRGN, 4) |
| TEST_TYPE_ALIGN (PEMREXTSELECTCLIPRGN, 4) |
| TEST_TARGET_SIZE (PEMREXTSELECTCLIPRGN, 20) |
| TEST_TARGET_ALIGN(PEMREXTSELECTCLIPRGN, 4) |
| } |
| |
| static void test_pack_PEMREXTTEXTOUTA(void) |
| { |
| /* PEMREXTTEXTOUTA */ |
| TEST_TYPE_SIZE (PEMREXTTEXTOUTA, 4) |
| TEST_TYPE_ALIGN (PEMREXTTEXTOUTA, 4) |
| TEST_TARGET_SIZE (PEMREXTTEXTOUTA, 76) |
| TEST_TARGET_ALIGN(PEMREXTTEXTOUTA, 4) |
| } |
| |
| static void test_pack_PEMREXTTEXTOUTW(void) |
| { |
| /* PEMREXTTEXTOUTW */ |
| TEST_TYPE_SIZE (PEMREXTTEXTOUTW, 4) |
| TEST_TYPE_ALIGN (PEMREXTTEXTOUTW, 4) |
| TEST_TARGET_SIZE (PEMREXTTEXTOUTW, 76) |
| TEST_TARGET_ALIGN(PEMREXTTEXTOUTW, 4) |
| } |
| |
| static void test_pack_PEMRFILLPATH(void) |
| { |
| /* PEMRFILLPATH */ |
| TEST_TYPE_SIZE (PEMRFILLPATH, 4) |
| TEST_TYPE_ALIGN (PEMRFILLPATH, 4) |
| TEST_TARGET_SIZE (PEMRFILLPATH, 24) |
| TEST_TARGET_ALIGN(PEMRFILLPATH, 4) |
| } |
| |
| static void test_pack_PEMRFILLRGN(void) |
| { |
| /* PEMRFILLRGN */ |
| TEST_TYPE_SIZE (PEMRFILLRGN, 4) |
| TEST_TYPE_ALIGN (PEMRFILLRGN, 4) |
| TEST_TARGET_SIZE (PEMRFILLRGN, 36) |
| TEST_TARGET_ALIGN(PEMRFILLRGN, 4) |
| } |
| |
| static void test_pack_PEMRFLATTENPATH(void) |
| { |
| /* PEMRFLATTENPATH */ |
| TEST_TYPE_SIZE (PEMRFLATTENPATH, 4) |
| TEST_TYPE_ALIGN (PEMRFLATTENPATH, 4) |
| TEST_TARGET_SIZE (PEMRFLATTENPATH, 8) |
| TEST_TARGET_ALIGN(PEMRFLATTENPATH, 4) |
| } |
| |
| static void test_pack_PEMRFORMAT(void) |
| { |
| /* PEMRFORMAT */ |
| TEST_TYPE_SIZE (PEMRFORMAT, 4) |
| TEST_TYPE_ALIGN (PEMRFORMAT, 4) |
| TEST_TARGET_SIZE (PEMRFORMAT, 16) |
| TEST_TARGET_ALIGN(PEMRFORMAT, 4) |
| } |
| |
| static void test_pack_PEMRFRAMERGN(void) |
| { |
| /* PEMRFRAMERGN */ |
| TEST_TYPE_SIZE (PEMRFRAMERGN, 4) |
| TEST_TYPE_ALIGN (PEMRFRAMERGN, 4) |
| TEST_TARGET_SIZE (PEMRFRAMERGN, 44) |
| TEST_TARGET_ALIGN(PEMRFRAMERGN, 4) |
| } |
| |
| static void test_pack_PEMRGDICOMMENT(void) |
| { |
| /* PEMRGDICOMMENT */ |
| TEST_TYPE_SIZE (PEMRGDICOMMENT, 4) |
| TEST_TYPE_ALIGN (PEMRGDICOMMENT, 4) |
| TEST_TARGET_SIZE (PEMRGDICOMMENT, 16) |
| TEST_TARGET_ALIGN(PEMRGDICOMMENT, 4) |
| } |
| |
| static void test_pack_PEMRGLSBOUNDEDRECORD(void) |
| { |
| /* PEMRGLSBOUNDEDRECORD */ |
| TEST_TYPE_SIZE (PEMRGLSBOUNDEDRECORD, 4) |
| TEST_TYPE_ALIGN (PEMRGLSBOUNDEDRECORD, 4) |
| TEST_TARGET_SIZE (PEMRGLSBOUNDEDRECORD, 32) |
| TEST_TARGET_ALIGN(PEMRGLSBOUNDEDRECORD, 4) |
| } |
| |
| static void test_pack_PEMRGLSRECORD(void) |
| { |
| /* PEMRGLSRECORD */ |
| TEST_TYPE_SIZE (PEMRGLSRECORD, 4) |
| TEST_TYPE_ALIGN (PEMRGLSRECORD, 4) |
| TEST_TARGET_SIZE (PEMRGLSRECORD, 16) |
| TEST_TARGET_ALIGN(PEMRGLSRECORD, 4) |
| } |
| |
| static void test_pack_PEMRINTERSECTCLIPRECT(void) |
| { |
| /* PEMRINTERSECTCLIPRECT */ |
| TEST_TYPE_SIZE (PEMRINTERSECTCLIPRECT, 4) |
| TEST_TYPE_ALIGN (PEMRINTERSECTCLIPRECT, 4) |
| TEST_TARGET_SIZE (PEMRINTERSECTCLIPRECT, 24) |
| TEST_TARGET_ALIGN(PEMRINTERSECTCLIPRECT, 4) |
| } |
| |
| static void test_pack_PEMRINVERTRGN(void) |
| { |
| /* PEMRINVERTRGN */ |
| TEST_TYPE_SIZE (PEMRINVERTRGN, 4) |
| TEST_TYPE_ALIGN (PEMRINVERTRGN, 4) |
| TEST_TARGET_SIZE (PEMRINVERTRGN, 32) |
| TEST_TARGET_ALIGN(PEMRINVERTRGN, 4) |
| } |
| |
| static void test_pack_PEMRLINETO(void) |
| { |
| /* PEMRLINETO */ |
| TEST_TYPE_SIZE (PEMRLINETO, 4) |
| TEST_TYPE_ALIGN (PEMRLINETO, 4) |
| TEST_TARGET_SIZE (PEMRLINETO, 16) |
| TEST_TARGET_ALIGN(PEMRLINETO, 4) |
| } |
| |
| static void test_pack_PEMRMASKBLT(void) |
| { |
| /* PEMRMASKBLT */ |
| TEST_TYPE_SIZE (PEMRMASKBLT, 4) |
| TEST_TYPE_ALIGN (PEMRMASKBLT, 4) |
| TEST_TARGET_SIZE (PEMRMASKBLT, 128) |
| TEST_TARGET_ALIGN(PEMRMASKBLT, 4) |
| } |
| |
| static void test_pack_PEMRMODIFYWORLDTRANSFORM(void) |
| { |
| /* PEMRMODIFYWORLDTRANSFORM */ |
| TEST_TYPE_SIZE (PEMRMODIFYWORLDTRANSFORM, 4) |
| TEST_TYPE_ALIGN (PEMRMODIFYWORLDTRANSFORM, 4) |
| TEST_TARGET_SIZE (PEMRMODIFYWORLDTRANSFORM, 36) |
| TEST_TARGET_ALIGN(PEMRMODIFYWORLDTRANSFORM, 4) |
| } |
| |
| static void test_pack_PEMRMOVETOEX(void) |
| { |
| /* PEMRMOVETOEX */ |
| TEST_TYPE_SIZE (PEMRMOVETOEX, 4) |
| TEST_TYPE_ALIGN (PEMRMOVETOEX, 4) |
| TEST_TARGET_SIZE (PEMRMOVETOEX, 16) |
| TEST_TARGET_ALIGN(PEMRMOVETOEX, 4) |
| } |
| |
| static void test_pack_PEMROFFSETCLIPRGN(void) |
| { |
| /* PEMROFFSETCLIPRGN */ |
| TEST_TYPE_SIZE (PEMROFFSETCLIPRGN, 4) |
| TEST_TYPE_ALIGN (PEMROFFSETCLIPRGN, 4) |
| TEST_TARGET_SIZE (PEMROFFSETCLIPRGN, 16) |
| TEST_TARGET_ALIGN(PEMROFFSETCLIPRGN, 4) |
| } |
| |
| static void test_pack_PEMRPAINTRGN(void) |
| { |
| /* PEMRPAINTRGN */ |
| TEST_TYPE_SIZE (PEMRPAINTRGN, 4) |
| TEST_TYPE_ALIGN (PEMRPAINTRGN, 4) |
| TEST_TARGET_SIZE (PEMRPAINTRGN, 32) |
| TEST_TARGET_ALIGN(PEMRPAINTRGN, 4) |
| } |
| |
| static void test_pack_PEMRPIE(void) |
| { |
| /* PEMRPIE */ |
| TEST_TYPE_SIZE (PEMRPIE, 4) |
| TEST_TYPE_ALIGN (PEMRPIE, 4) |
| TEST_TARGET_SIZE (PEMRPIE, 40) |
| TEST_TARGET_ALIGN(PEMRPIE, 4) |
| } |
| |
| static void test_pack_PEMRPIXELFORMAT(void) |
| { |
| /* PEMRPIXELFORMAT */ |
| TEST_TYPE_SIZE (PEMRPIXELFORMAT, 4) |
| TEST_TYPE_ALIGN (PEMRPIXELFORMAT, 4) |
| TEST_TARGET_SIZE (PEMRPIXELFORMAT, 48) |
| TEST_TARGET_ALIGN(PEMRPIXELFORMAT, 4) |
| } |
| |
| static void test_pack_PEMRPLGBLT(void) |
| { |
| /* PEMRPLGBLT */ |
| TEST_TYPE_SIZE (PEMRPLGBLT, 4) |
| TEST_TYPE_ALIGN (PEMRPLGBLT, 4) |
| TEST_TARGET_SIZE (PEMRPLGBLT, 140) |
| TEST_TARGET_ALIGN(PEMRPLGBLT, 4) |
| } |
| |
| static void test_pack_PEMRPOLYBEZIER(void) |
| { |
| /* PEMRPOLYBEZIER */ |
| TEST_TYPE_SIZE (PEMRPOLYBEZIER, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYBEZIER, 4) |
| TEST_TARGET_SIZE (PEMRPOLYBEZIER, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYBEZIER, 4) |
| } |
| |
| static void test_pack_PEMRPOLYBEZIER16(void) |
| { |
| /* PEMRPOLYBEZIER16 */ |
| TEST_TYPE_SIZE (PEMRPOLYBEZIER16, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYBEZIER16, 4) |
| TEST_TARGET_SIZE (PEMRPOLYBEZIER16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYBEZIER16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYBEZIERTO(void) |
| { |
| /* PEMRPOLYBEZIERTO */ |
| TEST_TYPE_SIZE (PEMRPOLYBEZIERTO, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYBEZIERTO, 4) |
| TEST_TARGET_SIZE (PEMRPOLYBEZIERTO, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYBEZIERTO, 4) |
| } |
| |
| static void test_pack_PEMRPOLYBEZIERTO16(void) |
| { |
| /* PEMRPOLYBEZIERTO16 */ |
| TEST_TYPE_SIZE (PEMRPOLYBEZIERTO16, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYBEZIERTO16, 4) |
| TEST_TARGET_SIZE (PEMRPOLYBEZIERTO16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYBEZIERTO16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYDRAW(void) |
| { |
| /* PEMRPOLYDRAW */ |
| TEST_TYPE_SIZE (PEMRPOLYDRAW, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYDRAW, 4) |
| TEST_TARGET_SIZE (PEMRPOLYDRAW, 40) |
| TEST_TARGET_ALIGN(PEMRPOLYDRAW, 4) |
| } |
| |
| static void test_pack_PEMRPOLYDRAW16(void) |
| { |
| /* PEMRPOLYDRAW16 */ |
| TEST_TYPE_SIZE (PEMRPOLYDRAW16, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYDRAW16, 4) |
| TEST_TARGET_SIZE (PEMRPOLYDRAW16, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYDRAW16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYGON(void) |
| { |
| /* PEMRPOLYGON */ |
| TEST_TYPE_SIZE (PEMRPOLYGON, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYGON, 4) |
| TEST_TARGET_SIZE (PEMRPOLYGON, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYGON, 4) |
| } |
| |
| static void test_pack_PEMRPOLYGON16(void) |
| { |
| /* PEMRPOLYGON16 */ |
| TEST_TYPE_SIZE (PEMRPOLYGON16, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYGON16, 4) |
| TEST_TARGET_SIZE (PEMRPOLYGON16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYGON16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYLINE(void) |
| { |
| /* PEMRPOLYLINE */ |
| TEST_TYPE_SIZE (PEMRPOLYLINE, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYLINE, 4) |
| TEST_TARGET_SIZE (PEMRPOLYLINE, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYLINE, 4) |
| } |
| |
| static void test_pack_PEMRPOLYLINE16(void) |
| { |
| /* PEMRPOLYLINE16 */ |
| TEST_TYPE_SIZE (PEMRPOLYLINE16, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYLINE16, 4) |
| TEST_TARGET_SIZE (PEMRPOLYLINE16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYLINE16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYLINETO(void) |
| { |
| /* PEMRPOLYLINETO */ |
| TEST_TYPE_SIZE (PEMRPOLYLINETO, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYLINETO, 4) |
| TEST_TARGET_SIZE (PEMRPOLYLINETO, 36) |
| TEST_TARGET_ALIGN(PEMRPOLYLINETO, 4) |
| } |
| |
| static void test_pack_PEMRPOLYLINETO16(void) |
| { |
| /* PEMRPOLYLINETO16 */ |
| TEST_TYPE_SIZE (PEMRPOLYLINETO16, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYLINETO16, 4) |
| TEST_TARGET_SIZE (PEMRPOLYLINETO16, 32) |
| TEST_TARGET_ALIGN(PEMRPOLYLINETO16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYPOLYGON(void) |
| { |
| /* PEMRPOLYPOLYGON */ |
| TEST_TYPE_SIZE (PEMRPOLYPOLYGON, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYPOLYGON, 4) |
| TEST_TARGET_SIZE (PEMRPOLYPOLYGON, 44) |
| TEST_TARGET_ALIGN(PEMRPOLYPOLYGON, 4) |
| } |
| |
| static void test_pack_PEMRPOLYPOLYGON16(void) |
| { |
| /* PEMRPOLYPOLYGON16 */ |
| TEST_TYPE_SIZE (PEMRPOLYPOLYGON16, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYPOLYGON16, 4) |
| TEST_TARGET_SIZE (PEMRPOLYPOLYGON16, 40) |
| TEST_TARGET_ALIGN(PEMRPOLYPOLYGON16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYPOLYLINE(void) |
| { |
| /* PEMRPOLYPOLYLINE */ |
| TEST_TYPE_SIZE (PEMRPOLYPOLYLINE, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYPOLYLINE, 4) |
| TEST_TARGET_SIZE (PEMRPOLYPOLYLINE, 44) |
| TEST_TARGET_ALIGN(PEMRPOLYPOLYLINE, 4) |
| } |
| |
| static void test_pack_PEMRPOLYPOLYLINE16(void) |
| { |
| /* PEMRPOLYPOLYLINE16 */ |
| TEST_TYPE_SIZE (PEMRPOLYPOLYLINE16, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYPOLYLINE16, 4) |
| TEST_TARGET_SIZE (PEMRPOLYPOLYLINE16, 40) |
| TEST_TARGET_ALIGN(PEMRPOLYPOLYLINE16, 4) |
| } |
| |
| static void test_pack_PEMRPOLYTEXTOUTA(void) |
| { |
| /* PEMRPOLYTEXTOUTA */ |
| TEST_TYPE_SIZE (PEMRPOLYTEXTOUTA, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYTEXTOUTA, 4) |
| TEST_TARGET_SIZE (PEMRPOLYTEXTOUTA, 80) |
| TEST_TARGET_ALIGN(PEMRPOLYTEXTOUTA, 4) |
| } |
| |
| static void test_pack_PEMRPOLYTEXTOUTW(void) |
| { |
| /* PEMRPOLYTEXTOUTW */ |
| TEST_TYPE_SIZE (PEMRPOLYTEXTOUTW, 4) |
| TEST_TYPE_ALIGN (PEMRPOLYTEXTOUTW, 4) |
| TEST_TARGET_SIZE (PEMRPOLYTEXTOUTW, 80) |
| TEST_TARGET_ALIGN(PEMRPOLYTEXTOUTW, 4) |
| } |
| |
| static void test_pack_PEMRREALIZEPALETTE(void) |
| { |
| /* PEMRREALIZEPALETTE */ |
| TEST_TYPE_SIZE (PEMRREALIZEPALETTE, 4) |
| TEST_TYPE_ALIGN (PEMRREALIZEPALETTE, 4) |
| TEST_TARGET_SIZE (PEMRREALIZEPALETTE, 8) |
| TEST_TARGET_ALIGN(PEMRREALIZEPALETTE, 4) |
| } |
| |
| static void test_pack_PEMRRECTANGLE(void) |
| { |
| /* PEMRRECTANGLE */ |
| TEST_TYPE_SIZE (PEMRRECTANGLE, 4) |
| TEST_TYPE_ALIGN (PEMRRECTANGLE, 4) |
| TEST_TARGET_SIZE (PEMRRECTANGLE, 24) |
| TEST_TARGET_ALIGN(PEMRRECTANGLE, 4) |
| } |
| |
| static void test_pack_PEMRRESIZEPALETTE(void) |
| { |
| /* PEMRRESIZEPALETTE */ |
| TEST_TYPE_SIZE (PEMRRESIZEPALETTE, 4) |
| TEST_TYPE_ALIGN (PEMRRESIZEPALETTE, 4) |
| TEST_TARGET_SIZE (PEMRRESIZEPALETTE, 16) |
| TEST_TARGET_ALIGN(PEMRRESIZEPALETTE, 4) |
| } |
| |
| static void test_pack_PEMRRESTOREDC(void) |
| { |
| /* PEMRRESTOREDC */ |
| TEST_TYPE_SIZE (PEMRRESTOREDC, 4) |
| TEST_TYPE_ALIGN (PEMRRESTOREDC, 4) |
| TEST_TARGET_SIZE (PEMRRESTOREDC, 12) |
| TEST_TARGET_ALIGN(PEMRRESTOREDC, 4) |
| } |
| |
| static void test_pack_PEMRROUNDRECT(void) |
| { |
| /* PEMRROUNDRECT */ |
| TEST_TYPE_SIZE (PEMRROUNDRECT, 4) |
| TEST_TYPE_ALIGN (PEMRROUNDRECT, 4) |
| TEST_TARGET_SIZE (PEMRROUNDRECT, 32) |
| TEST_TARGET_ALIGN(PEMRROUNDRECT, 4) |
| } |
| |
| static void test_pack_PEMRSAVEDC(void) |
| { |
| /* PEMRSAVEDC */ |
| TEST_TYPE_SIZE (PEMRSAVEDC, 4) |
| TEST_TYPE_ALIGN (PEMRSAVEDC, 4) |
| TEST_TARGET_SIZE (PEMRSAVEDC, 8) |
| TEST_TARGET_ALIGN(PEMRSAVEDC, 4) |
| } |
| |
| static void test_pack_PEMRSCALEVIEWPORTEXTEX(void) |
| { |
| /* PEMRSCALEVIEWPORTEXTEX */ |
| TEST_TYPE_SIZE (PEMRSCALEVIEWPORTEXTEX, 4) |
| TEST_TYPE_ALIGN (PEMRSCALEVIEWPORTEXTEX, 4) |
| TEST_TARGET_SIZE (PEMRSCALEVIEWPORTEXTEX, 24) |
| TEST_TARGET_ALIGN(PEMRSCALEVIEWPORTEXTEX, 4) |
| } |
| |
| static void test_pack_PEMRSCALEWINDOWEXTEX(void) |
| { |
| /* PEMRSCALEWINDOWEXTEX */ |
| TEST_TYPE_SIZE (PEMRSCALEWINDOWEXTEX, 4) |
| TEST_TYPE_ALIGN (PEMRSCALEWINDOWEXTEX, 4) |
| TEST_TARGET_SIZE (PEMRSCALEWINDOWEXTEX, 24) |
| TEST_TARGET_ALIGN(PEMRSCALEWINDOWEXTEX, 4) |
| } |
| |
| static void test_pack_PEMRSELECTCLIPPATH(void) |
| { |
| /* PEMRSELECTCLIPPATH */ |
| TEST_TYPE_SIZE (PEMRSELECTCLIPPATH, 4) |
| TEST_TYPE_ALIGN (PEMRSELECTCLIPPATH, 4) |
| TEST_TARGET_SIZE (PEMRSELECTCLIPPATH, 12) |
| TEST_TARGET_ALIGN(PEMRSELECTCLIPPATH, 4) |
| } |
| |
| static void test_pack_PEMRSELECTCOLORSPACE(void) |
| { |
| /* PEMRSELECTCOLORSPACE */ |
| TEST_TYPE_SIZE (PEMRSELECTCOLORSPACE, 4) |
| TEST_TYPE_ALIGN (PEMRSELECTCOLORSPACE, 4) |
| TEST_TARGET_SIZE (PEMRSELECTCOLORSPACE, 12) |
| TEST_TARGET_ALIGN(PEMRSELECTCOLORSPACE, 4) |
| } |
| |
| static void test_pack_PEMRSELECTOBJECT(void) |
| { |
| /* PEMRSELECTOBJECT */ |
| TEST_TYPE_SIZE (PEMRSELECTOBJECT, 4) |
| TEST_TYPE_ALIGN (PEMRSELECTOBJECT, 4) |
| TEST_TARGET_SIZE (PEMRSELECTOBJECT, 12) |
| TEST_TARGET_ALIGN(PEMRSELECTOBJECT, 4) |
| } |
| |
| static void test_pack_PEMRSELECTPALETTE(void) |
| { |
| /* PEMRSELECTPALETTE */ |
| TEST_TYPE_SIZE (PEMRSELECTPALETTE, 4) |
| TEST_TYPE_ALIGN (PEMRSELECTPALETTE, 4) |
| TEST_TARGET_SIZE (PEMRSELECTPALETTE, 12) |
| TEST_TARGET_ALIGN(PEMRSELECTPALETTE, 4) |
| } |
| |
| static void test_pack_PEMRSETARCDIRECTION(void) |
| { |
| /* PEMRSETARCDIRECTION */ |
| TEST_TYPE_SIZE (PEMRSETARCDIRECTION, 4) |
| TEST_TYPE_ALIGN (PEMRSETARCDIRECTION, 4) |
| TEST_TARGET_SIZE (PEMRSETARCDIRECTION, 12) |
| TEST_TARGET_ALIGN(PEMRSETARCDIRECTION, 4) |
| } |
| |
| static void test_pack_PEMRSETBKCOLOR(void) |
| { |
| /* PEMRSETBKCOLOR */ |
| TEST_TYPE_SIZE (PEMRSETBKCOLOR, 4) |
| TEST_TYPE_ALIGN (PEMRSETBKCOLOR, 4) |
| TEST_TARGET_SIZE (PEMRSETBKCOLOR, 12) |
| TEST_TARGET_ALIGN(PEMRSETBKCOLOR, 4) |
| } |
| |
| static void test_pack_PEMRSETBKMODE(void) |
| { |
| /* PEMRSETBKMODE */ |
| TEST_TYPE_SIZE (PEMRSETBKMODE, 4) |
| TEST_TYPE_ALIGN (PEMRSETBKMODE, 4) |
| TEST_TARGET_SIZE (PEMRSETBKMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETBKMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETBRUSHORGEX(void) |
| { |
| /* PEMRSETBRUSHORGEX */ |
| TEST_TYPE_SIZE (PEMRSETBRUSHORGEX, 4) |
| TEST_TYPE_ALIGN (PEMRSETBRUSHORGEX, 4) |
| TEST_TARGET_SIZE (PEMRSETBRUSHORGEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETBRUSHORGEX, 4) |
| } |
| |
| static void test_pack_PEMRSETCOLORADJUSTMENT(void) |
| { |
| /* PEMRSETCOLORADJUSTMENT */ |
| TEST_TYPE_SIZE (PEMRSETCOLORADJUSTMENT, 4) |
| TEST_TYPE_ALIGN (PEMRSETCOLORADJUSTMENT, 4) |
| TEST_TARGET_SIZE (PEMRSETCOLORADJUSTMENT, 32) |
| TEST_TARGET_ALIGN(PEMRSETCOLORADJUSTMENT, 4) |
| } |
| |
| static void test_pack_PEMRSETCOLORSPACE(void) |
| { |
| /* PEMRSETCOLORSPACE */ |
| TEST_TYPE_SIZE (PEMRSETCOLORSPACE, 4) |
| TEST_TYPE_ALIGN (PEMRSETCOLORSPACE, 4) |
| TEST_TARGET_SIZE (PEMRSETCOLORSPACE, 12) |
| TEST_TARGET_ALIGN(PEMRSETCOLORSPACE, 4) |
| } |
| |
| static void test_pack_PEMRSETDIBITSTODEVICE(void) |
| { |
| /* PEMRSETDIBITSTODEVICE */ |
| TEST_TYPE_SIZE (PEMRSETDIBITSTODEVICE, 4) |
| TEST_TYPE_ALIGN (PEMRSETDIBITSTODEVICE, 4) |
| TEST_TARGET_SIZE (PEMRSETDIBITSTODEVICE, 76) |
| TEST_TARGET_ALIGN(PEMRSETDIBITSTODEVICE, 4) |
| } |
| |
| static void test_pack_PEMRSETICMMODE(void) |
| { |
| /* PEMRSETICMMODE */ |
| TEST_TYPE_SIZE (PEMRSETICMMODE, 4) |
| TEST_TYPE_ALIGN (PEMRSETICMMODE, 4) |
| TEST_TARGET_SIZE (PEMRSETICMMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETICMMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETLAYOUT(void) |
| { |
| /* PEMRSETLAYOUT */ |
| TEST_TYPE_SIZE (PEMRSETLAYOUT, 4) |
| TEST_TYPE_ALIGN (PEMRSETLAYOUT, 4) |
| TEST_TARGET_SIZE (PEMRSETLAYOUT, 12) |
| TEST_TARGET_ALIGN(PEMRSETLAYOUT, 4) |
| } |
| |
| static void test_pack_PEMRSETMAPMODE(void) |
| { |
| /* PEMRSETMAPMODE */ |
| TEST_TYPE_SIZE (PEMRSETMAPMODE, 4) |
| TEST_TYPE_ALIGN (PEMRSETMAPMODE, 4) |
| TEST_TARGET_SIZE (PEMRSETMAPMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETMAPMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETMAPPERFLAGS(void) |
| { |
| /* PEMRSETMAPPERFLAGS */ |
| TEST_TYPE_SIZE (PEMRSETMAPPERFLAGS, 4) |
| TEST_TYPE_ALIGN (PEMRSETMAPPERFLAGS, 4) |
| TEST_TARGET_SIZE (PEMRSETMAPPERFLAGS, 12) |
| TEST_TARGET_ALIGN(PEMRSETMAPPERFLAGS, 4) |
| } |
| |
| static void test_pack_PEMRSETMETARGN(void) |
| { |
| /* PEMRSETMETARGN */ |
| TEST_TYPE_SIZE (PEMRSETMETARGN, 4) |
| TEST_TYPE_ALIGN (PEMRSETMETARGN, 4) |
| TEST_TARGET_SIZE (PEMRSETMETARGN, 8) |
| TEST_TARGET_ALIGN(PEMRSETMETARGN, 4) |
| } |
| |
| static void test_pack_PEMRSETMITERLIMIT(void) |
| { |
| /* PEMRSETMITERLIMIT */ |
| TEST_TYPE_SIZE (PEMRSETMITERLIMIT, 4) |
| TEST_TYPE_ALIGN (PEMRSETMITERLIMIT, 4) |
| TEST_TARGET_SIZE (PEMRSETMITERLIMIT, 12) |
| TEST_TARGET_ALIGN(PEMRSETMITERLIMIT, 4) |
| } |
| |
| static void test_pack_PEMRSETPALETTEENTRIES(void) |
| { |
| /* PEMRSETPALETTEENTRIES */ |
| TEST_TYPE_SIZE (PEMRSETPALETTEENTRIES, 4) |
| TEST_TYPE_ALIGN (PEMRSETPALETTEENTRIES, 4) |
| TEST_TARGET_SIZE (PEMRSETPALETTEENTRIES, 24) |
| TEST_TARGET_ALIGN(PEMRSETPALETTEENTRIES, 4) |
| } |
| |
| static void test_pack_PEMRSETPIXELV(void) |
| { |
| /* PEMRSETPIXELV */ |
| TEST_TYPE_SIZE (PEMRSETPIXELV, 4) |
| TEST_TYPE_ALIGN (PEMRSETPIXELV, 4) |
| TEST_TARGET_SIZE (PEMRSETPIXELV, 20) |
| TEST_TARGET_ALIGN(PEMRSETPIXELV, 4) |
| } |
| |
| static void test_pack_PEMRSETPOLYFILLMODE(void) |
| { |
| /* PEMRSETPOLYFILLMODE */ |
| TEST_TYPE_SIZE (PEMRSETPOLYFILLMODE, 4) |
| TEST_TYPE_ALIGN (PEMRSETPOLYFILLMODE, 4) |
| TEST_TARGET_SIZE (PEMRSETPOLYFILLMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETPOLYFILLMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETROP2(void) |
| { |
| /* PEMRSETROP2 */ |
| TEST_TYPE_SIZE (PEMRSETROP2, 4) |
| TEST_TYPE_ALIGN (PEMRSETROP2, 4) |
| TEST_TARGET_SIZE (PEMRSETROP2, 12) |
| TEST_TARGET_ALIGN(PEMRSETROP2, 4) |
| } |
| |
| static void test_pack_PEMRSETSTRETCHBLTMODE(void) |
| { |
| /* PEMRSETSTRETCHBLTMODE */ |
| TEST_TYPE_SIZE (PEMRSETSTRETCHBLTMODE, 4) |
| TEST_TYPE_ALIGN (PEMRSETSTRETCHBLTMODE, 4) |
| TEST_TARGET_SIZE (PEMRSETSTRETCHBLTMODE, 12) |
| TEST_TARGET_ALIGN(PEMRSETSTRETCHBLTMODE, 4) |
| } |
| |
| static void test_pack_PEMRSETTEXTALIGN(void) |
| { |
| /* PEMRSETTEXTALIGN */ |
| TEST_TYPE_SIZE (PEMRSETTEXTALIGN, 4) |
| TEST_TYPE_ALIGN (PEMRSETTEXTALIGN, 4) |
| TEST_TARGET_SIZE (PEMRSETTEXTALIGN, 12) |
| TEST_TARGET_ALIGN(PEMRSETTEXTALIGN, 4) |
| } |
| |
| static void test_pack_PEMRSETTEXTCOLOR(void) |
| { |
| /* PEMRSETTEXTCOLOR */ |
| TEST_TYPE_SIZE (PEMRSETTEXTCOLOR, 4) |
| TEST_TYPE_ALIGN (PEMRSETTEXTCOLOR, 4) |
| TEST_TARGET_SIZE (PEMRSETTEXTCOLOR, 12) |
| TEST_TARGET_ALIGN(PEMRSETTEXTCOLOR, 4) |
| } |
| |
| static void test_pack_PEMRSETVIEWPORTEXTEX(void) |
| { |
| /* PEMRSETVIEWPORTEXTEX */ |
| TEST_TYPE_SIZE (PEMRSETVIEWPORTEXTEX, 4) |
| TEST_TYPE_ALIGN (PEMRSETVIEWPORTEXTEX, 4) |
| TEST_TARGET_SIZE (PEMRSETVIEWPORTEXTEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETVIEWPORTEXTEX, 4) |
| } |
| |
| static void test_pack_PEMRSETVIEWPORTORGEX(void) |
| { |
| /* PEMRSETVIEWPORTORGEX */ |
| TEST_TYPE_SIZE (PEMRSETVIEWPORTORGEX, 4) |
| TEST_TYPE_ALIGN (PEMRSETVIEWPORTORGEX, 4) |
| TEST_TARGET_SIZE (PEMRSETVIEWPORTORGEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETVIEWPORTORGEX, 4) |
| } |
| |
| static void test_pack_PEMRSETWINDOWEXTEX(void) |
| { |
| /* PEMRSETWINDOWEXTEX */ |
| TEST_TYPE_SIZE (PEMRSETWINDOWEXTEX, 4) |
| TEST_TYPE_ALIGN (PEMRSETWINDOWEXTEX, 4) |
| TEST_TARGET_SIZE (PEMRSETWINDOWEXTEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETWINDOWEXTEX, 4) |
| } |
| |
| static void test_pack_PEMRSETWINDOWORGEX(void) |
| { |
| /* PEMRSETWINDOWORGEX */ |
| TEST_TYPE_SIZE (PEMRSETWINDOWORGEX, 4) |
| TEST_TYPE_ALIGN (PEMRSETWINDOWORGEX, 4) |
| TEST_TARGET_SIZE (PEMRSETWINDOWORGEX, 16) |
| TEST_TARGET_ALIGN(PEMRSETWINDOWORGEX, 4) |
| } |
| |
| static void test_pack_PEMRSETWORLDTRANSFORM(void) |
| { |
| /* PEMRSETWORLDTRANSFORM */ |
| TEST_TYPE_SIZE (PEMRSETWORLDTRANSFORM, 4) |
| TEST_TYPE_ALIGN (PEMRSETWORLDTRANSFORM, 4) |
| TEST_TARGET_SIZE (PEMRSETWORLDTRANSFORM, 32) |
| TEST_TARGET_ALIGN(PEMRSETWORLDTRANSFORM, 4) |
| } |
| |
| static void test_pack_PEMRSTRETCHBLT(void) |
| { |
| /* PEMRSTRETCHBLT */ |
| TEST_TYPE_SIZE (PEMRSTRETCHBLT, 4) |
| TEST_TYPE_ALIGN (PEMRSTRETCHBLT, 4) |
| TEST_TARGET_SIZE (PEMRSTRETCHBLT, 108) |
| TEST_TARGET_ALIGN(PEMRSTRETCHBLT, 4) |
| } |
| |
| static void test_pack_PEMRSTRETCHDIBITS(void) |
| { |
| /* PEMRSTRETCHDIBITS */ |
| TEST_TYPE_SIZE (PEMRSTRETCHDIBITS, 4) |
| TEST_TYPE_ALIGN (PEMRSTRETCHDIBITS, 4) |
| TEST_TARGET_SIZE (PEMRSTRETCHDIBITS, 80) |
| TEST_TARGET_ALIGN(PEMRSTRETCHDIBITS, 4) |
| } |
| |
| static void test_pack_PEMRSTROKEANDFILLPATH(void) |
| { |
| /* PEMRSTROKEANDFILLPATH */ |
| TEST_TYPE_SIZE (PEMRSTROKEANDFILLPATH, 4) |
| TEST_TYPE_ALIGN (PEMRSTROKEANDFILLPATH, 4) |
| TEST_TARGET_SIZE (PEMRSTROKEANDFILLPATH, 24) |
| TEST_TARGET_ALIGN(PEMRSTROKEANDFILLPATH, 4) |
| } |
| |
| static void test_pack_PEMRSTROKEPATH(void) |
| { |
| /* PEMRSTROKEPATH */ |
| TEST_TYPE_SIZE (PEMRSTROKEPATH, 4) |
| TEST_TYPE_ALIGN (PEMRSTROKEPATH, 4) |
| TEST_TARGET_SIZE (PEMRSTROKEPATH, 24) |
| TEST_TARGET_ALIGN(PEMRSTROKEPATH, 4) |
| } |
| |
| static void test_pack_PEMRTEXT(void) |
| { |
| /* PEMRTEXT */ |
| TEST_TYPE_SIZE (PEMRTEXT, 4) |
| TEST_TYPE_ALIGN (PEMRTEXT, 4) |
| TEST_TARGET_SIZE (PEMRTEXT, 40) |
| TEST_TARGET_ALIGN(PEMRTEXT, 4) |
| } |
| |
| static void test_pack_PEMRWIDENPATH(void) |
| { |
| /* PEMRWIDENPATH */ |
| TEST_TYPE_SIZE (PEMRWIDENPATH, 4) |
| TEST_TYPE_ALIGN (PEMRWIDENPATH, 4) |
| TEST_TARGET_SIZE (PEMRWIDENPATH, 8) |
| TEST_TARGET_ALIGN(PEMRWIDENPATH, 4) |
| } |
| |
| static void test_pack_PENHMETAHEADER(void) |
| { |
| /* PENHMETAHEADER */ |
| TEST_TYPE_SIZE (PENHMETAHEADER, 4) |
| TEST_TYPE_ALIGN (PENHMETAHEADER, 4) |
| TEST_TARGET_SIZE (PENHMETAHEADER, 108) |
| TEST_TARGET_ALIGN(PENHMETAHEADER, 4) |
| } |
| |
| static void test_pack_PEXTLOGFONTA(void) |
| { |
| /* PEXTLOGFONTA */ |
| TEST_TYPE_SIZE (PEXTLOGFONTA, 4) |
| TEST_TYPE_ALIGN (PEXTLOGFONTA, 4) |
| TEST_TARGET_SIZE (PEXTLOGFONTA, 192) |
| TEST_TARGET_ALIGN(PEXTLOGFONTA, 4) |
| } |
| |
| static void test_pack_PEXTLOGFONTW(void) |
| { |
| /* PEXTLOGFONTW */ |
| TEST_TYPE_SIZE (PEXTLOGFONTW, 4) |
| TEST_TYPE_ALIGN (PEXTLOGFONTW, 4) |
| TEST_TARGET_SIZE (PEXTLOGFONTW, 320) |
| TEST_TARGET_ALIGN(PEXTLOGFONTW, 4) |
| } |
| |
| static void test_pack_PEXTLOGPEN(void) |
| { |
| /* PEXTLOGPEN */ |
| TEST_TYPE_SIZE (PEXTLOGPEN, 4) |
| TEST_TYPE_ALIGN (PEXTLOGPEN, 4) |
| TEST_TARGET_SIZE (PEXTLOGPEN, 28) |
| TEST_TARGET_ALIGN(PEXTLOGPEN, 4) |
| } |
| |
| static void test_pack_PFONTSIGNATURE(void) |
| { |
| /* PFONTSIGNATURE */ |
| TEST_TYPE_SIZE (PFONTSIGNATURE, 4) |
| TEST_TYPE_ALIGN (PFONTSIGNATURE, 4) |
| TEST_TARGET_SIZE (PFONTSIGNATURE, 24) |
| TEST_TARGET_ALIGN(PFONTSIGNATURE, 4) |
| } |
| |
| static void test_pack_PGLYPHMETRICSFLOAT(void) |
| { |
| /* PGLYPHMETRICSFLOAT */ |
| TEST_TYPE_SIZE (PGLYPHMETRICSFLOAT, 4) |
| TEST_TYPE_ALIGN (PGLYPHMETRICSFLOAT, 4) |
| TEST_TARGET_SIZE (PGLYPHMETRICSFLOAT, 24) |
| TEST_TARGET_ALIGN(PGLYPHMETRICSFLOAT, 4) |
| } |
| |
| static void test_pack_PGRADIENT_RECT(void) |
| { |
| /* PGRADIENT_RECT */ |
| TEST_TYPE_SIZE (PGRADIENT_RECT, 4) |
| TEST_TYPE_ALIGN (PGRADIENT_RECT, 4) |
| TEST_TARGET_SIZE (PGRADIENT_RECT, 8) |
| TEST_TARGET_ALIGN(PGRADIENT_RECT, 4) |
| } |
| |
| static void test_pack_PGRADIENT_TRIANGLE(void) |
| { |
| /* PGRADIENT_TRIANGLE */ |
| TEST_TYPE_SIZE (PGRADIENT_TRIANGLE, 4) |
| TEST_TYPE_ALIGN (PGRADIENT_TRIANGLE, 4) |
| TEST_TARGET_SIZE (PGRADIENT_TRIANGLE, 12) |
| TEST_TARGET_ALIGN(PGRADIENT_TRIANGLE, 4) |
| } |
| |
| static void test_pack_PHANDLETABLE(void) |
| { |
| /* PHANDLETABLE */ |
| TEST_TYPE_SIZE (PHANDLETABLE, 4) |
| TEST_TYPE_ALIGN (PHANDLETABLE, 4) |
| TEST_TARGET_SIZE (PHANDLETABLE, 4) |
| TEST_TARGET_ALIGN(PHANDLETABLE, 4) |
| } |
| |
| static void test_pack_PIXELFORMATDESCRIPTOR(void) |
| { |
| /* PIXELFORMATDESCRIPTOR */ |
| TEST_TYPE_SIZE (PIXELFORMATDESCRIPTOR, 40) |
| TEST_TYPE_ALIGN (PIXELFORMATDESCRIPTOR, 4) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, nSize, 2) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, nSize, 2) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, nSize, 0) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, nVersion, 2) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, dwFlags, 4) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, iPixelType, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, iPixelType, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, iPixelType, 8) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cColorBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cColorBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cColorBits, 9) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cRedBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cRedBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cRedBits, 10) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cRedShift, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cRedShift, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cRedShift, 11) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cGreenBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cGreenBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cGreenBits, 12) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cGreenShift, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cGreenShift, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cGreenShift, 13) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cBlueBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cBlueBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cBlueBits, 14) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cBlueShift, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cBlueShift, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cBlueShift, 15) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAlphaBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAlphaBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAlphaBits, 16) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAlphaShift, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAlphaShift, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAlphaShift, 17) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumBits, 18) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumRedBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumRedBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumRedBits, 19) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumGreenBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumGreenBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumGreenBits, 20) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumBlueBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumBlueBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumBlueBits, 21) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAccumAlphaBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAccumAlphaBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAccumAlphaBits, 22) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cDepthBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cDepthBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cDepthBits, 23) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cStencilBits, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cStencilBits, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cStencilBits, 24) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, cAuxBuffers, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, cAuxBuffers, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, cAuxBuffers, 25) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, iLayerType, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, iLayerType, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, iLayerType, 26) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, bReserved, 1) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, bReserved, 1) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, bReserved, 27) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, dwLayerMask, 4) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, dwLayerMask, 4) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, dwLayerMask, 28) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, dwVisibleMask, 4) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, dwVisibleMask, 4) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, dwVisibleMask, 32) |
| TEST_FIELD_SIZE (PIXELFORMATDESCRIPTOR, dwDamageMask, 4) |
| TEST_FIELD_ALIGN (PIXELFORMATDESCRIPTOR, dwDamageMask, 4) |
| TEST_FIELD_OFFSET(PIXELFORMATDESCRIPTOR, dwDamageMask, 36) |
| } |
| |
| static void test_pack_PLAYERPLANEDESCRIPTOR(void) |
| { |
| /* PLAYERPLANEDESCRIPTOR */ |
| TEST_TYPE_SIZE (PLAYERPLANEDESCRIPTOR, 4) |
| TEST_TYPE_ALIGN (PLAYERPLANEDESCRIPTOR, 4) |
| TEST_TARGET_SIZE (PLAYERPLANEDESCRIPTOR, 32) |
| TEST_TARGET_ALIGN(PLAYERPLANEDESCRIPTOR, 4) |
| } |
| |
| static void test_pack_PLOCALESIGNATURE(void) |
| { |
| /* PLOCALESIGNATURE */ |
| TEST_TYPE_SIZE (PLOCALESIGNATURE, 4) |
| TEST_TYPE_ALIGN (PLOCALESIGNATURE, 4) |
| TEST_TARGET_SIZE (PLOCALESIGNATURE, 32) |
| TEST_TARGET_ALIGN(PLOCALESIGNATURE, 4) |
| } |
| |
| static void test_pack_PLOGBRUSH(void) |
| { |
| /* PLOGBRUSH */ |
| TEST_TYPE_SIZE (PLOGBRUSH, 4) |
| TEST_TYPE_ALIGN (PLOGBRUSH, 4) |
| TEST_TARGET_SIZE (PLOGBRUSH, 12) |
| TEST_TARGET_ALIGN(PLOGBRUSH, 4) |
| } |
| |
| static void test_pack_PLOGFONTA(void) |
| { |
| /* PLOGFONTA */ |
| TEST_TYPE_SIZE (PLOGFONTA, 4) |
| TEST_TYPE_ALIGN (PLOGFONTA, 4) |
| TEST_TARGET_SIZE (PLOGFONTA, 60) |
| TEST_TARGET_ALIGN(PLOGFONTA, 4) |
| } |
| |
| static void test_pack_PLOGFONTW(void) |
| { |
| /* PLOGFONTW */ |
| TEST_TYPE_SIZE (PLOGFONTW, 4) |
| TEST_TYPE_ALIGN (PLOGFONTW, 4) |
| TEST_TARGET_SIZE (PLOGFONTW, 92) |
| TEST_TARGET_ALIGN(PLOGFONTW, 4) |
| } |
| |
| static void test_pack_PMETAHEADER(void) |
| { |
| /* PMETAHEADER */ |
| TEST_TYPE_SIZE (PMETAHEADER, 4) |
| TEST_TYPE_ALIGN (PMETAHEADER, 4) |
| TEST_TARGET_SIZE (PMETAHEADER, 18) |
| TEST_TARGET_ALIGN(PMETAHEADER, 2) |
| } |
| |
| static void test_pack_PMETARECORD(void) |
| { |
| /* PMETARECORD */ |
| TEST_TYPE_SIZE (PMETARECORD, 4) |
| TEST_TYPE_ALIGN (PMETARECORD, 4) |
| TEST_TARGET_SIZE (PMETARECORD, 8) |
| TEST_TARGET_ALIGN(PMETARECORD, 4) |
| } |
| |
| static void test_pack_PNEWTEXTMETRICA(void) |
| { |
| /* PNEWTEXTMETRICA */ |
| TEST_TYPE_SIZE (PNEWTEXTMETRICA, 4) |
| TEST_TYPE_ALIGN (PNEWTEXTMETRICA, 4) |
| TEST_TARGET_SIZE (PNEWTEXTMETRICA, 72) |
| TEST_TARGET_ALIGN(PNEWTEXTMETRICA, 4) |
| } |
| |
| static void test_pack_PNEWTEXTMETRICW(void) |
| { |
| /* PNEWTEXTMETRICW */ |
| TEST_TYPE_SIZE (PNEWTEXTMETRICW, 4) |
| TEST_TYPE_ALIGN (PNEWTEXTMETRICW, 4) |
| TEST_TARGET_SIZE (PNEWTEXTMETRICW, 76) |
| TEST_TARGET_ALIGN(PNEWTEXTMETRICW, 4) |
| } |
| |
| static void test_pack_POINTFLOAT(void) |
| { |
| /* POINTFLOAT */ |
| TEST_TYPE_SIZE (POINTFLOAT, 8) |
| TEST_TYPE_ALIGN (POINTFLOAT, 4) |
| TEST_FIELD_SIZE (POINTFLOAT, x, 4) |
| TEST_FIELD_ALIGN (POINTFLOAT, x, 4) |
| TEST_FIELD_OFFSET(POINTFLOAT, x, 0) |
| TEST_FIELD_SIZE (POINTFLOAT, y, 4) |
| TEST_FIELD_ALIGN (POINTFLOAT, y, 4) |
| TEST_FIELD_OFFSET(POINTFLOAT, y, 4) |
| } |
| |
| static void test_pack_POINTFX(void) |
| { |
| /* POINTFX */ |
| TEST_TYPE_SIZE (POINTFX, 8) |
| TEST_TYPE_ALIGN (POINTFX, 2) |
| TEST_FIELD_SIZE (POINTFX, x, 4) |
| TEST_FIELD_ALIGN (POINTFX, x, 2) |
| TEST_FIELD_OFFSET(POINTFX, x, 0) |
| TEST_FIELD_SIZE (POINTFX, y, 4) |
| TEST_FIELD_ALIGN (POINTFX, y, 2) |
| TEST_FIELD_OFFSET(POINTFX, y, 4) |
| } |
| |
| static void test_pack_POLYTEXTA(void) |
| { |
| /* POLYTEXTA */ |
| TEST_TYPE_SIZE (POLYTEXTA, 40) |
| TEST_TYPE_ALIGN (POLYTEXTA, 4) |
| TEST_FIELD_SIZE (POLYTEXTA, x, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, x, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, x, 0) |
| TEST_FIELD_SIZE (POLYTEXTA, y, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, y, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, y, 4) |
| TEST_FIELD_SIZE (POLYTEXTA, n, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, n, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, n, 8) |
| TEST_FIELD_SIZE (POLYTEXTA, lpstr, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, lpstr, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, lpstr, 12) |
| TEST_FIELD_SIZE (POLYTEXTA, uiFlags, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, uiFlags, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, uiFlags, 16) |
| TEST_FIELD_SIZE (POLYTEXTA, rcl, 16) |
| TEST_FIELD_ALIGN (POLYTEXTA, rcl, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, rcl, 20) |
| TEST_FIELD_SIZE (POLYTEXTA, pdx, 4) |
| TEST_FIELD_ALIGN (POLYTEXTA, pdx, 4) |
| TEST_FIELD_OFFSET(POLYTEXTA, pdx, 36) |
| } |
| |
| static void test_pack_POLYTEXTW(void) |
| { |
| /* POLYTEXTW */ |
| TEST_TYPE_SIZE (POLYTEXTW, 40) |
| TEST_TYPE_ALIGN (POLYTEXTW, 4) |
| TEST_FIELD_SIZE (POLYTEXTW, x, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, x, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, x, 0) |
| TEST_FIELD_SIZE (POLYTEXTW, y, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, y, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, y, 4) |
| TEST_FIELD_SIZE (POLYTEXTW, n, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, n, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, n, 8) |
| TEST_FIELD_SIZE (POLYTEXTW, lpstr, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, lpstr, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, lpstr, 12) |
| TEST_FIELD_SIZE (POLYTEXTW, uiFlags, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, uiFlags, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, uiFlags, 16) |
| TEST_FIELD_SIZE (POLYTEXTW, rcl, 16) |
| TEST_FIELD_ALIGN (POLYTEXTW, rcl, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, rcl, 20) |
| TEST_FIELD_SIZE (POLYTEXTW, pdx, 4) |
| TEST_FIELD_ALIGN (POLYTEXTW, pdx, 4) |
| TEST_FIELD_OFFSET(POLYTEXTW, pdx, 36) |
| } |
| |
| static void test_pack_POUTLINETEXTMETRICA(void) |
| { |
| /* POUTLINETEXTMETRICA */ |
| TEST_TYPE_SIZE (POUTLINETEXTMETRICA, 4) |
| TEST_TYPE_ALIGN (POUTLINETEXTMETRICA, 4) |
| TEST_TARGET_SIZE (POUTLINETEXTMETRICA, 212) |
| TEST_TARGET_ALIGN(POUTLINETEXTMETRICA, 4) |
| } |
| |
| static void test_pack_POUTLINETEXTMETRICW(void) |
| { |
| /* POUTLINETEXTMETRICW */ |
| TEST_TYPE_SIZE (POUTLINETEXTMETRICW, 4) |
| TEST_TYPE_ALIGN (POUTLINETEXTMETRICW, 4) |
| TEST_TARGET_SIZE (POUTLINETEXTMETRICW, 216) |
| TEST_TARGET_ALIGN(POUTLINETEXTMETRICW, 4) |
| } |
| |
| static void test_pack_PPELARRAY(void) |
| { |
| /* PPELARRAY */ |
| TEST_TYPE_SIZE (PPELARRAY, 4) |
| TEST_TYPE_ALIGN (PPELARRAY, 4) |
| TEST_TARGET_SIZE (PPELARRAY, 20) |
| TEST_TARGET_ALIGN(PPELARRAY, 4) |
| } |
| |
| static void test_pack_PPIXELFORMATDESCRIPTOR(void) |
| { |
| /* PPIXELFORMATDESCRIPTOR */ |
| TEST_TYPE_SIZE (PPIXELFORMATDESCRIPTOR, 4) |
| TEST_TYPE_ALIGN (PPIXELFORMATDESCRIPTOR, 4) |
| TEST_TARGET_SIZE (PPIXELFORMATDESCRIPTOR, 40) |
| TEST_TARGET_ALIGN(PPIXELFORMATDESCRIPTOR, 4) |
| } |
| |
| static void test_pack_PPOINTFLOAT(void) |
| { |
| /* PPOINTFLOAT */ |
| TEST_TYPE_SIZE (PPOINTFLOAT, 4) |
| TEST_TYPE_ALIGN (PPOINTFLOAT, 4) |
| TEST_TARGET_SIZE (PPOINTFLOAT, 8) |
| TEST_TARGET_ALIGN(PPOINTFLOAT, 4) |
| } |
| |
| static void test_pack_PPOLYTEXTA(void) |
| { |
| /* PPOLYTEXTA */ |
| TEST_TYPE_SIZE (PPOLYTEXTA, 4) |
| TEST_TYPE_ALIGN (PPOLYTEXTA, 4) |
| TEST_TARGET_SIZE (PPOLYTEXTA, 40) |
| TEST_TARGET_ALIGN(PPOLYTEXTA, 4) |
| } |
| |
| static void test_pack_PPOLYTEXTW(void) |
| { |
| /* PPOLYTEXTW */ |
| TEST_TYPE_SIZE (PPOLYTEXTW, 4) |
| TEST_TYPE_ALIGN (PPOLYTEXTW, 4) |
| TEST_TARGET_SIZE (PPOLYTEXTW, 40) |
| TEST_TARGET_ALIGN(PPOLYTEXTW, 4) |
| } |
| |
| static void test_pack_PRGNDATA(void) |
| { |
| /* PRGNDATA */ |
| TEST_TYPE_SIZE (PRGNDATA, 4) |
| TEST_TYPE_ALIGN (PRGNDATA, 4) |
| TEST_TARGET_SIZE (PRGNDATA, 36) |
| TEST_TARGET_ALIGN(PRGNDATA, 4) |
| } |
| |
| static void test_pack_PRGNDATAHEADER(void) |
| { |
| /* PRGNDATAHEADER */ |
| TEST_TYPE_SIZE (PRGNDATAHEADER, 4) |
| TEST_TYPE_ALIGN (PRGNDATAHEADER, 4) |
| TEST_TARGET_SIZE (PRGNDATAHEADER, 32) |
| TEST_TARGET_ALIGN(PRGNDATAHEADER, 4) |
| } |
| |
| static void test_pack_PTEXTMETRICA(void) |
| { |
| /* PTEXTMETRICA */ |
| TEST_TYPE_SIZE (PTEXTMETRICA, 4) |
| TEST_TYPE_ALIGN (PTEXTMETRICA, 4) |
| TEST_TARGET_SIZE (PTEXTMETRICA, 56) |
| TEST_TARGET_ALIGN(PTEXTMETRICA, 4) |
| } |
| |
| static void test_pack_PTEXTMETRICW(void) |
| { |
| /* PTEXTMETRICW */ |
| TEST_TYPE_SIZE (PTEXTMETRICW, 4) |
| TEST_TYPE_ALIGN (PTEXTMETRICW, 4) |
| TEST_TARGET_SIZE (PTEXTMETRICW, 60) |
| TEST_TARGET_ALIGN(PTEXTMETRICW, 4) |
| } |
| |
| static void test_pack_PTRIVERTEX(void) |
| { |
| /* PTRIVERTEX */ |
| TEST_TYPE_SIZE (PTRIVERTEX, 4) |
| TEST_TYPE_ALIGN (PTRIVERTEX, 4) |
| TEST_TARGET_SIZE (PTRIVERTEX, 16) |
| TEST_TARGET_ALIGN(PTRIVERTEX, 4) |
| } |
| |
| static void test_pack_PXFORM(void) |
| { |
| /* PXFORM */ |
| TEST_TYPE_SIZE (PXFORM, 4) |
| TEST_TYPE_ALIGN (PXFORM, 4) |
| TEST_TARGET_SIZE (PXFORM, 24) |
| TEST_TARGET_ALIGN(PXFORM, 4) |
| } |
| |
| static void test_pack_RASTERIZER_STATUS(void) |
| { |
| /* RASTERIZER_STATUS */ |
| TEST_TYPE_SIZE (RASTERIZER_STATUS, 6) |
| TEST_TYPE_ALIGN (RASTERIZER_STATUS, 2) |
| TEST_FIELD_SIZE (RASTERIZER_STATUS, nSize, 2) |
| TEST_FIELD_ALIGN (RASTERIZER_STATUS, nSize, 2) |
| TEST_FIELD_OFFSET(RASTERIZER_STATUS, nSize, 0) |
| TEST_FIELD_SIZE (RASTERIZER_STATUS, wFlags, 2) |
| TEST_FIELD_ALIGN (RASTERIZER_STATUS, wFlags, 2) |
| TEST_FIELD_OFFSET(RASTERIZER_STATUS, wFlags, 2) |
| TEST_FIELD_SIZE (RASTERIZER_STATUS, nLanguageID, 2) |
| TEST_FIELD_ALIGN (RASTERIZER_STATUS, nLanguageID, 2) |
| TEST_FIELD_OFFSET(RASTERIZER_STATUS, nLanguageID, 4) |
| } |
| |
| static void test_pack_RGBQUAD(void) |
| { |
| /* RGBQUAD */ |
| TEST_TYPE_SIZE (RGBQUAD, 4) |
| TEST_TYPE_ALIGN (RGBQUAD, 1) |
| TEST_FIELD_SIZE (RGBQUAD, rgbBlue, 1) |
| TEST_FIELD_ALIGN (RGBQUAD, rgbBlue, 1) |
| TEST_FIELD_OFFSET(RGBQUAD, rgbBlue, 0) |
| TEST_FIELD_SIZE (RGBQUAD, rgbGreen, 1) |
| TEST_FIELD_ALIGN (RGBQUAD, rgbGreen, 1) |
| TEST_FIELD_OFFSET(RGBQUAD, rgbGreen, 1) |
| TEST_FIELD_SIZE (RGBQUAD, rgbRed, 1) |
| TEST_FIELD_ALIGN (RGBQUAD, rgbRed, 1) |
| TEST_FIELD_OFFSET(RGBQUAD, rgbRed, 2) |
| TEST_FIELD_SIZE (RGBQUAD, rgbReserved, 1) |
| TEST_FIELD_ALIGN (RGBQUAD, rgbReserved, 1) |
| TEST_FIELD_OFFSET(RGBQUAD, rgbReserved, 3) |
| } |
| |
| static void test_pack_RGBTRIPLE(void) |
| { |
| /* RGBTRIPLE */ |
| TEST_TYPE_SIZE (RGBTRIPLE, 3) |
| TEST_TYPE_ALIGN (RGBTRIPLE, 1) |
| TEST_FIELD_SIZE (RGBTRIPLE, rgbtBlue, 1) |
| TEST_FIELD_ALIGN (RGBTRIPLE, rgbtBlue, 1) |
| TEST_FIELD_OFFSET(RGBTRIPLE, rgbtBlue, 0) |
| TEST_FIELD_SIZE (RGBTRIPLE, rgbtGreen, 1) |
| TEST_FIELD_ALIGN (RGBTRIPLE, rgbtGreen, 1) |
| TEST_FIELD_OFFSET(RGBTRIPLE, rgbtGreen, 1) |
| TEST_FIELD_SIZE (RGBTRIPLE, rgbtRed, 1) |
| TEST_FIELD_ALIGN (RGBTRIPLE, rgbtRed, 1) |
| TEST_FIELD_OFFSET(RGBTRIPLE, rgbtRed, 2) |
| } |
| |
| static void test_pack_RGNDATA(void) |
| { |
| /* RGNDATA */ |
| TEST_TYPE_SIZE (RGNDATA, 36) |
| TEST_TYPE_ALIGN (RGNDATA, 4) |
| TEST_FIELD_SIZE (RGNDATA, rdh, 32) |
| TEST_FIELD_ALIGN (RGNDATA, rdh, 4) |
| TEST_FIELD_OFFSET(RGNDATA, rdh, 0) |
| TEST_FIELD_SIZE (RGNDATA, Buffer, 1) |
| TEST_FIELD_ALIGN (RGNDATA, Buffer, 1) |
| TEST_FIELD_OFFSET(RGNDATA, Buffer, 32) |
| } |
| |
| static void test_pack_RGNDATAHEADER(void) |
| { |
| /* RGNDATAHEADER */ |
| TEST_TYPE_SIZE (RGNDATAHEADER, 32) |
| TEST_TYPE_ALIGN (RGNDATAHEADER, 4) |
| TEST_FIELD_SIZE (RGNDATAHEADER, dwSize, 4) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, dwSize, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, dwSize, 0) |
| TEST_FIELD_SIZE (RGNDATAHEADER, iType, 4) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, iType, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, iType, 4) |
| TEST_FIELD_SIZE (RGNDATAHEADER, nCount, 4) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, nCount, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, nCount, 8) |
| TEST_FIELD_SIZE (RGNDATAHEADER, nRgnSize, 4) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, nRgnSize, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, nRgnSize, 12) |
| TEST_FIELD_SIZE (RGNDATAHEADER, rcBound, 16) |
| TEST_FIELD_ALIGN (RGNDATAHEADER, rcBound, 4) |
| TEST_FIELD_OFFSET(RGNDATAHEADER, rcBound, 16) |
| } |
| |
| static void test_pack_TEXTMETRICA(void) |
| { |
| /* TEXTMETRICA */ |
| TEST_TYPE_SIZE (TEXTMETRICA, 56) |
| TEST_TYPE_ALIGN (TEXTMETRICA, 4) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmHeight, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmHeight, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmHeight, 0) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmAscent, 4) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmDescent, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmDescent, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmDescent, 8) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmInternalLeading, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmInternalLeading, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmInternalLeading, 12) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmExternalLeading, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmExternalLeading, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmExternalLeading, 16) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmAveCharWidth, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmAveCharWidth, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmAveCharWidth, 20) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmMaxCharWidth, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmMaxCharWidth, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmMaxCharWidth, 24) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmWeight, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmWeight, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmWeight, 28) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmOverhang, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmOverhang, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmOverhang, 32) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmDigitizedAspectX, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmDigitizedAspectX, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmDigitizedAspectX, 36) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmDigitizedAspectY, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmDigitizedAspectY, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmDigitizedAspectY, 40) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmFirstChar, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmFirstChar, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmFirstChar, 44) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmLastChar, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmLastChar, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmLastChar, 45) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmDefaultChar, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmDefaultChar, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmDefaultChar, 46) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmBreakChar, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmBreakChar, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmBreakChar, 47) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmItalic, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmItalic, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmItalic, 48) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmUnderlined, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmUnderlined, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmUnderlined, 49) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmStruckOut, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmStruckOut, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmStruckOut, 50) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmPitchAndFamily, 51) |
| TEST_FIELD_SIZE (TEXTMETRICA, tmCharSet, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICA, tmCharSet, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICA, tmCharSet, 52) |
| } |
| |
| static void test_pack_TEXTMETRICW(void) |
| { |
| /* TEXTMETRICW */ |
| TEST_TYPE_SIZE (TEXTMETRICW, 60) |
| TEST_TYPE_ALIGN (TEXTMETRICW, 4) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmHeight, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmHeight, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmHeight, 0) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmAscent, 4) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmDescent, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmDescent, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmDescent, 8) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmInternalLeading, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmInternalLeading, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmInternalLeading, 12) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmExternalLeading, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmExternalLeading, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmExternalLeading, 16) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmAveCharWidth, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmAveCharWidth, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmAveCharWidth, 20) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmMaxCharWidth, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmMaxCharWidth, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmMaxCharWidth, 24) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmWeight, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmWeight, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmWeight, 28) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmOverhang, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmOverhang, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmOverhang, 32) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmDigitizedAspectX, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmDigitizedAspectX, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmDigitizedAspectX, 36) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmDigitizedAspectY, 4) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmDigitizedAspectY, 4) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmDigitizedAspectY, 40) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmFirstChar, 2) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmFirstChar, 2) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmFirstChar, 44) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmLastChar, 2) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmLastChar, 2) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmLastChar, 46) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmDefaultChar, 2) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmDefaultChar, 2) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmDefaultChar, 48) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmBreakChar, 2) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmBreakChar, 2) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmBreakChar, 50) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmItalic, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmItalic, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmItalic, 52) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmUnderlined, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmUnderlined, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmUnderlined, 53) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmStruckOut, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmStruckOut, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmStruckOut, 54) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmPitchAndFamily, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmPitchAndFamily, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmPitchAndFamily, 55) |
| TEST_FIELD_SIZE (TEXTMETRICW, tmCharSet, 1) |
| TEST_FIELD_ALIGN (TEXTMETRICW, tmCharSet, 1) |
| TEST_FIELD_OFFSET(TEXTMETRICW, tmCharSet, 56) |
| } |
| |
| static void test_pack_TRIVERTEX(void) |
| { |
| /* TRIVERTEX */ |
| TEST_TYPE_SIZE (TRIVERTEX, 16) |
| TEST_TYPE_ALIGN (TRIVERTEX, 4) |
| TEST_FIELD_SIZE (TRIVERTEX, x, 4) |
| TEST_FIELD_ALIGN (TRIVERTEX, x, 4) |
| TEST_FIELD_OFFSET(TRIVERTEX, x, 0) |
| TEST_FIELD_SIZE (TRIVERTEX, y, 4) |
| TEST_FIELD_ALIGN (TRIVERTEX, y, 4) |
| TEST_FIELD_OFFSET(TRIVERTEX, y, 4) |
| TEST_FIELD_SIZE (TRIVERTEX, Red, 2) |
| TEST_FIELD_ALIGN (TRIVERTEX, Red, 2) |
| TEST_FIELD_OFFSET(TRIVERTEX, Red, 8) |
| TEST_FIELD_SIZE (TRIVERTEX, Green, 2) |
| TEST_FIELD_ALIGN (TRIVERTEX, Green, 2) |
| TEST_FIELD_OFFSET(TRIVERTEX, Green, 10) |
| TEST_FIELD_SIZE (TRIVERTEX, Blue, 2) |
| TEST_FIELD_ALIGN (TRIVERTEX, Blue, 2) |
| TEST_FIELD_OFFSET(TRIVERTEX, Blue, 12) |
| TEST_FIELD_SIZE (TRIVERTEX, Alpha, 2) |
| TEST_FIELD_ALIGN (TRIVERTEX, Alpha, 2) |
| TEST_FIELD_OFFSET(TRIVERTEX, Alpha, 14) |
| } |
| |
| static void test_pack_TTPOLYCURVE(void) |
| { |
| /* TTPOLYCURVE */ |
| TEST_TYPE_SIZE (TTPOLYCURVE, 12) |
| TEST_TYPE_ALIGN (TTPOLYCURVE, 2) |
| TEST_FIELD_SIZE (TTPOLYCURVE, wType, 2) |
| TEST_FIELD_ALIGN (TTPOLYCURVE, wType, 2) |
| TEST_FIELD_OFFSET(TTPOLYCURVE, wType, 0) |
| TEST_FIELD_SIZE (TTPOLYCURVE, cpfx, 2) |
| TEST_FIELD_ALIGN (TTPOLYCURVE, cpfx, 2) |
| TEST_FIELD_OFFSET(TTPOLYCURVE, cpfx, 2) |
| TEST_FIELD_SIZE (TTPOLYCURVE, apfx, 8) |
| TEST_FIELD_ALIGN (TTPOLYCURVE, apfx, 2) |
| TEST_FIELD_OFFSET(TTPOLYCURVE, apfx, 4) |
| } |
| |
| static void test_pack_TTPOLYGONHEADER(void) |
| { |
| /* TTPOLYGONHEADER */ |
| TEST_TYPE_SIZE (TTPOLYGONHEADER, 16) |
| TEST_TYPE_ALIGN (TTPOLYGONHEADER, 4) |
| TEST_FIELD_SIZE (TTPOLYGONHEADER, cb, 4) |
| TEST_FIELD_ALIGN (TTPOLYGONHEADER, cb, 4) |
| TEST_FIELD_OFFSET(TTPOLYGONHEADER, cb, 0) |
| TEST_FIELD_SIZE (TTPOLYGONHEADER, dwType, 4) |
| TEST_FIELD_ALIGN (TTPOLYGONHEADER, dwType, 4) |
| TEST_FIELD_OFFSET(TTPOLYGONHEADER, dwType, 4) |
| TEST_FIELD_SIZE (TTPOLYGONHEADER, pfxStart, 8) |
| TEST_FIELD_ALIGN (TTPOLYGONHEADER, pfxStart, 2) |
| TEST_FIELD_OFFSET(TTPOLYGONHEADER, pfxStart, 8) |
| } |
| |
| static void test_pack_XFORM(void) |
| { |
| /* XFORM */ |
| TEST_TYPE_SIZE (XFORM, 24) |
| TEST_TYPE_ALIGN (XFORM, 4) |
| TEST_FIELD_SIZE (XFORM, eM11, 4) |
| TEST_FIELD_ALIGN (XFORM, eM11, 4) |
| TEST_FIELD_OFFSET(XFORM, eM11, 0) |
| TEST_FIELD_SIZE (XFORM, eM12, 4) |
| TEST_FIELD_ALIGN (XFORM, eM12, 4) |
| TEST_FIELD_OFFSET(XFORM, eM12, 4) |
| TEST_FIELD_SIZE (XFORM, eM21, 4) |
| TEST_FIELD_ALIGN (XFORM, eM21, 4) |
| TEST_FIELD_OFFSET(XFORM, eM21, 8) |
| TEST_FIELD_SIZE (XFORM, eM22, 4) |
| TEST_FIELD_ALIGN (XFORM, eM22, 4) |
| TEST_FIELD_OFFSET(XFORM, eM22, 12) |
| TEST_FIELD_SIZE (XFORM, eDx, 4) |
| TEST_FIELD_ALIGN (XFORM, eDx, 4) |
| TEST_FIELD_OFFSET(XFORM, eDx, 16) |
| TEST_FIELD_SIZE (XFORM, eDy, 4) |
| TEST_FIELD_ALIGN (XFORM, eDy, 4) |
| TEST_FIELD_OFFSET(XFORM, eDy, 20) |
| } |
| |
| #endif /* _WIN64 */ |
| |
| static void test_pack(void) |
| { |
| test_pack_ABC(); |
| test_pack_ABCFLOAT(); |
| test_pack_ABORTPROC(); |
| test_pack_BITMAP(); |
| test_pack_BITMAPCOREHEADER(); |
| test_pack_BITMAPCOREINFO(); |
| test_pack_BITMAPFILEHEADER(); |
| test_pack_BITMAPINFO(); |
| test_pack_BITMAPINFOHEADER(); |
| test_pack_BITMAPV4HEADER(); |
| test_pack_BITMAPV5HEADER(); |
| test_pack_BLENDFUNCTION(); |
| test_pack_CHARSETINFO(); |
| test_pack_CIEXYZ(); |
| test_pack_CIEXYZTRIPLE(); |
| test_pack_COLOR16(); |
| test_pack_COLORADJUSTMENT(); |
| test_pack_DEVMODEA(); |
| test_pack_DEVMODEW(); |
| test_pack_DIBSECTION(); |
| test_pack_DISPLAY_DEVICEA(); |
| test_pack_DISPLAY_DEVICEW(); |
| test_pack_DOCINFOA(); |
| test_pack_DOCINFOW(); |
| test_pack_EMR(); |
| test_pack_EMRABORTPATH(); |
| test_pack_EMRANGLEARC(); |
| test_pack_EMRARC(); |
| test_pack_EMRARCTO(); |
| test_pack_EMRBEGINPATH(); |
| test_pack_EMRBITBLT(); |
| test_pack_EMRCHORD(); |
| test_pack_EMRCLOSEFIGURE(); |
| test_pack_EMRCREATEBRUSHINDIRECT(); |
| test_pack_EMRCREATECOLORSPACE(); |
| test_pack_EMRCREATECOLORSPACEW(); |
| test_pack_EMRCREATEDIBPATTERNBRUSHPT(); |
| test_pack_EMRCREATEMONOBRUSH(); |
| test_pack_EMRCREATEPEN(); |
| test_pack_EMRDELETECOLORSPACE(); |
| test_pack_EMRDELETEOBJECT(); |
| test_pack_EMRELLIPSE(); |
| test_pack_EMRENDPATH(); |
| test_pack_EMREOF(); |
| test_pack_EMREXCLUDECLIPRECT(); |
| test_pack_EMREXTCREATEFONTINDIRECTW(); |
| test_pack_EMREXTCREATEPEN(); |
| test_pack_EMREXTFLOODFILL(); |
| test_pack_EMREXTSELECTCLIPRGN(); |
| test_pack_EMREXTTEXTOUTA(); |
| test_pack_EMREXTTEXTOUTW(); |
| test_pack_EMRFILLPATH(); |
| test_pack_EMRFILLRGN(); |
| test_pack_EMRFLATTENPATH(); |
| test_pack_EMRFORMAT(); |
| test_pack_EMRFRAMERGN(); |
| test_pack_EMRGDICOMMENT(); |
| test_pack_EMRGLSBOUNDEDRECORD(); |
| test_pack_EMRGLSRECORD(); |
| test_pack_EMRINTERSECTCLIPRECT(); |
| test_pack_EMRINVERTRGN(); |
| test_pack_EMRLINETO(); |
| test_pack_EMRMASKBLT(); |
| test_pack_EMRMODIFYWORLDTRANSFORM(); |
| test_pack_EMRMOVETOEX(); |
| test_pack_EMROFFSETCLIPRGN(); |
| test_pack_EMRPAINTRGN(); |
| test_pack_EMRPIE(); |
| test_pack_EMRPIXELFORMAT(); |
| test_pack_EMRPLGBLT(); |
| test_pack_EMRPOLYBEZIER(); |
| test_pack_EMRPOLYBEZIER16(); |
| test_pack_EMRPOLYBEZIERTO(); |
| test_pack_EMRPOLYBEZIERTO16(); |
| test_pack_EMRPOLYDRAW(); |
| test_pack_EMRPOLYDRAW16(); |
| test_pack_EMRPOLYGON(); |
| test_pack_EMRPOLYGON16(); |
| test_pack_EMRPOLYLINE(); |
| test_pack_EMRPOLYLINE16(); |
| test_pack_EMRPOLYLINETO(); |
| test_pack_EMRPOLYLINETO16(); |
| test_pack_EMRPOLYPOLYGON(); |
| test_pack_EMRPOLYPOLYGON16(); |
| test_pack_EMRPOLYPOLYLINE(); |
| test_pack_EMRPOLYPOLYLINE16(); |
| test_pack_EMRPOLYTEXTOUTA(); |
| test_pack_EMRPOLYTEXTOUTW(); |
| test_pack_EMRREALIZEPALETTE(); |
| test_pack_EMRRECTANGLE(); |
| test_pack_EMRRESIZEPALETTE(); |
| test_pack_EMRRESTOREDC(); |
| test_pack_EMRROUNDRECT(); |
| test_pack_EMRSAVEDC(); |
| test_pack_EMRSCALEVIEWPORTEXTEX(); |
| test_pack_EMRSCALEWINDOWEXTEX(); |
| test_pack_EMRSELECTCLIPPATH(); |
| test_pack_EMRSELECTCOLORSPACE(); |
| test_pack_EMRSELECTOBJECT(); |
| test_pack_EMRSELECTPALETTE(); |
| test_pack_EMRSETARCDIRECTION(); |
| test_pack_EMRSETBKCOLOR(); |
| test_pack_EMRSETBKMODE(); |
| test_pack_EMRSETBRUSHORGEX(); |
| test_pack_EMRSETCOLORADJUSTMENT(); |
| test_pack_EMRSETCOLORSPACE(); |
| test_pack_EMRSETDIBITSTODEVICE(); |
| test_pack_EMRSETICMMODE(); |
| test_pack_EMRSETLAYOUT(); |
| test_pack_EMRSETMAPMODE(); |
| test_pack_EMRSETMAPPERFLAGS(); |
| test_pack_EMRSETMETARGN(); |
| test_pack_EMRSETMITERLIMIT(); |
| test_pack_EMRSETPIXELV(); |
| test_pack_EMRSETPOLYFILLMODE(); |
| test_pack_EMRSETROP2(); |
| test_pack_EMRSETSTRETCHBLTMODE(); |
| test_pack_EMRSETTEXTALIGN(); |
| test_pack_EMRSETTEXTCOLOR(); |
| test_pack_EMRSETVIEWPORTEXTEX(); |
| test_pack_EMRSETVIEWPORTORGEX(); |
| test_pack_EMRSETWINDOWEXTEX(); |
| test_pack_EMRSETWINDOWORGEX(); |
| test_pack_EMRSETWORLDTRANSFORM(); |
| test_pack_EMRSTRETCHBLT(); |
| test_pack_EMRSTRETCHDIBITS(); |
| test_pack_EMRSTROKEANDFILLPATH(); |
| test_pack_EMRSTROKEPATH(); |
| test_pack_EMRTEXT(); |
| test_pack_EMRWIDENPATH(); |
| test_pack_ENHMETAHEADER(); |
| test_pack_ENHMETARECORD(); |
| test_pack_ENHMFENUMPROC(); |
| test_pack_ENUMLOGFONTA(); |
| test_pack_ENUMLOGFONTEXA(); |
| test_pack_ENUMLOGFONTEXW(); |
| test_pack_ENUMLOGFONTW(); |
| test_pack_EXTLOGFONTA(); |
| test_pack_EXTLOGFONTW(); |
| test_pack_EXTLOGPEN(); |
| test_pack_FIXED(); |
| test_pack_FONTENUMPROCA(); |
| test_pack_FONTENUMPROCW(); |
| test_pack_FONTSIGNATURE(); |
| test_pack_FXPT16DOT16(); |
| test_pack_FXPT2DOT30(); |
| test_pack_GCP_RESULTSA(); |
| test_pack_GCP_RESULTSW(); |
| test_pack_GLYPHMETRICS(); |
| test_pack_GLYPHMETRICSFLOAT(); |
| test_pack_GOBJENUMPROC(); |
| test_pack_GRADIENT_RECT(); |
| test_pack_GRADIENT_TRIANGLE(); |
| test_pack_HANDLETABLE(); |
| test_pack_ICMENUMPROCA(); |
| test_pack_ICMENUMPROCW(); |
| test_pack_KERNINGPAIR(); |
| test_pack_LAYERPLANEDESCRIPTOR(); |
| test_pack_LCSCSTYPE(); |
| test_pack_LCSGAMUTMATCH(); |
| test_pack_LINEDDAPROC(); |
| test_pack_LOCALESIGNATURE(); |
| test_pack_LOGBRUSH(); |
| test_pack_LOGCOLORSPACEA(); |
| test_pack_LOGCOLORSPACEW(); |
| test_pack_LOGFONTA(); |
| test_pack_LOGFONTW(); |
| test_pack_LOGPEN(); |
| test_pack_LPABC(); |
| test_pack_LPABCFLOAT(); |
| test_pack_LPBITMAP(); |
| test_pack_LPBITMAPCOREHEADER(); |
| test_pack_LPBITMAPCOREINFO(); |
| test_pack_LPBITMAPFILEHEADER(); |
| test_pack_LPBITMAPINFO(); |
| test_pack_LPBITMAPINFOHEADER(); |
| test_pack_LPBITMAPV5HEADER(); |
| test_pack_LPCHARSETINFO(); |
| test_pack_LPCIEXYZ(); |
| test_pack_LPCIEXYZTRIPLE(); |
| test_pack_LPCOLORADJUSTMENT(); |
| test_pack_LPDEVMODEA(); |
| test_pack_LPDEVMODEW(); |
| test_pack_LPDIBSECTION(); |
| test_pack_LPDISPLAY_DEVICEA(); |
| test_pack_LPDISPLAY_DEVICEW(); |
| test_pack_LPDOCINFOA(); |
| test_pack_LPDOCINFOW(); |
| test_pack_LPENHMETAHEADER(); |
| test_pack_LPENHMETARECORD(); |
| test_pack_LPENUMLOGFONTA(); |
| test_pack_LPENUMLOGFONTEXA(); |
| test_pack_LPENUMLOGFONTEXW(); |
| test_pack_LPENUMLOGFONTW(); |
| test_pack_LPEXTLOGFONTA(); |
| test_pack_LPEXTLOGFONTW(); |
| test_pack_LPEXTLOGPEN(); |
| test_pack_LPFONTSIGNATURE(); |
| test_pack_LPGCP_RESULTSA(); |
| test_pack_LPGCP_RESULTSW(); |
| test_pack_LPGLYPHMETRICS(); |
| test_pack_LPGLYPHMETRICSFLOAT(); |
| test_pack_LPGRADIENT_RECT(); |
| test_pack_LPGRADIENT_TRIANGLE(); |
| test_pack_LPHANDLETABLE(); |
| test_pack_LPKERNINGPAIR(); |
| test_pack_LPLAYERPLANEDESCRIPTOR(); |
| test_pack_LPLOCALESIGNATURE(); |
| test_pack_LPLOGBRUSH(); |
| test_pack_LPLOGCOLORSPACEA(); |
| test_pack_LPLOGCOLORSPACEW(); |
| test_pack_LPLOGFONTA(); |
| test_pack_LPLOGFONTW(); |
| test_pack_LPLOGPEN(); |
| test_pack_LPMAT2(); |
| test_pack_LPMETAFILEPICT(); |
| test_pack_LPMETAHEADER(); |
| test_pack_LPMETARECORD(); |
| test_pack_LPNEWTEXTMETRICA(); |
| test_pack_LPNEWTEXTMETRICW(); |
| test_pack_LPOUTLINETEXTMETRICA(); |
| test_pack_LPOUTLINETEXTMETRICW(); |
| test_pack_LPPANOSE(); |
| test_pack_LPPELARRAY(); |
| test_pack_LPPIXELFORMATDESCRIPTOR(); |
| test_pack_LPPOINTFX(); |
| test_pack_LPPOLYTEXTA(); |
| test_pack_LPPOLYTEXTW(); |
| test_pack_LPRASTERIZER_STATUS(); |
| test_pack_LPRGBQUAD(); |
| test_pack_LPRGNDATA(); |
| test_pack_LPTEXTMETRICA(); |
| test_pack_LPTEXTMETRICW(); |
| test_pack_LPTRIVERTEX(); |
| test_pack_LPTTPOLYCURVE(); |
| test_pack_LPTTPOLYGONHEADER(); |
| test_pack_LPXFORM(); |
| test_pack_MAT2(); |
| test_pack_METAFILEPICT(); |
| test_pack_METAHEADER(); |
| test_pack_METARECORD(); |
| test_pack_MFENUMPROC(); |
| test_pack_NEWTEXTMETRICA(); |
| test_pack_NEWTEXTMETRICEXA(); |
| test_pack_NEWTEXTMETRICEXW(); |
| test_pack_NEWTEXTMETRICW(); |
| test_pack_NPEXTLOGPEN(); |
| test_pack_OLDFONTENUMPROCA(); |
| test_pack_OLDFONTENUMPROCW(); |
| test_pack_OUTLINETEXTMETRICA(); |
| test_pack_OUTLINETEXTMETRICW(); |
| test_pack_PABC(); |
| test_pack_PABCFLOAT(); |
| test_pack_PANOSE(); |
| test_pack_PATTERN(); |
| test_pack_PBITMAP(); |
| test_pack_PBITMAPCOREHEADER(); |
| test_pack_PBITMAPCOREINFO(); |
| test_pack_PBITMAPFILEHEADER(); |
| test_pack_PBITMAPINFO(); |
| test_pack_PBITMAPINFOHEADER(); |
| test_pack_PBITMAPV4HEADER(); |
| test_pack_PBITMAPV5HEADER(); |
| test_pack_PBLENDFUNCTION(); |
| test_pack_PCHARSETINFO(); |
| test_pack_PCOLORADJUSTMENT(); |
| test_pack_PDEVMODEA(); |
| test_pack_PDEVMODEW(); |
| test_pack_PDIBSECTION(); |
| test_pack_PDISPLAY_DEVICEA(); |
| test_pack_PDISPLAY_DEVICEW(); |
| test_pack_PELARRAY(); |
| test_pack_PEMR(); |
| test_pack_PEMRABORTPATH(); |
| test_pack_PEMRANGLEARC(); |
| test_pack_PEMRARC(); |
| test_pack_PEMRARCTO(); |
| test_pack_PEMRBEGINPATH(); |
| test_pack_PEMRBITBLT(); |
| test_pack_PEMRCHORD(); |
| test_pack_PEMRCLOSEFIGURE(); |
| test_pack_PEMRCREATEBRUSHINDIRECT(); |
| test_pack_PEMRCREATECOLORSPACE(); |
| test_pack_PEMRCREATECOLORSPACEW(); |
| test_pack_PEMRCREATEDIBPATTERNBRUSHPT(); |
| test_pack_PEMRCREATEMONOBRUSH(); |
| test_pack_PEMRCREATEPALETTE(); |
| test_pack_PEMRCREATEPEN(); |
| test_pack_PEMRDELETECOLORSPACE(); |
| test_pack_PEMRDELETEOBJECT(); |
| test_pack_PEMRELLIPSE(); |
| test_pack_PEMRENDPATH(); |
| test_pack_PEMREOF(); |
| test_pack_PEMREXCLUDECLIPRECT(); |
| test_pack_PEMREXTCREATEFONTINDIRECTW(); |
| test_pack_PEMREXTCREATEPEN(); |
| test_pack_PEMREXTFLOODFILL(); |
| test_pack_PEMREXTSELECTCLIPRGN(); |
| test_pack_PEMREXTTEXTOUTA(); |
| test_pack_PEMREXTTEXTOUTW(); |
| test_pack_PEMRFILLPATH(); |
| test_pack_PEMRFILLRGN(); |
| test_pack_PEMRFLATTENPATH(); |
| test_pack_PEMRFORMAT(); |
| test_pack_PEMRFRAMERGN(); |
| test_pack_PEMRGDICOMMENT(); |
| test_pack_PEMRGLSBOUNDEDRECORD(); |
| test_pack_PEMRGLSRECORD(); |
| test_pack_PEMRINTERSECTCLIPRECT(); |
| test_pack_PEMRINVERTRGN(); |
| test_pack_PEMRLINETO(); |
| test_pack_PEMRMASKBLT(); |
| test_pack_PEMRMODIFYWORLDTRANSFORM(); |
| test_pack_PEMRMOVETOEX(); |
| test_pack_PEMROFFSETCLIPRGN(); |
| test_pack_PEMRPAINTRGN(); |
| test_pack_PEMRPIE(); |
| test_pack_PEMRPIXELFORMAT(); |
| test_pack_PEMRPLGBLT(); |
| test_pack_PEMRPOLYBEZIER(); |
| test_pack_PEMRPOLYBEZIER16(); |
| test_pack_PEMRPOLYBEZIERTO(); |
| test_pack_PEMRPOLYBEZIERTO16(); |
| test_pack_PEMRPOLYDRAW(); |
| test_pack_PEMRPOLYDRAW16(); |
| test_pack_PEMRPOLYGON(); |
| test_pack_PEMRPOLYGON16(); |
| test_pack_PEMRPOLYLINE(); |
| test_pack_PEMRPOLYLINE16(); |
| test_pack_PEMRPOLYLINETO(); |
| test_pack_PEMRPOLYLINETO16(); |
| test_pack_PEMRPOLYPOLYGON(); |
| test_pack_PEMRPOLYPOLYGON16(); |
| test_pack_PEMRPOLYPOLYLINE(); |
| test_pack_PEMRPOLYPOLYLINE16(); |
| test_pack_PEMRPOLYTEXTOUTA(); |
| test_pack_PEMRPOLYTEXTOUTW(); |
| test_pack_PEMRREALIZEPALETTE(); |
| test_pack_PEMRRECTANGLE(); |
| test_pack_PEMRRESIZEPALETTE(); |
| test_pack_PEMRRESTOREDC(); |
| test_pack_PEMRROUNDRECT(); |
| test_pack_PEMRSAVEDC(); |
| test_pack_PEMRSCALEVIEWPORTEXTEX(); |
| test_pack_PEMRSCALEWINDOWEXTEX(); |
| test_pack_PEMRSELECTCLIPPATH(); |
| test_pack_PEMRSELECTCOLORSPACE(); |
| test_pack_PEMRSELECTOBJECT(); |
| test_pack_PEMRSELECTPALETTE(); |
| test_pack_PEMRSETARCDIRECTION(); |
| test_pack_PEMRSETBKCOLOR(); |
| test_pack_PEMRSETBKMODE(); |
| test_pack_PEMRSETBRUSHORGEX(); |
| test_pack_PEMRSETCOLORADJUSTMENT(); |
| test_pack_PEMRSETCOLORSPACE(); |
| test_pack_PEMRSETDIBITSTODEVICE(); |
| test_pack_PEMRSETICMMODE(); |
| test_pack_PEMRSETLAYOUT(); |
| test_pack_PEMRSETMAPMODE(); |
| test_pack_PEMRSETMAPPERFLAGS(); |
| test_pack_PEMRSETMETARGN(); |
| test_pack_PEMRSETMITERLIMIT(); |
| test_pack_PEMRSETPALETTEENTRIES(); |
| test_pack_PEMRSETPIXELV(); |
| test_pack_PEMRSETPOLYFILLMODE(); |
| test_pack_PEMRSETROP2(); |
| test_pack_PEMRSETSTRETCHBLTMODE(); |
| test_pack_PEMRSETTEXTALIGN(); |
| test_pack_PEMRSETTEXTCOLOR(); |
| test_pack_PEMRSETVIEWPORTEXTEX(); |
| test_pack_PEMRSETVIEWPORTORGEX(); |
| test_pack_PEMRSETWINDOWEXTEX(); |
| test_pack_PEMRSETWINDOWORGEX(); |
| test_pack_PEMRSETWORLDTRANSFORM(); |
| test_pack_PEMRSTRETCHBLT(); |
| test_pack_PEMRSTRETCHDIBITS(); |
| test_pack_PEMRSTROKEANDFILLPATH(); |
| test_pack_PEMRSTROKEPATH(); |
| test_pack_PEMRTEXT(); |
| test_pack_PEMRWIDENPATH(); |
| test_pack_PENHMETAHEADER(); |
| test_pack_PEXTLOGFONTA(); |
| test_pack_PEXTLOGFONTW(); |
| test_pack_PEXTLOGPEN(); |
| test_pack_PFONTSIGNATURE(); |
| test_pack_PGLYPHMETRICSFLOAT(); |
| test_pack_PGRADIENT_RECT(); |
| test_pack_PGRADIENT_TRIANGLE(); |
| test_pack_PHANDLETABLE(); |
| test_pack_PIXELFORMATDESCRIPTOR(); |
| test_pack_PLAYERPLANEDESCRIPTOR(); |
| test_pack_PLOCALESIGNATURE(); |
| test_pack_PLOGBRUSH(); |
| test_pack_PLOGFONTA(); |
| test_pack_PLOGFONTW(); |
| test_pack_PMETAHEADER(); |
| test_pack_PMETARECORD(); |
| test_pack_PNEWTEXTMETRICA(); |
| test_pack_PNEWTEXTMETRICW(); |
| test_pack_POINTFLOAT(); |
| test_pack_POINTFX(); |
| test_pack_POLYTEXTA(); |
| test_pack_POLYTEXTW(); |
| test_pack_POUTLINETEXTMETRICA(); |
| test_pack_POUTLINETEXTMETRICW(); |
| test_pack_PPELARRAY(); |
| test_pack_PPIXELFORMATDESCRIPTOR(); |
| test_pack_PPOINTFLOAT(); |
| test_pack_PPOLYTEXTA(); |
| test_pack_PPOLYTEXTW(); |
| test_pack_PRGNDATA(); |
| test_pack_PRGNDATAHEADER(); |
| test_pack_PTEXTMETRICA(); |
| test_pack_PTEXTMETRICW(); |
| test_pack_PTRIVERTEX(); |
| test_pack_PXFORM(); |
| test_pack_RASTERIZER_STATUS(); |
| test_pack_RGBQUAD(); |
| test_pack_RGBTRIPLE(); |
| test_pack_RGNDATA(); |
| test_pack_RGNDATAHEADER(); |
| test_pack_TEXTMETRICA(); |
| test_pack_TEXTMETRICW(); |
| test_pack_TRIVERTEX(); |
| test_pack_TTPOLYCURVE(); |
| test_pack_TTPOLYGONHEADER(); |
| test_pack_XFORM(); |
| } |
| |
| START_TEST(generated) |
| { |
| test_pack(); |
| } |
