generated.c

Wine-20031016

/* File generated automatically from tools/winapi/test.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"

/***********************************************************************
 * Compability macros
 */

#define DWORD_PTR UINT_PTR
#define LONG_PTR INT_PTR
#define ULONG_PTR UINT_PTR

/***********************************************************************
 * Windows API extension
 */

#if (_MSC_VER >= 1300) && defined(__cplusplus)
# define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
#elif defined(__GNUC__)
# define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
#else
/* FIXME: Not sure if is possible to do without compiler extension */
#endif

#if (_MSC_VER >= 1300) && defined(__cplusplus)
# define _TYPE_ALIGNMENT(type) __alignof(type)
#elif defined(__GNUC__)
# define _TYPE_ALIGNMENT(type) __alignof__(type)
#else
/*
 * FIXME: Not sure if is possible to do without compiler extension
 *        (if type is not just a name that is, if so the normal)
 *         TYPE_ALIGNMENT can be used)
 */
#endif

#if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
# define TYPE_ALIGNMENT _TYPE_ALIGNMENT
#endif

/***********************************************************************
 * Test helper macros
 */

#ifdef FIELD_ALIGNMENT
# define TEST_FIELD_ALIGNMENT(type, field, align) \
   ok(FIELD_ALIGNMENT(type, field) == align, \
       "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")", \
           FIELD_ALIGNMENT(type, field))
#else
# define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
#endif

#define TEST_FIELD_OFFSET(type, field, offset) \
    ok(FIELD_OFFSET(type, field) == offset, \
        "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")", \
             FIELD_OFFSET(type, field))

#ifdef _TYPE_ALIGNMENT
#define TEST__TYPE_ALIGNMENT(type, align) \
    ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")", _TYPE_ALIGNMENT(type))
#else
# define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
#endif

#ifdef TYPE_ALIGNMENT
#define TEST_TYPE_ALIGNMENT(type, align) \
    ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")", TYPE_ALIGNMENT(type))
#else
# define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
#endif

#define TEST_TYPE_SIZE(type, size) \
    ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")", sizeof(type))

/***********************************************************************
 * Test macros
 */

#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
  TEST_TYPE_SIZE(field_type, field_size); \
  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
  TEST_FIELD_OFFSET(type, field_name, field_offset); \

#define TEST_TYPE(type, size, align) \
  TEST_TYPE_ALIGNMENT(type, align); \
  TEST_TYPE_SIZE(type, size)

#define TEST_TYPE_POINTER(type, size, align) \
    TEST__TYPE_ALIGNMENT(*(type)0, align); \
    TEST_TYPE_SIZE(*(type)0, size)

