#include <stdarg.h>
#include <stdio.h>
#include <math.h>
#include <float.h>
#include "windef.h"
#include "winbase.h"
#include "winsock2.h"
#include "wine/test.h"
#include "winuser.h"
#include "wingdi.h"
#include "winnls.h"
#include "winerror.h"
#include "winnt.h"
#include "wtypes.h"
#include "oleauto.h"

Include dependency graph for vartest.c:

Classes
struct	DummyDispatch

struct	IRecordInfoImpl

struct	test_VariantClearImpl

struct	decimal_t

struct	decimal_round_t

Macros
#define	COBJMACROS

#define	CONST_VTABLE

#define	CHECKPTR(func)

#define	EQ_DOUBLE(a, b) (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-14)

#define	EQ_FLOAT(a, b) (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-7)

#define	SKIPTESTS(a) if((a > VT_CLSID+10) && (a < VT_BSTR_BLOB-10)) continue

#define	V_EMPTY(v) V_I4(v)

#define	V_NULL(v) V_I4(v)

#define	I1_MAX 0x7f

#define	I1_MIN ((-I1_MAX)-1)

#define	UI1_MAX 0xff

#define	UI1_MIN 0

#define	I2_MAX 0x7fff

#define	I2_MIN ((-I2_MAX)-1)

#define	UI2_MAX 0xffff

#define	UI2_MIN 0

#define	I4_MAX 0x7fffffff

#define	I4_MIN ((-I4_MAX)-1)

#define	UI4_MAX 0xffffffff

#define	UI4_MIN 0

#define	I8_MAX (((LONGLONG)I4_MAX << 32) \| UI4_MAX)

#define	I8_MIN ((-I8_MAX)-1)

#define	UI8_MAX (((ULONGLONG)UI4_MAX << 32) \| UI4_MAX)

#define	UI8_MIN 0

#define	DATE_MAX 2958465

#define	DATE_MIN -657434

#define	R4_MAX FLT_MAX

#define	R4_MIN FLT_MIN

#define	R8_MAX DBL_MAX

#define	R8_MIN DBL_MIN

#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	CASE(vt) case VT_##vt: return #vt

#define	CASE(vt) case VT_##vt: return (V_##vt(result) == V_##vt(expected))

#define	test_bstr_var(a, b) _test_bstr_var(__LINE__,a,b)

#define	FAILDIG 255

#define	CONVERTN(str, dig, flags) hres = convert_str( str, dig, flags, &np, rgb, lcid )

#define	CONVERT(str, flags) CONVERTN(str,sizeof(rgb),flags)

#define	EXPECT(a, b, c, d, e, f) expect_NumFromStr( __LINE__, hres, &np, a, b, c, d, e, f )

#define	EXPECTRGB(a, b) ok(rgb[a] == b, "Digit[%d], expected %d, got %d\n", a, b, rgb[a])

#define	EXPECTFAIL ok(hres == (HRESULT)DISP_E_TYPEMISMATCH, "Call succeeded, hres = %08x\n", hres)

#define	EXPECT2(a, b) EXPECTRGB(0,a); EXPECTRGB(1,b)

#define	SETRGB(indx, val) if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val

#define	CONVERT(a, b, c, d, e, f, bits)

#define	EXPECT_OVERFLOW ok(hres == (HRESULT)DISP_E_OVERFLOW, szFailOverflow, hres)

#define	EXPECT_OK

#define	EXPECT_TYPE(typ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))

#define	EXPECT_I1(val)

#define	EXPECT_UI1(val)

#define	EXPECT_I2(val)

#define	EXPECT_UI2(val)

#define	EXPECT_I4(val)

#define	EXPECT_UI4(val)

#define	EXPECT_I8(high, low)

#define	EXPECT_UI8(val)

#define	EXPECT_R4(val)

#define	EXPECT_R8(val)

#define	CY_MULTIPLIER 10000

#define	EXPECT_CY(val)

#define	EXPECT_DECIMAL(valHi, valMid, valLo)

#define	INTEGER_VTBITS (VTBIT_I1\|VTBIT_UI1\|VTBIT_I2\|VTBIT_UI2\|VTBIT_I4\|VTBIT_UI4\|VTBIT_I8\|VTBIT_UI8)

#define	DT2UD(dt, flags, r, d, m, y, h, mn, s, ms, dw, dy) test_UdateFromDate(__LINE__,dt,flags,r,d,m,y,h,mn,s,ms,dw,dy)

#define	UD2T(d, m, y, h, mn, s, ms, dw, dy, flags, r, dt) test_DateFromUDate(__LINE__,d,m,y,h,mn,s,ms,dw,dy,flags,r,dt)

#define	ST2DT(d, m, y, h, mn, s, ms, r, dt) test_st2dt(__LINE__,d,m,y,h,mn,s,ms,r,dt)

#define	DT2ST(dt, r, d, m, y, h, mn, s, ms) test_dt2st(__LINE__,dt,r,d,m,y,h,mn,s,ms)

#define	MKDOSDATE(d, m, y) ((d & 0x1f) \| ((m & 0xf) << 5) \| (((y-1980) & 0x7f) << 9))

#define	MKDOSTIME(h, m, s) (((s>>1) & 0x1f) \| ((m & 0x3f) << 5) \| ((h & 0x1f) << 11))

#define	DOS2DT(d, m, y, h, mn, s, r, dt) test_dos2dt(__LINE__,d,m,y,h,mn,s,r,dt)

#define	DT2DOS(dt, r, d, m, y, h, mn, s) test_dt2dos(__LINE__,dt,r,d,m,y,h,mn,s)

#define	VARABS(vt, val, rvt, rval)

#define	VARNOT(vt, val, rvt, rval)

#define	VARSUB(vt1, val1, vt2, val2, rvt, rval)

#define	VARMOD(vt1, vt2, val1, val2, rvt, rval)

#define	VARMOD2(vt1, vt2, val1, val2, rvt, rval, hexpected)

#define	VARFIX(vt, val, rvt, rval)

#define	VARINT(vt, val, rvt, rval)

#define	VARNEG(vt, val, rvt, rval)

#define	VARROUND(vt, val, deci, rvt, rval)

#define	VARXOR(vt1, val1, vt2, val2, rvt, rval)

#define	VARXORCY(vt1, val1, val2, rvt, rval)

#define	VAROR(vt1, val1, vt2, val2, rvt, rval)

#define	VARORCY(vt1, val1, val2, rvt, rval)

#define	VAREQV(vt1, val1, vt2, val2, rvt, rval)

#define	VARMUL(vt1, val1, vt2, val2, rvt, rval)

#define	VARADD(vt1, val1, vt2, val2, rvt, rval)

#define	VARAND(vt1, val1, vt2, val2, rvt, rval)

#define	VARANDCY(vt1, val1, val2, rvt, rval)

#define	SKIPTESTAND(a)

#define	_VARCMP(vt1, val1, vtfl1, vt2, val2, vtfl2, lcid, flags, result)

#define	VARCMPEX(vt1, val1, vt2, val2, res1, res2, res3, res4)

#define	VARCMP(vt1, val1, vt2, val2, result) VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)

#define	V_NULL_ V_NULL

#define	VT_NULL_ VT_NULL

#define	VARPOW(vt1, val1, vt2, val2, rvt, rval)

#define	SKIPTESTPOW(a)

#define	VARDIV(vt1, val1, vt2, val2, rvt, rval)

#define	SKIPTESTDIV(a)

#define	VARIDIV(vt1, val1, vt2, val2, rvt, rval)

#define	SKIPTESTIDIV(a)

#define	VARIMP(vt1, val1, vt2, val2, rvt, rval)

#define	SKIPTESTIMP(a)

Typedefs
typedef struct IRecordInfoImpl	IRecordInfoImpl

Functions
static	HRESULT (WINAPI *pVarUdateFromDate)(DATE

static UDATE static DATE static	INT (WINAPI *pSystemTimeToVariantTime)(LPSYSTEMTIME

	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 (VARTYPE vt, DummyDispatch *dispatch)

static IRecordInfoImpl *	impl_from_IRecordInfo (IRecordInfo *iface)

static HRESULT WINAPI	RecordInfo_QueryInterface (IRecordInfo iface, REFIID riid, void *obj)

static ULONG WINAPI	RecordInfo_AddRef (IRecordInfo *iface)

static ULONG WINAPI	RecordInfo_Release (IRecordInfo *iface)

static HRESULT WINAPI	RecordInfo_RecordInit (IRecordInfo *iface, PVOID pvNew)

static HRESULT WINAPI	RecordInfo_RecordClear (IRecordInfo iface, void data)

static HRESULT WINAPI	RecordInfo_RecordCopy (IRecordInfo iface, void src, void *dest)

static HRESULT WINAPI	RecordInfo_GetGuid (IRecordInfo iface, GUID pguid)

static HRESULT WINAPI	RecordInfo_GetName (IRecordInfo iface, BSTR pbstrName)

static HRESULT WINAPI	RecordInfo_GetSize (IRecordInfo iface, ULONG size)

static HRESULT WINAPI	RecordInfo_GetTypeInfo (IRecordInfo iface, ITypeInfo *ppTypeInfo)

static HRESULT WINAPI	RecordInfo_GetField (IRecordInfo iface, PVOID pvData, LPCOLESTR szFieldName, VARIANT pvarField)

static HRESULT WINAPI	RecordInfo_GetFieldNoCopy (IRecordInfo iface, PVOID pvData, LPCOLESTR szFieldName, VARIANT pvarField, PVOID *ppvDataCArray)

static HRESULT WINAPI	RecordInfo_PutField (IRecordInfo iface, ULONG wFlags, PVOID pvData, LPCOLESTR szFieldName, VARIANT pvarField)

static HRESULT WINAPI	RecordInfo_PutFieldNoCopy (IRecordInfo iface, ULONG wFlags, PVOID pvData, LPCOLESTR szFieldName, VARIANT pvarField)

static HRESULT WINAPI	RecordInfo_GetFieldNames (IRecordInfo iface, ULONG pcNames, BSTR *rgBstrNames)

static BOOL WINAPI	RecordInfo_IsMatchingType (IRecordInfo iface, IRecordInfo info2)

static PVOID WINAPI	RecordInfo_RecordCreate (IRecordInfo *iface)

static HRESULT WINAPI	RecordInfo_RecordCreateCopy (IRecordInfo iface, PVOID pvSource, PVOID ppvDest)

static HRESULT WINAPI	RecordInfo_RecordDestroy (IRecordInfo *iface, PVOID pvRecord)

static IRecordInfoImpl *	get_test_recordinfo (void)

static void	init (void)

static void	setdec (DECIMAL *dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG64 lo64)

static void	setdec64 (DECIMAL *dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG mid32, ULONG lo32)

static const char *	vtstr (int x)

static const char *	variantstr (const VARIANT *var)

static BOOL	is_expected_variant (const VARIANT result, const VARIANT expected)

static void	test_var_call1 (int line, HRESULT(WINAPI func)(LPVARIANT, LPVARIANT), VARIANT arg, VARIANT *expected)

static void	test_var_call2 (int line, HRESULT(WINAPI func)(LPVARIANT, LPVARIANT, LPVARIANT), VARIANT left, VARIANT right, VARIANT expected)

static int	strcmp_wa (const WCHAR strw, const char stra)

static void	_test_bstr_var (unsigned line, const VARIANT v, const char str)

static void	test_VariantInit (void)

static BOOL	IsValidVariantClearVT (VARTYPE vt, VARTYPE extraFlags)

static test_VariantClearImpl *	impl_from_IUnknown (IUnknown *iface)

static HRESULT WINAPI	VC_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj)

static ULONG WINAPI	VC_AddRef (LPUNKNOWN iface)

static ULONG WINAPI	VC_Release (LPUNKNOWN iface)

static void	test_VariantClear (void)

static void	test_VariantCopy (void)

static BOOL	IsValidVariantCopyIndVT (VARTYPE vt, VARTYPE extraFlags)

static void	test_VariantCopyInd (void)

static HRESULT	convert_str (const char str, INT dig, ULONG flags, NUMPARSE np, BYTE rgb[128], LCID lcid)

static void	expect_NumFromStr (int line, HRESULT hres, NUMPARSE *np, INT a, ULONG b, ULONG c, INT d, INT e, INT f)

static void	test_VarParseNumFromStr (void)

static void	test_VarNumFromParseNum (void)

static void	test_UdateFromDate (int line, DATE dt, ULONG flags, HRESULT r, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms, WORD dw, WORD dy)

static void	test_VarUdateFromDate (void)

static void	test_DateFromUDate (int line, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms, WORD dw, WORD dy, ULONG flags, HRESULT r, DATE dt)

static void	test_VarDateFromUdate (void)

static void	test_st2dt (int line, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms, INT r, double dt)

static void	test_SystemTimeToVariantTime (void)

static void	test_dt2st (int line, double dt, INT r, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms)

static void	test_VariantTimeToSystemTime (void)

static void	test_dos2dt (int line, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, INT r, double dt)

static void	test_DosDateTimeToVariantTime (void)

static void	test_dt2dos (int line, double dt, INT r, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s)

static void	test_VariantTimeToDosDateTime (void)

static void	test_VarAbs (void)

static void	test_VarNot (void)

static void	test_VarSub (void)

static void	test_Mod (int line, VARIANT left, VARIANT right, VARIANT *expected, HRESULT expres)

static void	test_VarMod (void)

static void	test_VarFix (void)

static void	test_VarInt (void)

static void	test_VarNeg (void)

static void	test_Round (int line, VARIANT arg, int deci, VARIANT expected)

static void	test_VarRound (void)

static void	test_VarXor (void)

static void	test_VarOr (void)

static void	test_VarEqv (void)

static void	test_VarMul (void)

static void	test_VarAdd (void)

static void	test_VarCat (void)

static void	test_VarAnd (void)

static void	test_cmp (int line, LCID lcid, UINT flags, VARIANT left, VARIANT right, HRESULT result)

static void	test_cmpex (int line, LCID lcid, VARIANT left, VARIANT right, HRESULT res1, HRESULT res2, HRESULT res3, HRESULT res4)

static void	test_VarCmp (void)

static void	test_VarPow (void)

static void	test_VarDiv (void)

static void	test_VarIdiv (void)

static void	test_VarImp (void)

	START_TEST (vartest)

Variables
static HMODULE	hOleaut32

static	ULONG

static UDATE static DATE static double *static	LPSYSTEMTIME

static	USHORT

static double static USHORT USHORT static const WCHAR	sz12 [] = {'1','2','\0'}

static WCHAR	sz12_false [32]

static WCHAR	sz12_true [32]

static BOOL	has_i8

static const IDispatchVtbl	DummyDispatch_VTable

static const IRecordInfoVtbl	RecordInfoVtbl

static char	vtstr_buffer [16][256]

static int	vtstr_current =0

static const VARTYPE	ExtraFlags [16]

static const IUnknownVtbl	test_VariantClear_vtbl

static test_VariantClearImpl	test_myVariantClearImpl = {{&test_VariantClear_vtbl}, 1, 0}

static	LCID

static const char *	szFailOverflow = "Expected overflow, hres = %08x\n"

static const char *	szFailOk = "Call failed, hres = %08x\n"

static	LPVARIANT

static	int

static const struct decimal_round_t	decimal_round_data []

Macro Definition Documentation

◆ _VARCMP

#define _VARCMP	(	vt1,
		val1,
		vtfl1,
		vt2,
		val2,
		vtfl2,
		lcid,
		flags,
		result
	)

