#include "wine/test.h"
#include "oleauto.h"
#include <math.h>
#include <stdio.h>
#include "test_tlb.h"
#include "initguid.h"

Include dependency graph for vartype.c:

Classes
struct	tagINTERNAL_BSTR

struct	DummyDispatch

Macros
#define	CONST_VTABLE

#define	COBJMACROS

#define	HAS_UINT64_TO_FLOAT

#define	IS_MODERN_VTYPE(vt)

#define	CONVVARS(typ) HRESULT hres; CONV_TYPE out; typ in

#define	_EXPECT_NO_OUT(res) ok(hres == res, "expected " #res ", got hres=0x%08x\n", hres)

#define	EXPECT_OVERFLOW _EXPECT_NO_OUT(DISP_E_OVERFLOW)

#define	EXPECT_MISMATCH _EXPECT_NO_OUT(DISP_E_TYPEMISMATCH)

#define	EXPECT_BADVAR _EXPECT_NO_OUT(DISP_E_BADVARTYPE)

#define	EXPECT_INVALID _EXPECT_NO_OUT(E_INVALIDARG)

#define	EXPECT_LT _EXPECT_NO_OUT(VARCMP_LT)

#define	EXPECT_GT _EXPECT_NO_OUT(VARCMP_GT)

#define	EXPECT_EQ _EXPECT_NO_OUT(VARCMP_EQ)

#define	_EXPECTRES(res, x, fs) ok(hres == S_OK && out == (CONV_TYPE)(x), "expected " #x ", got " fs "; hres=0x%08x\n", out, hres)

#define	EXPECT(x) EXPECTRES(S_OK, (x))

#define	EXPECT_DBL(x) ok(hres == S_OK && fabs(out-(x))<=1e-14*(x), "expected %16.16g, got %16.16g; hres=0x%08x\n", (x), out, hres)

#define	CONVERT(func, val) in = val; hres = func(in, &out)

#define	CONVERTRANGE(func, start, end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT(i); };

#define	OVERFLOWRANGE(func, start, end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT_OVERFLOW; };

#define	CY_MULTIPLIER 10000

#define	DATE_MIN -657434

#define	DATE_MAX 2958465

#define	CONVERT_I8(func, hi, lo) in = hi; in = (in << 32) \| lo; hres = func(in, &out)

#define	CONVERT_CY(func, val) in.int64 = (LONGLONG)(val * CY_MULTIPLIER); hres = func(in, &out)

#define	CONVERT_CY64(func, hi, lo) S(in).Hi = hi; S(in).Lo = lo; in.int64 *= CY_MULTIPLIER; hres = func(in, &out)

#define	SETDEC(dec, scl, sgn, hi, lo)

#define	SETDEC64(dec, scl, sgn, hi, mid, lo)

#define	CONVERT_DEC(func, scl, sgn, hi, lo) SETDEC(in,scl,sgn,hi,lo); hres = func(&in, &out)

#define	CONVERT_DEC64(func, scl, sgn, hi, mid, lo) SETDEC64(in,scl,sgn,hi,mid,lo); hres = func(&in, &out)

#define	CONVERT_BADDEC(func)

#define	CONVERT_STR(func, str, flags)

#define	COPYTEST(val, vt, srcval, dstval, srcref, dstref, fs)

#define	CHANGETYPEEX(typ) hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, typ)

#define	TYPETEST(typ, res, fs)

#define	TYPETESTI8(typ, res)

#define	BADVAR(typ) CHANGETYPEEX(typ); EXPECT_BADVAR

#define	MISMATCH(typ) CHANGETYPEEX(typ); EXPECT_MISMATCH

#define	INITIAL_TYPETEST(vt, val, fs)

#define	NEGATIVE_TYPETEST(vt, val, fs, vtneg, valneg)

#define	INITIAL_TYPETESTI8(vt, val)

#define	COMMON_TYPETEST

#define	DEFINE_EXPECT(func) static BOOL expect_ ## func = FALSE, called_ ## func = FALSE

#define	SET_EXPECT(func) do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)

#define	CHECK_EXPECT2(func)

#define	CHECK_EXPECT(func)

#define	CHECK_CALLED(func)

#define	CONV_TYPE signed char

#define	EXPECTRES(res, x) _EXPECTRES(res, x, "%d")

#define	CONV_TYPE BYTE

#define	CONV_TYPE SHORT

#define	CONV_TYPE USHORT

#define	CONV_TYPE LONG

#define	CONV_TYPE ULONG

#define	EXPECTRES(res, x) _EXPECTRES(res, x, "%u")

#define	CONV_TYPE LONG64

#define	EXPECTI8(x)

#define	EXPECTI864(x, y)

#define	CONV_TYPE ULONG64

#define	CONV_TYPE float

#define	EXPECTRES(res, x) _EXPECTRES(res, x, "%15.15f")

#define	CONV_TYPE double

#define	MATHRND(l, r) left = l; right = r; hres = VarR8Round(left, right, &out)

#define	CONV_TYPE DATE

#define	DFS(str)

#define	MKRELDATE(day, mth)

#define	CONV_TYPE CY

#define	EXPECTCY(x)

#define	EXPECTCY64(x, y)

#define	MATHVARS1 HRESULT hres; double left = 0.0; CY cyLeft, out

#define	MATHVARS2 MATHVARS1; double right = 0.0; CY cyRight

#define	MATH1(func, l) left = (double)l; VarCyFromR8(left, &cyLeft); hres = func(cyLeft, &out)

#define	MATH2(func, l, r)

#define	MATHMULI4(l, r)

#define	MATHMULI8(l, r)

#define	MATHCMP(l, r)

#define	MATHCMPR8(l, r)

#define	MATHRND(l, r)

#define	MATHFIX(l)

#define	MATHINT(l)

#define	CONV_TYPE DECIMAL

#define	EXPECTDEC(scl, sgn, hi, lo)

#define	EXPECTDEC64(scl, sgn, hi, mid, lo)

#define	EXPECTDECZERO()

#define	EXPECTDECI if (i < 0) EXPECTDEC(0, 0x80, 0, -i); else EXPECTDEC(0, 0, 0, i)

#define	MATHVARS1 HRESULT hres; DECIMAL l, out

#define	MATHVARS2 MATHVARS1; DECIMAL r

#define	MATH1(func) hres = func(&l, &out)

#define	MATH2(func) hres = func(&l, &r, &out)

#define	MATH3(func) hres = func(&l, r)

#define	CLEAR(x) memset(&(x), 0xBB, sizeof(x))

#define	CONV_TYPE VARIANT_BOOL

#define	EXPECTRES(res, x) _EXPECTRES(res, x, "%d")

#define	CONVERTRANGE(func, start, end)

#define	BOOL_STR(flags, str)

#define	BSTR_DATE(dt, str) _BSTR_DATE(dt,str,__LINE__)

#define	BSTR_CY(a, b, str, lcid) _BSTR_CY(a, b, str, lcid, __LINE__)

#define	BSTR_DEC(scale, sign, hi, lo, str, lcid) _BSTR_DEC(scale, sign, hi, 0, lo, str, lcid, __LINE__)

#define	BSTR_DEC64(scale, sign, hi, mid, lo, str, lcid) _BSTR_DEC(scale, sign, hi, mid, lo, str, lcid, __LINE__)

#define	_VARBSTRCMP(left, right, lcid, flags, result)

#define	VARBSTRCMP(left, right, flags, result) _VARBSTRCMP(left,right,lcid,flags,result)

#define	NUM_CUST_ITEMS 16

Typedefs
typedef struct tagINTERNAL_BSTR	INTERNAL_BSTR

typedef struct tagINTERNAL_BSTR *	LPINTERNAL_BSTR

Functions
	DEFINE_GUID (UUID_test_struct, 0x4029f190, 0xca4a, 0x4611, 0xae, 0xb9, 0x67, 0x39, 0x83, 0xcb, 0x96, 0xdd)

	DEFINE_EXPECT (dispatch_invoke)

static DummyDispatch *	impl_from_IDispatch (IDispatch *iface)

static ULONG WINAPI	DummyDispatch_AddRef (IDispatch *iface)

static ULONG WINAPI	DummyDispatch_Release (IDispatch *iface)

static HRESULT WINAPI	DummyDispatch_QueryInterface (IDispatch iface, REFIID riid, void *ppvObject)

static HRESULT WINAPI	DummyDispatch_GetTypeInfoCount (IDispatch iface, UINT pctinfo)

static HRESULT WINAPI	DummyDispatch_GetTypeInfo (IDispatch iface, UINT tinfo, LCID lcid, ITypeInfo *ti)

static HRESULT WINAPI	DummyDispatch_GetIDsOfNames (IDispatch iface, REFIID riid, LPOLESTR names, UINT cnames, LCID lcid, DISPID *dispid)

static HRESULT WINAPI	DummyDispatch_Invoke (IDispatch iface, DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS params, VARIANT res, EXCEPINFO ei, UINT *arg_err)

static void	init_test_dispatch (LONG ref, VARTYPE vt, DummyDispatch *dispatch)

static void	test_VarI1FromI2 (void)

static void	test_VarI1FromI4 (void)

static void	test_VarI1FromI8 (void)

static void	test_VarI1FromUI1 (void)

static void	test_VarI1FromUI2 (void)

static void	test_VarI1FromUI4 (void)

static void	test_VarI1FromUI8 (void)

static void	test_VarI1FromBool (void)

static void	test_VarI1FromR4 (void)

static void	test_VarI1FromR8 (void)

static void	test_VarI1FromDate (void)

static void	test_VarI1FromCy (void)

static void	test_VarI1FromDec (void)

static void	test_VarI1FromStr (void)

static void	test_VarI1Copy (void)

static void	test_VarI1ChangeTypeEx (void)

static void	test_VarUI1FromI1 (void)

static void	test_VarUI1FromI2 (void)

static void	test_VarUI1FromI4 (void)

static void	test_VarUI1FromI8 (void)

static void	test_VarUI1FromUI2 (void)

static void	test_VarUI1FromUI4 (void)

static void	test_VarUI1FromUI8 (void)

static void	test_VarUI1FromBool (void)

static void	test_VarUI1FromR4 (void)

static void	test_VarUI1FromR8 (void)

static void	test_VarUI1FromDate (void)

static void	test_VarUI1FromCy (void)

static void	test_VarUI1FromDec (void)

static void	test_VarUI1FromStr (void)

static void	test_VarUI1FromDisp (void)

static void	test_VarUI1Copy (void)

static void	test_VarUI1ChangeTypeEx (void)

static void	test_VarI2FromI1 (void)

static void	test_VarI2FromI4 (void)

static void	test_VarI2FromI8 (void)

static void	test_VarI2FromUI1 (void)

static void	test_VarI2FromUI2 (void)

static void	test_VarI2FromUI4 (void)

static void	test_VarI2FromUI8 (void)

static void	test_VarI2FromBool (void)

static void	test_VarI2FromR4 (void)

static void	test_VarI2FromR8 (void)

static void	test_VarI2FromDate (void)

static void	test_VarI2FromCy (void)

static void	test_VarI2FromDec (void)

static void	test_VarI2FromStr (void)

static void	test_VarI2Copy (void)

static void	test_VarI2ChangeTypeEx (void)

static void	test_VarUI2FromI1 (void)

static void	test_VarUI2FromI2 (void)

static void	test_VarUI2FromI4 (void)

static void	test_VarUI2FromI8 (void)

static void	test_VarUI2FromUI1 (void)

static void	test_VarUI2FromUI4 (void)

static void	test_VarUI2FromUI8 (void)

static void	test_VarUI2FromBool (void)

static void	test_VarUI2FromR4 (void)

static void	test_VarUI2FromR8 (void)

static void	test_VarUI2FromDate (void)

static void	test_VarUI2FromCy (void)

static void	test_VarUI2FromDec (void)

static void	test_VarUI2FromStr (void)

static void	test_VarUI2Copy (void)

static void	test_VarUI2ChangeTypeEx (void)

static void	test_VarI4FromI1 (void)

static void	test_VarI4FromI2 (void)

static void	test_VarI4FromI8 (void)

static void	test_VarI4FromUI1 (void)

