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_ACCEL(void)
{
    /* ACCEL (pack 4) */
    TEST_TYPE(ACCEL, 6, 2);
    TEST_FIELD(ACCEL, BYTE, fVirt, 0, 1, 1);
    TEST_FIELD(ACCEL, WORD, key, 2, 2, 2);
    TEST_FIELD(ACCEL, WORD, cmd, 4, 2, 2);
}

static void test_pack_ACCESSTIMEOUT(void)
{
    /* ACCESSTIMEOUT (pack 4) */
    TEST_TYPE(ACCESSTIMEOUT, 12, 4);
    TEST_FIELD(ACCESSTIMEOUT, UINT, cbSize, 0, 4, 4);
    TEST_FIELD(ACCESSTIMEOUT, DWORD, dwFlags, 4, 4, 4);
    TEST_FIELD(ACCESSTIMEOUT, DWORD, iTimeOutMSec, 8, 4, 4);
}

static void test_pack_ANIMATIONINFO(void)
{
    /* ANIMATIONINFO (pack 4) */
    TEST_TYPE(ANIMATIONINFO, 8, 4);
    TEST_FIELD(ANIMATIONINFO, UINT, cbSize, 0, 4, 4);
    TEST_FIELD(ANIMATIONINFO, INT, iMinAnimate, 4, 4, 4);
}

static void test_pack_CBTACTIVATESTRUCT(void)
{
    /* CBTACTIVATESTRUCT (pack 4) */
    TEST_TYPE(CBTACTIVATESTRUCT, 8, 4);
    TEST_FIELD(CBTACTIVATESTRUCT, BOOL, fMouse, 0, 4, 4);
    TEST_FIELD(CBTACTIVATESTRUCT, HWND, hWndActive, 4, 4, 4);
}

static void test_pack_CBT_CREATEWNDA(void)
{
    /* CBT_CREATEWNDA (pack 4) */
    TEST_TYPE(CBT_CREATEWNDA, 8, 4);
    TEST_FIELD(CBT_CREATEWNDA, CREATESTRUCTA *, lpcs, 0, 4, 4);
    TEST_FIELD(CBT_CREATEWNDA, HWND, hwndInsertAfter, 4, 4, 4);
}

static void test_pack_CBT_CREATEWNDW(void)
{
    /* CBT_CREATEWNDW (pack 4) */
    TEST_TYPE(CBT_CREATEWNDW, 8, 4);
    TEST_FIELD(CBT_CREATEWNDW, CREATESTRUCTW *, lpcs, 0, 4, 4);
    TEST_FIELD(CBT_CREATEWNDW, HWND, hwndInsertAfter, 4, 4, 4);
}

static void test_pack_CLIENTCREATESTRUCT(void)
{
    /* CLIENTCREATESTRUCT (pack 4) */
    TEST_TYPE(CLIENTCREATESTRUCT, 8, 4);
    TEST_FIELD(CLIENTCREATESTRUCT, HMENU, hWindowMenu, 0, 4, 4);
    TEST_FIELD(CLIENTCREATESTRUCT, UINT, idFirstChild, 4, 4, 4);
}

static void test_pack_COMBOBOXINFO(void)
{
    /* COMBOBOXINFO (pack 4) */
    TEST_TYPE(COMBOBOXINFO, 52, 4);
    TEST_FIELD(COMBOBOXINFO, DWORD, cbSize, 0, 4, 4);
    TEST_FIELD(COMBOBOXINFO, RECT, rcItem, 4, 16, 4);
    TEST_FIELD(COMBOBOXINFO, RECT, rcButton, 20, 16, 4);
    TEST_FIELD(COMBOBOXINFO, DWORD, stateButton, 36, 4, 4);
    TEST_FIELD(COMBOBOXINFO, HWND, hwndCombo, 40, 4, 4);
    TEST_FIELD(COMBOBOXINFO, HWND, hwndItem, 44, 4, 4);
    TEST_FIELD(COMBOBOXINFO, HWND, hwndList, 48, 4, 4);
}