Value:

        V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1 | vtfl1; \
        V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2 | vtfl2; \
        test_cmp( __LINE__, lcid, flags, &left, &right, result )

Definition at line 6899 of file vartest.c.

◆ CASE [1/2]

#define CASE ( vt ) case VT_##vt: return #vt

◆ CASE [2/2]

#define CASE ( vt ) case VT_##vt: return (V_##vt(result) == V_##vt(expected))

◆ CHECK_CALLED

#define CHECK_CALLED ( func )

Value:

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

Definition at line 118 of file vartest.c.

◆ CHECK_EXPECT

#define CHECK_EXPECT ( func )

Value:

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

Definition at line 112 of file vartest.c.

◆ CHECK_EXPECT2

#define CHECK_EXPECT2 ( func )

Value:

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

Definition at line 106 of file vartest.c.

◆ CHECKPTR

#define CHECKPTR ( func )

Value:

p##func = (void*)GetProcAddress(hOleaut32, #func); \

if (!p##func) { win_skip("function " # func " not available, not testing it\n"); return; }

GetProcAddress

#define GetProcAddress(x, y)

Definition: compat.h:753

p

GLfloat GLfloat p

Definition: glext.h:8902

win_skip

#define win_skip

Definition: test.h:160

hOleaut32

static HMODULE hOleaut32

Definition: vartest.c:43

Definition at line 58 of file vartest.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 27 of file vartest.c.

◆ CONST_VTABLE

#define CONST_VTABLE

Definition at line 28 of file vartest.c.

◆ CONVERT [1/2]

#define CONVERT	(	a,
		b,
		c,
		d,
		e,
		f,
		bits
	)

Value:

np.cDig = (a); np.dwInFlags = (b); np.dwOutFlags = (c); np.cchUsed = (d); \

np.nBaseShift = (e); np.nPwr10 = (f); hres = pVarNumFromParseNum(&np, rgb, bits, &vOut)

bits

GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits

Definition: glext.h:10929

d

#define d

Definition: ke_i.h:81

e

#define e

Definition: ke_i.h:82

f

#define f

Definition: ke_i.h:83

a

#define a

Definition: ke_i.h:78

c

#define c

Definition: ke_i.h:80

b

#define b

Definition: ke_i.h:79

hres

HRESULT hres

Definition: protocol.c:465

rgb

_In_ ULONG _In_ ULONG rgb

Definition: winddi.h:3521

Definition at line 1744 of file vartest.c.

◆ CONVERT [2/2]

#define CONVERT	(	str,
		flags
	)	CONVERTN(str,sizeof(rgb),flags)

Definition at line 1744 of file vartest.c.

◆ CONVERTN

#define CONVERTN	(	str,
		dig,
		flags
	)	hres = convert_str( str, dig, flags, &np, rgb, lcid )

Definition at line 1301 of file vartest.c.

◆ CY_MULTIPLIER

#define CY_MULTIPLIER 10000

Definition at line 1775 of file vartest.c.

◆ DATE_MAX

#define DATE_MAX 2958465

Definition at line 93 of file vartest.c.

◆ DATE_MIN

#define DATE_MIN -657434

Definition at line 94 of file vartest.c.

◆ DEFINE_EXPECT

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

Definition at line 100 of file vartest.c.

◆ DOS2DT

#define DOS2DT	(	d,
		m,
		y,
		h,
		mn,
		s,
		r,
		dt
	)	test_dos2dt(__LINE__,d,m,y,h,mn,s,r,dt)

Definition at line 2168 of file vartest.c.

◆ DT2DOS

#define DT2DOS	(	dt,
		r,
		d,
		m,
		y,
		h,
		mn,
		s
	)	test_dt2dos(__LINE__,dt,r,d,m,y,h,mn,s)

Definition at line 2256 of file vartest.c.

◆ DT2ST

#define DT2ST	(	dt,
		r,
		d,
		m,
		y,
		h,
		mn,
		s,
		ms
	)	test_dt2st(__LINE__,dt,r,d,m,y,h,mn,s,ms)

Definition at line 2142 of file vartest.c.

◆ DT2UD

#define DT2UD	(	dt,
		flags,
		r,
		d,
		m,
		y,
		h,
		mn,
		s,
		ms,
		dw,
		dy
	)	test_UdateFromDate(__LINE__,dt,flags,r,d,m,y,h,mn,s,ms,dw,dy)

Definition at line 1974 of file vartest.c.

◆ EQ_DOUBLE

#define EQ_DOUBLE	(	a,
		b
	)	(fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-14)

Definition at line 67 of file vartest.c.

◆ EQ_FLOAT

#define EQ_FLOAT	(	a,
		b
	)	(fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-7)

Definition at line 68 of file vartest.c.

◆ EXPECT

#define EXPECT	(	a,
		b,
		c,
		d,
		e,
		f
	)	expect_NumFromStr( __LINE__, hres, &np, a, b, c, d, e, f )

Definition at line 1303 of file vartest.c.

◆ EXPECT2

#define EXPECT2	(	a,
		b
	)	EXPECTRGB(0,a); EXPECTRGB(1,b)

Definition at line 1306 of file vartest.c.

◆ EXPECT_CY

#define EXPECT_CY ( val )

Value:

  EXPECT_OK { EXPECT_TYPE(VT_CY); \
  ok(V_CY(&vOut).int64 == (LONG64)(val * CY_MULTIPLIER), "Expected r8 = 0x%x%08x, got 0x%x%08x\n", \
      (DWORD)((LONG64)val >> 23), (DWORD)(LONG64)val, (DWORD)(V_CY(&vOut).int64 >>32), (DWORD)V_CY(&vOut).int64); }

Definition at line 1776 of file vartest.c.

◆ EXPECT_DECIMAL

#define EXPECT_DECIMAL	(	valHi,
		valMid,
		valLo
	)

Value:

      EXPECT_OK { EXPECT_TYPE(VT_DECIMAL); \
      ok((V_DECIMAL(&vOut).Hi32 == valHi) && (S1(U1(V_DECIMAL(&vOut))).Mid32 == valMid) && \
      (S1(U1(V_DECIMAL(&vOut))).Lo32 == valLo),                      \
  "Expected decimal = %x/0x%x%08x, got %x/0x%x%08x\n", valHi, valMid, valLo, \
      V_DECIMAL(&vOut).Hi32, S1(U1(V_DECIMAL(&vOut))).Mid32, S1(U1(V_DECIMAL(&vOut))).Lo32); }

Definition at line 1779 of file vartest.c.

◆ EXPECT_I1

#define EXPECT_I1 ( val )

Value:

EXPECT_OK { EXPECT_TYPE(VT_I1); \

ok(V_I1(&vOut) == val, "Expected i1 = %d, got %d\n", (signed char)val, V_I1(&vOut)); }

VT_I1

@ VT_I1

Definition: compat.h:2310

V_I1

#define V_I1(A)

Definition: oleauto.h:243

Definition at line 1753 of file vartest.c.

◆ EXPECT_I2

#define EXPECT_I2 ( val )

Value:

EXPECT_OK { EXPECT_TYPE(VT_I2); \

ok(V_I2(&vOut) == val, "Expected i2 = %d, got %d\n", (SHORT)val, V_I2(&vOut)); }

VT_I2

@ VT_I2

Definition: compat.h:2297

V_I2

#define V_I2(A)

Definition: oleauto.h:245

SHORT

short SHORT

Definition: pedump.c:59

Definition at line 1757 of file vartest.c.

◆ EXPECT_I4

#define EXPECT_I4 ( val )

Value:

EXPECT_OK { EXPECT_TYPE(VT_I4); \

ok(V_I4(&vOut) == val, "Expected i4 = %d, got %d\n", (LONG)val, V_I4(&vOut)); }

VT_I4

@ VT_I4

Definition: compat.h:2298

V_I4

#define V_I4(A)

Definition: oleauto.h:247

LONG

long LONG

Definition: pedump.c:60

Definition at line 1761 of file vartest.c.

◆ EXPECT_I8

#define EXPECT_I8	(	high,
		low
	)

Value:

  EXPECT_OK { EXPECT_TYPE(VT_I8); \
  ok(V_I8(&vOut) == ((((ULONG64)(high))<<32)|(low)), "Expected i8 = %x%08x, got %x%08x\n", \
     (LONG)(high), (LONG)(low), (LONG)(V_I8(&vOut)>>32), (LONG)V_I8(&vOut) ); }

Definition at line 1765 of file vartest.c.

◆ EXPECT_OK

#define EXPECT_OK

Value:

ok(hres == (HRESULT)S_OK, szFailOk, hres); \

if (hres == (HRESULT)S_OK)

ok

#define ok(value,...)

Definition: atltest.h:57

HRESULT

Definition: mshtmhst.idl:286

S_OK

#define S_OK

Definition: intsafe.h:52

szFailOk

static const char * szFailOk

Definition: vartest.c:1749

Definition at line 1750 of file vartest.c.

◆ EXPECT_OVERFLOW

#define EXPECT_OVERFLOW ok(hres == (HRESULT)DISP_E_OVERFLOW, szFailOverflow, hres)

Definition at line 1748 of file vartest.c.

◆ EXPECT_R4

#define EXPECT_R4 ( val )

Value:

EXPECT_OK { EXPECT_TYPE(VT_R4); \

ok(V_R4(&vOut) == val, "Expected r4 = %f, got %f\n", val, V_R4(&vOut)); }

VT_R4

@ VT_R4

Definition: compat.h:2299

V_R4

#define V_R4(A)

Definition: oleauto.h:260

Definition at line 1771 of file vartest.c.

◆ EXPECT_R8

#define EXPECT_R8 ( val )

Value:

EXPECT_OK { EXPECT_TYPE(VT_R8); \

ok(V_R8(&vOut) == val, "Expected r8 = %g, got %g\n", val, V_R8(&vOut)); }

VT_R8

@ VT_R8

Definition: compat.h:2300

V_R8

#define V_R8(A)

Definition: oleauto.h:262

Definition at line 1773 of file vartest.c.

◆ EXPECT_TYPE

#define EXPECT_TYPE ( typ ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))

Definition at line 1752 of file vartest.c.

◆ EXPECT_UI1

#define EXPECT_UI1 ( val )

Value:

EXPECT_OK { EXPECT_TYPE(VT_UI1); \

ok(V_UI1(&vOut) == val, "Expected ui1 = %d, got %d\n", (BYTE)val, V_UI1(&vOut)); }

VT_UI1

@ VT_UI1

Definition: compat.h:2311

V_UI1

#define V_UI1(A)

Definition: oleauto.h:266

BYTE

unsigned char BYTE

Definition: xxhash.c:193

Definition at line 1755 of file vartest.c.

◆ EXPECT_UI2

#define EXPECT_UI2 ( val )

Value:

EXPECT_OK { EXPECT_TYPE(VT_UI2); \

ok(V_UI2(&vOut) == val, "Expected ui2 = %d, got %d\n", (USHORT)val, V_UI2(&vOut)); }

VT_UI2

@ VT_UI2

Definition: compat.h:2312

V_UI2

#define V_UI2(A)

Definition: oleauto.h:268

USHORT

unsigned short USHORT

Definition: pedump.c:61

Definition at line 1759 of file vartest.c.

◆ EXPECT_UI4

#define EXPECT_UI4 ( val )

Value:

EXPECT_OK { EXPECT_TYPE(VT_UI4); \

ok(V_UI4(&vOut) == val, "Expected ui4 = %d, got %d\n", (ULONG)val, V_UI4(&vOut)); }

VT_UI4

@ VT_UI4

Definition: compat.h:2313

V_UI4

#define V_UI4(A)

Definition: oleauto.h:270

ULONG

uint32_t ULONG

Definition: typedefs.h:59

Definition at line 1763 of file vartest.c.

◆ EXPECT_UI8

#define EXPECT_UI8 ( val )