static void	test_VarI4FromUI2 (void)

static void	test_VarI4FromUI4 (void)

static void	test_VarI4FromUI8 (void)

static void	test_VarI4FromBool (void)

static void	test_VarI4FromR4 (void)

static void	test_VarI4FromR8 (void)

static void	test_VarI4FromDate (void)

static void	test_VarI4FromCy (void)

static void	test_VarI4FromDec (void)

static void	test_VarI4FromStr (void)

static void	test_VarI4Copy (void)

static void	test_VarI4ChangeTypeEx (void)

static void	test_VarUI4FromI1 (void)

static void	test_VarUI4FromI2 (void)

static void	test_VarUI4FromUI2 (void)

static void	test_VarUI4FromI8 (void)

static void	test_VarUI4FromUI1 (void)

static void	test_VarUI4FromI4 (void)

static void	test_VarUI4FromUI8 (void)

static void	test_VarUI4FromBool (void)

static void	test_VarUI4FromR4 (void)

static void	test_VarUI4FromR8 (void)

static void	test_VarUI4FromDate (void)

static void	test_VarUI4FromCy (void)

static void	test_VarUI4FromDec (void)

static void	test_VarUI4FromStr (void)

static void	test_VarUI4Copy (void)

static void	test_VarUI4ChangeTypeEx (void)

static void	test_VarI8FromI1 (void)

static void	test_VarI8FromUI1 (void)

static void	test_VarI8FromI2 (void)

static void	test_VarI8FromUI2 (void)

static void	test_VarI8FromUI4 (void)

static void	test_VarI8FromR4 (void)

static void	test_VarI8FromR8 (void)

static void	test_VarI8FromDate (void)

static void	test_VarI8FromBool (void)

static void	test_VarI8FromUI8 (void)

static void	test_VarI8FromCy (void)

static void	test_VarI8FromDec (void)

static void	test_VarI8FromStr (void)

static void	test_VarI8Copy (void)

static void	test_VarI8ChangeTypeEx (void)

static void	test_VarUI8FromI1 (void)

static void	test_VarUI8FromUI1 (void)

static void	test_VarUI8FromI2 (void)

static void	test_VarUI8FromUI2 (void)

static void	test_VarUI8FromUI4 (void)

static void	test_VarUI8FromR4 (void)

static void	test_VarUI8FromR8 (void)

static void	test_VarUI8FromDate (void)

static void	test_VarUI8FromBool (void)

static void	test_VarUI8FromI8 (void)

static void	test_VarUI8FromCy (void)

static void	test_VarUI8FromDec (void)

static void	test_VarUI8FromStr (void)

static void	test_VarUI8Copy (void)

static void	test_VarUI8ChangeTypeEx (void)

static void	test_VarR4FromI1 (void)

static void	test_VarR4FromUI1 (void)

static void	test_VarR4FromI2 (void)

static void	test_VarR4FromUI2 (void)

static void	test_VarR4FromI4 (void)

static void	test_VarR4FromUI4 (void)

static void	test_VarR4FromR8 (void)

static void	test_VarR4FromBool (void)

static void	test_VarR4FromCy (void)

static void	test_VarR4FromI8 (void)

static void	test_VarR4FromUI8 (void)

static void	test_VarR4FromDec (void)

static void	test_VarR4FromDate (void)

static void	test_VarR4FromStr (void)

static void	test_VarR4Copy (void)

static void	test_VarR4ChangeTypeEx (void)

static void	test_VarR8FromI1 (void)

static void	test_VarR8FromUI1 (void)

static void	test_VarR8FromI2 (void)

static void	test_VarR8FromUI2 (void)

static void	test_VarR8FromI4 (void)

static void	test_VarR8FromUI4 (void)

static void	test_VarR8FromR4 (void)

static void	test_VarR8FromBool (void)

static void	test_VarR8FromCy (void)

static void	test_VarR8FromI8 (void)

static void	test_VarR8FromUI8 (void)

static void	test_VarR8FromDec (void)

static void	test_VarR8FromDate (void)

static void	test_VarR8FromStr (void)

static void	test_VarR8Copy (void)

static void	test_VarR8ChangeTypeEx (void)

static void	test_VarR8Round (void)

static void	test_VarDateFromI1 (void)

static void	test_VarDateFromUI1 (void)

static void	test_VarDateFromI2 (void)

static void	test_VarDateFromUI2 (void)

static void	test_VarDateFromI4 (void)

static void	test_VarDateFromUI4 (void)

static void	test_VarDateFromR4 (void)

static void	test_VarDateFromR8 (void)

static void	test_VarDateFromBool (void)

static void	test_VarDateFromCy (void)

static void	test_VarDateFromI8 (void)

static void	test_VarDateFromUI8 (void)

static void	test_VarDateFromDec (void)

static void	test_VarDateFromStr (void)

static void	test_VarDateCopy (void)

static const char *	wtoascii (LPWSTR lpszIn)

static void	test_VarDateChangeTypeEx (void)

static void	test_VarCyFromI1 (void)

static void	test_VarCyFromUI1 (void)

static void	test_VarCyFromI2 (void)

static void	test_VarCyFromUI2 (void)

static void	test_VarCyFromI4 (void)

static void	test_VarCyFromUI4 (void)

static void	test_VarCyFromR4 (void)

static void	test_VarCyFromR8 (void)

static void	test_VarCyFromBool (void)

static void	test_VarCyFromI8 (void)

static void	test_VarCyFromUI8 (void)

static void	test_VarCyFromDec (void)

static void	test_VarCyFromDate (void)

static void	test_VarCyAdd (void)

static void	test_VarCyMul (void)

static void	test_VarCySub (void)

static void	test_VarCyAbs (void)

static void	test_VarCyNeg (void)

static void	test_VarCyMulI4 (void)

static void	test_VarCyMulI8 (void)

static void	test_VarCyCmp (void)

static void	test_VarCyCmpR8 (void)

static void	test_VarCyRound (void)

static void	test_VarCyFix (void)

static void	test_VarCyInt (void)

static void	test_VarDecFromI1 (void)

static void	test_VarDecFromI2 (void)

static void	test_VarDecFromI4 (void)

static void	test_VarDecFromI8 (void)

static void	test_VarDecFromUI1 (void)

static void	test_VarDecFromUI2 (void)

static void	test_VarDecFromUI4 (void)

static void	test_VarDecFromUI8 (void)

static void	test_VarDecFromBool (void)

static void	test_VarDecFromR4 (void)

static void	test_VarDecFromR8 (void)

static void	test_VarDecFromDate (void)

static void	test_VarDecFromStr (void)

static void	test_VarDecFromCy (void)

static void	test_VarDecAbs (void)

static void	test_VarDecNeg (void)

static void	test_VarDecAdd (void)

static void	test_VarDecSub (void)

static void	test_VarDecMul (void)

static void	test_VarDecDiv (void)

static void	test_VarDecCmp (void)

static void	test_VarDecCmpR8 (void)

static void	test_VarDecRound (void)

static void	test_VarBoolFromI1 (void)

static void	test_VarBoolFromUI1 (void)

static void	test_VarBoolFromI2 (void)

static void	test_VarBoolFromUI2 (void)

static void	test_VarBoolFromI4 (void)

static void	test_VarBoolFromUI4 (void)

static void	test_VarBoolFromR4 (void)

static void	test_VarBoolFromR8 (void)

static void	test_VarBoolFromCy (void)

static void	test_VarBoolFromI8 (void)

static void	test_VarBoolFromUI8 (void)

static void	test_VarBoolFromDec (void)

static void	test_VarBoolFromDate (void)

static void	test_VarBoolFromStr (void)

static void	test_VarBoolCopy (void)

static void	test_VarBoolChangeTypeEx (void)

static void	test_VarBstrFromI4 (void)

static void	test_VarBstrFromR4 (void)

static void	_BSTR_DATE (DATE dt, const char *str, int line)

static void	test_VarBstrFromDate (void)

static void	_BSTR_CY (LONG a, LONG b, const char *str, LCID lcid, int line)

static void	test_VarBstrFromCy (void)

static void	_BSTR_DEC (BYTE scale, BYTE sign, ULONG hi, ULONG mid, ULONGLONG lo, const char *str, LCID lcid, int line)

static void	test_VarBstrFromDec (void)

static void	test_VarBstrCmp (void)

static LPINTERNAL_BSTR	Get (const BSTR lpszString)

static BSTR	GetBSTR (const LPINTERNAL_BSTR bstr)

static void	test_SysStringLen (void)

static void	test_SysStringByteLen (void)

static void	test_SysAllocString (void)

static void	test_SysAllocStringLen (void)

static void	test_SysAllocStringByteLen (void)

static void	test_SysReAllocString (void)

static void	test_SysReAllocStringLen (void)

static void	test_BstrCopy (void)

static void	test_VarBstrCat (void)

static void	test_IUnknownClear (void)

static void	test_IUnknownCopy (void)

static void	test_IUnknownChangeTypeEx (void)

static void	test_IDispatchClear (void)

static void	test_IDispatchCopy (void)

static void	test_IDispatchChangeTypeEx (void)

static void	test_ErrorChangeTypeEx (void)

static void	test_EmptyChangeTypeEx (void)

static void	test_NullChangeTypeEx (void)

static void	test_UintChangeTypeEx (void)

static void	test_ClearCustData (void)

static void	test_NullByRef (void)

static void	test_ChangeType_keep_dst (void)

static void	test_bstr_cache (void)

static void	write_typelib (int res_no, const char *filename)

static const char *	create_test_typelib (int res_no)

static void	test_recinfo (void)

	START_TEST (vartype)

Variables
static HMODULE	hOleaut32

static BOOL	has_i8

static BOOL	has_locales

static const IDispatchVtbl	DummyDispatch_VTable

static const char *const	BadDateStrings []

Macro Definition Documentation

◆ _EXPECT_NO_OUT

#define _EXPECT_NO_OUT ( res ) ok(hres == res, "expected " #res ", got hres=0x%08x\n", hres)

Definition at line 67 of file vartype.c.

◆ _EXPECTRES

#define _EXPECTRES	(	res,
		x,
		fs
	)	ok(hres == S_OK && out == (CONV_TYPE)(x), "expected " #x ", got " fs "; hres=0x%08x\n", out, hres)

Definition at line 76 of file vartype.c.

◆ _VARBSTRCMP

#define _VARBSTRCMP	(	left,
		right,
		lcid,
		flags,
		result
	)

Value:

hres = VarBstrCmp(left,right,lcid,flags); \

ok(hres == result, "VarBstrCmp: expected " #result ", got hres=0x%x\n", hres)

VarBstrCmp

HRESULT WINAPI VarBstrCmp(BSTR pbstrLeft, BSTR pbstrRight, LCID lcid, DWORD dwFlags)

Definition: vartype.c:7158

right

GLdouble GLdouble right

Definition: glext.h:10859

left

GLint left

Definition: glext.h:7726

flags

GLbitfield flags

Definition: glext.h:7161

result

GLuint64EXT * result

Definition: glext.h:11304

hres

HRESULT hres

Definition: protocol.c:465

Definition at line 4808 of file vartype.c.

◆ BADVAR

#define BADVAR ( typ ) CHANGETYPEEX(typ); EXPECT_BADVAR

Definition at line 144 of file vartype.c.

◆ BOOL_STR

#define BOOL_STR	(	flags,
		str
	)

Value:

  hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, flags, VT_BSTR); \
  ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && \
     V_BSTR(&vDst) && !memcmp(V_BSTR(&vDst), str, sizeof(str)), \
     "hres=0x%X, type=%d (should be VT_BSTR), *bstr='%c'\n", \
     hres, V_VT(&vDst), V_BSTR(&vDst) ? *V_BSTR(&vDst) : '?'); \
  VariantClear(&vDst)

Definition at line 4494 of file vartype.c.

◆ BSTR_CY

#define BSTR_CY	(	a,
		b,
		str,
		lcid
	)	_BSTR_CY(a, b, str, lcid, __LINE__)

◆ BSTR_DATE

#define BSTR_DATE	(	dt,
		str
	)	_BSTR_DATE(dt,str,__LINE__)

◆ BSTR_DEC