static void test_pack_COMPAREITEMSTRUCT(void)
{
    /* COMPAREITEMSTRUCT (pack 4) */
    TEST_TYPE(COMPAREITEMSTRUCT, 32, 4);
    TEST_FIELD(COMPAREITEMSTRUCT, UINT, CtlType, 0, 4, 4);
    TEST_FIELD(COMPAREITEMSTRUCT, UINT, CtlID, 4, 4, 4);
    TEST_FIELD(COMPAREITEMSTRUCT, HWND, hwndItem, 8, 4, 4);
    TEST_FIELD(COMPAREITEMSTRUCT, UINT, itemID1, 12, 4, 4);
    TEST_FIELD(COMPAREITEMSTRUCT, ULONG_PTR, itemData1, 16, 4, 4);
    TEST_FIELD(COMPAREITEMSTRUCT, UINT, itemID2, 20, 4, 4);
    TEST_FIELD(COMPAREITEMSTRUCT, ULONG_PTR, itemData2, 24, 4, 4);
    TEST_FIELD(COMPAREITEMSTRUCT, DWORD, dwLocaleId, 28, 4, 4);
}

static void test_pack_COPYDATASTRUCT(void)
{
    /* COPYDATASTRUCT (pack 4) */
    TEST_TYPE(COPYDATASTRUCT, 12, 4);
    TEST_FIELD(COPYDATASTRUCT, ULONG_PTR, dwData, 0, 4, 4);
    TEST_FIELD(COPYDATASTRUCT, DWORD, cbData, 4, 4, 4);
    TEST_FIELD(COPYDATASTRUCT, PVOID, lpData, 8, 4, 4);
}

static void test_pack_CREATESTRUCTA(void)
{
    /* CREATESTRUCTA (pack 4) */
    TEST_TYPE(CREATESTRUCTA, 48, 4);
    TEST_FIELD(CREATESTRUCTA, LPVOID, lpCreateParams, 0, 4, 4);
    TEST_FIELD(CREATESTRUCTA, HINSTANCE, hInstance, 4, 4, 4);
    TEST_FIELD(CREATESTRUCTA, HMENU, hMenu, 8, 4, 4);
    TEST_FIELD(CREATESTRUCTA, HWND, hwndParent, 12, 4, 4);
    TEST_FIELD(CREATESTRUCTA, INT, cy, 16, 4, 4);
    TEST_FIELD(CREATESTRUCTA, INT, cx, 20, 4, 4);
    TEST_FIELD(CREATESTRUCTA, INT, y, 24, 4, 4);
    TEST_FIELD(CREATESTRUCTA, INT, x, 28, 4, 4);
    TEST_FIELD(CREATESTRUCTA, LONG, style, 32, 4, 4);
    TEST_FIELD(CREATESTRUCTA, LPCSTR, lpszName, 36, 4, 4);
    TEST_FIELD(CREATESTRUCTA, LPCSTR, lpszClass, 40, 4, 4);
    TEST_FIELD(CREATESTRUCTA, DWORD, dwExStyle, 44, 4, 4);
}

static void test_pack_CREATESTRUCTW(void)
{
    /* CREATESTRUCTW (pack 4) */
    TEST_TYPE(CREATESTRUCTW, 48, 4);
    TEST_FIELD(CREATESTRUCTW, LPVOID, lpCreateParams, 0, 4, 4);
    TEST_FIELD(CREATESTRUCTW, HINSTANCE, hInstance, 4, 4, 4);
    TEST_FIELD(CREATESTRUCTW, HMENU, hMenu, 8, 4, 4);
    TEST_FIELD(CREATESTRUCTW, HWND, hwndParent, 12, 4, 4);
    TEST_FIELD(CREATESTRUCTW, INT, cy, 16, 4, 4);
    TEST_FIELD(CREATESTRUCTW, INT, cx, 20, 4, 4);
    TEST_FIELD(CREATESTRUCTW, INT, y, 24, 4, 4);
    TEST_FIELD(CREATESTRUCTW, INT, x, 28, 4, 4);
    TEST_FIELD(CREATESTRUCTW, LONG, style, 32, 4, 4);
    TEST_FIELD(CREATESTRUCTW, LPCWSTR, lpszName, 36, 4, 4);
    TEST_FIELD(CREATESTRUCTW, LPCWSTR, lpszClass, 40, 4, 4);
    TEST_FIELD(CREATESTRUCTW, DWORD, dwExStyle, 44, 4, 4);
}