Value:

  EXPECT_OK { EXPECT_TYPE(VT_UI8); \
  ok(V_UI8(&vOut) == val, "Expected ui8 = 0x%x%08x, got 0x%x%08x\n", \
      (DWORD)((ULONG64)val >> 32), (DWORD)(ULONG64)val, (DWORD)(V_UI8(&vOut) >> 32), (DWORD)V_UI8(&vOut)); }

Definition at line 1768 of file vartest.c.

◆ EXPECTFAIL

#define EXPECTFAIL ok(hres == (HRESULT)DISP_E_TYPEMISMATCH, "Call succeeded, hres = %08x\n", hres)

Definition at line 1305 of file vartest.c.

◆ EXPECTRGB

#define EXPECTRGB	(	a,
		b
	)	ok(rgb[a] == b, "Digit[%d], expected %d, got %d\n", a, b, rgb[a])

Definition at line 1304 of file vartest.c.

◆ FAILDIG

#define FAILDIG 255

Definition at line 1273 of file vartest.c.

◆ I1_MAX

#define I1_MAX 0x7f

Definition at line 77 of file vartest.c.

◆ I1_MIN

#define I1_MIN ((-I1_MAX)-1)

Definition at line 78 of file vartest.c.

◆ I2_MAX

#define I2_MAX 0x7fff

Definition at line 81 of file vartest.c.

◆ I2_MIN

#define I2_MIN ((-I2_MAX)-1)

Definition at line 82 of file vartest.c.

◆ I4_MAX

#define I4_MAX 0x7fffffff

Definition at line 85 of file vartest.c.

◆ I4_MIN

#define I4_MIN ((-I4_MAX)-1)

Definition at line 86 of file vartest.c.

◆ I8_MAX

#define I8_MAX (((LONGLONG)I4_MAX << 32) | UI4_MAX)

Definition at line 89 of file vartest.c.

◆ I8_MIN

#define I8_MIN ((-I8_MAX)-1)

Definition at line 90 of file vartest.c.

◆ INTEGER_VTBITS

◆ MKDOSDATE

#define MKDOSDATE	(	d,
		m,
		y
	)	((d & 0x1f) \| ((m & 0xf) << 5) \| (((y-1980) & 0x7f) << 9))

Definition at line 2151 of file vartest.c.

◆ MKDOSTIME

#define MKDOSTIME	(	h,
		m,
		s
	)	(((s>>1) & 0x1f) \| ((m & 0x3f) << 5) \| ((h & 0x1f) << 11))

Definition at line 2152 of file vartest.c.

◆ R4_MAX

#define R4_MAX FLT_MAX

Definition at line 95 of file vartest.c.

◆ R4_MIN

#define R4_MIN FLT_MIN

Definition at line 96 of file vartest.c.

◆ R8_MAX

#define R8_MAX DBL_MAX

Definition at line 97 of file vartest.c.

◆ R8_MIN

#define R8_MIN DBL_MIN

Definition at line 98 of file vartest.c.

◆ SET_EXPECT

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

Definition at line 103 of file vartest.c.

◆ SETRGB

#define SETRGB	(	indx,
		val
	)	if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val

Definition at line 1742 of file vartest.c.

◆ SKIPTESTAND

#define SKIPTESTAND ( a )

Value:

        if (a == VT_ERROR || a == VT_VARIANT ||       \
            a == VT_DISPATCH || a == VT_UNKNOWN ||    \
            a > VT_UINT || a == 15 /*not defined*/)   \
            continue

Definition at line 6211 of file vartest.c.

◆ SKIPTESTDIV

#define SKIPTESTDIV ( a )

Value:

    if (a == VT_ERROR || a == VT_VARIANT ||       \
        a == VT_DISPATCH || a == VT_UNKNOWN ||    \
        a == VT_RECORD || a > VT_UINT ||          \
        a == VT_I1 || a == VT_UI8 ||              \
        a == VT_INT || a == VT_UINT ||            \
        a == VT_UI2 || a == VT_UI4 ||             \
        a == 15 /*not defined*/)                  \
        continue

Definition at line 7684 of file vartest.c.

◆ SKIPTESTIDIV

#define SKIPTESTIDIV ( a )

Value:

    if (a == VT_ERROR || a == VT_VARIANT ||       \
        a == VT_DISPATCH || a == VT_UNKNOWN ||    \
        a == VT_RECORD || a > VT_UINT ||          \
        a == 15 /*not defined*/)                  \
        continue

Definition at line 8058 of file vartest.c.

◆ SKIPTESTIMP

#define SKIPTESTIMP ( a )

Value:

    if (a == VT_ERROR || a == VT_VARIANT ||       \
        a == VT_DISPATCH || a == VT_UNKNOWN ||    \
        a == VT_RECORD || a > VT_UINT ||          \
        a == 15 /*not defined*/)                  \
        continue

Definition at line 8624 of file vartest.c.

◆ SKIPTESTPOW

#define SKIPTESTPOW ( a )

Value:

    if (a == VT_ERROR || a == VT_VARIANT ||       \
        a == VT_DISPATCH || a == VT_UNKNOWN ||    \
        a == VT_RECORD || a > VT_UINT ||          \
        a == 15 /*not defined*/)                  \
        continue

Definition at line 7162 of file vartest.c.

◆ SKIPTESTS

#define SKIPTESTS ( a ) if((a > VT_CLSID+10) && (a < VT_BSTR_BLOB-10)) continue

Definition at line 70 of file vartest.c.

◆ ST2DT

#define ST2DT	(	d,
		m,
		y,
		h,
		mn,
		s,
		ms,
		r,
		dt
	)	test_st2dt(__LINE__,d,m,y,h,mn,s,ms,r,dt)

Definition at line 2106 of file vartest.c.

◆ test_bstr_var

#define test_bstr_var	(	a,
		b
	)	_test_bstr_var(__LINE__,a,b)

Definition at line 671 of file vartest.c.

◆ UD2T

#define UD2T	(	d,
		m,
		y,
		h,
		mn,
		s,
		ms,
		dw,
		dy,
		flags,
		r,
		dt
	)	test_DateFromUDate(__LINE__,d,m,y,h,mn,s,ms,dw,dy,flags,r,dt)

Definition at line 2030 of file vartest.c.

◆ UI1_MAX

#define UI1_MAX 0xff

Definition at line 79 of file vartest.c.

◆ UI1_MIN

#define UI1_MIN 0

Definition at line 80 of file vartest.c.

◆ UI2_MAX

#define UI2_MAX 0xffff

Definition at line 83 of file vartest.c.

◆ UI2_MIN

#define UI2_MIN 0

Definition at line 84 of file vartest.c.

◆ UI4_MAX

#define UI4_MAX 0xffffffff

Definition at line 87 of file vartest.c.

◆ UI4_MIN

#define UI4_MIN 0

Definition at line 88 of file vartest.c.

◆ UI8_MAX

#define UI8_MAX (((ULONGLONG)UI4_MAX << 32) | UI4_MAX)

Definition at line 91 of file vartest.c.

◆ UI8_MIN

#define UI8_MIN 0

Definition at line 92 of file vartest.c.

◆ V_EMPTY

#define V_EMPTY ( v ) V_I4(v)

Definition at line 73 of file vartest.c.

◆ V_NULL

#define V_NULL ( v ) V_I4(v)

Definition at line 74 of file vartest.c.

◆ V_NULL_

#define V_NULL_ V_NULL

Definition at line 6910 of file vartest.c.

◆ VARABS

#define VARABS	(	vt,
		val,
		rvt,
		rval
	)

Value:

    V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
    V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
    test_var_call1( __LINE__, pVarAbs, &v, &exp )

Definition at line 2277 of file vartest.c.

◆ VARADD

#define VARADD	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarAdd, &left, &right, &exp )

Definition at line 5548 of file vartest.c.

◆ VARAND

#define VARAND	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )

Definition at line 6198 of file vartest.c.

◆ VARANDCY

#define VARANDCY	(	vt1,
		val1,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )

Definition at line 6204 of file vartest.c.

◆ VARCMP

#define VARCMP	(	vt1,
		val1,
		vt2,
		val2,
		result
	)	VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)

Definition at line 6907 of file vartest.c.

◆ VARCMPEX

#define VARCMPEX	(	vt1,
		val1,
		vt2,
		val2,
		res1,
		res2,
		res3,
		res4
	)

Value:

        V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1; \
        V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2; \
        test_cmpex( __LINE__, lcid, &left, &right, res1, res2, res3, res4 )

Definition at line 6903 of file vartest.c.

◆ VARDIV

#define VARDIV	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarDiv, &left, &right, &exp )

Definition at line 7677 of file vartest.c.

◆ VAREQV

#define VAREQV	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

    V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
    V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
    V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
    test_var_call2( __LINE__, pVarEqv, &left, &right, &exp )

Definition at line 5238 of file vartest.c.

◆ VARFIX

#define VARFIX	(	vt,
		val,
		rvt,
		rval
	)

Value:

    V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
    V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
    test_var_call1( __LINE__, pVarFix, &v, &exp )

Definition at line 3238 of file vartest.c.

◆ VARIDIV

#define VARIDIV	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarIdiv, &left, &right, &exp )

Definition at line 8051 of file vartest.c.

◆ VARIMP

#define VARIMP	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarImp, &left, &right, &exp )

Definition at line 8617 of file vartest.c.

◆ VARINT

#define VARINT	(	vt,
		val,
		rvt,
		rval
	)

Value:

    V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
    V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
    test_var_call1( __LINE__, pVarInt, &v, &exp )

Definition at line 3353 of file vartest.c.

◆ VARMOD

#define VARMOD	(	vt1,
		vt2,
		val1,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarMod, &left, &right, &exp )

Definition at line 2745 of file vartest.c.

◆ VARMOD2

#define VARMOD2	(	vt1,
		vt2,
		val1,
		val2,
		rvt,
		rval,
		hexpected
	)

Value:

        V_VT(&left) = VT_##vt1; V_I4(&left) = val1;           \
        V_VT(&right) = VT_##vt2; V_I4(&right) = val2;         \
        V_VT(&exp) = VT_##rvt; V_I4(&exp) = rval;             \
        test_Mod( __LINE__, &left, &right, &exp, hexpected )

Definition at line 2751 of file vartest.c.

◆ VARMUL

#define VARMUL	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarMul, &left, &right, &exp )

Definition at line 5377 of file vartest.c.

◆ VARNEG

#define VARNEG	(	vt,
		val,
		rvt,
		rval
	)

Value:

    V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
    V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
    test_var_call1( __LINE__, pVarNeg, &v, &exp )

Definition at line 3469 of file vartest.c.

◆ VARNOT

#define VARNOT	(	vt,
		val,
		rvt,
		rval
	)

Value:

    V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
    V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
    test_var_call1( __LINE__, pVarNot, &v, &exp )

Definition at line 2375 of file vartest.c.

◆ VAROR

#define VAROR	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarOr, &left, &right, &exp )

Definition at line 4497 of file vartest.c.

◆ VARORCY

#define VARORCY	(	vt1,
		val1,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarOr, &left, &right, &exp )

Definition at line 4503 of file vartest.c.

◆ VARPOW

#define VARPOW	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarPow, &left, &right, &exp )

Definition at line 7155 of file vartest.c.

◆ VARROUND

#define VARROUND	(	vt,
		val,
		deci,
		rvt,
		rval
	)

Value:

    V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
    V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
    test_Round( __LINE__, &v, deci, &exp )

Definition at line 3605 of file vartest.c.

◆ VARSUB

#define VARSUB	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarSub, &left, &right, &exp )

Definition at line 2502 of file vartest.c.

◆ VARXOR

#define VARXOR	(	vt1,
		val1,
		vt2,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarXor, &left, &right, &exp )

Definition at line 3763 of file vartest.c.

◆ VARXORCY

#define VARXORCY	(	vt1,
		val1,
		val2,
		rvt,
		rval
	)

Value:

        V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
        V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
        test_var_call2( __LINE__, pVarXor, &left, &right, &exp )

Definition at line 3769 of file vartest.c.

◆ VT_NULL_

#define VT_NULL_ VT_NULL

Definition at line 6911 of file vartest.c.

Typedef Documentation

◆ IRecordInfoImpl

typedef struct IRecordInfoImpl IRecordInfoImpl

Function Documentation

◆ _test_bstr_var()

static void _test_bstr_var	(	unsigned	line,
		const VARIANT *	v,
		const char *	str
	)

static

Definition at line 672 of file vartest.c.

{
    ok_(__FILE__,line)(V_VT(v) == VT_BSTR, "unexpected vt=%d\n", V_VT(v));
    if(V_VT(v) == VT_BSTR)
        ok(!strcmp_wa(V_BSTR(v), str), "v=%s, expected %s\n", wine_dbgstr_w(V_BSTR(v)), str);
}

◆ convert_str()

static HRESULT convert_str	(	const char *	str,
		INT	dig,
		ULONG	flags,
		NUMPARSE *	np,
		BYTE	rgb[128],
		LCID	lcid
	)

static

Definition at line 1275 of file vartest.c.

{
    OLECHAR buff[128];
    MultiByteToWideChar( CP_ACP,0, str, -1, buff, ARRAY_SIZE( buff ));
    memset( rgb, FAILDIG, 128 );
    memset( np, 255, sizeof(*np) );
    np->cDig = dig;
    np->dwInFlags = flags;
    return pVarParseNumFromStr( buff, lcid, LOCALE_NOUSEROVERRIDE, np, rgb);
}

◆ DEFINE_EXPECT()

DEFINE_EXPECT ( dispatch_invoke )

◆ DummyDispatch_AddRef()

static ULONG WINAPI DummyDispatch_AddRef ( IDispatch * iface )

static

Definition at line 138 of file vartest.c.

{
    return 2;
}

◆ DummyDispatch_GetIDsOfNames()

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