#define BSTR_DEC	(	scale,
		sign,
		hi,
		lo,
		str,
		lcid
	)	_BSTR_DEC(scale, sign, hi, 0, lo, str, lcid, __LINE__)

◆ BSTR_DEC64

#define BSTR_DEC64	(	scale,
		sign,
		hi,
		mid,
		lo,
		str,
		lcid
	)	_BSTR_DEC(scale, sign, hi, mid, lo, str, lcid, __LINE__)

◆ CHANGETYPEEX

#define CHANGETYPEEX ( typ ) hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, typ)

Definition at line 134 of file vartype.c.

◆ CHECK_CALLED

#define CHECK_CALLED ( func )

Value:

    do { \
        ok(called_ ## func, "expected " #func "\n"); \
        expect_ ## func = called_ ## func = FALSE; \
    }while(0)

Definition at line 268 of file vartype.c.

◆ CHECK_EXPECT

#define CHECK_EXPECT ( func )

Value:

    do { \
        CHECK_EXPECT2(func); \
        expect_ ## func = FALSE; \
    }while(0)

Definition at line 262 of file vartype.c.

◆ CHECK_EXPECT2

#define CHECK_EXPECT2 ( func )

Value:

    do { \
        ok(expect_ ##func, "unexpected call " #func "\n"); \
        called_ ## func = TRUE; \
    }while(0)

Definition at line 256 of file vartype.c.

◆ CLEAR

#define CLEAR ( x ) memset(&(x), 0xBB, sizeof(x))

Definition at line 4232 of file vartype.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 22 of file vartype.c.

◆ COMMON_TYPETEST

#define COMMON_TYPETEST

Definition at line 195 of file vartype.c.

◆ CONST_VTABLE

#define CONST_VTABLE

Definition at line 21 of file vartype.c.

◆ CONV_TYPE [1/14]

#define CONV_TYPE signed char

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [2/14]

#define CONV_TYPE BYTE

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [3/14]

#define CONV_TYPE SHORT

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [4/14]

#define CONV_TYPE USHORT

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [5/14]

#define CONV_TYPE LONG

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [6/14]

#define CONV_TYPE ULONG

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [7/14]

#define CONV_TYPE LONG64

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [8/14]

#define CONV_TYPE ULONG64

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [9/14]

#define CONV_TYPE float

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [10/14]

#define CONV_TYPE double

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [11/14]

#define CONV_TYPE DATE

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [12/14]

#define CONV_TYPE CY

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [13/14]

#define CONV_TYPE DECIMAL

Definition at line 4268 of file vartype.c.

◆ CONV_TYPE [14/14]

#define CONV_TYPE VARIANT_BOOL

Definition at line 4268 of file vartype.c.

◆ CONVERT

#define CONVERT	(	func,
		val
	)	in = val; hres = func(in, &out)

Definition at line 82 of file vartype.c.

◆ CONVERT_BADDEC

#define CONVERT_BADDEC ( func )

Value:

  CONVERT_DEC(func,29,0,0,0);   EXPECT_INVALID; \
  CONVERT_DEC(func,0,0x1,0,0);  EXPECT_INVALID; \
  CONVERT_DEC(func,0,0x40,0,0); EXPECT_INVALID; \
  CONVERT_DEC(func,0,0x7f,0,0); EXPECT_INVALID;

Definition at line 107 of file vartype.c.

◆ CONVERT_CY

#define CONVERT_CY	(	func,
		val
	)	in.int64 = (LONGLONG)(val * CY_MULTIPLIER); hres = func(in, &out)

Definition at line 93 of file vartype.c.

◆ CONVERT_CY64

#define CONVERT_CY64	(	func,
		hi,
		lo
	)	S(in).Hi = hi; S(in).Lo = lo; in.int64 *= CY_MULTIPLIER; hres = func(in, &out)

Definition at line 95 of file vartype.c.

◆ CONVERT_DEC

#define CONVERT_DEC	(	func,
		scl,
		sgn,
		hi,
		lo
	)	SETDEC(in,scl,sgn,hi,lo); hres = func(&in, &out)

Definition at line 103 of file vartype.c.

◆ CONVERT_DEC64

#define CONVERT_DEC64	(	func,
		scl,
		sgn,
		hi,
		mid,
		lo
	)	SETDEC64(in,scl,sgn,hi,mid,lo); hres = func(&in, &out)

Definition at line 105 of file vartype.c.

◆ CONVERT_I8

#define CONVERT_I8	(	func,
		hi,
		lo
	)	in = hi; in = (in << 32) \| lo; hres = func(in, &out)

Definition at line 91 of file vartype.c.

◆ CONVERT_STR

#define CONVERT_STR	(	func,
		str,
		flags
	)

Value:

  SetLastError(0); \
  if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,ARRAY_SIZE(buff)); \
  hres = func(str ? buff : NULL,in,flags,&out)

Definition at line 113 of file vartype.c.

◆ CONVERTRANGE [1/2]

#define CONVERTRANGE	(	func,
		start,
		end
	)	for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT(i); };

Definition at line 4272 of file vartype.c.

◆ CONVERTRANGE [2/2]

#define CONVERTRANGE	(	func,
		start,
		end
	)

Value:

for (i = start; i < end; i++) { \

CONVERT(func, i); if (i) { EXPECT(VARIANT_TRUE); } else { EXPECT(VARIANT_FALSE); } }

start

GLuint start

Definition: gl.h:1545

end

GLuint GLuint end

Definition: gl.h:1545

i

GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i

Definition: glfuncs.h:248

EXPECT

#define EXPECT(x)

Definition: vartype.c:78

Definition at line 4272 of file vartype.c.

◆ CONVVARS

#define CONVVARS ( typ ) HRESULT hres; CONV_TYPE out; typ in

Definition at line 65 of file vartype.c.

◆ COPYTEST

#define COPYTEST	(	val,
		vt,
		srcval,
		dstval,
		srcref,
		dstref,
		fs
	)

Value:

  do { \
  HRESULT hres; VARIANTARG vSrc, vDst; CONV_TYPE in = val; \
  VariantInit(&vSrc); VariantInit(&vDst); \
  V_VT(&vSrc) = vt; srcval = in; \
  hres = VariantCopy(&vDst, &vSrc); \
  ok(hres == S_OK && V_VT(&vDst) == vt && dstval == in, \
     "copy hres 0x%X, type %d, value (" fs ") " fs "\n", hres, V_VT(&vDst), val, dstval); \
  V_VT(&vSrc) = vt|VT_BYREF; srcref = &in; \
  hres = VariantCopy(&vDst, &vSrc); \
  ok(hres == S_OK && V_VT(&vDst) == (vt|VT_BYREF) && dstref == &in, \
     "ref hres 0x%X, type %d, ref (%p) %p\n", hres, V_VT(&vDst), &in, dstref); \
  hres = VariantCopyInd(&vDst, &vSrc); \
  ok(hres == S_OK && V_VT(&vDst) == vt && dstval == in, \
     "ind hres 0x%X, type %d, value (" fs ") " fs "\n", hres, V_VT(&vDst), val, dstval); \
  } while(0)

Definition at line 118 of file vartype.c.

◆ CY_MULTIPLIER

#define CY_MULTIPLIER 10000

Definition at line 86 of file vartype.c.

◆ DATE_MAX

#define DATE_MAX 2958465

Definition at line 89 of file vartype.c.

◆ DATE_MIN

#define DATE_MIN -657434

Definition at line 88 of file vartype.c.

◆ DEFINE_EXPECT

#define DEFINE_EXPECT ( func ) static BOOL expect_ ## func = FALSE, called_ ## func = FALSE

Definition at line 250 of file vartype.c.

◆ DFS

#define DFS ( str )

Value:

  buff[0] = '\0'; out = 0.0; \
  if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,ARRAY_SIZE(buff)); \
  hres = VarDateFromStr(str ? buff : NULL,lcid,LOCALE_NOUSEROVERRIDE,&out)

Definition at line 2945 of file vartype.c.

◆ EXPECT

#define EXPECT ( x ) EXPECTRES(S_OK, (x))

Definition at line 78 of file vartype.c.

◆ EXPECT_BADVAR

#define EXPECT_BADVAR _EXPECT_NO_OUT(DISP_E_BADVARTYPE)

Definition at line 70 of file vartype.c.

◆ EXPECT_DBL

#define EXPECT_DBL ( x ) ok(hres == S_OK && fabs(out-(x))<=1e-14*(x), "expected %16.16g, got %16.16g; hres=0x%08x\n", (x), out, hres)

Definition at line 79 of file vartype.c.

◆ EXPECT_EQ

#define EXPECT_EQ _EXPECT_NO_OUT(VARCMP_EQ)

Definition at line 74 of file vartype.c.

◆ EXPECT_GT

#define EXPECT_GT _EXPECT_NO_OUT(VARCMP_GT)

Definition at line 73 of file vartype.c.

◆ EXPECT_INVALID

#define EXPECT_INVALID _EXPECT_NO_OUT(E_INVALIDARG)

Definition at line 71 of file vartype.c.

◆ EXPECT_LT

#define EXPECT_LT _EXPECT_NO_OUT(VARCMP_LT)

Definition at line 72 of file vartype.c.

◆ EXPECT_MISMATCH

#define EXPECT_MISMATCH _EXPECT_NO_OUT(DISP_E_TYPEMISMATCH)

Definition at line 69 of file vartype.c.

◆ EXPECT_OVERFLOW

#define EXPECT_OVERFLOW _EXPECT_NO_OUT(DISP_E_OVERFLOW)

Definition at line 68 of file vartype.c.

◆ EXPECTCY

#define EXPECTCY ( x )

Value:

ok((hres == S_OK && out.int64 == (LONGLONG)(x*CY_MULTIPLIER)), \

"expected " #x "*CY_MULTIPLIER, got (%8x %8x); hres=0x%08x\n", S(out).Hi, S(out).Lo, hres)

ok

#define ok(value,...)

Definition: atltest.h:57

CY_MULTIPLIER

#define CY_MULTIPLIER

Definition: vartype.c:38

x

GLint GLint GLint GLint GLint x

Definition: gl.h:1548

S

#define S(x)

Definition: test.h:217

S

Definition: movable.cpp:9

LONGLONG

int64_t LONGLONG

Definition: typedefs.h:68

Definition at line 3201 of file vartype.c.

◆ EXPECTCY64

#define EXPECTCY64	(	x,
		y
	)

Value:

  ok(hres == S_OK && S(out).Hi == (LONG)x && S(out).Lo == y, \
     "expected " #x " " #y " (%u,%u), got (%u,%u); hres=0x%08x\n", \
      (ULONG)(x), (ULONG)(y), S(out).Hi, S(out).Lo, hres)

Definition at line 3205 of file vartype.c.

◆ EXPECTDEC

#define EXPECTDEC	(	scl,
		sgn,
		hi,
		lo
	)

Value:

  ok(hres == S_OK && \
  S(U(out)).scale == (BYTE)(scl) && S(U(out)).sign == (BYTE)(sgn) && \
  out.Hi32 == (ULONG)(hi) && U1(out).Lo64 == (ULONG64)(lo), \
  "expected (%d,%d,%d,(%x %x)), got (%d,%d,%d,(%x %x)) hres 0x%08x\n", \
  scl, sgn, hi, (LONG)((LONG64)(lo) >> 32), (LONG)((lo) & 0xffffffff), S(U(out)).scale, \
  S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)

Definition at line 3676 of file vartype.c.

◆ EXPECTDEC64

#define EXPECTDEC64	(	scl,
		sgn,
		hi,
		mid,
		lo
	)

Value:

  ok(hres == S_OK && \
  S(U(out)).scale == (BYTE)(scl) && S(U(out)).sign == (BYTE)(sgn) && \
  out.Hi32 == (ULONG)(hi) && S1(U1(out)).Mid32 == (ULONG)(mid) && \
  S1(U1(out)).Lo32 == (ULONG)(lo), \
  "expected (%d,%d,%d,(%x %x)), got (%d,%d,%d,(%x %x)) hres 0x%08x\n", \
  scl, sgn, hi, (LONG)(mid), (LONG)(lo), S(U(out)).scale, \
  S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)