static void test_pack_CURSORINFO(void)
{
    /* CURSORINFO (pack 4) */
    TEST_TYPE(CURSORINFO, 20, 4);
    TEST_FIELD(CURSORINFO, DWORD, cbSize, 0, 4, 4);
    TEST_FIELD(CURSORINFO, DWORD, flags, 4, 4, 4);
    TEST_FIELD(CURSORINFO, HCURSOR, hCursor, 8, 4, 4);
    TEST_FIELD(CURSORINFO, POINT, ptScreenPos, 12, 8, 4);
}

static void test_pack_CWPRETSTRUCT(void)
{
    /* CWPRETSTRUCT (pack 4) */
    TEST_TYPE(CWPRETSTRUCT, 20, 4);
    TEST_FIELD(CWPRETSTRUCT, LRESULT, lResult, 0, 4, 4);
    TEST_FIELD(CWPRETSTRUCT, LPARAM, lParam, 4, 4, 4);
    TEST_FIELD(CWPRETSTRUCT, WPARAM, wParam, 8, 4, 4);
    TEST_FIELD(CWPRETSTRUCT, DWORD, message, 12, 4, 4);
    TEST_FIELD(CWPRETSTRUCT, HWND, hwnd, 16, 4, 4);
}

static void test_pack_CWPSTRUCT(void)
{
    /* CWPSTRUCT (pack 4) */
    TEST_TYPE(CWPSTRUCT, 16, 4);
    TEST_FIELD(CWPSTRUCT, LPARAM, lParam, 0, 4, 4);
    TEST_FIELD(CWPSTRUCT, WPARAM, wParam, 4, 4, 4);
    TEST_FIELD(CWPSTRUCT, UINT, message, 8, 4, 4);
    TEST_FIELD(CWPSTRUCT, HWND, hwnd, 12, 4, 4);
}

static void test_pack_DEBUGHOOKINFO(void)
{
    /* DEBUGHOOKINFO (pack 4) */
    TEST_TYPE(DEBUGHOOKINFO, 20, 4);
    TEST_FIELD(DEBUGHOOKINFO, DWORD, idThread, 0, 4, 4);
    TEST_FIELD(DEBUGHOOKINFO, DWORD, idThreadInstaller, 4, 4, 4);
    TEST_FIELD(DEBUGHOOKINFO, LPARAM, lParam, 8, 4, 4);
    TEST_FIELD(DEBUGHOOKINFO, WPARAM, wParam, 12, 4, 4);
    TEST_FIELD(DEBUGHOOKINFO, INT, code, 16, 4, 4);
}

static void test_pack_DELETEITEMSTRUCT(void)
{
    /* DELETEITEMSTRUCT (pack 4) */
    TEST_TYPE(DELETEITEMSTRUCT, 20, 4);
    TEST_FIELD(DELETEITEMSTRUCT, UINT, CtlType, 0, 4, 4);
    TEST_FIELD(DELETEITEMSTRUCT, UINT, CtlID, 4, 4, 4);
    TEST_FIELD(DELETEITEMSTRUCT, UINT, itemID, 8, 4, 4);
    TEST_FIELD(DELETEITEMSTRUCT, HWND, hwndItem, 12, 4, 4);
    TEST_FIELD(DELETEITEMSTRUCT, ULONG_PTR, itemData, 16, 4, 4);
}

static void test_pack_DESKTOPENUMPROCA(void)
{
    /* DESKTOPENUMPROCA */
    TEST_TYPE(DESKTOPENUMPROCA, 4, 4);
}