#define TEST_TYPE_SIGNED(type) \
    ok((type) -1 < 0, "(" #type ") -1 < 0");

#define TEST_TYPE_UNSIGNED(type) \
     ok((type) -1 > 0, "(" #type ") -1 > 0");

static void test_pack_ABC(void)
{
    /* ABC (pack 4) */
    TEST_TYPE(ABC, 12, 4);
    TEST_FIELD(ABC, INT, abcA, 0, 4, 4);
    TEST_FIELD(ABC, UINT, abcB, 4, 4, 4);
    TEST_FIELD(ABC, INT, abcC, 8, 4, 4);
}

static void test_pack_ABCFLOAT(void)
{
    /* ABCFLOAT (pack 4) */
    TEST_TYPE(ABCFLOAT, 12, 4);
    TEST_FIELD(ABCFLOAT, FLOAT, abcfA, 0, 4, 4);
    TEST_FIELD(ABCFLOAT, FLOAT, abcfB, 4, 4, 4);
    TEST_FIELD(ABCFLOAT, FLOAT, abcfC, 8, 4, 4);
}

static void test_pack_ABORTPROC(void)
{
    /* ABORTPROC */
    TEST_TYPE(ABORTPROC, 4, 4);
}

static void test_pack_BITMAP(void)
{
    /* BITMAP (pack 4) */
    TEST_TYPE(BITMAP, 24, 4);
    TEST_FIELD(BITMAP, INT, bmType, 0, 4, 4);
    TEST_FIELD(BITMAP, INT, bmWidth, 4, 4, 4);
    TEST_FIELD(BITMAP, INT, bmHeight, 8, 4, 4);
    TEST_FIELD(BITMAP, INT, bmWidthBytes, 12, 4, 4);
    TEST_FIELD(BITMAP, WORD, bmPlanes, 16, 2, 2);
    TEST_FIELD(BITMAP, WORD, bmBitsPixel, 18, 2, 2);
    TEST_FIELD(BITMAP, LPVOID, bmBits, 20, 4, 4);
}

static void test_pack_BITMAPCOREHEADER(void)
{
    /* BITMAPCOREHEADER (pack 4) */
    TEST_TYPE(BITMAPCOREHEADER, 12, 4);
    TEST_FIELD(BITMAPCOREHEADER, DWORD, bcSize, 0, 4, 4);
    TEST_FIELD(BITMAPCOREHEADER, WORD, bcWidth, 4, 2, 2);
    TEST_FIELD(BITMAPCOREHEADER, WORD, bcHeight, 6, 2, 2);
    TEST_FIELD(BITMAPCOREHEADER, WORD, bcPlanes, 8, 2, 2);
    TEST_FIELD(BITMAPCOREHEADER, WORD, bcBitCount, 10, 2, 2);
}

static void test_pack_BITMAPCOREINFO(void)
{
    /* BITMAPCOREINFO (pack 4) */
    TEST_TYPE(BITMAPCOREINFO, 16, 4);
    TEST_FIELD(BITMAPCOREINFO, BITMAPCOREHEADER, bmciHeader, 0, 12, 4);
    TEST_FIELD(BITMAPCOREINFO, RGBTRIPLE[1], bmciColors, 12, 3, 1);
}

static void test_pack_BITMAPFILEHEADER(void)
{
    /* BITMAPFILEHEADER (pack 2) */
    TEST_TYPE(BITMAPFILEHEADER, 14, 2);
    TEST_FIELD(BITMAPFILEHEADER, WORD, bfType, 0, 2, 2);
    TEST_FIELD(BITMAPFILEHEADER, DWORD, bfSize, 2, 4, 2);
    TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved1, 6, 2, 2);
    TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved2, 8, 2, 2);
    TEST_FIELD(BITMAPFILEHEADER, DWORD, bfOffBits, 10, 4, 2);
}

static void test_pack_BITMAPINFO(void)
{
    /* BITMAPINFO (pack 4) */
    TEST_TYPE(BITMAPINFO, 44, 4);
    TEST_FIELD(BITMAPINFO, BITMAPINFOHEADER, bmiHeader, 0, 40, 4);
    TEST_FIELD(BITMAPINFO, RGBQUAD[1], bmiColors, 40, 4, 1);
}

static void test_pack_BITMAPINFOHEADER(void)
{
    /* BITMAPINFOHEADER (pack 4) */
    TEST_TYPE(BITMAPINFOHEADER, 40, 4);
    TEST_FIELD(BITMAPINFOHEADER, DWORD, biSize, 0, 4, 4);
    TEST_FIELD(BITMAPINFOHEADER, LONG, biWidth, 4, 4, 4);
    TEST_FIELD(BITMAPINFOHEADER, LONG, biHeight, 8, 4, 4);
    TEST_FIELD(BITMAPINFOHEADER, WORD, biPlanes, 12, 2, 2);
    TEST_FIELD(BITMAPINFOHEADER, WORD, biBitCount, 14, 2, 2);
    TEST_FIELD(BITMAPINFOHEADER, DWORD, biCompression, 16, 4, 4);
    TEST_FIELD(BITMAPINFOHEADER, DWORD, biSizeImage, 20, 4, 4);
    TEST_FIELD(BITMAPINFOHEADER, LONG, biXPelsPerMeter, 24, 4, 4);
    TEST_FIELD(BITMAPINFOHEADER, LONG, biYPelsPerMeter, 28, 4, 4);
    TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrUsed, 32, 4, 4);
    TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrImportant, 36, 4, 4);
}