Definition at line 3683 of file vartype.c.

◆ EXPECTDECI

#define EXPECTDECI if (i < 0) EXPECTDEC(0, 0x80, 0, -i); else EXPECTDEC(0, 0, 0, i)

Definition at line 3697 of file vartype.c.

◆ EXPECTDECZERO

#define EXPECTDECZERO ( )

Value:

  ok(hres == S_OK && S(U(out)).scale == 0 && \
  (S(U(out)).sign == 0 || S(U(out)).sign == 0x80) && out.Hi32 == 0 && U1(out).Lo64 == 0, \
  "expected zero, got (%d,%d,%d,(%x %x)) hres 0x%08x\n", \
  S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)

Definition at line 3692 of file vartype.c.

◆ EXPECTI8

#define EXPECTI8 ( x )

Value:

  ok((hres == S_OK && out == (CONV_TYPE)(x)), \
     "expected " #x "(%u,%u), got (%u,%u); hres=0x%08x\n", \
      (ULONG)((LONG64)(x) >> 32), (ULONG)((x) & 0xffffffff), \
      (ULONG)(out >> 32), (ULONG)(out & 0xffffffff), hres)

Definition at line 1865 of file vartype.c.

◆ EXPECTI864

#define EXPECTI864	(	x,
		y
	)

Value:

  ok(hres == S_OK && (out >> 32) == (CONV_TYPE)(x) && (out & 0xffffffff) == (CONV_TYPE)(y), \
     "expected " #x "(%u,%u), got (%u,%u); hres=0x%08x\n", \
      (ULONG)(x), (ULONG)(y), \
      (ULONG)(out >> 32), (ULONG)(out & 0xffffffff), hres)

Definition at line 1871 of file vartype.c.

◆ EXPECTRES [1/4]

#define EXPECTRES	(	res,
		x
	)	_EXPECTRES(res, x, "%d")

Definition at line 4270 of file vartype.c.

◆ EXPECTRES [2/4]

#define EXPECTRES	(	res,
		x
	)	_EXPECTRES(res, x, "%u")

Definition at line 4270 of file vartype.c.

◆ EXPECTRES [3/4]

#define EXPECTRES	(	res,
		x
	)	_EXPECTRES(res, x, "%15.15f")

Definition at line 4270 of file vartype.c.

◆ EXPECTRES [4/4]

#define EXPECTRES	(	res,
		x
	)	_EXPECTRES(res, x, "%d")

Definition at line 4270 of file vartype.c.

◆ HAS_UINT64_TO_FLOAT

#define HAS_UINT64_TO_FLOAT

Definition at line 39 of file vartype.c.

◆ INITIAL_TYPETEST

#define INITIAL_TYPETEST	(	vt,
		val,
		fs
	)

Value:

  VariantInit(&vSrc); \
  VariantInit(&vDst); \
  V_VT(&vSrc) = vt; \
  (val(&vSrc)) = in; \
  TYPETEST(VT_I1, V_I1(&vDst), fs); \
  TYPETEST(VT_UI2, V_UI2(&vDst), fs); \
  TYPETEST(VT_UI4, V_UI4(&vDst), fs); \
  TYPETEST(VT_INT, V_INT(&vDst), fs); \
  TYPETEST(VT_UINT, V_UINT(&vDst), fs); \
  TYPETEST(VT_UI1, V_UI1(&vDst), fs); \
  TYPETEST(VT_I2, V_I2(&vDst), fs); \
  TYPETEST(VT_I4, V_I4(&vDst), fs); \
  TYPETEST(VT_R4, V_R4(&vDst), fs); \
  TYPETEST(VT_R8, V_R8(&vDst), fs); \
  TYPETEST(VT_DATE, V_DATE(&vDst), fs); \
  if (has_i8) \
  { \
    TYPETEST(VT_I8, V_I8(&vDst), fs); \
    TYPETEST(VT_UI8, V_UI8(&vDst), fs); \
  }

Definition at line 147 of file vartype.c.

◆ INITIAL_TYPETESTI8

#define INITIAL_TYPETESTI8	(	vt,
		val
	)

Value:

  VariantInit(&vSrc); \
  VariantInit(&vDst); \
  V_VT(&vSrc) = vt; \
  (val(&vSrc)) = in; \
  TYPETESTI8(VT_I1, V_I1(&vDst)); \
  TYPETESTI8(VT_UI1, V_UI1(&vDst)); \
  TYPETESTI8(VT_I2, V_I2(&vDst)); \
  TYPETESTI8(VT_UI2, V_UI2(&vDst)); \
  TYPETESTI8(VT_I4, V_I4(&vDst)); \
  TYPETESTI8(VT_UI4, V_UI4(&vDst)); \
  TYPETESTI8(VT_INT, V_INT(&vDst)); \
  TYPETESTI8(VT_UINT, V_UINT(&vDst)); \
  TYPETESTI8(VT_R4, V_R4(&vDst)); \
  TYPETESTI8(VT_R8, V_R8(&vDst)); \
  TYPETESTI8(VT_DATE, V_DATE(&vDst)); \
  TYPETESTI8(VT_I8, V_I8(&vDst)); \
  TYPETESTI8(VT_UI8, V_UI8(&vDst))

Definition at line 176 of file vartype.c.

◆ IS_MODERN_VTYPE

#define IS_MODERN_VTYPE ( vt )

Value:

(vt==VT_VARIANT||vt==VT_DECIMAL|| \

vt==VT_I1||vt==VT_UI2||vt==VT_UI4||vt == VT_INT||vt == VT_UINT)

VT_DECIMAL

@ VT_DECIMAL

Definition: compat.h:2309

VT_VARIANT

@ VT_VARIANT

Definition: compat.h:2307

Definition at line 61 of file vartype.c.

◆ MATH1 [1/2]

#define MATH1 ( func ) hres = func(&l, &out)

Definition at line 3875 of file vartype.c.

◆ MATH1 [2/2]

#define MATH1	(	func,
		l
	)	left = (double)l; VarCyFromR8(left, &cyLeft); hres = func(cyLeft, &out)

Definition at line 3875 of file vartype.c.

◆ MATH2 [1/2]

#define MATH2 ( func ) hres = func(&l, &r, &out)

Definition at line 3877 of file vartype.c.

◆ MATH2 [2/2]

#define MATH2	(	func,
		l,
		r
	)

Value:

  left = (double)l; right = (double)r; \
  VarCyFromR8(left, &cyLeft); VarCyFromR8(right, &cyRight); \
  hres = func(cyLeft, cyRight, &out)

Definition at line 3877 of file vartype.c.

◆ MATH3

#define MATH3 ( func ) hres = func(&l, r)

Definition at line 3879 of file vartype.c.

◆ MATHCMP

#define MATHCMP	(	l,
		r
	)

Value:

left = l; right = r; VarCyFromR8(left, &cyLeft); VarCyFromR8(right, &cyRight); \

hres = VarCyCmp(cyLeft, cyRight)

VarCyCmp

HRESULT WINAPI VarCyCmp(CY cyLeft, CY cyRight)

Definition: vartype.c:4012

Definition at line 3541 of file vartype.c.

◆ MATHCMPR8

#define MATHCMPR8	(	l,
		r
	)

Value:

left = l; right = r; VarCyFromR8(left, &cyLeft); \

hres = VarCyCmpR8(cyLeft, right);

VarCyCmpR8

HRESULT WINAPI VarCyCmpR8(CY cyLeft, double dblRight)

Definition: vartype.c:4046

Definition at line 3563 of file vartype.c.

◆ MATHFIX

#define MATHFIX ( l )

Value:

left = l; VarCyFromR8(left, &cyLeft); \

hres = VarCyFix(cyLeft, &out)

VarCyFix

HRESULT WINAPI VarCyFix(CY cyIn, CY *pCyOut)

Definition: vartype.c:3902

Definition at line 3619 of file vartype.c.

◆ MATHINT

#define MATHINT ( l )

Value:

left = l; VarCyFromR8(left, &cyLeft); \

hres = VarCyInt(cyLeft, &out)

VarCyInt

HRESULT WINAPI VarCyInt(CY cyIn, CY *pCyOut)

Definition: vartype.c:3926

Definition at line 3644 of file vartype.c.

◆ MATHMULI4

#define MATHMULI4	(	l,
		r
	)

Value:

left = l; right = r; VarCyFromR8(left, &cyLeft); \

hres = VarCyMulI4(cyLeft, right, &out)

VarCyMulI4

HRESULT WINAPI VarCyMulI4(CY cyLeft, LONG lRight, CY *pCyOut)

Definition: vartype.c:3831

Definition at line 3511 of file vartype.c.

◆ MATHMULI8

#define MATHMULI8	(	l,
		r
	)

Value:

left = l; right = r; VarCyFromR8(left, &cyLeft); \

hres = VarCyMulI8(cyLeft, right, &out)

VarCyMulI8

HRESULT WINAPI VarCyMulI8(CY cyLeft, LONG64 llRight, CY *pCyOut)

Definition: vartype.c:4073

Definition at line 3526 of file vartype.c.

◆ MATHRND [1/2]

#define MATHRND	(	l,
		r
	)	left = l; right = r; hres = VarR8Round(left, right, &out)

Definition at line 3587 of file vartype.c.

◆ MATHRND [2/2]

#define MATHRND	(	l,
		r
	)

Value:

left = l; right = r; VarCyFromR8(left, &cyLeft); \

hres = VarCyRound(cyLeft, right, &out)

VarCyRound

HRESULT WINAPI VarCyRound(CY cyIn, int cDecimals, CY *pCyOut)

Definition: vartype.c:3974

Definition at line 3587 of file vartype.c.

◆ MATHVARS1 [1/2]

#define MATHVARS1 HRESULT hres; double left = 0.0; CY cyLeft, out

Definition at line 3871 of file vartype.c.

◆ MATHVARS1 [2/2]

#define MATHVARS1 HRESULT hres; DECIMAL l, out

Definition at line 3871 of file vartype.c.

◆ MATHVARS2 [1/2]

#define MATHVARS2 MATHVARS1; double right = 0.0; CY cyRight

Definition at line 3873 of file vartype.c.

◆ MATHVARS2 [2/2]

#define MATHVARS2 MATHVARS1; DECIMAL r

Definition at line 3873 of file vartype.c.

◆ MISMATCH

#define MISMATCH ( typ ) CHANGETYPEEX(typ); EXPECT_MISMATCH

Definition at line 145 of file vartype.c.

◆ MKRELDATE

#define MKRELDATE	(	day,
		mth
	)

Value:

st.wMonth = mth; st.wDay = day; \

SystemTimeToVariantTime(&st,&relative)

day

static DOUBLE day(DOUBLE time)

Definition: date.c:117

Definition at line 2950 of file vartype.c.

◆ NEGATIVE_TYPETEST

#define NEGATIVE_TYPETEST	(	vt,
		val,
		fs,
		vtneg,
		valneg
	)

Value:

  in = -in; \
  VariantInit(&vSrc); \
  VariantInit(&vDst); \
  V_VT(&vSrc) = vt; \
  (val(&vSrc)) = in; \
  TYPETEST(vtneg, valneg(&vDst), fs);

Definition at line 168 of file vartype.c.

◆ NUM_CUST_ITEMS

#define NUM_CUST_ITEMS 16

Definition at line 5823 of file vartype.c.

◆ OVERFLOWRANGE

#define OVERFLOWRANGE	(	func,
		start,
		end
	)	for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT_OVERFLOW; };

Definition at line 84 of file vartype.c.

◆ SET_EXPECT

#define SET_EXPECT ( func ) do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)

Definition at line 253 of file vartype.c.

◆ SETDEC

#define SETDEC	(	dec,
		scl,
		sgn,
		hi,
		lo
	)

Value:

S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \

dec.Hi32 = (ULONG)hi; U1(dec).Lo64 = (ULONG64)lo

dec

ios_base &_STLP_CALL dec(ios_base &__s)

Definition: _ios_base.h:321

Definition at line 97 of file vartype.c.

◆ SETDEC64

#define SETDEC64	(	dec,
		scl,
		sgn,
		hi,
		mid,
		lo
	)

Value:

S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \

dec.Hi32 = (ULONG)hi; S1(U1(dec)).Mid32 = mid; S1(U1(dec)).Lo32 = lo;

Definition at line 100 of file vartype.c.

◆ TYPETEST

#define TYPETEST	(	typ,
		res,
		fs
	)

Value:

  CHANGETYPEEX(typ); \
  ok(hres == S_OK && V_VT(&vDst) == typ && (CONV_TYPE)res == in, \
     "hres=0x%X, type=%d (should be %d(" #typ ")), value=" fs " (should be " fs ")\n", \
      hres, V_VT(&vDst), typ, (CONV_TYPE)res, in);

Definition at line 136 of file vartype.c.

◆ TYPETESTI8

#define TYPETESTI8	(	typ,
		res
	)

Value:

  CHANGETYPEEX(typ); \
  ok(hres == S_OK && V_VT(&vDst) == typ && (CONV_TYPE)res == in, \
     "hres=0x%X, type=%d (should be %d(" #typ ")), value=%d (should be 1)\n", \
      hres, V_VT(&vDst), typ, (int)res);

Definition at line 140 of file vartype.c.

◆ VARBSTRCMP

#define VARBSTRCMP	(	left,
		right,
		flags,
		result
	)	_VARBSTRCMP(left,right,lcid,flags,result)

Definition at line 4811 of file vartype.c.

Typedef Documentation

◆ INTERNAL_BSTR

typedef struct tagINTERNAL_BSTR INTERNAL_BSTR

◆ LPINTERNAL_BSTR

typedef struct tagINTERNAL_BSTR * LPINTERNAL_BSTR

Function Documentation

◆ _BSTR_CY()

static void _BSTR_CY	(	LONG	a,
		LONG	b,
		const char *	str,
		LCID	lcid,
		int	line
	)

static

Definition at line 4675 of file vartype.c.