static

Definition at line 176 of file vartest.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 170 of file vartest.c.

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

◆ DummyDispatch_GetTypeInfoCount()

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

static

Definition at line 164 of file vartest.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 183 of file vartest.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 (FAILED(This->result))
        return This->result;
 
    V_VT(res) = This->vt;
    if (This->vt == VT_UI1)
        V_UI1(res) = 34;
    else if (This->vt == VT_NULL)
    {
        V_VT(res) = VT_NULL;
        V_BSTR(res) = NULL;
    }
    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 148 of file vartest.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 143 of file vartest.c.

{
    return 1;
}

◆ expect_NumFromStr()

static void expect_NumFromStr	(	int	line,
		HRESULT	hres,
		NUMPARSE *	np,
		INT	a,
		ULONG	b,
		ULONG	c,
		INT	d,
		INT	e,
		INT	f
	)

static

Definition at line 1287 of file vartest.c.

{
    if (hres == (HRESULT)S_OK)
    {
        ok_(__FILE__,line)(np->cDig == a, "Expected cDig = %d, got %d\n", a, np->cDig);
        ok_(__FILE__,line)(np->dwInFlags == b, "Expected dwInFlags = 0x%x, got 0x%x\n", b, np->dwInFlags);
        ok_(__FILE__,line)(np->dwOutFlags == c, "Expected dwOutFlags = 0x%x, got 0x%x\n", c, np->dwOutFlags);
        ok_(__FILE__,line)(np->cchUsed == d, "Expected cchUsed = %d, got %d\n", d, np->cchUsed);
        ok_(__FILE__,line)(np->nBaseShift == e, "Expected nBaseShift = %d, got %d\n", e, np->nBaseShift);
        ok_(__FILE__,line)(np->nPwr10 == f, "Expected nPwr10 = %d, got %d\n", f, np->nPwr10);
    }
}

◆ get_test_recordinfo()

static IRecordInfoImpl * get_test_recordinfo ( void )

static

Definition at line 422 of file vartest.c.

{
    IRecordInfoImpl *rec;
 
    rec = HeapAlloc(GetProcessHeap(), 0, sizeof(IRecordInfoImpl));
    rec->IRecordInfo_iface.lpVtbl = &RecordInfoVtbl;
    rec->ref = 1;
    rec->recordclear = 0;
    rec->getsize = 0;
    rec->recordcopy = 0;
 
    return rec;
}

Referenced by test_VariantClear(), and test_VariantCopy().

◆ HRESULT()

static HRESULT ( WINAPI * pVarUdateFromDate )

static

◆ impl_from_IDispatch()

static DummyDispatch * impl_from_IDispatch ( IDispatch * iface )

inlinestatic

Definition at line 133 of file vartest.c.

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

Referenced by DummyDispatch_Invoke().

◆ impl_from_IRecordInfo()

static IRecordInfoImpl * impl_from_IRecordInfo ( IRecordInfo * iface )

inlinestatic

Definition at line 254 of file vartest.c.

{
    return CONTAINING_RECORD(iface, IRecordInfoImpl, IRecordInfo_iface);
}

Referenced by RecordInfo_AddRef(), RecordInfo_GetSize(), RecordInfo_RecordClear(), RecordInfo_RecordCopy(), and RecordInfo_Release().

◆ impl_from_IUnknown()

static test_VariantClearImpl * impl_from_IUnknown ( IUnknown * iface )

inlinestatic

Definition at line 735 of file vartest.c.

{
    return CONTAINING_RECORD(iface, test_VariantClearImpl, IUnknown_iface);
}

Referenced by VC_AddRef(), VC_QueryInterface(), and VC_Release().

◆ init()

static void init ( void )

static

Definition at line 436 of file vartest.c.

