vartest.c File Reference

#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:

Go to the source code of this file.

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 6901 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; }

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	(		str,
			flags
	)		CONVERTN(str,sizeof(rgb),flags)

Definition at line 1744 of file vartest.c.

CONVERT [2/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)

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)); }

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)); }

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)); }

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)

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)); }

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)); }

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)); }

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)); }

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)); }

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

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

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 6213 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 7686 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 8063 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 8629 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 7164 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 6912 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 5550 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 6200 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 6206 of file vartest.c.

VARCMP

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

Definition at line 6909 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 6905 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 7679 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 5240 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 3240 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 8056 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 8622 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 3355 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 2747 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 2753 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 5379 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 3471 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 4499 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 4505 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 7157 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 3607 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 3765 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 3771 of file vartest.c.

VT_NULL_

#define VT_NULL_   VT_NULL

Definition at line 6913 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 9182 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 6875 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 6885 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 2734 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 3595 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 5556 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 ==