{
  HRESULT hr;
  BSTR bstr = NULL;
  char buff[256];
  CY l;
 
  S(l).Lo = b;
  S(l).Hi = a;
  hr = VarBstrFromCy(l, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
  ok(hr == S_OK, "got hr 0x%08x\n", hr);
 
  if(bstr)
  {
    WideCharToMultiByte(CP_ACP, 0, bstr, -1, buff, sizeof(buff), 0, 0);
    SysFreeString(bstr);
  }
  else
    buff[0] = 0;
 
  if(hr == S_OK)
  {
    ok_(__FILE__, line)(!strcmp(str, buff), "Expected '%s', got '%s'\n", str, buff);
  }
}

◆ _BSTR_DATE()

static void _BSTR_DATE	(	DATE	dt,
		const char *	str,
		int	line
	)

static

Definition at line 4638 of file vartype.c.

{
  LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
  char buff[256];
  BSTR bstr = NULL;
  HRESULT hres;
 
  hres = VarBstrFromDate(dt, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
  if (bstr)
  {
    WideCharToMultiByte(CP_ACP, 0, bstr, -1, buff, sizeof(buff), 0, 0);
    SysFreeString(bstr);
  }
  else
    buff[0] = 0;
  ok_(__FILE__, line)(hres == S_OK && !strcmp(str, buff),
      "Expected '%s', got '%s', hres = 0x%08x\n", str, buff, hres);
}

◆ _BSTR_DEC()

static void _BSTR_DEC	(	BYTE	scale,
		BYTE	sign,
		ULONG	hi,
		ULONG	mid,
		ULONGLONG	lo,
		const char *	str,
		LCID	lcid,
		int	line
	)

static

Definition at line 4726 of file vartype.c.

{
  char buff[256];
  HRESULT hr;
  BSTR bstr = NULL;
  DECIMAL dec;
 
  SETDEC64(dec, scale, sign, hi, mid, lo);
  hr = VarBstrFromDec(&dec, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
  ok_(__FILE__, line)(hr == S_OK, "got hr 0x%08x\n", hr);
 
  if(bstr)
  {
    WideCharToMultiByte(CP_ACP, 0, bstr, -1, buff, sizeof(buff), 0, 0);
    SysFreeString(bstr);
  }
  else
    buff[0] = 0;
 
  if(hr == S_OK)
  {
    ok_(__FILE__, line)(!strcmp(str, buff), "Expected '%s', got '%s'\n", str, buff);
  }
}

◆ create_test_typelib()

static const char * create_test_typelib ( int res_no )

static

Definition at line 5969 of file vartype.c.

{
    static char filename[MAX_PATH];
 
    GetTempFileNameA( ".", "tlb", 0, filename );
    write_typelib(res_no, filename);
    return filename;
}

Referenced by test_recinfo().

◆ DEFINE_EXPECT()

DEFINE_EXPECT ( dispatch_invoke )

◆ DEFINE_GUID()

DEFINE_GUID	(	UUID_test_struct	,
		0x4029f190	,
		0xca4a	,
		0x4611	,
		0xae	,
		0xb9	,
		0x67	,
		0x39	,
		0x83	,
		0xcb	,
		0x96	,
		0xdd
	)

◆ DummyDispatch_AddRef()

static ULONG WINAPI DummyDispatch_AddRef ( IDispatch * iface )

static

Definition at line 296 of file vartype.c.

{
  DummyDispatch *This = impl_from_IDispatch(iface);
  return InterlockedIncrement(&This->ref);
}

◆ DummyDispatch_GetIDsOfNames()

static HRESULT WINAPI DummyDispatch_GetIDsOfNames	(	IDispatch *	iface,
		REFIID	riid,
		LPOLESTR *	names,
		UINT	cnames,
		LCID	lcid,
		DISPID *	dispid
	)

static

Definition at line 336 of file vartype.c.

{
  ok(0, "Unexpected call\n");
  return E_NOTIMPL;
}

◆ DummyDispatch_GetTypeInfo()

static HRESULT WINAPI DummyDispatch_GetTypeInfo	(	IDispatch *	iface,
		UINT	tinfo,
		LCID	lcid,
		ITypeInfo **	ti
	)

static

Definition at line 330 of file vartype.c.

{
  ok(0, "Unexpected call\n");
  return E_NOTIMPL;
}

◆ DummyDispatch_GetTypeInfoCount()

static HRESULT WINAPI DummyDispatch_GetTypeInfoCount	(	IDispatch *	iface,
		UINT *	pctinfo
	)

static

Definition at line 324 of file vartype.c.

{
  ok(0, "Unexpected call\n");
  return E_NOTIMPL;
}

◆ DummyDispatch_Invoke()

static HRESULT WINAPI DummyDispatch_Invoke	(	IDispatch *	iface,
		DISPID	dispid,
		REFIID	riid,
		LCID	lcid,
		WORD	wFlags,
		DISPPARAMS *	params,
		VARIANT *	res,
		EXCEPINFO *	ei,
		UINT *	arg_err
	)

static

Definition at line 343 of file vartype.c.

{
  DummyDispatch *This = impl_from_IDispatch(iface);
 
  CHECK_EXPECT(dispatch_invoke);
 
  ok(dispid == DISPID_VALUE, "got dispid %d\n", dispid);
  ok(IsEqualIID(riid, &IID_NULL), "go riid %s\n", wine_dbgstr_guid(riid));
  ok(wFlags == DISPATCH_PROPERTYGET, "Flags wrong\n");
 
  ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
  ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
  ok(params->cArgs == 0, "got %d\n", params->cArgs);
  ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
 
  ok(res != NULL, "got %p\n", res);
  ok(V_VT(res) == VT_EMPTY, "got %d\n", V_VT(res));
  ok(ei == NULL, "got %p\n", ei);
  ok(arg_err == NULL, "got %p\n", arg_err);
 
  if (This->bFailInvoke)
    return E_OUTOFMEMORY;
 
  V_VT(res) = This->vt;
  if (This->vt == VT_UI1)
      V_UI1(res) = 1;
  else
      memset(res, 0, sizeof(*res));
 
  return S_OK;
}

◆ DummyDispatch_QueryInterface()

static HRESULT WINAPI DummyDispatch_QueryInterface	(	IDispatch *	iface,
		REFIID	riid,
		void **	ppvObject
	)

static

Definition at line 308 of file vartype.c.

{
  *ppvObject = NULL;
 
  if (IsEqualIID(riid, &IID_IDispatch) ||
      IsEqualIID(riid, &IID_IUnknown))
  {
      *ppvObject = iface;
      IDispatch_AddRef(iface);
  }
 
  return *ppvObject ? S_OK : E_NOINTERFACE;
}

◆ DummyDispatch_Release()

static ULONG WINAPI DummyDispatch_Release ( IDispatch * iface )

static

Definition at line 302 of file vartype.c.

{
  DummyDispatch *This = impl_from_IDispatch(iface);
  return InterlockedDecrement(&This->ref);
}

◆ Get()

static LPINTERNAL_BSTR Get ( const BSTR lpszString )

inlinestatic

Definition at line 4895 of file vartype.c.

{
  return lpszString ? (LPINTERNAL_BSTR)((char*)lpszString - sizeof(DWORD)) : NULL;
}

Referenced by DECLARE_INTERFACE_(), test_BstrCopy(), test_SysAllocString(), test_SysAllocStringByteLen(), test_SysAllocStringLen(), test_SysReAllocString(), and test_SysReAllocStringLen().

◆ GetBSTR()

static BSTR GetBSTR ( const LPINTERNAL_BSTR bstr )

inlinestatic

Definition at line 4900 of file vartype.c.

{
  return (BSTR)bstr->szString;
}

Referenced by test_SysStringByteLen(), and test_SysStringLen().

◆ impl_from_IDispatch()

static DummyDispatch * impl_from_IDispatch ( IDispatch * iface )

inlinestatic

Definition at line 291 of file vartype.c.

{
  return CONTAINING_RECORD(iface, DummyDispatch, IDispatch_iface);
}

Referenced by DummyDispatch_AddRef(), DummyDispatch_Invoke(), and DummyDispatch_Release().

◆ init_test_dispatch()

static void init_test_dispatch	(	LONG	ref,
		VARTYPE	vt,
		DummyDispatch *	dispatch
	)

static

Definition at line 392 of file vartype.c.

{
    dispatch->IDispatch_iface.lpVtbl = &DummyDispatch_VTable;
    dispatch->ref = ref;
    dispatch->vt = vt;
    dispatch->bFailInvoke = FALSE;
}

Referenced by test_IDispatchChangeTypeEx(), test_IDispatchClear(), test_IDispatchCopy(), test_IUnknownChangeTypeEx(), test_IUnknownClear(), test_IUnknownCopy(), test_recinfo(), and test_VarUI1FromDisp().

◆ START_TEST()

START_TEST ( vartype )

Definition at line 6115 of file vartype.c.

{
  hOleaut32 = GetModuleHandleA("oleaut32.dll");
 
  has_i8 = GetProcAddress(hOleaut32, "VarI8FromI1") != NULL;
  has_locales = has_i8 && GetProcAddress(hOleaut32, "GetVarConversionLocaleSetting") != NULL;
 
  trace("LCIDs: System=0x%08x, User=0x%08x\n", GetSystemDefaultLCID(),
        GetUserDefaultLCID());
 
  test_bstr_cache();
 
  test_VarI1FromI2();
  test_VarI1FromI4();
  test_VarI1FromI8();
  test_VarI1FromUI1();
  test_VarI1FromUI2();
  test_VarI1FromUI4();
  test_VarI1FromUI8();
  test_VarI1FromBool();
  test_VarI1FromR4();
  test_VarI1FromR8();
  test_VarI1FromDate();
  test_VarI1FromCy();
  test_VarI1FromDec();
  test_VarI1FromStr();
  test_VarUI1FromDisp();
  test_VarI1Copy();
  test_VarI1ChangeTypeEx();
 
  test_VarUI1FromI1();
  test_VarUI1FromI2();
  test_VarUI1FromI4();
  test_VarUI1FromI8();
  test_VarUI1FromUI2();
  test_VarUI1FromUI4();
  test_VarUI1FromUI8();
  test_VarUI1FromBool();
  test_VarUI1FromR4();
  test_VarUI1FromR8();
  test_VarUI1FromDate();
  test_VarUI1FromCy();
  test_VarUI1FromDec();
  test_VarUI1FromStr();
  test_VarUI1Copy();
  test_VarUI1ChangeTypeEx();
 
  test_VarI2FromI1();
  test_VarI2FromI4();
  test_VarI2FromI8();
  test_VarI2FromUI1();
  test_VarI2FromUI2();
  test_VarI2FromUI4();
  test_VarI2FromUI8();
  test_VarI2FromBool();
  test_VarI2FromR4();
  test_VarI2FromR8();
  test_VarI2FromDate();
  test_VarI2FromCy();
  test_VarI2FromDec();
  test_VarI2FromStr();
  test_VarI2Copy();
  test_VarI2ChangeTypeEx();
 
  test_VarUI2FromI1();
  test_VarUI2FromI2();
  test_VarUI2FromI4();
  test_VarUI2FromI8();
  test_VarUI2FromUI1();
  test_VarUI2FromUI4();
  test_VarUI2FromUI8();
  test_VarUI2FromBool();
  test_VarUI2FromR4();
  test_VarUI2FromR8();
  test_VarUI2FromDate();
  test_VarUI2FromCy();
  test_VarUI2FromDec();
  test_VarUI2FromStr();
  test_VarUI2Copy();
  test_VarUI2ChangeTypeEx();
 
  test_VarI4FromI1();
  test_VarI4FromI2();
  test_VarI4FromI8();
  test_VarI4FromUI1();
  test_VarI4FromUI2();
  test_VarI4FromUI4();
  test_VarI4FromUI8();
  test_VarI4FromBool();
  test_VarI4FromR4();
  test_VarI4FromR8();
  test_VarI4FromDate();
  test_VarI4FromCy();
  test_VarI4FromDec();
  test_VarI4FromStr();
  test_VarI4Copy();
  test_VarI4ChangeTypeEx();
 
  test_VarUI4FromI1();
  test_VarUI4FromI2();
  test_VarUI4FromUI2();
  test_VarUI4FromI8();
  test_VarUI4FromUI1();
  test_VarUI4FromI4();
  test_VarUI4FromUI8();
  test_VarUI4FromBool();
  test_VarUI4FromR4();
  test_VarUI4FromR8();
  test_VarUI4FromDate();
  test_VarUI4FromCy();
  test_VarUI4FromDec();
  test_VarUI4FromStr();
  test_VarUI4Copy();
  test_VarUI4ChangeTypeEx();
 
  test_VarI8FromI1();
  test_VarI8FromUI1();
  test_VarI8FromI2();
  test_VarI8FromUI2();
  test_VarI8FromUI4();
  test_VarI8FromR4();
  test_VarI8FromR8();
  test_VarI8FromBool();
  test_VarI8FromUI8();
  test_VarI8FromCy();
  test_VarI8FromDec();
  test_VarI8FromDate();
  test_VarI8FromStr();
  test_VarI8Copy();
  test_VarI8ChangeTypeEx();
 
  test_VarUI8FromI1();
  test_VarUI8FromUI1();
  test_VarUI8FromI2();
  test_VarUI8FromUI2();
  test_VarUI8FromUI4();
  test_VarUI8FromR4();
  test_VarUI8FromR8();
  test_VarUI8FromBool();
  test_VarUI8FromI8();
  test_VarUI8FromCy();
  test_VarUI8FromDec();
  test_VarUI8FromDate();
  test_VarUI8FromStr();
  test_VarUI8Copy();
  test_VarUI8ChangeTypeEx();
 
  test_VarR4FromI1();
  test_VarR4FromUI1();
  test_VarR4FromI2();
  test_VarR4FromUI2();
  test_VarR4FromI4();
  test_VarR4FromUI4();
  test_VarR4FromR8();
  test_VarR4FromBool();
  test_VarR4FromCy();
  test_VarR4FromI8();
  test_VarR4FromUI8();
  test_VarR4FromDec();
  test_VarR4FromDate();
  test_VarR4FromStr();
  test_VarR4Copy();
  test_VarR4ChangeTypeEx();
 
  test_VarR8FromI1();
  test_VarR8FromUI1();
  test_VarR8FromI2();
  test_VarR8FromUI2();
  test_VarR8FromI4();
  test_VarR8FromUI4();
  test_VarR8FromR4();
  test_VarR8FromBool();
  test_VarR8FromCy();
  test_VarR8FromI8();
  test_VarR8FromUI8();
  test_VarR8FromDec();
  test_VarR8FromDate();
  test_VarR8FromStr();
  test_VarR8Copy();
  test_VarR8ChangeTypeEx();
  test_VarR8Round();
 
  test_VarDateFromI1();
  test_VarDateFromUI1();
  test_VarDateFromI2();
  test_VarDateFromUI2();
  test_VarDateFromI4();
  test_VarDateFromUI4();
  test_VarDateFromR4();
  test_VarDateFromR8();
  test_VarDateFromBool();
  test_VarDateFromCy();
  test_VarDateFromI8();
  test_VarDateFromUI8();
  test_VarDateFromDec();
  test_VarDateFromStr();
  test_VarDateCopy();
  test_VarDateChangeTypeEx();
 
  test_VarCyFromI1();
  test_VarCyFromUI1();
  test_VarCyFromI2();
  test_VarCyFromUI2();
  test_VarCyFromI4();
  test_VarCyFromUI4();
  test_VarCyFromR4();
  test_VarCyFromR8();
  test_VarCyFromBool();
  test_VarCyFromI8();
  test_VarCyFromUI8();
  test_VarCyFromDec();
  test_VarCyFromDate();
 
  test_VarCyAdd();
  test_VarCyMul();
  test_VarCySub();
  test_VarCyAbs();
  test_VarCyNeg();
  test_VarCyMulI4();
  test_VarCyMulI8();
  test_VarCyCmp();
  test_VarCyCmpR8();
  test_VarCyRound();
  test_VarCyFix();
  test_VarCyInt();
 
  test_VarDecFromI1();
  test_VarDecFromI2();
  test_VarDecFromI4();
  test_VarDecFromI8();
  test_VarDecFromUI1();
  test_VarDecFromUI2();
  test_VarDecFromUI4();
  test_VarDecFromUI8();
  test_VarDecFromR4();
  test_VarDecFromR8();
  test_VarDecFromDate();
  test_VarDecFromStr();
  test_VarDecFromCy();
  test_VarDecFromDate();
  test_VarDecFromBool();
 
  test_VarDecAbs();
  test_VarDecNeg();
  test_VarDecAdd();
  test_VarDecSub();
  test_VarDecCmp();
  test_VarDecCmpR8();
  test_VarDecMul();
  test_VarDecDiv();
  test_VarDecRound();
 
  test_VarBoolFromI1();
  test_VarBoolFromUI1();
  test_VarBoolFromI2();
  test_VarBoolFromUI2();
  test_VarBoolFromI4();
  test_VarBoolFromUI4();
  test_VarBoolFromR4();
  test_VarBoolFromR8();
  test_VarBoolFromCy();
  test_VarBoolFromI8();
  test_VarBoolFromUI8();
  test_VarBoolFromDec();
  test_VarBoolFromDate();
  test_VarBoolFromStr();
  test_VarBoolCopy();
  test_VarBoolChangeTypeEx();
 
  test_VarBstrFromI4();
  test_VarBstrFromR4();
  test_VarBstrFromDate();
  test_VarBstrFromCy();
  test_VarBstrFromDec();
  test_VarBstrCmp();
  test_SysStringLen();
  test_SysStringByteLen();
  test_SysAllocString();
  test_SysAllocStringLen();
  test_SysAllocStringByteLen();
  test_SysReAllocString();
  test_SysReAllocStringLen();
  test_BstrCopy();
  test_VarBstrCat();
 
  test_IUnknownClear();
  test_IUnknownCopy();
  test_IUnknownChangeTypeEx();
 
  test_IDispatchClear();
  test_IDispatchCopy();
  test_IDispatchChangeTypeEx();
 
  test_ErrorChangeTypeEx();
  test_EmptyChangeTypeEx();
  test_NullChangeTypeEx();
  test_UintChangeTypeEx();
 
  test_ClearCustData();
 
  test_NullByRef();
  test_ChangeType_keep_dst();
 
  test_recinfo();
}

◆ test_bstr_cache()

static void test_bstr_cache ( void )

static

Definition at line 5900 of file vartype.c.

{
    BSTR str, str2, strs[20];
    unsigned i;
 
    static const WCHAR testW[] = {'t','e','s','t',0};
 
    if (GetEnvironmentVariableA("OANOCACHE", NULL, 0)) {
        skip("BSTR cache is disabled, some tests will be skipped.\n");
        return;
    }
 
    str = SysAllocString(testW);
    /* This should put the string into cache */
    SysFreeString(str);
    /* The string is in cache, this won't touch it */
    SysFreeString(str);
 
    ok(SysStringLen(str) == 4, "unexpected len\n");
    ok(!lstrcmpW(str, testW), "string changed\n");
 
    str2 = SysAllocString(testW);
    ok(str == str2, "str != str2\n");
    SysFreeString(str2);
 
    /* Fill the bucket with cached entries.
       We roll our own, to show that the cache doesn't use
       the bstr length field to determine bucket allocation. */
    for(i=0; i < ARRAY_SIZE(strs); i++)
    {
        DWORD_PTR *ptr = CoTaskMemAlloc(64);
        ptr[0] = 0;
        strs[i] = (BSTR)(ptr + 1);
    }
    for(i=0; i < ARRAY_SIZE(strs); i++)
        SysFreeString(strs[i]);
 
    /* Following allocation will be made from cache */
    str = SysAllocStringLen(NULL, 24);
    ok(str == strs[0], "str != strs[0]\n");
 
    /* Smaller buffers may also use larget cached buffers */
    str2 = SysAllocStringLen(NULL, 16);
    ok(str2 == strs[1], "str2 != strs[1]\n");
 
    SysFreeString(str);
    SysFreeString(str2);
    SysFreeString(str);
    SysFreeString(str2);
}

Referenced by START_TEST().

◆ test_BstrCopy()

static void test_BstrCopy ( void )

static

Definition at line 5198 of file vartype.c.

{
  const CHAR szTestA[6] = { 'T','e','s','t','\0','?' };
  const CHAR szTestTruncA[4] = { 'T','e','s','\0' };
  LPINTERNAL_BSTR bstr;
  BSTR str;
  HRESULT hres;
  VARIANT vt1, vt2;
 
  str = SysAllocStringByteLen(szTestA, 3);
  ok (str != NULL, "Expected non-NULL\n");
  if (str)
  {
    V_VT(&vt1) = VT_BSTR;
    V_BSTR(&vt1) = str;
    V_VT(&vt2) = VT_EMPTY;
    hres = VariantCopy(&vt2, &vt1);
    ok (hres == S_OK,"Failed to copy binary bstring with hres 0x%08x\n", hres);
    bstr = Get(V_BSTR(&vt2));
    ok (bstr->dwLen == 3, "Expected 3, got %d\n", bstr->dwLen);
    ok (!lstrcmpA((LPCSTR)bstr->szString, szTestTruncA), "String different\n");
    VariantClear(&vt2);
    VariantClear(&vt1);
  }
}

Referenced by START_TEST().

◆ test_ChangeType_keep_dst()

static void test_ChangeType_keep_dst ( void )

static

Definition at line 5869 of file vartype.c.

{
     VARIANT v1, v2;
     BSTR bstr;
     static const WCHAR testW[] = {'t','e','s','t',0};
     HRESULT hres;
 
     bstr = SysAllocString(testW);
     VariantInit(&v1);
     VariantInit(&v2);
     V_VT(&v1) = VT_BSTR;
     V_BSTR(&v1) = bstr;
     hres = VariantChangeTypeEx(&v1, &v1, 0, 0, VT_INT);
     ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08x\n", hres);
     ok(V_VT(&v1) == VT_BSTR && V_BSTR(&v1) == bstr, "VariantChangeTypeEx changed dst variant\n");
     V_VT(&v2) = VT_INT;
     V_INT(&v2) = 4;
     hres = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_INT);
     ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08x\n", hres);
     ok(V_VT(&v2) == VT_INT && V_INT(&v2) == 4, "VariantChangeTypeEx changed dst variant\n");
     V_VT(&v2) = 0xff; /* incorrect variant type */
     hres = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_INT);
     ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08x\n", hres);
     ok(V_VT(&v2) == 0xff, "VariantChangeTypeEx changed dst variant\n");
     hres = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_BSTR);
     ok(hres == DISP_E_BADVARTYPE, "VariantChangeTypeEx returns %08x\n", hres);
     ok(V_VT(&v2) == 0xff, "VariantChangeTypeEx changed dst variant\n");
     SysFreeString(bstr);
}