static void test_pack_BITMAPV4HEADER(void)
{
    /* BITMAPV4HEADER (pack 4) */
    TEST_TYPE(BITMAPV4HEADER, 108, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4Size, 0, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, LONG, bV4Width, 4, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, LONG, bV4Height, 8, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, WORD, bV4Planes, 12, 2, 2);
    TEST_FIELD(BITMAPV4HEADER, WORD, bV4BitCount, 14, 2, 2);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4V4Compression, 16, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4SizeImage, 20, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, LONG, bV4XPelsPerMeter, 24, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, LONG, bV4YPelsPerMeter, 28, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrUsed, 32, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrImportant, 36, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4RedMask, 40, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GreenMask, 44, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4BlueMask, 48, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4AlphaMask, 52, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4CSType, 56, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, CIEXYZTRIPLE, bV4Endpoints, 60, 36, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaRed, 96, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaGreen, 100, 4, 4);
    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaBlue, 104, 4, 4);
}

static void test_pack_BITMAPV5HEADER(void)
{
    /* BITMAPV5HEADER (pack 4) */
    TEST_TYPE(BITMAPV5HEADER, 124, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Size, 0, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, LONG, bV5Width, 4, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, LONG, bV5Height, 8, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, WORD, bV5Planes, 12, 2, 2);
    TEST_FIELD(BITMAPV5HEADER, WORD, bV5BitCount, 14, 2, 2);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Compression, 16, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5SizeImage, 20, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, LONG, bV5XPelsPerMeter, 24, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, LONG, bV5YPelsPerMeter, 28, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrUsed, 32, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrImportant, 36, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5RedMask, 40, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GreenMask, 44, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5BlueMask, 48, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5AlphaMask, 52, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5CSType, 56, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, CIEXYZTRIPLE, bV5Endpoints, 60, 36, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaRed, 96, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaGreen, 100, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaBlue, 104, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Intent, 108, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileData, 112, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileSize, 116, 4, 4);
    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Reserved, 120, 4, 4);
}

static void test_pack_BLENDFUNCTION(void)
{
    /* BLENDFUNCTION (pack 4) */
    TEST_TYPE(BLENDFUNCTION, 4, 1);
    TEST_FIELD(BLENDFUNCTION, BYTE, BlendOp, 0, 1, 1);
    TEST_FIELD(BLENDFUNCTION, BYTE, BlendFlags, 1, 1, 1);
    TEST_FIELD(BLENDFUNCTION, BYTE, SourceConstantAlpha, 2, 1, 1);
    TEST_FIELD(BLENDFUNCTION, BYTE, AlphaFormat, 3, 1, 1);
}

static void test_pack_CHARSETINFO(void)
{
    /* CHARSETINFO (pack 4) */
    TEST_TYPE(CHARSETINFO, 32, 4);
    TEST_FIELD(CHARSETINFO, UINT, ciCharset, 0, 4, 4);
    TEST_FIELD(CHARSETINFO, UINT, ciACP, 4, 4, 4);
    TEST_FIELD(CHARSETINFO, FONTSIGNATURE, fs, 8, 24, 4);
}

static void test_pack_CIEXYZ(void)
{
    /* CIEXYZ (pack 4) */
    TEST_TYPE(CIEXYZ, 12, 4);
    TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzX, 0, 4, 4);
    TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzY, 4, 4, 4);
    TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzZ, 8, 4, 4);
}

static void test_pack_CIEXYZTRIPLE(void)
{
    /* CIEXYZTRIPLE (pack 4) */
    TEST_TYPE(CIEXYZTRIPLE, 36, 4);
    TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzRed, 0, 12, 4);
    TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzGreen, 12, 12, 4);
    TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzBlue, 24, 12, 4);
}

static void test_pack_COLOR16(void)
{
    /* COLOR16 */
    TEST_TYPE(COLOR16, 2, 2);
}

static void test_pack_COLORADJUSTMENT(void)
{
    /* COLORADJUSTMENT (pack 4) */
    TEST_TYPE(COLORADJUSTMENT, 24, 2);
    TEST_FIELD(COLORADJUSTMENT, WORD, caSize, 0, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, WORD, caFlags, 2, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, WORD, caIlluminantIndex, 4, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, WORD, caRedGamma, 6, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, WORD, caGreenGamma, 8, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, WORD, caBlueGamma, 10, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceBlack, 12, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceWhite, 14, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, SHORT, caContrast, 16, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, SHORT, caBrightness, 18, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, SHORT, caColorfulness, 20, 2, 2);
    TEST_FIELD(COLORADJUSTMENT, SHORT, caRedGreenTint, 22, 2, 2);
}