static void test_pack_DESKTOPENUMPROCW(void)
{
    /* DESKTOPENUMPROCW */
    TEST_TYPE(DESKTOPENUMPROCW, 4, 4);
}

static void test_pack_DLGITEMTEMPLATE(void)
{
    /* DLGITEMTEMPLATE (pack 2) */
    TEST_TYPE(DLGITEMTEMPLATE, 18, 2);
    TEST_FIELD(DLGITEMTEMPLATE, DWORD, style, 0, 4, 2);
    TEST_FIELD(DLGITEMTEMPLATE, DWORD, dwExtendedStyle, 4, 4, 2);
    TEST_FIELD(DLGITEMTEMPLATE, short, x, 8, 2, 2);
    TEST_FIELD(DLGITEMTEMPLATE, short, y, 10, 2, 2);
    TEST_FIELD(DLGITEMTEMPLATE, short, cx, 12, 2, 2);
    TEST_FIELD(DLGITEMTEMPLATE, short, cy, 14, 2, 2);
    TEST_FIELD(DLGITEMTEMPLATE, WORD, id, 16, 2, 2);
}

static void test_pack_DLGPROC(void)
{
    /* DLGPROC */
    TEST_TYPE(DLGPROC, 4, 4);
}

static void test_pack_DLGTEMPLATE(void)
{
    /* DLGTEMPLATE (pack 2) */
    TEST_TYPE(DLGTEMPLATE, 18, 2);
    TEST_FIELD(DLGTEMPLATE, DWORD, style, 0, 4, 2);
    TEST_FIELD(DLGTEMPLATE, DWORD, dwExtendedStyle, 4, 4, 2);
    TEST_FIELD(DLGTEMPLATE, WORD, cdit, 8, 2, 2);
    TEST_FIELD(DLGTEMPLATE, short, x, 10, 2, 2);
    TEST_FIELD(DLGTEMPLATE, short, y, 12, 2, 2);
    TEST_FIELD(DLGTEMPLATE, short, cx, 14, 2, 2);
    TEST_FIELD(DLGTEMPLATE, short, cy, 16, 2, 2);
}

static void test_pack_DRAWSTATEPROC(void)
{
    /* DRAWSTATEPROC */
    TEST_TYPE(DRAWSTATEPROC, 4, 4);
}

static void test_pack_DRAWTEXTPARAMS(void)
{
    /* DRAWTEXTPARAMS (pack 4) */
    TEST_TYPE(DRAWTEXTPARAMS, 20, 4);
    TEST_FIELD(DRAWTEXTPARAMS, UINT, cbSize, 0, 4, 4);
    TEST_FIELD(DRAWTEXTPARAMS, INT, iTabLength, 4, 4, 4);
    TEST_FIELD(DRAWTEXTPARAMS, INT, iLeftMargin, 8, 4, 4);
    TEST_FIELD(DRAWTEXTPARAMS, INT, iRightMargin, 12, 4, 4);
    TEST_FIELD(DRAWTEXTPARAMS, UINT, uiLengthDrawn, 16, 4, 4);
}

static void test_pack_EDITWORDBREAKPROCA(void)
{
    /* EDITWORDBREAKPROCA */
    TEST_TYPE(EDITWORDBREAKPROCA, 4, 4);
}

static void test_pack_EDITWORDBREAKPROCW(void)
{
    /* EDITWORDBREAKPROCW */
    TEST_TYPE(EDITWORDBREAKPROCW, 4, 4);
}

static void test_pack_EVENTMSG(void)
{
    /* EVENTMSG (pack 4) */
    TEST_TYPE(EVENTMSG, 20, 4);
    TEST_FIELD(EVENTMSG, UINT, message, 0, 4, 4);
    TEST_FIELD(EVENTMSG, UINT, paramL, 4, 4, 4);
    TEST_FIELD(EVENTMSG, UINT, paramH, 8, 4, 4);
    TEST_FIELD(EVENTMSG, DWORD, time, 12, 4, 4);
    TEST_FIELD(EVENTMSG, HWND, hwnd, 16, 4, 4);
}