Referenced by START_TEST().

◆ test_ClearCustData()

static void test_ClearCustData ( void )

static

Definition at line 5825 of file vartype.c.

{
  CUSTDATA ci;
  unsigned i;
 
  ci.cCustData = NUM_CUST_ITEMS;
  ci.prgCustData = CoTaskMemAlloc( sizeof(CUSTDATAITEM) * NUM_CUST_ITEMS );
  for (i = 0; i < NUM_CUST_ITEMS; i++)
    VariantInit(&ci.prgCustData[i].varValue);
  ClearCustData(&ci);
  ok(!ci.cCustData && !ci.prgCustData, "ClearCustData didn't clear fields!\n");
}

Referenced by START_TEST().

◆ test_EmptyChangeTypeEx()

static void test_EmptyChangeTypeEx ( void )

static

Definition at line 5657 of file vartype.c.

{
  VARTYPE vt;
  LCID lcid;
 
  lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 
  for (vt = VT_EMPTY; vt <= VT_BSTR_BLOB; vt++)
  {
    HRESULT hExpected, hres;
    VARIANTARG vSrc, vDst;
 
    /* skip for undefined types */
    if ((vt == 15) || (vt > VT_VERSIONED_STREAM && vt < VT_BSTR_BLOB))
        continue;
 
    switch (vt)
    {
    case VT_I8:
    case VT_UI8:
      if (has_i8)
        hExpected = S_OK;
      else
        hExpected = DISP_E_BADVARTYPE;
      break;
    case VT_RECORD:
    case VT_VARIANT:
    case VT_DISPATCH:
    case VT_UNKNOWN:
    case VT_ERROR:
      hExpected = DISP_E_TYPEMISMATCH;
      break;
    case VT_EMPTY:
    case VT_NULL:
    case VT_I2:
    case VT_I4:
    case VT_R4:
    case VT_R8:
    case VT_CY:
    case VT_DATE:
    case VT_BSTR:
    case VT_BOOL:
    case VT_DECIMAL:
    case VT_I1:
    case VT_UI1:
    case VT_UI2:
    case VT_UI4:
    case VT_INT:
    case VT_UINT:
      hExpected = S_OK;
      break;
    default:
      hExpected = DISP_E_BADVARTYPE;
    }
 
    VariantInit(&vSrc);
    V_VT(&vSrc) = VT_EMPTY;
    memset(&vDst, 0, sizeof(vDst));
    V_VT(&vDst) = VT_NULL;
 
    hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
    ok(hres == hExpected, "change empty: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
        vt, hExpected, hres, V_VT(&vDst));
    if (hres == S_OK)
    {
        ok(V_VT(&vDst) == vt, "change empty: vt %d, got %d\n", vt, V_VT(&vDst));
        VariantClear(&vDst);
    }
  }
}

Referenced by START_TEST().

◆ test_ErrorChangeTypeEx()

static void test_ErrorChangeTypeEx ( void )

static

Definition at line 5616 of file vartype.c.

{
  HRESULT hres;
  VARIANTARG vSrc, vDst;
  VARTYPE vt;
  LCID lcid;
 
  lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 
  for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
  {
    HRESULT hExpected = DISP_E_BADVARTYPE;
 
    V_VT(&vSrc) = VT_ERROR;
    V_ERROR(&vSrc) = 1;
    VariantInit(&vDst);
    hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
 
    if (vt == VT_ERROR)
      hExpected = S_OK;
    else
    {
      if (vt == VT_I8 || vt == VT_UI8)
      {
        if (has_i8)
          hExpected = DISP_E_TYPEMISMATCH;
      }
      else if (vt == VT_RECORD)
      {
        hExpected = DISP_E_TYPEMISMATCH;
      }
      else if (vt <= VT_UINT && vt != (VARTYPE)15)
        hExpected = DISP_E_TYPEMISMATCH;
    }
 
    ok(hres == hExpected,
     "change err: vt %d expected 0x%08x, got 0x%08x\n", vt, hExpected, hres);
  }
}

Referenced by START_TEST().

◆ test_IDispatchChangeTypeEx()

static void test_IDispatchChangeTypeEx ( void )

static

Definition at line 5565 of file vartype.c.

{
  HRESULT hres;
  VARIANTARG vSrc, vDst;
  LCID lcid;
  DummyDispatch d;
  IDispatch* pd;
 
  init_test_dispatch(1, VT_UI1, &d);
  pd = &d.IDispatch_iface;
 
  lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 
  /* NULL IDispatch -> IUnknown */
  V_VT(&vSrc) = VT_DISPATCH;
  V_DISPATCH(&vSrc) = NULL;
  VariantInit(&vDst);
  V_UNKNOWN(&vDst) = (void*)0xdeadbeef;
  hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
  ok(hres == S_OK && V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == NULL,
     "change unk(src,dst): expected 0x%08x,%d,%p, got 0x%08x,%d,%p\n",
     S_OK, VT_UNKNOWN, NULL, hres, V_VT(&vDst), V_UNKNOWN(&vDst));
 
  V_VT(&vSrc) = VT_DISPATCH;
  V_DISPATCH(&vSrc) = pd;
 
  /* =>IUnknown in place */
  hres = VariantChangeTypeEx(&vSrc, &vSrc, lcid, 0, VT_UNKNOWN);
  ok(hres == S_OK && d.ref == 1 &&
     V_VT(&vSrc) == VT_UNKNOWN && V_UNKNOWN(&vSrc) == (IUnknown*)pd,
     "change disp(src=src): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
     S_OK, 1, VT_UNKNOWN, pd, hres, d.ref, V_VT(&vSrc), V_UNKNOWN(&vSrc));
 
  /* =>IUnknown */
  d.ref = 1;
  V_VT(&vSrc) = VT_DISPATCH;
  V_DISPATCH(&vSrc) = pd;
  VariantInit(&vDst);
  hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
  /* Note vSrc is not cleared, as final refcount is 2 */
  ok(hres == S_OK && d.ref == 2 &&
     V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == (IUnknown*)pd,
     "change disp(src,dst): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
     S_OK, 2, VT_UNKNOWN, pd, hres, d.ref, V_VT(&vDst), V_UNKNOWN(&vDst));
 
  /* FIXME: Verify that VARIANT_NOVALUEPROP prevents conversion to integral
   *        types. this requires that the xxxFromDisp tests work first.
   */
}

Referenced by START_TEST().

◆ test_IDispatchClear()

static void test_IDispatchClear ( void )

static

Definition at line 5490 of file vartype.c.

