generated.c

winNT技术操作系统,国外开放的原代码和LIUX一样

/* 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 <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wtypes.h"
#include "shellapi.h"
#include "winuser.h"
#include "wingdi.h"
#include "shlobj.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 defined(_MSC_VER) && (_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 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: 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(_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
 */

#ifdef FIELD_ALIGNMENT
# define TEST_FIELD_ALIGNMENT(type, field, align) \
   ok(FIELD_ALIGNMENT(type, field) == align, \
       "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")\n", \
           (int)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 ")\n", \
             (long int)FIELD_OFFSET(type, field))

#ifdef _TYPE_ALIGNMENT
#define TEST__TYPE_ALIGNMENT(type, align) \
    ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)_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 ")\n", (int)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 ")\n", ((int) 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\n");

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

static void test_pack_BLOB(void)
{
    /* BLOB (pack 4) */
    TEST_TYPE(BLOB, 8, 4);
    TEST_FIELD(BLOB, ULONG, cbSize, 0, 4, 4);
    TEST_FIELD(BLOB, BYTE *, pBlobData, 4, 4, 4);
}

static void test_pack_BSTR(void)
{
    /* BSTR */
    TEST_TYPE(BSTR, 4, 4);
    TEST_TYPE_POINTER(BSTR, 2, 2);
}

static void test_pack_BSTRBLOB(void)
{
    /* BSTRBLOB (pack 4) */
    TEST_TYPE(BSTRBLOB, 8, 4);
    TEST_FIELD(BSTRBLOB, ULONG, cbSize, 0, 4, 4);
    TEST_FIELD(BSTRBLOB, BYTE *, pData, 4, 4, 4);
}

static void test_pack_BYTE_BLOB(void)
{
    /* BYTE_BLOB (pack 4) */
    TEST_TYPE(BYTE_BLOB, 8, 4);
    TEST_FIELD(BYTE_BLOB, unsigned long, clSize, 0, 4, 4);
    TEST_FIELD(BYTE_BLOB, byte[1], abData, 4, 1, 1);
}

static void test_pack_BYTE_SIZEDARR(void)
{
    /* BYTE_SIZEDARR (pack 4) */
    TEST_TYPE(BYTE_SIZEDARR, 8, 4);
    TEST_FIELD(BYTE_SIZEDARR, unsigned long, clSize, 0, 4, 4);
    TEST_FIELD(BYTE_SIZEDARR, byte *, pData, 4, 4, 4);
}

static void test_pack_CLIPDATA(void)
{
    /* CLIPDATA (pack 4) */
    TEST_TYPE(CLIPDATA, 12, 4);
    TEST_FIELD(CLIPDATA, ULONG, cbSize, 0, 4, 4);
    TEST_FIELD(CLIPDATA, long, ulClipFmt, 4, 4, 4);
    TEST_FIELD(CLIPDATA, BYTE *, pClipData, 8, 4, 4);
}

static void test_pack_CLIPFORMAT(void)
{
    /* CLIPFORMAT */
    TEST_TYPE(CLIPFORMAT, 2, 2);
    TEST_TYPE_UNSIGNED(CLIPFORMAT);
}

static void test_pack_COAUTHIDENTITY(void)
{
    /* COAUTHIDENTITY (pack 4) */
    TEST_TYPE(COAUTHIDENTITY, 28, 4);
    TEST_FIELD(COAUTHIDENTITY, USHORT *, User, 0, 4, 4);
    TEST_FIELD(COAUTHIDENTITY, ULONG, UserLength, 4, 4, 4);
    TEST_FIELD(COAUTHIDENTITY, USHORT *, Domain, 8, 4, 4);
    TEST_FIELD(COAUTHIDENTITY, ULONG, DomainLength, 12, 4, 4);
    TEST_FIELD(COAUTHIDENTITY, USHORT *, Password, 16, 4, 4);
    TEST_FIELD(COAUTHIDENTITY, ULONG, PasswordLength, 20, 4, 4);
    TEST_FIELD(COAUTHIDENTITY, ULONG, Flags, 24, 4, 4);
}

static void test_pack_COAUTHINFO(void)
{
    /* COAUTHINFO (pack 4) */
    TEST_TYPE(COAUTHINFO, 28, 4);
    TEST_FIELD(COAUTHINFO, DWORD, dwAuthnSvc, 0, 4, 4);
    TEST_FIELD(COAUTHINFO, DWORD, dwAuthzSvc, 4, 4, 4);
    TEST_FIELD(COAUTHINFO, LPWSTR, pwszServerPrincName, 8, 4, 4);
    TEST_FIELD(COAUTHINFO, DWORD, dwAuthnLevel, 12, 4, 4);
    TEST_FIELD(COAUTHINFO, DWORD, dwImpersonationLevel, 16, 4, 4);
    TEST_FIELD(COAUTHINFO, COAUTHIDENTITY *, pAuthIdentityData, 20, 4, 4);
    TEST_FIELD(COAUTHINFO, DWORD, dwCapabilities, 24, 4, 4);
}

static void test_pack_COSERVERINFO(void)
{
    /* COSERVERINFO (pack 4) */
    TEST_TYPE(COSERVERINFO, 16, 4);
    TEST_FIELD(COSERVERINFO, DWORD, dwReserved1, 0, 4, 4);
    TEST_FIELD(COSERVERINFO, LPWSTR, pwszName, 4, 4, 4);
    TEST_FIELD(COSERVERINFO, COAUTHINFO *, pAuthInfo, 8, 4, 4);
    TEST_FIELD(COSERVERINFO, DWORD, dwReserved2, 12, 4, 4);
}

static void test_pack_DWORD_SIZEDARR(void)
{
    /* DWORD_SIZEDARR (pack 4) */
    TEST_TYPE(DWORD_SIZEDARR, 8, 4);
    TEST_FIELD(DWORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
    TEST_FIELD(DWORD_SIZEDARR, unsigned long *, pData, 4, 4, 4);
}

static void test_pack_FLAGGED_BYTE_BLOB(void)
{
    /* FLAGGED_BYTE_BLOB (pack 4) */
    TEST_TYPE(FLAGGED_BYTE_BLOB, 12, 4);
    TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, fFlags, 0, 4, 4);
    TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, clSize, 4, 4, 4);
    TEST_FIELD(FLAGGED_BYTE_BLOB, byte[1], abData, 8, 1, 1);
}