{
    BSTR bstr;
    HRESULT res;
 
    res = VarBstrFromBool(VARIANT_TRUE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
    ok(res == S_OK && bstr[0], "Expected localized string for 'True'\n");
    /* lstrcpyW / lstrcatW do not work on win95 */
    memcpy(sz12_true, sz12, sizeof(sz12));
    if (bstr) memcpy(&sz12_true[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
    SysFreeString(bstr);
 
    res = VarBstrFromBool(VARIANT_FALSE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
    ok(res == S_OK && bstr[0], "Expected localized string for 'False'\n");
    memcpy(sz12_false, sz12, sizeof(sz12));
    if (bstr) memcpy(&sz12_false[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
    SysFreeString(bstr);
 
    hOleaut32 = GetModuleHandleA("oleaut32.dll");
    has_i8 = GetProcAddress(hOleaut32, "VarI8FromI1") != NULL;
    if (!has_i8)
        skip("No support for I8 and UI8 data types\n");
}

Referenced by START_TEST().

◆ init_test_dispatch()

static void init_test_dispatch	(	VARTYPE	vt,
		DummyDispatch *	dispatch
	)

static

Definition at line 237 of file vartest.c.

{
    dispatch->IDispatch_iface.lpVtbl = &DummyDispatch_VTable;
    dispatch->vt = vt;
    dispatch->result = S_OK;
}

Referenced by test_VarCat().

◆ INT()

static UDATE *static DATE *static INT ( WINAPI * pSystemTimeToVariantTime )

static

◆ is_expected_variant()

static BOOL is_expected_variant	(	const VARIANT *	result,
		const VARIANT *	expected
	)

static

Definition at line 585 of file vartest.c.

{
    if (V_VT(result) != V_VT(expected)) return FALSE;
    switch(V_VT(expected))
    {
    case VT_EMPTY:
    case VT_NULL:
        return TRUE;
 
#define CASE(vt) case VT_##vt: return (V_##vt(result) == V_##vt(expected))
    CASE(BOOL);
    CASE(I1);
    CASE(UI1);
    CASE(I2);
    CASE(UI2);
    CASE(I4);
    CASE(UI4);
    CASE(I8);
    CASE(UI8);
    CASE(INT);
    CASE(UINT);
#undef CASE
 
    case VT_DATE:
        return EQ_FLOAT(V_DATE(result), V_DATE(expected));
    case VT_R4:
        return EQ_FLOAT(V_R4(result), V_R4(expected));
    case VT_R8:
        return EQ_FLOAT(V_R8(result), V_R8(expected));
    case VT_CY:
        return (V_CY(result).int64 == V_CY(expected).int64);
    case VT_BSTR:
        return !lstrcmpW( V_BSTR(result), V_BSTR(expected) );
    case VT_DECIMAL:
        return !memcmp( &V_DECIMAL(result), &V_DECIMAL(expected), sizeof(DECIMAL) );
    default:
        ok(0, "unhandled variant type %s\n",vtstr(V_VT(expected)));
        return FALSE;
    }
}

Referenced by test_Mod(), test_Round(), test_var_call1(), and test_var_call2().

◆ IsValidVariantClearVT()

static BOOL IsValidVariantClearVT	(	VARTYPE	vt,
		VARTYPE	extraFlags
	)

static

Definition at line 710 of file vartest.c.

{
  BOOL ret = FALSE;
 
  /* Only the following flags/types are valid */
  if ((vt <= VT_LPWSTR || vt == VT_RECORD || vt == VT_CLSID) &&
      vt != (VARTYPE)15 &&
      (vt < (VARTYPE)24 || vt > (VARTYPE)31) &&
      (!(extraFlags & (VT_BYREF|VT_ARRAY)) || vt > VT_NULL) &&
      (extraFlags == 0 || extraFlags == VT_BYREF || extraFlags == VT_ARRAY ||
       extraFlags == (VT_ARRAY|VT_BYREF)))
    ret = TRUE; /* ok */
 
  if (!has_i8 && (vt == VT_I8 || vt == VT_UI8))
    ret = FALSE; /* Old versions of oleaut32 */
  return ret;
}

Referenced by test_VarAbs(), test_VarAdd(), test_VarCmp(), test_VarEqv(), test_VariantClear(), test_VariantCopy(), test_VariantCopyInd(), test_VarMul(), test_VarNot(), test_VarOr(), test_VarSub(), and test_VarXor().

◆ IsValidVariantCopyIndVT()

static BOOL IsValidVariantCopyIndVT	(	VARTYPE	vt,
		VARTYPE	extraFlags
	)

static

Definition at line 1058 of file vartest.c.

{
  BOOL ret = FALSE;
 
  if ((extraFlags & VT_ARRAY) ||
     (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
     !(extraFlags & (VT_VECTOR|VT_RESERVED))))
  {
    ret = TRUE; /* ok */
  }
  return ret;
}

Referenced by test_VariantCopyInd().

◆ RecordInfo_AddRef()

static ULONG WINAPI RecordInfo_AddRef ( IRecordInfo * iface )

static

Definition at line 274 of file vartest.c.

{
    IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
    return InterlockedIncrement(&This->ref);
}

◆ RecordInfo_GetField()

static HRESULT WINAPI RecordInfo_GetField	(	IRecordInfo *	iface,
		PVOID	pvData,
		LPCOLESTR	szFieldName,
		VARIANT *	pvarField
	)

static

Definition at line 339 of file vartest.c.

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

◆ RecordInfo_GetFieldNames()

static HRESULT WINAPI RecordInfo_GetFieldNames	(	IRecordInfo *	iface,
		ULONG *	pcNames,
		BSTR *	rgBstrNames
	)

static

Definition at line 367 of file vartest.c.

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

◆ RecordInfo_GetFieldNoCopy()

static HRESULT WINAPI RecordInfo_GetFieldNoCopy	(	IRecordInfo *	iface,
		PVOID	pvData,
		LPCOLESTR	szFieldName,
		VARIANT *	pvarField,
		PVOID *	ppvDataCArray
	)

static

Definition at line 346 of file vartest.c.

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

◆ RecordInfo_GetGuid()

static HRESULT WINAPI RecordInfo_GetGuid	(	IRecordInfo *	iface,
		GUID *	pguid
	)

static

Definition at line 313 of file vartest.c.

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

◆ RecordInfo_GetName()

static HRESULT WINAPI RecordInfo_GetName	(	IRecordInfo *	iface,
		BSTR *	pbstrName
	)

static

Definition at line 319 of file vartest.c.

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

◆ RecordInfo_GetSize()

static HRESULT WINAPI RecordInfo_GetSize	(	IRecordInfo *	iface,
		ULONG *	size
	)

static

Definition at line 325 of file vartest.c.

{
    IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
    This->getsize++;
    *size = 0;
    return S_OK;
}

◆ RecordInfo_GetTypeInfo()

static HRESULT WINAPI RecordInfo_GetTypeInfo	(	IRecordInfo *	iface,
		ITypeInfo **	ppTypeInfo
	)

static

Definition at line 333 of file vartest.c.

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

◆ RecordInfo_IsMatchingType()

static BOOL WINAPI RecordInfo_IsMatchingType	(	IRecordInfo *	iface,
		IRecordInfo *	info2
	)

static

Definition at line 374 of file vartest.c.

{
    ok(0, "unexpected call\n");
    return FALSE;
}

◆ RecordInfo_PutField()

static HRESULT WINAPI RecordInfo_PutField	(	IRecordInfo *	iface,
		ULONG	wFlags,
		PVOID	pvData,
		LPCOLESTR	szFieldName,
		VARIANT *	pvarField
	)

static

Definition at line 353 of file vartest.c.

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

◆ RecordInfo_PutFieldNoCopy()

static HRESULT WINAPI RecordInfo_PutFieldNoCopy	(	IRecordInfo *	iface,
		ULONG	wFlags,
		PVOID	pvData,
		LPCOLESTR	szFieldName,
		VARIANT *	pvarField
	)

static

Definition at line 360 of file vartest.c.

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

◆ RecordInfo_QueryInterface()

static HRESULT WINAPI RecordInfo_QueryInterface	(	IRecordInfo *	iface,
		REFIID	riid,
		void **	obj
	)

static

Definition at line 259 of file vartest.c.

{
    *obj = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IRecordInfo))
    {
        *obj = iface;
        IRecordInfo_AddRef(iface);
        return S_OK;
    }
 
    return E_NOINTERFACE;
}

◆ RecordInfo_RecordClear()

static HRESULT WINAPI RecordInfo_RecordClear	(	IRecordInfo *	iface,
		void *	data
	)

static

Definition at line 297 of file vartest.c.

{
    IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
    This->recordclear++;
    This->rec->pvRecord = NULL;
    return S_OK;
}

◆ RecordInfo_RecordCopy()

static HRESULT WINAPI RecordInfo_RecordCopy	(	IRecordInfo *	iface,
		void *	src,
		void *	dest
	)

static

Definition at line 305 of file vartest.c.

{
    IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
    This->recordcopy++;
    ok(src == (void*)0xdeadbeef, "wrong src pointer %p\n", src);
    return S_OK;
}

◆ RecordInfo_RecordCreate()

static PVOID WINAPI RecordInfo_RecordCreate ( IRecordInfo * iface )

static

Definition at line 380 of file vartest.c.

{
    ok(0, "unexpected call\n");
    return NULL;
}

◆ RecordInfo_RecordCreateCopy()

static HRESULT WINAPI RecordInfo_RecordCreateCopy	(	IRecordInfo *	iface,
		PVOID	pvSource,
		PVOID *	ppvDest
	)

static

Definition at line 386 of file vartest.c.

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

◆ RecordInfo_RecordDestroy()

static HRESULT WINAPI RecordInfo_RecordDestroy	(	IRecordInfo *	iface,
		PVOID	pvRecord
	)

static

Definition at line 393 of file vartest.c.

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

◆ RecordInfo_RecordInit()

static HRESULT WINAPI RecordInfo_RecordInit	(	IRecordInfo *	iface,
		PVOID	pvNew
	)

static

Definition at line 291 of file vartest.c.

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

◆ RecordInfo_Release()

static ULONG WINAPI RecordInfo_Release ( IRecordInfo * iface )

static

Definition at line 280 of file vartest.c.

{
    IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    if (!ref)
        HeapFree(GetProcessHeap(), 0, This);
 
    return ref;
}

◆ setdec()

static void setdec	(	DECIMAL *	dec,
		BYTE	scl,
		BYTE	sgn,
		ULONG	hi32,
		ULONG64	lo64
	)

static

Definition at line 461 of file vartest.c.

{
    S(U(*dec)).scale = scl;
    S(U(*dec)).sign = sgn;
    dec->Hi32 = hi32;
    U1(*dec).Lo64 = lo64;
}

Referenced by test_VarCmp().

◆ setdec64()

static void setdec64	(	DECIMAL *	dec,
		BYTE	scl,
		BYTE	sgn,
		ULONG	hi32,
		ULONG	mid32,
		ULONG	lo32
	)

static

Definition at line 469 of file vartest.c.

{
    S(U(*dec)).scale = scl;
    S(U(*dec)).sign = sgn;
    dec->Hi32 = hi32;
    S1(U1(*dec)).Mid32 = mid32;
    S1(U1(*dec)).Lo32 = lo32;
}

Referenced by test_VarCmp().

◆ START_TEST()

START_TEST ( vartest )

Definition at line 9177 of file vartest.c.

{
  init();
 
  test_VariantInit();
  test_VariantClear();
  test_VariantCopy();
  test_VariantCopyInd();
  test_VarParseNumFromStr();
  test_VarNumFromParseNum();
  test_VarUdateFromDate();
  test_VarDateFromUdate();
  test_SystemTimeToVariantTime();
  test_VariantTimeToSystemTime();
  test_DosDateTimeToVariantTime();
  test_VariantTimeToDosDateTime();
  test_VarAbs();
  test_VarNot();
  test_VarSub();
  test_VarMod();
  test_VarFix();
  test_VarInt();
  test_VarNeg();
  test_VarRound();
  test_VarXor();
  test_VarOr();
  test_VarPow();
  test_VarEqv();
  test_VarMul();
  test_VarAdd();
  test_VarCmp(); /* Before test_VarCat() which needs VarCmp() */
  test_VarCat();
  test_VarAnd();
  test_VarDiv();
  test_VarIdiv();
  test_VarImp();
}

◆ strcmp_wa()

static int strcmp_wa	(	const WCHAR *	strw,
		const char *	stra
	)

static

Definition at line 664 of file vartest.c.

{
    WCHAR buf[512];
    MultiByteToWideChar(CP_ACP, 0, stra, -1, buf, ARRAY_SIZE(buf));
    return lstrcmpW(strw, buf);
}

Referenced by _test_bstr_var(), and test_VarCat().

◆ test_cmp()

static void test_cmp	(	int	line,
		LCID	lcid,
		UINT	flags,
		VARIANT *	left,
		VARIANT *	right,
		HRESULT	result
	)

static

Definition at line 6873 of file vartest.c.

{
    HRESULT hres;
 
    CHECKPTR(VarCmp);
 
    hres = pVarCmp(left,right,lcid,flags);
    ok_(__FILE__,line)(hres == result, "VarCmp(%s,%s): expected 0x%x, got hres=0x%x\n",
                       variantstr(left), variantstr(right), result, hres );
}

Referenced by test_cmpex().

◆ test_cmpex()

static void test_cmpex	(	int	line,
		LCID	lcid,
		VARIANT *	left,
		VARIANT *	right,
		HRESULT	res1,
		HRESULT	res2,
		HRESULT	res3,
		HRESULT	res4
	)

static

Definition at line 6883 of file vartest.c.

{
    test_cmp( line, lcid, 0, left, right, res1 );
    V_VT(left) |= VT_RESERVED;
    test_cmp( line, lcid, 0, left, right, res2 );
    V_VT(left) &= ~VT_RESERVED;
    V_VT(right) |= VT_RESERVED;
    test_cmp( line, lcid, 0, left, right, res3 );
    V_VT(left) |= VT_RESERVED;
    test_cmp( line, lcid, 0, left, right, res4 );
    ok_(__FILE__,line)(V_VT(left) & V_VT(right) & VT_RESERVED, "VT_RESERVED filtered out\n");
}

◆ test_DateFromUDate()

static void test_DateFromUDate	(	int	line,
		WORD	d,
		WORD	m,
		WORD	y,
		WORD	h,
		WORD	mn,
		WORD	s,
		WORD	ms,
		WORD	dw,
		WORD	dy,
		ULONG	flags,
		HRESULT	r,
		DATE	dt
	)

static

Definition at line 2010 of file vartest.c.

{
    UDATE ud;
    double out;
    HRESULT res;
 
    ud.st.wYear = y;
    ud.st.wMonth = m;
    ud.st.wDay = d;
    ud.st.wHour = h;
    ud.st.wMinute = mn;
    ud.st.wSecond = s;
    ud.st.wMilliseconds = ms;
    ud.st.wDayOfWeek = dw;
    ud.wDayOfYear = dy;
    res = pVarDateFromUdate(&ud, flags, &out);
    ok_(__FILE__,line)(r == res && (r != S_OK || EQ_DOUBLE(out, dt)),
                       "expected %x, %.16g, got %x, %.16g\n", r, dt, res, out);
}

◆ test_dos2dt()

static void test_dos2dt	(	int	line,
		WORD	d,
		WORD	m,
		WORD	y,
		WORD	h,
		WORD	mn,
		WORD	s,
		INT	r,
		double	dt
	)

static

Definition at line 2154 of file vartest.c.

{
    unsigned short dosDate, dosTime;
    double out;
    INT res;
 
    out = 0.0;
    dosDate = MKDOSDATE(d, m, y);
    dosTime = MKDOSTIME(h, mn, s);
    res = pDosDateTimeToVariantTime(dosDate, dosTime, &out);
    ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
                       "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
}

◆ test_DosDateTimeToVariantTime()

static void test_DosDateTimeToVariantTime ( void )

static

Definition at line 2170 of file vartest.c.

{
  CHECKPTR(DosDateTimeToVariantTime);
 
  /* Date */
  DOS2DT(1,1,1980,0,0,0,1,29221.0); /* 1/1/1980 */
  DOS2DT(31,12,2099,0,0,0,1,73050.0); /* 31/12/2099 */
  /* Dates are limited to the dos date max of 31/12/2099 */
  DOS2DT(31,12,2100,0,0,0,0,0.0); /* 31/12/2100 */
  /* Days and months of 0 cause date to roll back 1 day or month */
  DOS2DT(0,1,1980,0,0,0,1,29220.0); /* 0 Day => 31/12/1979 */
  DOS2DT(1,0,1980,0,0,0,1,29190.0); /* 0 Mth =>  1/12/1979 */
  DOS2DT(0,0,1980,0,0,0,1,29189.0); /* 0 D/M => 30/11/1979 */
  /* Days > days in the month cause date to roll forward 1 month */
  DOS2DT(29,2,1981,0,0,0,1,29646.0); /* 29/2/1981 -> 3/1/1980 */
  DOS2DT(30,2,1981,0,0,0,1,29647.0); /* 30/2/1981 -> 4/1/1980 */
  /* Takes leap years into account when rolling forward */
  DOS2DT(29,2,1980,0,0,0,1,29280.0); /* 2/29/1980 */
  /* Months > 12 cause an error */
  DOS2DT(2,13,1980,0,0,0,0,0.0);
 
  /* Time */
  DOS2DT(1,1,1980,0,0,29,1,29221.00032407407); /* 1/1/1980 12:00:28 AM */
  DOS2DT(1,1,1980,0,0,31,1,29221.00034722222); /* 1/1/1980 12:00:30 AM */
  DOS2DT(1,1,1980,0,59,0,1,29221.04097222222); /* 1/1/1980 12:59:00 AM */
  DOS2DT(1,1,1980,0,60,0,0,0.0);               /* Invalid minutes */
  DOS2DT(1,1,1980,0,0,60,0,0.0);               /* Invalid seconds */
  DOS2DT(1,1,1980,23,0,0,1,29221.95833333333); /* 1/1/1980 11:00:00 PM */
  DOS2DT(1,1,1980,24,0,0,0,0.0);               /* Invalid hours */
 
  DOS2DT(1,1,1980,0,0,1,1,29221.0);
  DOS2DT(2,1,1980,0,0,0,1,29222.0);
  DOS2DT(2,1,1980,0,0,0,1,29222.0);
  DOS2DT(31,12,1990,0,0,0,1,33238.0);
  DOS2DT(31,12,90,0,0,0,1,40543.0);
  DOS2DT(30,12,1899,0,0,0,1,46751.0);
  DOS2DT(1,1,100,0,0,0,1,43831.0);
  DOS2DT(31,12,9999,0,0,0,1,59901.0);
  DOS2DT(1,1,10000,0,0,0,1,59902.0);
  DOS2DT(1,1,-10000,0,0,0,1,48214.0);
 
  DOS2DT(30,12,1899,0,0,0,1,46751.0);
  DOS2DT(30,12,1899,0,0,1,1,46751.0);
 
  DOS2DT(1,1,1980,18,1,16,1,29221.75087962963);
  DOS2DT(1,300,1980,18,1,16,1,29556.75087962963);
  DOS2DT(300,1,1980,18,1,16,1,29232.75087962963);
  DOS2DT(0,1,1980,42,1,16,1,29220.4175462963);
  DOS2DT(1,1,1980,17,61,16,0,0.0);
  DOS2DT(1,1,1980,18,0,76,1,29221.75013888889);
  DOS2DT(1,-300,1980,18,1,16,1,29312.75087962963);
  DOS2DT(-300,1,1980,18,1,16,1,29240.75087962963);
  DOS2DT(3,1,1980,-30,1,16,1,29223.08421296296);
  DOS2DT(1,1,1980,20,-119,16,1,29221.83976851852);
  DOS2DT(1,1,1980,18,3,-104,1,29221.75236111111);
  DOS2DT(1,12001,-1020,18,1,16,1,55519.75087962963);
  DOS2DT(1,-23,1982,18,1,16,1,30195.75087962963);
  DOS2DT(-59,3,1980,18,1,16,1,29285.75087962963);
  DOS2DT(1,1,0,0,0,0,1,54058.0);
  DOS2DT(0,0,1980,0,0,0,1,29189.0);
  DOS2DT(0,1,1980,0,0,0,1,29220.0);
  DOS2DT(-1,1,1980,18,1,16,1,29251.75087962963);
  DOS2DT(1,1,-1,18,1,16,1,53693.75087962963);
  DOS2DT(1,-1,1980,18,1,16,0,0);
}

Referenced by START_TEST().

◆ test_dt2dos()

static void test_dt2dos	(	int	line,
		double	dt,
		INT	r,
		WORD	d,
		WORD	m,
		WORD	y,
		WORD	h,
		WORD	mn,
		WORD	s
	)

static

Definition at line 2236 of file vartest.c.

{
    unsigned short dosDate, dosTime, expDosDate, expDosTime;
    INT res;
 
    dosTime = dosDate = 0;
    expDosDate = MKDOSDATE(d,m,y);
    expDosTime = MKDOSTIME(h,mn,s);
    res = pVariantTimeToDosDateTime(dt, &dosDate, &dosTime);
    ok_(__FILE__,line)(r == res && (!r || (dosTime == expDosTime && dosDate == expDosDate)),
                       "%g: expected %d,%d(%d/%d/%d),%d(%d:%d:%d) got %d,%d(%d/%d/%d),%d(%d:%d:%d)\n",
                       dt, r, expDosDate, expDosDate & 0x1f,
                       (expDosDate >> 5) & 0xf, 1980 + (expDosDate >> 9),
                       expDosTime, expDosTime >> 11, (expDosTime >> 5) & 0x3f,
                       (expDosTime & 0x1f),
                       res, dosDate, dosDate & 0x1f, (dosDate >> 5) & 0xf,
                       1980 + (dosDate >> 9), dosTime, dosTime >> 11,
                       (dosTime >> 5) & 0x3f, (dosTime & 0x1f));
}

◆ test_dt2st()

static void test_dt2st	(	int	line,
		double	dt,
		INT	r,
		WORD	d,
		WORD	m,
		WORD	y,
		WORD	h,
		WORD	mn,
		WORD	s,
		WORD	ms
	)

static

Definition at line 2125 of file vartest.c.

{
  SYSTEMTIME st;
  INT res;
 
  memset(&st, 0, sizeof(st));
  res = pVariantTimeToSystemTime(dt, &st);
  ok_(__FILE__,line)(r == res &&
                     (!r || (st.wYear == y && st.wMonth == m && st.wDay == d &&
                             st.wHour == h && st.wMinute == mn &&
                             st.wSecond == s && st.wMilliseconds == ms)),
                     "%.16g expected %d, %d,%d,%d,%d,%d,%d,%d, got %d, %d,%d,%d,%d,%d,%d,%d\n",
                     dt, r, d, m, y, h, mn, s, ms, res, st.wDay, st.wMonth,
                     st.wYear, st.wHour, st.wMinute, st.wSecond,
                     st.wMilliseconds);
}

◆ test_Mod()

static void test_Mod	(	int	line,
		VARIANT *	left,
		VARIANT *	right,
		VARIANT *	expected,
		HRESULT	expres
	)

static

Definition at line 2732 of file vartest.c.

{
    VARIANT result;
    HRESULT hres;
 
    memset( &result, 0, sizeof(result) );
    hres = pVarMod( left, right, &result );
    ok_(__FILE__,line)( hres == expres, "wrong result %x/%x\n", hres, expres );
    if (hres == S_OK)
        ok_(__FILE__,line)( is_expected_variant( &result, expected ),
                            "got %s expected %s\n", variantstr(&result), variantstr(expected) );
}

◆ test_Round()

static void test_Round	(	int	line,
		VARIANT *	arg,
		int	deci,
		VARIANT *	expected
	)

static

Definition at line 3593 of file vartest.c.

{
    VARIANT result;
    HRESULT hres;
 
    memset( &result, 0, sizeof(result) );
    hres = pVarRound( arg, deci, &result );
    ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
    if (hres == S_OK)
        ok_(__FILE__,line)( is_expected_variant( &result, expected ),
                            "got %s expected %s\n", variantstr(&result), variantstr(expected) );
}

◆ test_st2dt()

static void test_st2dt	(	int	line,
		WORD	d,
		WORD	m,
		WORD	y,
		WORD	h,
		WORD	mn,
		WORD	s,
		WORD	ms,
		INT	r,
		double	dt
	)

static

Definition at line 2087 of file vartest.c.

{
    SYSTEMTIME st;
    double out;
    INT res;
 
    st.wYear = y;
    st.wMonth = m;
    st.wDay = d;
    st.wHour = h;
    st.wMinute = mn;
    st.wSecond = s;
    st.wMilliseconds = ms;
    st.wDayOfWeek = 0;
    res = pSystemTimeToVariantTime(&st, &out);
    ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
                       "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
}

◆ test_SystemTimeToVariantTime()

static void test_SystemTimeToVariantTime ( void )

static

Definition at line 2108 of file vartest.c.

{
  CHECKPTR(SystemTimeToVariantTime);
  ST2DT(1,1,1980,0,0,0,0,TRUE,29221.0);
  ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0);
  ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0);   /* Rolls back to 31 Dec 1899 */
  ST2DT(1,13,1980,0,0,0,0,FALSE,29587.0); /* Fails on invalid month */
  ST2DT(32,1,1980,0,0,0,0,FALSE,0.0);     /* Fails on invalid day */
  ST2DT(1,1,-1,0,0,0,0,FALSE,0.0);        /* Fails on invalid year */
  ST2DT(1,1,10000,0,0,0,0,FALSE,0.0);     /* Fails on invalid year */
  ST2DT(1,1,9999,0,0,0,0,TRUE,2958101.0); /* 9999 is last valid year */
  ST2DT(31,12,90,0,0,0,0,TRUE,33238.0);   /* 30 <= year < 100 is 1900+year */
  ST2DT(1,1,30,0,0,0,0,TRUE,10959.0);     /* 30 <= year < 100 is 1900+year */
  ST2DT(1,1,29,0,0,0,0,TRUE,47119.0);     /* 0 <= year < 30 is 2000+year */
  ST2DT(1,1,0,0,0,0,0,TRUE,36526.0);      /* 0 <= year < 30 is 2000+year */
}

Referenced by START_TEST().

◆ test_UdateFromDate()

static void test_UdateFromDate	(	int	line,
		DATE	dt,
		ULONG	flags,
		HRESULT	r,
		WORD	d,
		WORD	m,
		WORD	y,
		WORD	h,
		WORD	mn,
		WORD	s,
		WORD	ms,
		WORD	dw,
		WORD	dy
	)

static

Definition at line 1958 of file vartest.c.

{
    UDATE ud;
    HRESULT res;
 
    memset(&ud, 0, sizeof(ud));
    res = pVarUdateFromDate(dt, flags, &ud);
    ok_(__FILE__,line)(r == res && (res != S_OK || (ud.st.wYear == y && ud.st.wMonth == m && ud.st.wDay == d &&
                       ud.st.wHour == h && ud.st.wMinute == mn && ud.st.wSecond == s &&
                       ud.st.wMilliseconds == ms && ud.st.wDayOfWeek == dw && ud.wDayOfYear == dy)),
                       "%.16g expected res(%x) %d,%d,%d,%d,%d,%d,%d  %d %d, got res(%x) %d,%d,%d,%d,%d,%d,%d  %d %d\n",
                       dt, r, d, m, y, h, mn, s, ms, dw, dy,
                       res, ud.st.wDay, ud.st.wMonth, ud.st.wYear, ud.st.wHour, ud.st.wMinute,
                       ud.st.wSecond, ud.st.wMilliseconds, ud.st.wDayOfWeek, ud.wDayOfYear );
}

◆ test_var_call1()

static void test_var_call1	(	int	line,
		HRESULT(WINAPI *func)(LPVARIANT, LPVARIANT)	,
		VARIANT *	arg,
		VARIANT *	expected
	)

static

Definition at line 626 of file vartest.c.

{
    VARIANT old_arg = *arg;
    VARIANT result;
    HRESULT hres;
 
    memset( &result, 0, sizeof(result) );
    hres = func( arg, &result );
    ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
    if (hres == S_OK)
        ok_(__FILE__,line)( is_expected_variant( &result, expected ),
                            "got %s expected %s\n", variantstr(&result), variantstr(expected) );
    ok_(__FILE__,line)( is_expected_variant( arg, &old_arg ), "Modified argument %s / %s\n",
                        variantstr(&old_arg), variantstr(arg));
    VariantClear( &result );
}

◆ test_var_call2()

static void test_var_call2	(	int	line,
		HRESULT(WINAPI *func)(LPVARIANT, LPVARIANT, LPVARIANT)	,
		VARIANT *	left,
		VARIANT *	right,
		VARIANT *	expected
	)

static

Definition at line 644 of file vartest.c.

{
    VARIANT old_left = *left, old_right = *right;
    VARIANT result;
    HRESULT hres;
 
    memset( &result, 0, sizeof(result) );
    hres = func( left, right, &result );
    ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
    if (hres == S_OK)
        ok_(__FILE__,line)( is_expected_variant( &result, expected ),
                            "got %s expected %s\n", variantstr(&result), variantstr(expected) );
    ok_(__FILE__,line)( is_expected_variant( left, &old_left ), "Modified left argument %s / %s\n",
                        variantstr(&old_left), variantstr(left));
    ok_(__FILE__,line)( is_expected_variant( right, &old_right ), "Modified right argument %s / %s\n",
                        variantstr(&old_right), variantstr(right));
    VariantClear( &result );
}

◆ test_VarAbs()

static void test_VarAbs ( void )

static

Definition at line 2282 of file vartest.c.

{
    static WCHAR szNum[] = {'-','1','.','1','\0' };
    char buff[8];
    HRESULT hres;
    VARIANT v, vDst, exp;
    size_t i;
 
    CHECKPTR(VarAbs);
 
    /* Test all possible V_VT values.
     */
    for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
    {
        VARTYPE vt;
 
        for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
        {
            HRESULT hExpected = DISP_E_BADVARTYPE;
 
            SKIPTESTS(vt);
 
            memset(&v, 0, sizeof(v));
            V_VT(&v) = vt | ExtraFlags[i];
            V_VT(&vDst) = VT_EMPTY;
 
            hres = pVarAbs(&v,&vDst);
            if (ExtraFlags[i] & VT_ARRAY ||
                (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
                 vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
            {
                hExpected = DISP_E_TYPEMISMATCH;
            }
            else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
            {
                hExpected = DISP_E_BADVARTYPE;
            }
            else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
                hExpected = S_OK;
 
            /* Native always fails on some vartypes that should be valid. don't
             * check that Wine does the same; these are bugs in native.
             */
            if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
                vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
                continue;
            ok(hres == hExpected, "VarAbs: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
               hExpected, hres, vt, ExtraFlags[i]);
        }
    }
 
    /* BOOL->I2, BSTR->R8, all others remain the same */
    VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
    VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
    VARABS(EMPTY,0,I2,0);
    VARABS(EMPTY,1,I2,0);
    VARABS(NULL,0,NULL,0);
    VARABS(NULL,1,NULL,0);
    VARABS(I2,1,I2,1);
    VARABS(I2,-1,I2,1);
    VARABS(I4,1,I4,1);
    VARABS(I4,-1,I4,1);
    VARABS(UI1,1,UI1,1);
    VARABS(R4,1,R4,1);
    VARABS(R4,-1,R4,1);
    VARABS(R8,1,R8,1);
    VARABS(R8,-1,R8,1);
    VARABS(DATE,1,DATE,1);
    VARABS(DATE,-1,DATE,1);
    V_VT(&v) = VT_CY;
    V_CY(&v).int64 = -10000;
    memset(&vDst,0,sizeof(vDst));
    hres = pVarAbs(&v,&vDst);
    ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
       "VarAbs(CY): expected 0x0 got 0x%X\n", hres);
    GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, ARRAY_SIZE(buff));
    if (buff[1])
    {
        trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
        return;
    } else {
    szNum[2] = buff[0];
    }
    V_VT(&v) = VT_BSTR;
    V_BSTR(&v) = (BSTR)szNum;
    memset(&vDst,0,sizeof(vDst));
    hres = pVarAbs(&v,&vDst);
    ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
       "VarAbs: expected 0x0,%d,%g, got 0x%X,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
}

Referenced by START_TEST().

◆ test_VarAdd()

static void test_VarAdd ( void )

static

Definition at line 5554 of file vartest.c.

{
    VARIANT left, right, exp, result, cy, dec;
    VARTYPE i;
    BSTR lbstr, rbstr;
    HRESULT hres;
    double r;
 
    CHECKPTR(VarAdd);
 
    lbstr = SysAllocString(sz12);
    rbstr = SysAllocString(sz12);
 
    /* Test all possible flag/vt combinations & the resulting vt type */
    for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
    {
        VARTYPE leftvt, rightvt, resvt;
 
        for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
        {
 
            SKIPTESTS(leftvt);
 
            for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
            {
                BOOL bFail = FALSE;
 
                SKIPTESTS(rightvt);
 
                if (leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
                    continue;
 
                memset(&left, 0, sizeof(left));
                memset(&right, 0, sizeof(right));
                V_VT(&left) = leftvt | ExtraFlags[i];
                if (leftvt == VT_BSTR)
                    V_BSTR(&left) = lbstr;
                V_VT(&right) = rightvt | ExtraFlags[i];
                if (rightvt == VT_BSTR)
                    V_BSTR(&right) = rbstr;
                V_VT(&result) = VT_EMPTY;
                resvt = VT_ERROR;
 
                /* Don't ask me why but native VarAdd cannot handle:
                   VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
                   Tested with DCOM98, Win2k, WinXP */
                if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
                    !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
                    !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
                    leftvt == VT_CLSID || rightvt == VT_CLSID ||
                    leftvt == VT_RECORD || rightvt == VT_RECORD ||
                    leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
                    leftvt == VT_ERROR || rightvt == VT_ERROR ||
                    leftvt == VT_I1 || rightvt == VT_I1 ||
                    leftvt == VT_UI2 || rightvt == VT_UI2 ||
                    leftvt == VT_UI4 || rightvt == VT_UI4 ||
                    leftvt == VT_UI8 || rightvt == VT_UI8 ||
                    leftvt == VT_INT || rightvt == VT_INT ||
                    leftvt == VT_UINT || rightvt == VT_UINT) {
                    bFail = TRUE;
                }
 
                if (leftvt == VT_NULL || rightvt == VT_NULL)
                    resvt = VT_NULL;
                else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH)
                    bFail = TRUE;
                else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
                    resvt = VT_DECIMAL;
                else if (leftvt == VT_DATE || rightvt == VT_DATE)
                    resvt = VT_DATE;
                else if (leftvt == VT_CY || rightvt == VT_CY)
                    resvt = VT_CY;
                else if (leftvt == VT_R8 || rightvt == VT_R8)
                    resvt = VT_R8;
                else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
                    if ((leftvt == VT_BSTR && rightvt == VT_BSTR) ||
                         leftvt == VT_EMPTY || rightvt == VT_EMPTY)
                        resvt = VT_BSTR;
                    else
                        resvt = VT_R8;
                } else if (leftvt == VT_R4 || rightvt == VT_R4) {
                    if (leftvt == VT_I4 || rightvt == VT_I4 ||
                        leftvt == VT_I8 || rightvt == VT_I8)
                        resvt = VT_R8;
                    else
                        resvt = VT_R4;
                }
                else if (leftvt == VT_I8 || rightvt == VT_I8)
                    resvt = VT_I8;
                else if (leftvt == VT_I4 || rightvt == VT_I4)
                    resvt = VT_I4;
                else if (leftvt == VT_I2 || rightvt == VT_I2 ||
                         leftvt == VT_BOOL || rightvt == VT_BOOL ||
                         (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
                    resvt = VT_I2;
                else if (leftvt == VT_UI1 || rightvt == VT_UI1)
                    resvt = VT_UI1;
 
                hres = pVarAdd(&left, &right, &result);
                if (bFail) {
                    ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
                       "VarAdd: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
                       leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
                       V_VT(&result));
                } else {
                    ok(hres == S_OK && V_VT(&result) == resvt,
                       "VarAdd: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
                       leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
                       V_VT(&result));
                }
                /* Note, we don't clear left/right deliberately here */
                VariantClear(&result);
            }
        }
    }
 
    /* Test returned values */
    VARADD(I4,4,I4,2,I4,6);
    VARADD(I2,4,I2,2,I2,6);
    VARADD(I2,-13,I4,5,I4,-8);
    VARADD(I4,-13,I4,5,I4,-8);
    VARADD(I2,7,R4,0.5f,R4,7.5f);
    VARADD(R4,0.5f,I4,5,R8,5.5);
    VARADD(R8,7.1,BOOL,0,R8,7.1);
    VARADD(BSTR,lbstr,I2,4,R8,16);
    VARADD(BSTR,lbstr,BOOL,1,R8,13);
    VARADD(BSTR,lbstr,R4,0.1f,R8,12.1);
    VARADD(R4,0.2f,BSTR,rbstr,R8,12.2);
    VARADD(DATE,2.25,I4,7,DATE,9.25);
    VARADD(DATE,1.25,R4,-1.7f,DATE,-0.45);
 
    VARADD(UI1, UI1_MAX, UI1, UI1_MAX, I2, UI1_MAX + UI1_MAX);
    VARADD(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX + I2_MAX);
    VARADD(I2, I2_MAX, I2, I2_MIN, I2, I2_MAX + I2_MIN);
    VARADD(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN + I2_MIN);
    VARADD(I4, I4_MAX, I4, I4_MIN, I4, I4_MAX + I4_MIN);
    VARADD(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX + I4_MAX);
    VARADD(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN + I4_MIN);
    VARADD(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX + R4_MAX);
    VARADD(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX + R4_MIN);
    VARADD(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN + R4_MIN);
    VARADD(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX + R8_MIN);
    VARADD(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN + R8_MIN);
 
    /* Manually test BSTR + BSTR */
    V_VT(&left) = VT_BSTR;
    V_BSTR(&left) = lbstr;
    V_VT(&right) = VT_BSTR;
    V_BSTR(&right) = rbstr;
    hres = pVarAdd(&left, &right, &result);
    ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n", vtstr(V_VT(&result)));
    hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
    ok(hres == S_OK && EQ_DOUBLE(r, 1212.0), "VarAdd: BSTR value %f, expected %f\n", r, 1212.0);
    VariantClear(&result);
 
    /* Manuly test some VT_CY and VT_DECIMAL variants */
    V_VT(&cy) = VT_CY;
    hres = VarCyFromI4(4711, &V_CY(&cy));
    ok(hres == S_OK, "VarCyFromI4 failed!\n");
    V_VT(&dec) = VT_DECIMAL;
    hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
    ok(hres == S_OK, "VarDecFromR4 failed!\n");
    memset(&left, 0, sizeof(left));
    memset(&right, 0, sizeof(right));
    V_VT(&left) = VT_I4;
    V_I4(&left) = -11;
    V_VT(&right) = VT_UI1;
    V_UI1(&right) = 9;
 
    hres = pVarAdd(&cy, &right, &result);
    ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
    hres = VarR8FromCy(V_CY(&result), &r);
    ok(hres == S_OK && EQ_DOUBLE(r, 4720.0), "VarAdd: CY value %f, expected %f\n", r, 4720.0);
 
    hres = pVarAdd(&left, &dec, &result);
    ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
    hres = VarR8FromDec(&V_DECIMAL(&result), &r);
    ok(hres == S_OK && EQ_DOUBLE(r, -15.2), "VarAdd: DECIMAL value %f, expected %f\n", r, -15.2);
    VariantClear(&result);
 
    SysFreeString(lbstr);
    SysFreeString(rbstr);
}

Referenced by START_TEST().

◆ test_VarAnd()

static void test_VarAnd ( void )

static

Definition at line 6217 of file vartest.c.

{
    static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
    static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
    VARIANT left, right, exp, result;
    BSTR false_str, true_str;
    VARTYPE i;
    HRESULT hres;
 
    CHECKPTR(VarAnd);
 
    true_str = SysAllocString(szTrue);
    false_str = SysAllocString(szFalse);
 
    /* Test all possible flag/vt combinations & the resulting vt type */
    for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
    {
        VARTYPE leftvt, rightvt, resvt;
 
        for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
        {
            SKIPTESTAND(leftvt);
 
            /* Check if we need/have support for I8 and/or UI8 */
            if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
                continue;
 
            for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
            {
                BOOL bFail = FALSE;
                SKIPTESTAND(rightvt);
 
                /* Check if we need/have support for I8 and/or UI8 */
                if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
                    continue;
 
                memset(&left, 0, sizeof(left));
                memset(&right, 0, sizeof(right));
                V_VT(&left) = leftvt | ExtraFlags[i];
                V_VT(&right) = rightvt | ExtraFlags[i];
                V_VT(&result) = VT_EMPTY;
                resvt = VT_EMPTY;
                if ((leftvt | ExtraFlags[i]) == VT_BSTR)
                    V_BSTR(&left) = true_str;
                if ((rightvt | ExtraFlags[i]) == VT_BSTR)
                    V_BSTR(&right) = true_str;
 
                /* Native VarAnd always returns an error when using extra
                 * flags or if the variant combination is I8 and INT.
                 */
                if ((leftvt == VT_I8 && rightvt == VT_INT) ||
                    (leftvt == VT_INT && rightvt == VT_I8) ||
                    ExtraFlags[i] != 0)
                    bFail = TRUE;
 
                /* Determine return type */
                else if (leftvt == VT_I8 || rightvt == VT_I8)
                    resvt = VT_I8;
                else if (leftvt == VT_I4 || rightvt == VT_I4 ||
                    leftvt == VT_UINT || rightvt == VT_UINT ||
                    leftvt == VT_INT || rightvt == VT_INT ||
                    leftvt == VT_R4 || rightvt == VT_R4 ||
                    leftvt == VT_R8 || rightvt == VT_R8 ||
                    leftvt == VT_CY || rightvt == VT_CY ||
                    leftvt == VT_DATE || rightvt == VT_DATE ||
                    leftvt == VT_I1 || rightvt == VT_I1 ||
                    leftvt == VT_UI2 || rightvt == VT_UI2 ||
                    leftvt == VT_UI4 || rightvt == VT_UI4 ||
                    leftvt == VT_UI8 || rightvt == VT_UI8 ||
                    leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
                    resvt = VT_I4;
                else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
                    leftvt == VT_I2 || rightvt == VT_I2 ||
                    leftvt == VT_EMPTY || rightvt == VT_EMPTY)
                    if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
                        (leftvt == VT_UI1 && rightvt == VT_NULL) ||
                        (leftvt == VT_UI1 && rightvt == VT_UI1))
                        resvt = VT_UI1;
                    else
                        resvt = VT_I2;
                else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
                    (leftvt == VT_BSTR && rightvt == VT_BSTR))
                    resvt = VT_BOOL;
                else if (leftvt == VT_NULL || rightvt == VT_NULL ||
                    leftvt == VT_BSTR || rightvt == VT_BSTR)
                    resvt = VT_NULL;
                else
                    bFail = TRUE;
 
                hres = pVarAnd(&left, &right, &result);
 
                /* Check expected HRESULT and if result variant type is correct */
                if (bFail)
                    ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
                        "VarAnd: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
                        vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
                        vtstr(V_VT(&result)), hres);
                else
                    ok (hres == S_OK && resvt == V_VT(&result),
                        "VarAnd: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
                        vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
                        S_OK, vtstr(V_VT(&result)), hres);
            }
        }
    }
 
    /*
     * Test returned values. Since we know the returned type is correct
     * and that we handle all combinations of invalid types, just check
     * that good type combinations produce the desired value.
     * FIXME: Test VT_DECIMAL
     */
    VARAND(EMPTY,0,EMPTY,0,I2,0);
    VARAND(EMPTY,1,EMPTY,0,I2,0);
    VARAND(EMPTY,1,EMPTY,1,I2,0);
    VARAND(EMPTY,0,NULL,0,I2,0);
    VARAND(EMPTY,1,NULL,0,I2,0);
    VARAND(EMPTY,1,NULL,1,I2,0);
    VARAND(EMPTY,0,I1,0,I4,0);
    VARAND(EMPTY,0,I1,1,I4,0);
    VARAND(EMPTY,1,I1,1,I4,0);
    VARAND(EMPTY,0,UI1,0,I2,0);
    VARAND(EMPTY,0,UI1,1,I2,0);
    VARAND(EMPTY,1,UI1,1,I2,0);
    VARAND(EMPTY,0,I2,0,I2,0);
    VARAND(EMPTY,0,I2,1,I2,0);
    VARAND(EMPTY,1,I2,1,I2,0);
    VARAND(EMPTY,0,UI2,0,I4,0);
    VARAND(EMPTY,0,UI2,1,I4,0);
    VARAND(EMPTY,1,UI2,1,I4,0);
    VARAND(EMPTY,0,I4,0,I4,0);
    VARAND(EMPTY,0,I4,1,I4,0);
    VARAND(EMPTY,1,I4,1,I4,0);
    VARAND(EMPTY,0,UI4,0,I4,0);
    VARAND(EMPTY,0,UI4,1,I4,0);
    VARAND(EMPTY,1,UI4,1,I4,0);
    if (has_i8)
    {
        VARAND(EMPTY,0,I8,0,I8,0);
        VARAND(EMPTY,0,I8,1,I8,0);
        VARAND(EMPTY,1,I8,1,I8,0);
        VARAND(EMPTY,0,UI8,0,I4,0);
        VARAND(EMPTY,0,UI8,1,I4,0);
        VARAND(EMPTY,1,UI8,1,I4,0);
    }
    VARAND(EMPTY,0,INT,0,I4,0);
    VARAND(EMPTY,0,INT,1,I4,0);
    VARAND(EMPTY,1,INT,1,I4,0);
    VARAND(EMPTY,0,UINT,0,I4,0);
    VARAND(EMPTY,0,UINT,1,I4,0);
    VARAND(EMPTY,1,UINT,1,I4,0);
    VARAND(EMPTY,0,BOOL,0,I2,0);
    VARAND(EMPTY,0,BOOL,1,I2,0);
    VARAND(EMPTY,1,BOOL,1,I2,0);
    VARAND(EMPTY,0,R4,0,I4,0);
    VARAND(EMPTY,0,R4,1,I4,0);
    VARAND(EMPTY,1,R4,1,I4,0);
    VARAND(EMPTY,0,R8,0,I4,0);
    VARAND(EMPTY,0,R8,1,I4,0);
    VARAND(EMPTY,1,R8,1,I4,0);
    VARAND(EMPTY,0,BSTR,false_str,I2,0);
    VARAND(EMPTY,0,BSTR,true_str,I2,0);
    VARANDCY(EMPTY,0,10000,I4,0);
 
    /* NULL OR 0 = NULL. NULL OR n = n */
    VARAND(NULL,0,NULL,0,NULL,0);
    VARAND(NULL,1,NULL,0,NULL,0);
    VARAND(NULL,0,I1,0,I4,0);
    VARAND(NULL,0,I1,1,NULL,0);
    VARAND(NULL,0,UI1,0,UI1,0);
    VARAND(NULL,0,UI1,1,NULL,0);
    VARAND(NULL,0,I2,0,I2,0);
    VARAND(NULL,0,I2,1,NULL,0);
    VARAND(NULL,0,UI2,0,I4,0);
    VARAND(NULL,0,UI2,1,NULL,0);
    VARAND(NULL,0,I4,0,I4,0);
    VARAND(NULL,0,I4,1,NULL,0);
    VARAND(NULL,0,UI4,0,I4,0);
    VARAND(NULL,0,UI4,1,NULL,0);
    if (has_i8)
    {
        VARAND(NULL,0,I8,0,I8,0);
        VARAND(NULL,0,I8,1,NULL,0);
        VARAND(NULL,0,UI8,0,I4,0);
        VARAND(NULL,0,UI8,1,NULL,0);
    }
    VARAND(NULL,0,INT,0,I4,0);
    VARAND(NULL,0,INT,1,NULL,0);
    VARAND(NULL,0,UINT,0,I4,0);
    VARAND(NULL,0,UINT,1,NULL,0);
    VARAND(NULL,0,BOOL,0,BOOL,0);
    VARAND(NULL,0,BOOL,1,NULL,0);
    VARAND(NULL,0,R4,0,I4,0);
    VARAND(NULL,0,R4,1,NULL,0);
    VARAND(NULL,0,R8,0,I4,0);
    VARAND(NULL,0,R8,1,NULL,0);
    VARAND(NULL,0,BSTR,false_str,BOOL,0);
    VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE);
    VARANDCY(NULL,0,10000,NULL,0);
    VARANDCY(NULL,0,0,I4,0);
    VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
    VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
    VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
    VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
 
    /* Assume x,y & y,x are the same from now on to reduce the number of tests */
    VARAND(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
    VARAND(BOOL,VARIANT_TRUE,I1,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,I1,0,I4,0);
    VARAND(BOOL,VARIANT_TRUE,UI1,255,I2,255);
    VARAND(BOOL,VARIANT_TRUE,UI1,0,I2,0);
    VARAND(BOOL,VARIANT_FALSE,UI1,0,I2,0);
    VARAND(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
    VARAND(BOOL,VARIANT_TRUE,I2,0,I2,0);
    VARAND(BOOL,VARIANT_FALSE,I2,0,I2,0);
    VARAND(BOOL,VARIANT_TRUE,UI2,65535,I4,65535);
    VARAND(BOOL,VARIANT_TRUE,UI2,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,UI2,0,I4,0);
    VARAND(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
    VARAND(BOOL,VARIANT_TRUE,I4,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,I4,0,I4,0);
    VARAND(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
    VARAND(BOOL,VARIANT_TRUE,UI4,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,UI4,0,I4,0);
    VARAND(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
    VARAND(BOOL,VARIANT_TRUE,R4,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,R4,0,I4,0);
    VARAND(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
    VARAND(BOOL,VARIANT_TRUE,R8,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,R8,0,I4,0);
    VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
    VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
    if (has_i8)
    {
        VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
        VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
        VARAND(BOOL,VARIANT_FALSE,I8,0,I8,0);
        VARAND(BOOL,VARIANT_TRUE,UI8,0,I4,0);
        VARAND(BOOL,VARIANT_FALSE,UI8,0,I4,0);
    }
    VARAND(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
    VARAND(BOOL,VARIANT_TRUE,INT,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,INT,0,I4,0);
    VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
    VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0);
    VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE);
    VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE);
    VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE);
    VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE);
    VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1);
    VARANDCY(BOOL,VARIANT_TRUE,0,I4,0);
    VARANDCY(BOOL,VARIANT_FALSE,0,I4,0);
    VARAND(I1,-1,I1,-1,I4,-1);
    VARAND(I1,-1,I1,0,I4,0);
    VARAND(I1,0,I1,0,I4,0);
    VARAND(I1,-1,UI1,255,I4,255);
    VARAND(I1,-1,UI1,0,I4,0);
    VARAND(I1,0,UI1,0,I4,0);
    VARAND(I1,-1,I2,-1,I4,-1);
    VARAND(I1,-1,I2,0,I4,0);
    VARAND(I1,0,I2,0,I4,0);
    VARAND(I1,-1,UI2,65535,I4,65535);
    VARAND(I1,-1,UI2,0,I4,0);
    VARAND(I1,0,UI2,0,I4,0);
    VARAND(I1,-1,I4,-1,I4,-1);
    VARAND(I1,-1,I4,0,I4,0);
    VARAND(I1,0,I4,0,I4,0);
    VARAND(I1,-1,UI4,0xffffffff,I4,-1);
    VARAND(I1,-1,UI4,0,I4,0);
    VARAND(I1,0,UI4,0,I4,0);
    VARAND(I1,-1,R4,-1,I4,-1);
    VARAND(I1,-1,R4,0,I4,0);
    VARAND(I1,0,R4,0,I4,0);
    VARAND(I1,-1,R8,-1,I4,-1);
    VARAND(I1,-1,R8,0,I4,0);
    VARAND(I1,0,R8,0,I4,0);
    VARAND(I1,-1,DATE,-1,I4,-1);
    VARAND(I1,-1,DATE,0,I4,0);
    VARAND(I1,0,DATE,0,I4,0);
    if (has_i8)
    {
        VARAND(I1,-1,I8,-1,I8,-1);
        VARAND(I1,-1,I8,0,I8,0);
        VARAND(I1,0,I8,0,I8,0);
        VARAND(I1,-1,UI8,0,I4,0);
        VARAND(I1,0,UI8,0,I4,0);
    }
    VARAND(I1,-1,INT,-1,I4,-1);
    VARAND(I1,-1,INT,0,I4,0);
    VARAND(I1,0,INT,0,I4,0);
    VARAND(I1,-1,UINT,0xffffffff,I4,-1);
    VARAND(I1,-1,UINT,0,I4,0);
    VARAND(I1,0,UINT,0,I4,0);
    VARAND(I1,0,BSTR,false_str,I4,0);
    VARAND(I1,-1,BSTR,false_str,I4,0);
    VARAND(I1,0,BSTR,true_str,I4,0);
    VARAND(I1,-1,BSTR,true_str,I4,-1);
    VARANDCY(I1,-1,10000,I4,1);
    VARANDCY(I1,-1,0,I4,0);
    VARANDCY(I1,0,0,I4,0);
 
    VARAND(UI1,255,UI1,255,UI1,255);
    VARAND(UI1,255,UI1,0,UI1,0);
    VARAND(UI1,0,UI1,0,UI1,0);
    VARAND(UI1,255,I2,-1,I2,255);
    VARAND(UI1,255,I2,0,I2,0);
    VARAND(UI1,0,I2,0,I2,0);
    VARAND(UI1,255,UI2,65535,I4,255);
    VARAND(UI1,255,UI2,0,I4,0);
    VARAND(UI1,0,UI2,0,I4,0);
    VARAND(UI1,255,I4,-1,I4,255);
    VARAND(UI1,255,I4,0,I4,0);
    VARAND(UI1,0,I4,0,I4,0);
    VARAND(UI1,255,UI4,0xffffffff,I4,255);
    VARAND(UI1,255,UI4,0,I4,0);
    VARAND(UI1,0,UI4,0,I4,0);
    VARAND(UI1,255,R4,-1,I4,255);
    VARAND(UI1,255,R4,0,I4,0);
    VARAND(UI1,0,R4,0,I4,0);
    VARAND(UI1,255,R8,-1,I4,255);
    VARAND(UI1,255,R8,0,I4,0);
    VARAND(UI1,0,R8,0,I4,0);
    VARAND(UI1,255,DATE,-1,I4,255);
    VARAND(UI1,255,DATE,0,I4,0);
    VARAND(UI1,0,DATE,0,I4,0);
    if (has_i8)
    {
        VARAND(UI1,255,I8,-1,I8,255);
        VARAND(UI1,255,I8,0,I8,0);
        VARAND(UI1,0,I8,0,I8,0);
        VARAND(UI1,255,UI8,0,I4,0);
        VARAND(UI1,0,UI8,0,I4,0);
    }
    VARAND(UI1,255,INT,-1,I4,255);
    VARAND(UI1,255,INT,0,I4,0);
    VARAND(UI1,0,INT,0,I4,0);
    VARAND(UI1,255,UINT,0xffffffff,I4,255);
    VARAND(UI1,255,UINT,0,I4,0);
    VARAND(UI1,0,UINT,0,I4,0);
    VARAND(UI1,0,BSTR,false_str,I2,0);
    VARAND(UI1,255,BSTR,false_str,I2,0);
    VARAND(UI1,0,BSTR,true_str,I2,0);
    VARAND(UI1,255,BSTR,true_str,I2,255);
    VARANDCY(UI1,255,10000,I4,1);
    VARANDCY(UI1,255,0,I4,0);
    VARANDCY(UI1,0,0,I4,0);
 
    VARAND(I2,-1,I2,-1,I2,-1);
    VARAND(I2,-1,I2,0,I2,0);
    VARAND(I2,0,I2,0,I2,0);
    VARAND(I2,-1,UI2,65535,I4,65535);
    VARAND(I2,-1,UI2,0,I4,0);
    VARAND(I2,0,UI2,0,I4,0);
    VARAND(I2,-1,I4,-1,I4,-1);
    VARAND(I2,-1,I4,0,I4,0);
    VARAND(I2,0,I4,0,I4,0);
    VARAND(I2,-1,UI4,0xffffffff,I4,-1);
    VARAND(I2,-1,UI4,0,I4,0);
    VARAND(I2,0,UI4,0,I4,0);
    VARAND(I2,-1,R4,-1,I4,-1);
    VARAND(I2,-1,R4,0,I4,0);
    VARAND(I2,0,R4,0,I4,0);
    VARAND(I2,-1,R8,-1,I4,-1);
    VARAND(I2,-1,R8,0,I4,0);
    VARAND(I2,0,R8,0,I4,0);
    VARAND(I2,-1,DATE,-1,I4,-1);
    VARAND(I2,-1,DATE,0,I4,0);
    VARAND(I2,0,DATE,0,I4,0);
    if (has_i8)
    {
        VARAND(I2,-1,I8,-1,I8,-1);
        VARAND(I2,-1,I8,0,I8,0);
        VARAND(I2,0,I8,0,I8,0);
        VARAND(I2,-1,UI8,0,I4,0);
        VARAND(I2,0,UI8,0,I4,0);
    }
    VARAND(I2,-1,INT,-1,I4,-1);
    VARAND(I2,-1,INT,0,I4,0);
    VARAND(I2,0,INT,0,I4,0);
    VARAND(I2,-1,UINT,0xffffffff,I4,-1);
    VARAND(I2,-1,UINT,0,I4,0);
    VARAND(I2,0,UINT,0,I4,0);
    VARAND(I2,0,BSTR,false_str,I2,0);
    VARAND(I2,-1,BSTR,false_str,I2,0);
    VARAND(I2,0,BSTR,true_str,I2,0);
    VARAND(I2,-1,BSTR,true_str,I2,-1);
    VARANDCY(I2,-1,10000,I4,1);
    VARANDCY(I2,-1,0,I4,0);
    VARANDCY(I2,0,0,I4,0);
 
    VARAND(UI2,65535,UI2,65535,I4,65535);
    VARAND(UI2,65535,UI2,0,I4,0);
    VARAND(UI2,0,UI2,0,I4,0);
    VARAND(UI2,65535,I4,-1,I4,65535);
    VARAND(UI2,65535,I4,0,I4,0);
    VARAND(UI2,0,I4,0,I4,0);
    VARAND(UI2,65535,UI4,0xffffffff,I4,65535);
    VARAND(UI2,65535,UI4,0,I4,0);
    VARAND(UI2,0,UI4,0,I4,0);
    VARAND(UI2,65535,R4,-1,I4,65535);
    VARAND(UI2,65535,R4,0,I4,0);
    VARAND(UI2,0,R4,0,I4,0);
    VARAND(UI2,65535,R8,-1,I4,65535);
    VARAND(UI2,65535,R8,0,I4,0);
    VARAND(UI2,0,R8,0,I4,0);
    VARAND(UI2,65535,DATE,-1,I4,65535);
    VARAND(UI2,65535,DATE,0,I4,0);
    VARAND(UI2,0,DATE,0,I4,0);
    if (has_i8)
    {
        VARAND(UI2,65535,I8,-1,I8,65535);
        VARAND(UI2,65535,I8,0,I8,0);
        VARAND(UI2,0,I8,0,I8,0);
        VARAND(UI2,65535,UI8,0,I4,0);
        VARAND(UI2,0,UI8,0,I4,0);
    }
    VARAND(UI2,65535,INT,-1,I4,65535);
    VARAND(UI2,65535,INT,0,I4,0);
    VARAND(UI2,0,INT,0,I4,0);
    VARAND(UI2,65535,UINT,0xffffffff,I4,65535);
    VARAND(UI2,65535,UINT,0,I4,0);
    VARAND(UI2,0,UINT,0,I4,0);
    VARAND(UI2,0,BSTR,false_str,I4,0);
    VARAND(UI2,65535,BSTR,false_str,I4,0);
    VARAND(UI2,0,BSTR,true_str,I4,0);
    VARAND(UI2,65535,BSTR,true_str,I4,65535);
    VARANDCY(UI2,65535,10000,I4,1);
    VARANDCY(UI2,65535,0,I4,0);
    VARANDCY(UI2,0,0,I4,0);
 
    VARAND(I4,-1,I4,-1,I4,-1);
    VARAND(I4,-1,I4,0,I4,0);
    VARAND(I4,0,I4,0,I4,0);
    VARAND(I4,-1,UI4,0xffffffff,I4,-1);
    VARAND(I4,-1,UI4,0,I4,0);
    VARAND(I4,0,UI4,0,I4,0);
    VARAND(I4,-1,R4,-1,I4,-1);
    VARAND(I4,-1,R4,0,I4,0);
    VARAND(I4,0,R4,0,I4,0);
    VARAND(I4,-1,R8,-1,I4,-1);
    VARAND(I4,-1,R8,0,I4,0);
    VARAND(I4,0,R8,0,I4,0);
    VARAND(I4,-1,DATE,-1,I4,-1);
    VARAND(I4,-1,DATE,0,I4,0);
    VARAND(I4,0,DATE,0,I4,0);
    if (has_i8)
    {
        VARAND(I4,-1,I8,-1,I8,-1);
        VARAND(I4,-1,I8,0,I8,0);
        VARAND(I4,0,I8,0,I8,0);
        VARAND(I4,-1,UI8,0,I4,0);
        VARAND(I4,0,UI8,0,I4,0);
    }
    VARAND(I4,-1,INT,-1,I4,-1);
    VARAND(I4,-1,INT,0,I4,0);
    VARAND(I4,0,INT,0,I4,0);
    VARAND(I4,-1,UINT,0xffffffff,I4,-1);
    VARAND(I4,-1,UINT,0,I4,0);
    VARAND(I4,0,UINT,0,I4,0);
    VARAND(

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ _VARCMP

◆ CASE [1/2]

◆ CASE [2/2]

◆ CHECK_CALLED

◆ CHECK_EXPECT

◆ CHECK_EXPECT2

◆ CHECKPTR

◆ COBJMACROS

◆ CONST_VTABLE

◆ CONVERT [1/2]

◆ CONVERT [2/2]

◆ CONVERTN

◆ CY_MULTIPLIER

◆ DATE_MAX

◆ DATE_MIN

◆ DEFINE_EXPECT

◆ DOS2DT

◆ DT2DOS

◆ DT2ST

◆ DT2UD

◆ EQ_DOUBLE

◆ EQ_FLOAT

◆ EXPECT

◆ EXPECT2

◆ EXPECT_CY

◆ EXPECT_DECIMAL

◆ EXPECT_I1

◆ EXPECT_I2

◆ EXPECT_I4

◆ EXPECT_I8

◆ EXPECT_OK

◆ EXPECT_OVERFLOW

◆ EXPECT_R4

◆ EXPECT_R8

◆ EXPECT_TYPE

◆ EXPECT_UI1

◆ EXPECT_UI2

◆ EXPECT_UI4

◆ EXPECT_UI8

◆ EXPECTFAIL

◆ EXPECTRGB

◆ FAILDIG

◆ I1_MAX

◆ I1_MIN

◆ I2_MAX

◆ I2_MIN

◆ I4_MAX

◆ I4_MIN

◆ I8_MAX

◆ I8_MIN

◆ INTEGER_VTBITS

◆ MKDOSDATE

◆ MKDOSTIME

◆ R4_MAX

◆ R4_MIN

◆ R8_MAX

◆ R8_MIN

◆ SET_EXPECT

◆ SETRGB

◆ SKIPTESTAND

◆ SKIPTESTDIV

◆ SKIPTESTIDIV

◆ SKIPTESTIMP

◆ SKIPTESTPOW

◆ SKIPTESTS

◆ ST2DT

◆ test_bstr_var

◆ UD2T

◆ UI1_MAX

◆ UI1_MIN

◆ UI2_MAX

◆ UI2_MIN

◆ UI4_MAX

◆ UI4_MIN