{
  HRESULT hres;
  VARIANTARG v;
  DummyDispatch d;
  IDispatch* pd;
 
  init_test_dispatch(1, VT_UI1, &d);
  pd = &d.IDispatch_iface;
 
  /* As per IUnknown */
 
  V_VT(&v) = VT_DISPATCH;
  V_DISPATCH(&v) = pd;
  hres = VariantClear(&v);
  ok(hres == S_OK && d.ref == 0 && V_VT(&v) == VT_EMPTY,
     "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 0, VT_EMPTY, hres, d.ref, V_VT(&v));
 
  d.ref = 1;
  V_VT(&v) = VT_DISPATCH|VT_BYREF;
  V_DISPATCHREF(&v) = &pd;
  hres = VariantClear(&v);
  ok(hres == S_OK && d.ref == 1 && V_VT(&v) == VT_EMPTY,
     "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 1, VT_EMPTY, hres, d.ref, V_VT(&v));
}

Referenced by START_TEST().

◆ test_IDispatchCopy()

static void test_IDispatchCopy ( void )

static

Definition at line 5518 of file vartype.c.

{
  HRESULT hres;
  VARIANTARG vSrc, vDst;
  DummyDispatch d;
  IDispatch* pd;
 
  init_test_dispatch(1, VT_UI1, &d);
  pd = &d.IDispatch_iface;
 
  /* As per IUnknown */
 
  VariantInit(&vDst);
  V_VT(&vSrc) = VT_DISPATCH;
  V_DISPATCH(&vSrc) = pd;
  hres = VariantCopy(&vDst, &vSrc);
  ok(hres == S_OK && d.ref == 2 && V_VT(&vDst) == VT_DISPATCH,
     "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 2, VT_EMPTY, hres, d.ref, V_VT(&vDst));
 
  VariantInit(&vDst);
  d.ref = 1;
  V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
  V_DISPATCHREF(&vSrc) = &pd;
  hres = VariantCopy(&vDst, &vSrc);
  ok(hres == S_OK && d.ref == 1 && V_VT(&vDst) == (VT_DISPATCH|VT_BYREF),
     "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 1, VT_DISPATCH, hres, d.ref, V_VT(&vDst));
 
  VariantInit(&vDst);
  d.ref = 1;
  V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
  V_DISPATCHREF(&vSrc) = &pd;
  hres = VariantCopyInd(&vDst, &vSrc);
  ok(hres == S_OK && d.ref == 2 && V_VT(&vDst) == VT_DISPATCH,
     "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 2, VT_DISPATCH, hres, d.ref, V_VT(&vDst));
 
  d.ref = 1;
  V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
  V_DISPATCHREF(&vSrc) = &pd;
  hres = VariantCopyInd(&vSrc, &vSrc);
  ok(hres == S_OK && d.ref == 2 && V_VT(&vSrc) == VT_DISPATCH,
     "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 2, VT_DISPATCH, hres, d.ref, V_VT(&vSrc));
}

Referenced by START_TEST().

◆ test_IUnknownChangeTypeEx()

static void test_IUnknownChangeTypeEx ( void )

static

Definition at line 5410 of file vartype.c.

{
  HRESULT hres;
  VARIANTARG vSrc, vDst;
  LCID lcid;
  VARTYPE vt;
  DummyDispatch u;
  IUnknown* pu;
 
  init_test_dispatch(1, VT_UI1, &u);
  pu = (IUnknown*)&u.IDispatch_iface;
 
  lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 
  /* NULL IUnknown -> IDispatch */
  V_VT(&vSrc) = VT_UNKNOWN;
  V_UNKNOWN(&vSrc) = NULL;
  VariantInit(&vDst);
  V_DISPATCH(&vDst) = (void*)0xdeadbeef;
  hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_DISPATCH);
  ok(hres == S_OK && V_VT(&vDst) == VT_DISPATCH && V_DISPATCH(&vDst) == NULL,
     "change unk(src,dst): expected 0x%08x,%d,%p, got 0x%08x,%d,%p\n",
     S_OK, VT_DISPATCH, NULL, hres, V_VT(&vDst), V_DISPATCH(&vDst));
 
  V_VT(&vSrc) = VT_UNKNOWN;
  V_UNKNOWN(&vSrc) = pu;
 
  /* =>IDispatch in place */
  hres = VariantChangeTypeEx(&vSrc, &vSrc, lcid, 0, VT_DISPATCH);
  ok(hres == S_OK && u.ref == 1 &&
     V_VT(&vSrc) == VT_DISPATCH && V_DISPATCH(&vSrc) == (IDispatch*)pu,
     "change unk(src=src): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
     S_OK, 1, VT_DISPATCH, pu, hres, u.ref, V_VT(&vSrc), V_DISPATCH(&vSrc));
 
  /* =>IDispatch */
  u.ref = 1;
  V_VT(&vSrc) = VT_UNKNOWN;
  V_UNKNOWN(&vSrc) = pu;
  VariantInit(&vDst);
  hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
  /* Note vSrc is not cleared, as final refcount is 2 */
  ok(hres == S_OK && u.ref == 2 &&
     V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == pu,
     "change unk(src,dst): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
     S_OK, 2, VT_UNKNOWN, pu, hres, u.ref, V_VT(&vDst), V_UNKNOWN(&vDst));
 
  /* Can't change unknown to anything else */
  for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
  {
    HRESULT hExpected = DISP_E_BADVARTYPE;
 
    V_VT(&vSrc) = VT_UNKNOWN;
    V_UNKNOWN(&vSrc) = pu;
    VariantInit(&vDst);
 
    if (vt == VT_UNKNOWN || vt == VT_DISPATCH || vt == VT_EMPTY || vt == VT_NULL)
      hExpected = S_OK;
    else
    {
      if (vt == VT_I8 || vt == VT_UI8)
      {
        if (has_i8)
          hExpected = DISP_E_TYPEMISMATCH;
      }
      else if (vt == VT_RECORD)
      {
        hExpected = DISP_E_TYPEMISMATCH;
      }
      else if (vt  >= VT_I2 && vt <= VT_UINT && vt != (VARTYPE)15)
        hExpected = DISP_E_TYPEMISMATCH;
    }
 
    hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
    ok(hres == hExpected,
       "change unk(badvar): vt %d expected 0x%08x, got 0x%08x\n",
       vt, hExpected, hres);
  }
}

Referenced by START_TEST().

◆ test_IUnknownClear()

static void test_IUnknownClear ( void )

static

Definition at line 5333 of file vartype.c.

{
  HRESULT hres;
  VARIANTARG v;
  DummyDispatch u;
  IUnknown* pu;
 
  init_test_dispatch(1, VT_UI1, &u);
  pu = (IUnknown*)&u.IDispatch_iface;
 
  /* Test that IUnknown_Release is called on by-value */
  V_VT(&v) = VT_UNKNOWN;
  V_UNKNOWN(&v) = (IUnknown*)&u.IDispatch_iface;
  hres = VariantClear(&v);
  ok(hres == S_OK && u.ref == 0 && V_VT(&v) == VT_EMPTY,
     "clear unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 0, VT_EMPTY, hres, u.ref, V_VT(&v));
 
  /* But not when clearing a by-reference*/
  u.ref = 1;
  V_VT(&v) = VT_UNKNOWN|VT_BYREF;
  V_UNKNOWNREF(&v) = &pu;
  hres = VariantClear(&v);
  ok(hres == S_OK && u.ref == 1 && V_VT(&v) == VT_EMPTY,
     "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 1, VT_EMPTY, hres, u.ref, V_VT(&v));
}

Referenced by START_TEST().

◆ test_IUnknownCopy()

static void test_IUnknownCopy ( void )

static

Definition at line 5361 of file vartype.c.

{
  HRESULT hres;
  VARIANTARG vSrc, vDst;
  DummyDispatch u;
  IUnknown* pu;
 
  init_test_dispatch(1, VT_UI1, &u);
  pu = (IUnknown*)&u.IDispatch_iface;
 
  /* AddRef is called on by-value copy */
  VariantInit(&vDst);
  V_VT(&vSrc) = VT_UNKNOWN;
  V_UNKNOWN(&vSrc) = pu;
  hres = VariantCopy(&vDst, &vSrc);
  ok(hres == S_OK && u.ref == 2 && V_VT(&vDst) == VT_UNKNOWN,
     "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 2, VT_EMPTY, hres, u.ref, V_VT(&vDst));
 
  /* AddRef is skipped on copy of by-reference IDispatch */
  VariantInit(&vDst);
  u.ref = 1;
  V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
  V_UNKNOWNREF(&vSrc) = &pu;
  hres = VariantCopy(&vDst, &vSrc);
  ok(hres == S_OK && u.ref == 1 && V_VT(&vDst) == (VT_UNKNOWN|VT_BYREF),
     "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 1, VT_DISPATCH, hres, u.ref, V_VT(&vDst));
 
  /* AddRef is called copying by-reference IDispatch with indirection */
  VariantInit(&vDst);
  u.ref = 1;
  V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
  V_UNKNOWNREF(&vSrc) = &pu;
  hres = VariantCopyInd(&vDst, &vSrc);
  ok(hres == S_OK && u.ref == 2 && V_VT(&vDst) == VT_UNKNOWN,
     "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 2, VT_DISPATCH, hres, u.ref, V_VT(&vDst));
 
  /* Indirection in place also calls AddRef */
  u.ref = 1;
  V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
  V_UNKNOWNREF(&vSrc) = &pu;
  hres = VariantCopyInd(&vSrc, &vSrc);
  ok(hres == S_OK && u.ref == 2 && V_VT(&vSrc) == VT_UNKNOWN,
     "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
     S_OK, 2, VT_DISPATCH, hres, u.ref, V_VT(&vSrc));
}

Referenced by START_TEST().

◆ test_NullByRef()

static void test_NullByRef ( void )

static

Definition at line 5838 of file vartype.c.

{
  VARIANT v1, v2;
  HRESULT hRes;
 
  VariantInit(&v1);
  VariantInit(&v2);
  V_VT(&v1) = VT_BYREF|VT_VARIANT;
  V_BYREF(&v1) = 0;
 
  hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_I4);
  ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
 
  VariantClear(&v1);
  V_VT(&v1) = VT_BYREF|VT_VARIANT;
  V_BYREF(&v1) = 0;
  V_VT(&v2) = VT_I4;
  V_I4(&v2) = 123;
 
  hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_VARIANT);
  ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
  ok(V_VT(&v2) == VT_I4 && V_I4(&v2) == 123, "VariantChangeTypeEx shouldn't change pvargDest\n");
 
  hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_BYREF|VT_I4);
  ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
 
  hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, 0x3847);
  ok(hRes == DISP_E_BADVARTYPE, "VariantChangeTypeEx should return DISP_E_BADVARTYPE\n");
}

Referenced by START_TEST().

◆ test_NullChangeTypeEx()

static void test_NullChangeTypeEx ( void )

static

Definition at line 5729 of file vartype.c.

{
  VARTYPE vt;
  LCID lcid;
 
  lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 
  for (vt = VT_EMPTY; vt <= VT_BSTR_BLOB; vt++)
  {
    VARIANTARG vSrc, vDst;
    HRESULT hExpected, hres;
 
    /* skip for undefined types */
    if ((vt == 15) || (vt > VT_VERSIONED_STREAM && vt < VT_BSTR_BLOB))
        continue;
 
    switch (vt)
    {
    case VT_I8:
    case VT_UI8:
        if (has_i8)
            hExpected = DISP_E_TYPEMISMATCH;
        else
            hExpected = DISP_E_BADVARTYPE;
        break;
    case VT_NULL:
        hExpected = S_OK;
        break;
    case VT_EMPTY:
    case VT_I2:
    case VT_I4:
    case VT_R4:
    case VT_R8:
    case VT_CY:
    case VT_DATE:
    case VT_BSTR:
    case VT_DISPATCH:
    case VT_ERROR:
    case VT_BOOL:
    case VT_VARIANT:
    case VT_UNKNOWN:
    case VT_DECIMAL:
    case VT_I1:
    case VT_UI1:
    case VT_UI2:
    case VT_UI4:
    case VT_INT:
    case VT_UINT:
    case VT_RECORD:
        hExpected = DISP_E_TYPEMISMATCH;
        break;
    default:
        hExpected = DISP_E_BADVARTYPE;
    }
 
    VariantInit(&vSrc);
    V_VT(&vSrc) = VT_NULL;
    memset(&vDst, 0, sizeof(vDst));
    V_VT(&vDst) = VT_EMPTY;
 
    hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
    ok(hres == hExpected, "change null: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
       vt, hExpected, hres, V_VT(&vDst));
 
    /* should work only for VT_NULL -> VT_NULL case */
    if (hres == S_OK)
        ok(V_VT(&vDst) == VT_NULL, "change null: VT_NULL expected 0x%08x, got 0x%08x, vt %d\n",
            hExpected, hres, V_VT(&vDst));
    else
        ok(V_VT(&vDst) == VT_EMPTY, "change null: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
            vt, hExpected, hres, V_VT(&vDst));
  }
}

Referenced by START_TEST().

◆ test_recinfo()

static void test_recinfo ( void )

static

Definition at line 5978 of file vartype.c.

{
    static const WCHAR testW[] = {'t','e','s','t',0};
    static WCHAR teststructW[] = {'t','e','s','t','_','s','t','r','u','c','t',0};
    static WCHAR teststruct2W[] = {'t','e','s','t','_','s','t','r','u','c','t','2',0};
    static WCHAR teststruct3W[] = {'t','e','s','t','_','s','t','r','u','c','t','3',0};
    WCHAR filenameW[MAX_PATH], filename2W[MAX_PATH];
    ITypeInfo *typeinfo, *typeinfo2, *typeinfo3;
    IRecordInfo *recinfo, *recinfo2, *recinfo3;
    struct test_struct teststruct, testcopy;
    ITypeLib *typelib, *typelib2;
    const char *filename;
    DummyDispatch dispatch;
    TYPEATTR *attr;
    MEMBERID memid;
    UINT16 found;
    HRESULT hr;
    ULONG size;
    BOOL ret;
 
    filename = create_test_typelib(2);
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, MAX_PATH);
    hr = LoadTypeLibEx(filenameW, REGKIND_NONE, &typelib);
    ok(hr == S_OK, "got 0x%08x\n", hr);
 
    filename = create_test_typelib(3);
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filename2W, MAX_PATH);
    hr = LoadTypeLibEx(filename2W, REGKIND_NONE, &typelib2);
    ok(hr == S_OK, "got 0x%08x\n", hr);
 
    typeinfo = NULL;
    found = 1;
    hr = ITypeLib_FindName(typelib, teststructW, 0, &typeinfo, &memid, &found);
    ok(hr == S_OK, "got 0x%08x\n", 

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ _EXPECT_NO_OUT

◆ _EXPECTRES

◆ _VARBSTRCMP

◆ BADVAR

◆ BOOL_STR

◆ BSTR_CY

◆ BSTR_DATE

◆ BSTR_DEC

◆ BSTR_DEC64

◆ CHANGETYPEEX

◆ CHECK_CALLED

◆ CHECK_EXPECT

◆ CHECK_EXPECT2

◆ CLEAR

◆ COBJMACROS

◆ COMMON_TYPETEST

◆ CONST_VTABLE

◆ CONV_TYPE [1/14]

◆ CONV_TYPE [2/14]

◆ CONV_TYPE [3/14]

◆ CONV_TYPE [4/14]

◆ CONV_TYPE [5/14]

◆ CONV_TYPE [6/14]

◆ CONV_TYPE [7/14]

◆ CONV_TYPE [8/14]

◆ CONV_TYPE [9/14]

◆ CONV_TYPE [10/14]

◆ CONV_TYPE [11/14]

◆ CONV_TYPE [12/14]

◆ CONV_TYPE [13/14]

◆ CONV_TYPE [14/14]

◆ CONVERT

◆ CONVERT_BADDEC

◆ CONVERT_CY

◆ CONVERT_CY64

◆ CONVERT_DEC

◆ CONVERT_DEC64

◆ CONVERT_I8

◆ CONVERT_STR

◆ CONVERTRANGE [1/2]

◆ CONVERTRANGE [2/2]

◆ CONVVARS

◆ COPYTEST

◆ CY_MULTIPLIER

◆ DATE_MAX

◆ DATE_MIN

◆ DEFINE_EXPECT

◆ DFS

◆ EXPECT

◆ EXPECT_BADVAR

◆ EXPECT_DBL

◆ EXPECT_EQ

◆ EXPECT_GT

◆ EXPECT_INVALID

◆ EXPECT_LT

◆ EXPECT_MISMATCH

◆ EXPECT_OVERFLOW

◆ EXPECTCY

◆ EXPECTCY64

◆ EXPECTDEC

◆ EXPECTDEC64

◆ EXPECTDECI

◆ EXPECTDECZERO

◆ EXPECTI8

◆ EXPECTI864

◆ EXPECTRES [1/4]

◆ EXPECTRES [2/4]

◆ EXPECTRES [3/4]

◆ EXPECTRES [4/4]

◆ HAS_UINT64_TO_FLOAT

◆ INITIAL_TYPETEST

◆ INITIAL_TYPETESTI8

◆ IS_MODERN_VTYPE

◆ MATH1 [1/2]