static void test_pack_FLAGGED_WORD_BLOB(void)
{
    /* FLAGGED_WORD_BLOB (pack 4) */
    TEST_TYPE(FLAGGED_WORD_BLOB, 12, 4);
    TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, fFlags, 0, 4, 4);
    TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, clSize, 4, 4, 4);
    TEST_FIELD(FLAGGED_WORD_BLOB, unsigned short[1], asData, 8, 2, 2);
}

static void test_pack_HMETAFILEPICT(void)
{
    /* HMETAFILEPICT */
    TEST_TYPE(HMETAFILEPICT, 4, 4);
}

static void test_pack_HYPER_SIZEDARR(void)
{
    /* HYPER_SIZEDARR (pack 4) */
    TEST_TYPE(HYPER_SIZEDARR, 8, 4);
    TEST_FIELD(HYPER_SIZEDARR, unsigned long, clSize, 0, 4, 4);
    TEST_FIELD(HYPER_SIZEDARR, hyper *, pData, 4, 4, 4);
}

static void test_pack_LPBLOB(void)
{
    /* LPBLOB */
    TEST_TYPE(LPBLOB, 4, 4);
    TEST_TYPE_POINTER(LPBLOB, 8, 4);
}

static void test_pack_LPBSTR(void)
{
    /* LPBSTR */
    TEST_TYPE(LPBSTR, 4, 4);
    TEST_TYPE_POINTER(LPBSTR, 4, 4);
}

static void test_pack_LPBSTRBLOB(void)
{
    /* LPBSTRBLOB */
    TEST_TYPE(LPBSTRBLOB, 4, 4);
    TEST_TYPE_POINTER(LPBSTRBLOB, 8, 4);
}