static void test_pack_DIBSECTION(void)
{
    /* DIBSECTION (pack 4) */
    TEST_TYPE(DIBSECTION, 84, 4);
    TEST_FIELD(DIBSECTION, BITMAP, dsBm, 0, 24, 4);
    TEST_FIELD(DIBSECTION, BITMAPINFOHEADER, dsBmih, 24, 40, 4);
    TEST_FIELD(DIBSECTION, DWORD[3], dsBitfields, 64, 12, 4);
    TEST_FIELD(DIBSECTION, HANDLE, dshSection, 76, 4, 4);
    TEST_FIELD(DIBSECTION, DWORD, dsOffset, 80, 4, 4);
}

static void test_pack_DISPLAY_DEVICEA(void)
{
    /* DISPLAY_DEVICEA (pack 4) */
    TEST_FIELD(DISPLAY_DEVICEA, DWORD, cb, 0, 4, 4);
    TEST_FIELD(DISPLAY_DEVICEA, CHAR[32], DeviceName, 4, 32, 1);
    TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceString, 36, 128, 1);
    TEST_FIELD(DISPLAY_DEVICEA, DWORD, StateFlags, 164, 4, 4);
}

static void test_pack_DISPLAY_DEVICEW(void)
{
    /* DISPLAY_DEVICEW (pack 4) */
    TEST_FIELD(DISPLAY_DEVICEW, DWORD, cb, 0, 4, 4);
    TEST_FIELD(DISPLAY_DEVICEW, WCHAR[32], DeviceName, 4, 64, 2);
    TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceString, 68, 256, 2);
    TEST_FIELD(DISPLAY_DEVICEW, DWORD, StateFlags, 324, 4, 4);
}

static void test_pack_DOCINFOA(void)
{
    /* DOCINFOA (pack 4) */
    TEST_TYPE(DOCINFOA, 20, 4);
    TEST_FIELD(DOCINFOA, INT, cbSize, 0, 4, 4);
    TEST_FIELD(DOCINFOA, LPCSTR, lpszDocName, 4, 4, 4);
    TEST_FIELD(DOCINFOA, LPCSTR, lpszOutput, 8, 4, 4);
    TEST_FIELD(DOCINFOA, LPCSTR, lpszDatatype, 12, 4, 4);
    TEST_FIELD(DOCINFOA, DWORD, fwType, 16, 4, 4);
}

static void test_pack_DOCINFOW(void)
{
    /* DOCINFOW (pack 4) */
    TEST_TYPE(DOCINFOW, 20, 4);
    TEST_FIELD(DOCINFOW, INT, cbSize, 0, 4, 4);
    TEST_FIELD(DOCINFOW, LPCWSTR, lpszDocName, 4, 4, 4);
    TEST_FIELD(DOCINFOW, LPCWSTR, lpszOutput, 8, 4, 4);
    TEST_FIELD(DOCINFOW, LPCWSTR, lpszDatatype, 12, 4, 4);
    TEST_FIELD(DOCINFOW, DWORD, fwType, 16, 4, 4);
}

static void test_pack_EMR(void)
{
    /* EMR (pack 4) */
    TEST_TYPE(EMR, 8, 4);
    TEST_FIELD(EMR, DWORD, iType, 0, 4, 4);
    TEST_FIELD(EMR, DWORD, nSize, 4, 4, 4);
}

static void test_pack_EMRABORTPATH(void)
{
    /* EMRABORTPATH (pack 4) */
    TEST_TYPE(EMRABORTPATH, 8, 4);
    TEST_FIELD(EMRABORTPATH, EMR, emr, 0, 8, 4);
}

static void test_pack_EMRANGLEARC(void)
{
    /* EMRANGLEARC (pack 4) */
    TEST_TYPE(EMRANGLEARC, 28, 4);
    TEST_FIELD(EMRANGLEARC, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRANGLEARC, POINTL, ptlCenter, 8, 8, 4);
    TEST_FIELD(EMRANGLEARC, DWORD, nRadius, 16, 4, 4);
    TEST_FIELD(EMRANGLEARC, FLOAT, eStartAngle, 20, 4, 4);
    TEST_FIELD(EMRANGLEARC, FLOAT, eSweepAngle, 24, 4, 4);
}

static void test_pack_EMRARC(void)