static void test_pack_FILTERKEYS(void)
{
    /* FILTERKEYS (pack 4) */
    TEST_TYPE(FILTERKEYS, 24, 4);
    TEST_FIELD(FILTERKEYS, UINT, cbSize, 0, 4, 4);
    TEST_FIELD(FILTERKEYS, DWORD, dwFlags, 4, 4, 4);
    TEST_FIELD(FILTERKEYS, DWORD, iWaitMSec, 8, 4, 4);
    TEST_FIELD(FILTERKEYS, DWORD, iDelayMSec, 12, 4, 4);
    TEST_FIELD(FILTERKEYS, DWORD, iRepeatMSec, 16, 4, 4);
    TEST_FIELD(FILTERKEYS, DWORD, iBounceMSec, 20, 4, 4);
}

static void test_pack_GUITHREADINFO(void)
{
    /* GUITHREADINFO (pack 4) */
    TEST_TYPE(GUITHREADINFO, 48, 4);
    TEST_FIELD(GUITHREADINFO, DWORD, cbSize, 0, 4, 4);
    TEST_FIELD(GUITHREADINFO, DWORD, flags, 4, 4, 4);
    TEST_FIELD(GUITHREADINFO, HWND, hwndActive, 8, 4, 4);
    TEST_FIELD(GUITHREADINFO, HWND, hwndFocus, 12, 4, 4);
    TEST_FIELD(GUITHREADINFO, HWND, hwndCapture, 16, 4, 4);
    TEST_FIELD(GUITHREADINFO, HWND, hwndMenuOwner, 20, 4, 4);
    TEST_FIELD(GUITHREADINFO, HWND, hwndMoveSize, 24, 4, 4);
    TEST_FIELD(GUITHREADINFO, HWND, hwndCaret, 28, 4, 4);
    TEST_FIELD(GUITHREADINFO, RECT, rcCaret, 32, 16, 4);
}

static void test_pack_GRAYSTRINGPROC(void)
{
    /* GRAYSTRINGPROC */
    TEST_TYPE(GRAYSTRINGPROC, 4, 4);
}

static void test_pack_HARDWAREHOOKSTRUCT(void)
{
    /* HARDWAREHOOKSTRUCT (pack 4) */
    TEST_TYPE(HARDWAREHOOKSTRUCT, 16, 4);
    TEST_FIELD(HARDWAREHOOKSTRUCT, HWND, hwnd, 0, 4, 4);
    TEST_FIELD(HARDWAREHOOKSTRUCT, UINT, message, 4, 4, 4);
    TEST_FIELD(HARDWAREHOOKSTRUCT, WPARAM, wParam, 8, 4, 4);
    TEST_FIELD(HARDWAREHOOKSTRUCT, LPARAM, lParam, 12, 4, 4);
}

static void test_pack_HARDWAREINPUT(void)
{
    /* HARDWAREINPUT (pack 4) */
    TEST_TYPE(HARDWAREINPUT, 8, 4);
    TEST_FIELD(HARDWAREINPUT, DWORD, uMsg, 0, 4, 4);
    TEST_FIELD(HARDWAREINPUT, WORD, wParamL, 4, 2, 2);
    TEST_FIELD(HARDWAREINPUT, WORD, wParamH, 6, 2, 2);
}

static void test_pack_HDEVNOTIFY(void)
{
    /* HDEVNOTIFY */
    TEST_TYPE(HDEVNOTIFY, 4, 4);
}

static void test_pack_HDWP(void)
{
    /* HDWP */
    TEST_TYPE(HDWP, 4, 4);
}

static void test_pack_HELPINFO(void)
{
    /* HELPINFO (pack 4) */
    TEST_TYPE(HELPINFO, 28, 4);
    TEST_FIELD(HELPINFO, UINT, cbSize, 0, 4, 4);
    TEST_FIELD(HELPINFO, INT, iContextType, 4, 4, 4);
    TEST_FIELD(HELPINFO, INT, iCtrlId, 8, 4, 4);