static void test_pack_LPCOLESTR(void)
{
    /* LPCOLESTR */
    TEST_TYPE(LPCOLESTR, 4, 4);
    TEST_TYPE_POINTER(LPCOLESTR, 2, 2);
}

static void test_pack_LPCY(void)
{
    /* LPCY */
    TEST_TYPE(LPCY, 4, 4);
}

static void test_pack_LPDECIMAL(void)
{
    /* LPDECIMAL */
    TEST_TYPE(LPDECIMAL, 4, 4);
}

static void test_pack_LPOLESTR(void)
{
    /* LPOLESTR */
    TEST_TYPE(LPOLESTR, 4, 4);
    TEST_TYPE_POINTER(LPOLESTR, 2, 2);
}

static void test_pack_OLECHAR(void)
{
    /* OLECHAR */
    TEST_TYPE(OLECHAR, 2, 2);
}

static void test_pack_PROPID(void)
{
    /* PROPID */
    TEST_TYPE(PROPID, 4, 4);
}

static void test_pack_RemHBITMAP(void)
{
    /* RemHBITMAP (pack 4) */
    TEST_TYPE(RemHBITMAP, 8, 4);
    TEST_FIELD(RemHBITMAP, unsigned long, cbData, 0, 4, 4);
    TEST_FIELD(RemHBITMAP, byte[1], data, 4, 1, 1);
}

static void test_pack_RemHENHMETAFILE(void)
{
    /* RemHENHMETAFILE (pack 4) */
    TEST_TYPE(RemHENHMETAFILE, 8, 4);
    TEST_FIELD(RemHENHMETAFILE, unsigned long, cbData, 0, 4, 4);
    TEST_FIELD(RemHENHMETAFILE, byte[1], data, 4, 1, 1);
}

static void test_pack_RemHGLOBAL(void)
{
    /* RemHGLOBAL (pack 4) */
    TEST_TYPE(RemHGLOBAL, 12, 4);
    TEST_FIELD(RemHGLOBAL, long, fNullHGlobal, 0, 4, 4);
    TEST_FIELD(RemHGLOBAL, unsigned long, cbData, 4, 4, 4);
    TEST_FIELD(RemHGLOBAL, byte[1], data, 8, 1, 1);
}

static void test_pack_RemHMETAFILEPICT(void)
{
    /* RemHMETAFILEPICT (pack 4) */
    TEST_TYPE(RemHMETAFILEPICT, 20, 4);
    TEST_FIELD(RemHMETAFILEPICT, long, mm, 0, 4, 4);
    TEST_FIELD(RemHMETAFILEPICT, long, xExt, 4, 4, 4);
    TEST_FIELD(RemHMETAFILEPICT, long, yExt, 8, 4, 4);
    TEST_FIELD(RemHMETAFILEPICT, unsigned long, cbData, 12, 4, 4);
    TEST_FIELD(RemHMETAFILEPICT, byte[1], data, 16, 1, 1);
}

static void test_pack_RemHPALETTE(void)
{
    /* RemHPALETTE (pack 4) */
    TEST_TYPE(RemHPALETTE, 8, 4);
    TEST_FIELD(RemHPALETTE, unsigned long, cbData, 0, 4, 4);
    TEST_FIELD(RemHPALETTE, byte[1], data, 4, 1, 1);
}

static void test_pack_SCODE(void)
{
    /* SCODE */
    TEST_TYPE(SCODE, 4, 4);
}

static void test_pack_UP_BYTE_BLOB(void)
{
    /* UP_BYTE_BLOB */
    TEST_TYPE(UP_BYTE_BLOB, 4, 4);
    TEST_TYPE_POINTER(UP_BYTE_BLOB, 8, 4);
}

static void test_pack_UP_FLAGGED_BYTE_BLOB(void)
{
    /* UP_FLAGGED_BYTE_BLOB */
    TEST_TYPE(UP_FLAGGED_BYTE_BLOB, 4, 4);
    TEST_TYPE_POINTER(UP_FLAGGED_BYTE_BLOB, 12, 4);
}

static void test_pack_UP_FLAGGED_WORD_BLOB(void)
{
    /* UP_FLAGGED_WORD_BLOB */
    TEST_TYPE(UP_FLAGGED_WORD_BLOB, 4, 4);
    TEST_TYPE_POINTER(UP_FLAGGED_WORD_BLOB, 12, 4);
}

static void test_pack_VARIANT_BOOL(void)
{
    /* VARIANT_BOOL */
    TEST_TYPE(VARIANT_BOOL, 2, 2);
    TEST_TYPE_SIGNED(VARIANT_BOOL);
}

static void test_pack_VARTYPE(void)
{
    /* VARTYPE */
    TEST_TYPE(VARTYPE, 2, 2);
    TEST_TYPE_UNSIGNED(VARTYPE);
}

static void test_pack_WORD_SIZEDARR(void)
{
    /* WORD_SIZEDARR (pack 4) */
    TEST_TYPE(WORD_SIZEDARR, 8, 4);
    TEST_FIELD(WORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
    TEST_FIELD(WORD_SIZEDARR, unsigned short *, pData, 4, 4, 4);
}

static void test_pack_remoteMETAFILEPICT(void)
{
    /* remoteMETAFILEPICT (pack 4) */
    TEST_TYPE(remoteMETAFILEPICT, 16, 4);
    TEST_FIELD(remoteMETAFILEPICT, long, mm, 0, 4, 4);
    TEST_FIELD(remoteMETAFILEPICT, long, xExt, 4, 4, 4);
    TEST_FIELD(remoteMETAFILEPICT, long, yExt, 8, 4, 4);
    TEST_FIELD(remoteMETAFILEPICT, userHMETAFILE *, hMF, 12, 4, 4);
}

static void test_pack_userBITMAP(void)
{
    /* userBITMAP (pack 4) */
    TEST_TYPE(userBITMAP, 28, 4);
    TEST_FIELD(userBITMAP, LONG, bmType, 0, 4, 4);
    TEST_FIELD(userBITMAP, LONG, bmWidth, 4, 4, 4);
    TEST_FIELD(userBITMAP, LONG, bmHeight, 8, 4, 4);
    TEST_FIELD(userBITMAP, LONG, bmWidthBytes, 12, 4, 4);
    TEST_FIELD(userBITMAP, WORD, bmPlanes, 16, 2, 2);
    TEST_FIELD(userBITMAP, WORD, bmBitsPixel, 18, 2, 2);
    TEST_FIELD(userBITMAP, ULONG, cbSize, 20, 4, 4);
    TEST_FIELD(userBITMAP, byte[1], pBuffer, 24, 1, 1);
}

static void test_pack_userCLIPFORMAT(void)
{
    /* userCLIPFORMAT (pack 4) */
    TEST_FIELD(userCLIPFORMAT, long, fContext, 0, 4, 4);
}

static void test_pack_userHBITMAP(void)
{
    /* userHBITMAP (pack 4) */
    TEST_FIELD(userHBITMAP, long, fContext, 0, 4, 4);
}

static void test_pack_userHENHMETAFILE(void)
{
    /* userHENHMETAFILE (pack 4) */
    TEST_FIELD(userHENHMETAFILE, long, fContext, 0, 4, 4);
}

static void test_pack_userHGLOBAL(void)
{
    /* userHGLOBAL (pack 4) */
    TEST_FIELD(userHGLOBAL, long, fContext, 0, 4, 4);
}

static void test_pack_userHMETAFILE(void)
{
    /* userHMETAFILE (pack 4) */
    TEST_FIELD(userHMETAFILE, long, fContext, 0, 4, 4);
}

static void test_pack_userHMETAFILEPICT(void)
{
    /* userHMETAFILEPICT (pack 4) */
    TEST_FIELD(userHMETAFILEPICT, long, fContext, 0, 4, 4);
}

static void test_pack_userHPALETTE(void)
{
    /* userHPALETTE (pack 4) */
    TEST_FIELD(userHPALETTE, long, fContext, 0, 4, 4);
}

static void test_pack_wireBSTR(void)