static HMODULE hOleaut32;
-/* Get a conversion function ptr, return if function not available */
-#define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
- if (!p##func) { \
- win_skip("function " # func " not available, not testing it\n"); return; }
-
/* Has I8/UI8 data type? */
static BOOL has_i8;
/* Has proper locale conversions? */
#define EXPECT_DBL(x) \
ok(hres == S_OK && fabs(out-(x))<=1e-14*(x), "expected %16.16g, got %16.16g; hres=0x%08x\n", (x), out, hres)
-#define CONVERT(func, val) in = val; hres = p##func(in, &out)
+#define CONVERT(func, val) in = val; hres = func(in, &out)
#define CONVERTRANGE(func,start,end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT(i); };
#define OVERFLOWRANGE(func,start,end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT_OVERFLOW; };
#define DATE_MIN -657434
#define DATE_MAX 2958465
-#define CONVERT_I8(func,hi,lo) in = hi; in = (in << 32) | lo; hres = p##func(in, &out)
+#define CONVERT_I8(func,hi,lo) in = hi; in = (in << 32) | lo; hres = func(in, &out)
-#define CONVERT_CY(func,val) in.int64 = (LONGLONG)(val * CY_MULTIPLIER); hres = p##func(in, &out)
+#define CONVERT_CY(func,val) in.int64 = (LONGLONG)(val * CY_MULTIPLIER); hres = func(in, &out)
-#define CONVERT_CY64(func,hi,lo) S(in).Hi = hi; S(in).Lo = lo; in.int64 *= CY_MULTIPLIER; hres = p##func(in, &out)
+#define CONVERT_CY64(func,hi,lo) S(in).Hi = hi; S(in).Lo = lo; in.int64 *= CY_MULTIPLIER; hres = func(in, &out)
#define SETDEC(dec, scl, sgn, hi, lo) S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \
dec.Hi32 = (ULONG)hi; U1(dec).Lo64 = (ULONG64)lo
#define SETDEC64(dec, scl, sgn, hi, mid, lo) S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \
dec.Hi32 = (ULONG)hi; S1(U1(dec)).Mid32 = mid; S1(U1(dec)).Lo32 = lo;
-#define CONVERT_DEC(func,scl,sgn,hi,lo) SETDEC(in,scl,sgn,hi,lo); hres = p##func(&in, &out)
+#define CONVERT_DEC(func,scl,sgn,hi,lo) SETDEC(in,scl,sgn,hi,lo); hres = func(&in, &out)
-#define CONVERT_DEC64(func,scl,sgn,hi,mid,lo) SETDEC64(in,scl,sgn,hi,mid,lo); hres = p##func(&in, &out)
+#define CONVERT_DEC64(func,scl,sgn,hi,mid,lo) SETDEC64(in,scl,sgn,hi,mid,lo); hres = func(&in, &out)
#define CONVERT_BADDEC(func) \
CONVERT_DEC(func,29,0,0,0); EXPECT_INVALID; \
#define CONVERT_STR(func,str,flags) \
SetLastError(0); \
if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,sizeof(buff)/sizeof(WCHAR)); \
- hres = p##func(str ? buff : NULL,in,flags,&out)
+ hres = func(str ? buff : NULL,in,flags,&out)
#define COPYTEST(val, vt, srcval, dstval, srcref, dstref, fs) do { \
HRESULT hres; VARIANTARG vSrc, vDst; CONV_TYPE in = val; \
DEFINE_EXPECT(dispatch_invoke);
-/* Early versions of oleaut32 are missing many functions */
-static HRESULT (WINAPI *pVarI1FromUI1)(BYTE,signed char*);
-static HRESULT (WINAPI *pVarI1FromI2)(SHORT,signed char*);
-static HRESULT (WINAPI *pVarI1FromI4)(LONG,signed char*);
-static HRESULT (WINAPI *pVarI1FromR4)(FLOAT,signed char*);
-static HRESULT (WINAPI *pVarI1FromR8)(double,signed char*);
-static HRESULT (WINAPI *pVarI1FromDate)(DATE,signed char*);
-static HRESULT (WINAPI *pVarI1FromCy)(CY,signed char*);
-static HRESULT (WINAPI *pVarI1FromStr)(OLECHAR*,LCID,ULONG,signed char*);
-static HRESULT (WINAPI *pVarI1FromBool)(VARIANT_BOOL,signed char*);
-static HRESULT (WINAPI *pVarI1FromUI2)(USHORT,signed char*);
-static HRESULT (WINAPI *pVarI1FromUI4)(ULONG,signed char*);
-static HRESULT (WINAPI *pVarI1FromDec)(DECIMAL*,signed char*);
-static HRESULT (WINAPI *pVarI1FromI8)(LONG64,signed char*);
-static HRESULT (WINAPI *pVarI1FromUI8)(ULONG64,signed char*);
-static HRESULT (WINAPI *pVarUI1FromI2)(SHORT,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromI4)(LONG,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromR4)(FLOAT,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromR8)(double,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromCy)(CY,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromDate)(DATE,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromStr)(OLECHAR*,LCID,ULONG,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromBool)(VARIANT_BOOL,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromI1)(signed char,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromUI2)(USHORT,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromUI4)(ULONG,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromDec)(DECIMAL*,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromI8)(LONG64,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromUI8)(ULONG64,BYTE*);
-static HRESULT (WINAPI *pVarUI1FromDisp)(IDispatch*,LCID,BYTE*);
-
-static HRESULT (WINAPI *pVarI2FromUI1)(BYTE,SHORT*);
-static HRESULT (WINAPI *pVarI2FromI4)(LONG,SHORT*);
-static HRESULT (WINAPI *pVarI2FromR4)(FLOAT,SHORT*);
-static HRESULT (WINAPI *pVarI2FromR8)(double,SHORT*);
-static HRESULT (WINAPI *pVarI2FromCy)(CY,SHORT*);
-static HRESULT (WINAPI *pVarI2FromDate)(DATE,SHORT*);
-static HRESULT (WINAPI *pVarI2FromStr)(OLECHAR*,LCID,ULONG,SHORT*);
-static HRESULT (WINAPI *pVarI2FromBool)(VARIANT_BOOL,SHORT*);
-static HRESULT (WINAPI *pVarI2FromI1)(signed char,SHORT*);
-static HRESULT (WINAPI *pVarI2FromUI2)(USHORT,SHORT*);
-static HRESULT (WINAPI *pVarI2FromUI4)(ULONG,SHORT*);
-static HRESULT (WINAPI *pVarI2FromDec)(DECIMAL*,SHORT*);
-static HRESULT (WINAPI *pVarI2FromI8)(LONG64,SHORT*);
-static HRESULT (WINAPI *pVarI2FromUI8)(ULONG64,SHORT*);
-static HRESULT (WINAPI *pVarUI2FromUI1)(BYTE,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromI2)(SHORT,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromI4)(LONG,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromR4)(FLOAT,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromR8)(double,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromDate)(DATE,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromCy)(CY,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromStr)(OLECHAR*,LCID,ULONG,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromBool)(VARIANT_BOOL,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromI1)(signed char,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromUI4)(ULONG,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromDec)(DECIMAL*,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromI8)(LONG64,USHORT*);
-static HRESULT (WINAPI *pVarUI2FromUI8)(ULONG64,USHORT*);
-
-static HRESULT (WINAPI *pVarI4FromUI1)(BYTE,LONG*);
-static HRESULT (WINAPI *pVarI4FromI2)(SHORT,LONG*);
-static HRESULT (WINAPI *pVarI4FromR4)(FLOAT,LONG*);
-static HRESULT (WINAPI *pVarI4FromR8)(DOUBLE,LONG*);
-static HRESULT (WINAPI *pVarI4FromCy)(CY,LONG*);
-static HRESULT (WINAPI *pVarI4FromDate)(DATE,LONG*);
-static HRESULT (WINAPI *pVarI4FromStr)(OLECHAR*,LCID,ULONG,LONG*);
-static HRESULT (WINAPI *pVarI4FromBool)(VARIANT_BOOL,LONG*);
-static HRESULT (WINAPI *pVarI4FromI1)(signed char,LONG*);
-static HRESULT (WINAPI *pVarI4FromUI2)(USHORT,LONG*);
-static HRESULT (WINAPI *pVarI4FromUI4)(ULONG,LONG*);
-static HRESULT (WINAPI *pVarI4FromDec)(DECIMAL*,LONG*);
-static HRESULT (WINAPI *pVarI4FromI8)(LONG64,LONG*);
-static HRESULT (WINAPI *pVarI4FromUI8)(ULONG64,LONG*);
-static HRESULT (WINAPI *pVarUI4FromUI1)(BYTE,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromI2)(SHORT,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromI4)(LONG,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromR4)(FLOAT,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromR8)(DOUBLE,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromDate)(DATE,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromCy)(CY,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromStr)(OLECHAR*,LCID,ULONG,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromBool)(VARIANT_BOOL,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromI1)(signed char,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromUI2)(USHORT,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromDec)(DECIMAL*,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromI8)(LONG64,ULONG*);
-static HRESULT (WINAPI *pVarUI4FromUI8)(ULONG64,ULONG*);
-
-static HRESULT (WINAPI *pVarI8FromUI1)(BYTE,LONG64*);
-static HRESULT (WINAPI *pVarI8FromI2)(SHORT,LONG64*);
-static HRESULT (WINAPI *pVarI8FromR4)(FLOAT,LONG64*);
-static HRESULT (WINAPI *pVarI8FromR8)(double,LONG64*);
-static HRESULT (WINAPI *pVarI8FromCy)(CY,LONG64*);
-static HRESULT (WINAPI *pVarI8FromDate)(DATE,LONG64*);
-static HRESULT (WINAPI *pVarI8FromStr)(OLECHAR*,LCID,ULONG,LONG64*);
-static HRESULT (WINAPI *pVarI8FromBool)(VARIANT_BOOL,LONG64*);
-static HRESULT (WINAPI *pVarI8FromI1)(signed char,LONG64*);
-static HRESULT (WINAPI *pVarI8FromUI2)(USHORT,LONG64*);
-static HRESULT (WINAPI *pVarI8FromUI4)(ULONG,LONG64*);
-static HRESULT (WINAPI *pVarI8FromDec)(DECIMAL*,LONG64*);
-static HRESULT (WINAPI *pVarI8FromUI8)(ULONG64,LONG64*);
-static HRESULT (WINAPI *pVarUI8FromI8)(LONG64,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromUI1)(BYTE,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromI2)(SHORT,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromR4)(FLOAT,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromR8)(double,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromCy)(CY,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromDate)(DATE,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromStr)(OLECHAR*,LCID,ULONG,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromBool)(VARIANT_BOOL,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromI1)(signed char,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromUI2)(USHORT,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromUI4)(ULONG,ULONG64*);
-static HRESULT (WINAPI *pVarUI8FromDec)(DECIMAL*,ULONG64*);
-
-static HRESULT (WINAPI *pVarR4FromUI1)(BYTE,float*);
-static HRESULT (WINAPI *pVarR4FromI2)(SHORT,float*);
-static HRESULT (WINAPI *pVarR4FromI4)(LONG,float*);
-static HRESULT (WINAPI *pVarR4FromR8)(double,float*);
-static HRESULT (WINAPI *pVarR4FromCy)(CY,float*);
-static HRESULT (WINAPI *pVarR4FromDate)(DATE,float*);
-static HRESULT (WINAPI *pVarR4FromStr)(OLECHAR*,LCID,ULONG,float*);
-static HRESULT (WINAPI *pVarR4FromBool)(VARIANT_BOOL,float*);
-static HRESULT (WINAPI *pVarR4FromI1)(signed char,float*);
-static HRESULT (WINAPI *pVarR4FromUI2)(USHORT,float*);
-static HRESULT (WINAPI *pVarR4FromUI4)(ULONG,float*);
-static HRESULT (WINAPI *pVarR4FromDec)(DECIMAL*,float*);
-static HRESULT (WINAPI *pVarR4FromI8)(LONG64,float*);
-static HRESULT (WINAPI *pVarR4FromUI8)(ULONG64,float*);
-
-static HRESULT (WINAPI *pVarR8FromUI1)(BYTE,double*);
-static HRESULT (WINAPI *pVarR8FromI2)(SHORT,double*);
-static HRESULT (WINAPI *pVarR8FromI4)(LONG,double*);
-static HRESULT (WINAPI *pVarR8FromR4)(FLOAT,double*);
-static HRESULT (WINAPI *pVarR8FromCy)(CY,double*);
-static HRESULT (WINAPI *pVarR8FromDate)(DATE,double*);
-static HRESULT (WINAPI *pVarR8FromStr)(OLECHAR*,LCID,ULONG,double*);
-static HRESULT (WINAPI *pVarR8FromBool)(VARIANT_BOOL,double*);
-static HRESULT (WINAPI *pVarR8FromI1)(signed char,double*);
-static HRESULT (WINAPI *pVarR8FromUI2)(USHORT,double*);
-static HRESULT (WINAPI *pVarR8FromUI4)(ULONG,double*);
-static HRESULT (WINAPI *pVarR8FromDec)(DECIMAL*,double*);
-static HRESULT (WINAPI *pVarR8FromI8)(LONG64,double*);
-static HRESULT (WINAPI *pVarR8FromUI8)(ULONG64,double*);
-static HRESULT (WINAPI *pVarR8Round)(double,int,double*);
-
-static HRESULT (WINAPI *pVarDateFromUI1)(BYTE,DATE*);
-static HRESULT (WINAPI *pVarDateFromI2)(SHORT,DATE*);
-static HRESULT (WINAPI *pVarDateFromI4)(LONG,DATE*);
-static HRESULT (WINAPI *pVarDateFromR4)(FLOAT,DATE*);
-static HRESULT (WINAPI *pVarDateFromCy)(CY,DATE*);
-static HRESULT (WINAPI *pVarDateFromR8)(double,DATE*);
-static HRESULT (WINAPI *pVarDateFromStr)(OLECHAR*,LCID,ULONG,DATE*);
-static HRESULT (WINAPI *pVarDateFromBool)(VARIANT_BOOL,DATE*);
-static HRESULT (WINAPI *pVarDateFromI1)(signed char,DATE*);
-static HRESULT (WINAPI *pVarDateFromUI2)(USHORT,DATE*);
-static HRESULT (WINAPI *pVarDateFromUI4)(ULONG,DATE*);
-static HRESULT (WINAPI *pVarDateFromDec)(DECIMAL*,DATE*);
-static HRESULT (WINAPI *pVarDateFromI8)(LONG64,DATE*);
-static HRESULT (WINAPI *pVarDateFromUI8)(ULONG64,DATE*);
-
-static HRESULT (WINAPI *pVarCyFromUI1)(BYTE,CY*);
-static HRESULT (WINAPI *pVarCyFromI2)(SHORT,CY*);
-static HRESULT (WINAPI *pVarCyFromI4)(LONG,CY*);
-static HRESULT (WINAPI *pVarCyFromR4)(FLOAT,CY*);
-static HRESULT (WINAPI *pVarCyFromR8)(double,CY*);
-static HRESULT (WINAPI *pVarCyFromDate)(DATE,CY*);
-static HRESULT (WINAPI *pVarCyFromBool)(VARIANT_BOOL,CY*);
-static HRESULT (WINAPI *pVarCyFromI1)(signed char,CY*);
-static HRESULT (WINAPI *pVarCyFromUI2)(USHORT,CY*);
-static HRESULT (WINAPI *pVarCyFromUI4)(ULONG,CY*);
-static HRESULT (WINAPI *pVarCyFromDec)(DECIMAL*,CY*);
-static HRESULT (WINAPI *pVarCyFromI8)(LONG64,CY*);
-static HRESULT (WINAPI *pVarCyFromUI8)(ULONG64,CY*);
-static HRESULT (WINAPI *pVarCyAdd)(const CY,const CY,CY*);
-static HRESULT (WINAPI *pVarCyMul)(const CY,const CY,CY*);
-static HRESULT (WINAPI *pVarCyMulI4)(const CY,LONG,CY*);
-static HRESULT (WINAPI *pVarCySub)(const CY,const CY,CY*);
-static HRESULT (WINAPI *pVarCyAbs)(const CY,CY*);
-static HRESULT (WINAPI *pVarCyFix)(const CY,CY*);
-static HRESULT (WINAPI *pVarCyInt)(const CY,CY*);
-static HRESULT (WINAPI *pVarCyNeg)(const CY,CY*);
-static HRESULT (WINAPI *pVarCyRound)(const CY,int,CY*);
-static HRESULT (WINAPI *pVarCyCmp)(const CY,const CY);
-static HRESULT (WINAPI *pVarCyCmpR8)(const CY,double);
-static HRESULT (WINAPI *pVarCyMulI8)(const CY,LONG64,CY*);
-
-static HRESULT (WINAPI *pVarDecFromUI1)(BYTE,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromI2)(SHORT,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromI4)(LONG,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromI8)(LONG64,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromR4)(FLOAT,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromR8)(DOUBLE,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromDate)(DATE,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromStr)(OLECHAR*,LCID,ULONG,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromBool)(VARIANT_BOOL,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromI1)(signed char,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromUI2)(USHORT,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromUI4)(ULONG,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromUI8)(ULONG64,DECIMAL*);
-static HRESULT (WINAPI *pVarDecFromCy)(CY,DECIMAL*);
-static HRESULT (WINAPI *pVarDecAbs)(const DECIMAL*,DECIMAL*);
-static HRESULT (WINAPI *pVarDecAdd)(const DECIMAL*,const DECIMAL*,DECIMAL*);
-static HRESULT (WINAPI *pVarDecSub)(const DECIMAL*,const DECIMAL*,DECIMAL*);
-static HRESULT (WINAPI *pVarDecMul)(const DECIMAL*,const DECIMAL*,DECIMAL*);
-static HRESULT (WINAPI *pVarDecDiv)(const DECIMAL*,const DECIMAL*,DECIMAL*);
-static HRESULT (WINAPI *pVarDecCmp)(const DECIMAL*,const DECIMAL*);
-static HRESULT (WINAPI *pVarDecCmpR8)(const DECIMAL*,double);
-static HRESULT (WINAPI *pVarDecNeg)(const DECIMAL*,DECIMAL*);
-static HRESULT (WINAPI *pVarDecRound)(const DECIMAL*,int,DECIMAL*);
-
-static HRESULT (WINAPI *pVarBoolFromUI1)(BYTE,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromI2)(SHORT,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromI4)(LONG,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromR4)(FLOAT,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromR8)(DOUBLE,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromDate)(DATE,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromCy)(CY,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromStr)(OLECHAR*,LCID,ULONG,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromI1)(signed char,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromUI2)(USHORT,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromUI4)(ULONG,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromDec)(DECIMAL*,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromI8)(LONG64,VARIANT_BOOL*);
-static HRESULT (WINAPI *pVarBoolFromUI8)(ULONG64,VARIANT_BOOL*);
-
-static HRESULT (WINAPI *pVarBstrFromR4)(FLOAT,LCID,ULONG,BSTR*);
-static HRESULT (WINAPI *pVarBstrFromDate)(DATE,LCID,ULONG,BSTR*);
-static HRESULT (WINAPI *pVarBstrFromCy)(CY,LCID,ULONG,BSTR*);
-static HRESULT (WINAPI *pVarBstrFromDec)(DECIMAL*,LCID,ULONG,BSTR*);
-static HRESULT (WINAPI *pVarBstrCmp)(BSTR,BSTR,LCID,ULONG);
-static HRESULT (WINAPI *pVarBstrCat)(BSTR,BSTR,BSTR*);
-
-static INT (WINAPI *pSystemTimeToVariantTime)(LPSYSTEMTIME,double*);
-static void (WINAPI *pClearCustData)(LPCUSTDATA);
-
/* Internal representation of a BSTR */
typedef struct tagINTERNAL_BSTR
{
CONVVARS(SHORT);
int i;
- CHECKPTR(VarI1FromI2);
OVERFLOWRANGE(VarI1FromI2, -32768, -128);
CONVERTRANGE(VarI1FromI2, -128, 128);
OVERFLOWRANGE(VarI1FromI2, 129, 32768);
CONVVARS(LONG);
int i;
- CHECKPTR(VarI1FromI4);
CONVERT(VarI1FromI4, -129); EXPECT_OVERFLOW;
CONVERTRANGE(VarI1FromI4, -128, 128);
CONVERT(VarI1FromI4, 128); EXPECT_OVERFLOW;
CONVVARS(LONG64);
int i;
- CHECKPTR(VarI1FromI8);
CONVERT(VarI1FromI8, -129); EXPECT_OVERFLOW;
CONVERTRANGE(VarI1FromI8, -127, 128);
CONVERT(VarI1FromI8, 128); EXPECT_OVERFLOW;
CONVVARS(BYTE);
int i;
- CHECKPTR(VarI1FromUI1);
CONVERTRANGE(VarI1FromUI1, 0, 127);
OVERFLOWRANGE(VarI1FromUI1, 128, 255);
}
CONVVARS(USHORT);
int i;
- CHECKPTR(VarI1FromUI2);
CONVERTRANGE(VarI1FromUI2, 0, 127);
OVERFLOWRANGE(VarI1FromUI2, 128, 32768);
}
CONVVARS(ULONG);
int i;
- CHECKPTR(VarI1FromUI4);
CONVERTRANGE(VarI1FromUI4, 0, 127);
CONVERT(VarI1FromUI4, 128); EXPECT_OVERFLOW;
}
CONVVARS(ULONG64);
int i;
- CHECKPTR(VarI1FromUI8);
CONVERTRANGE(VarI1FromUI8, 0, 127);
CONVERT(VarI1FromUI8, 128); EXPECT_OVERFLOW;
}
CONVVARS(VARIANT_BOOL);
int i;
- CHECKPTR(VarI1FromBool);
/* Note that conversions from bool wrap around! */
CONVERT(VarI1FromBool, -129); EXPECT(127);
CONVERTRANGE(VarI1FromBool, -128, 128);
{
CONVVARS(FLOAT);
- CHECKPTR(VarI1FromR4);
CONVERT(VarI1FromR4, -129.0f); EXPECT_OVERFLOW;
CONVERT(VarI1FromR4, -128.51f); EXPECT_OVERFLOW;
CONVERT(VarI1FromR4, -128.5f); EXPECT(-128);
{
CONVVARS(DOUBLE);
- CHECKPTR(VarI1FromR8);
CONVERT(VarI1FromR8, -129.0); EXPECT_OVERFLOW;
CONVERT(VarI1FromR8, -128.51); EXPECT_OVERFLOW;
CONVERT(VarI1FromR8, -128.5); EXPECT(-128);
{
CONVVARS(DATE);
- CHECKPTR(VarI1FromDate);
CONVERT(VarI1FromDate, -129.0); EXPECT_OVERFLOW;
CONVERT(VarI1FromDate, -128.0); EXPECT(-128);
CONVERT(VarI1FromDate, -1.0); EXPECT(-1);
{
CONVVARS(CY);
- CHECKPTR(VarI1FromCy);
CONVERT_CY(VarI1FromCy,-129); EXPECT_OVERFLOW;
CONVERT_CY(VarI1FromCy,-128); EXPECT(128);
CONVERT_CY(VarI1FromCy,-1); EXPECT(-1);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarI1FromDec);
-
CONVERT_BADDEC(VarI1FromDec);
CONVERT_DEC(VarI1FromDec,0,0x80,0,129); EXPECT_OVERFLOW;
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarI1FromStr);
-
CONVERT_STR(VarI1FromStr,NULL, 0); EXPECT_MISMATCH;
CONVERT_STR(VarI1FromStr,"0", 0); EXPECT(0);
CONVERT_STR(VarI1FromStr,"-129", 0); EXPECT_OVERFLOW;
CONVVARS(signed char);
int i;
- CHECKPTR(VarUI1FromI1);
OVERFLOWRANGE(VarUI1FromI1, -128, 0);
CONVERTRANGE(VarUI1FromI1, 0, 128);
}
CONVVARS(SHORT);
int i;
- CHECKPTR(VarUI1FromI2);
OVERFLOWRANGE(VarUI1FromI2, -32768, 0);
CONVERTRANGE(VarUI1FromI2, 0, 256);
OVERFLOWRANGE(VarUI1FromI2, 256, 32768);
CONVVARS(LONG);
int i;
- CHECKPTR(VarUI1FromI4);
CONVERT(VarUI1FromI4, -1); EXPECT_OVERFLOW;
CONVERTRANGE(VarUI1FromI4, 0, 256);
CONVERT(VarUI1FromI4, 256); EXPECT_OVERFLOW;
CONVVARS(LONG64);
int i;
- CHECKPTR(VarUI1FromI8);
CONVERT(VarUI1FromI8, -1); EXPECT_OVERFLOW;
CONVERTRANGE(VarUI1FromI8, 0, 256);
CONVERT(VarUI1FromI8, 256); EXPECT_OVERFLOW;
CONVVARS(USHORT);
int i;
- CHECKPTR(VarUI1FromUI2);
CONVERTRANGE(VarUI1FromUI2, 0, 256);
OVERFLOWRANGE(VarUI1FromUI2, 256, 65536);
}
CONVVARS(ULONG);
int i;
- CHECKPTR(VarUI1FromUI4);
CONVERTRANGE(VarUI1FromUI4, 0, 256);
CONVERT(VarUI1FromUI4, 256); EXPECT_OVERFLOW;
}
CONVVARS(ULONG64);
int i;
- CHECKPTR(VarUI1FromUI8);
CONVERTRANGE(VarUI1FromUI8, 0, 256);
CONVERT(VarUI1FromUI8, 256); EXPECT_OVERFLOW;
}
CONVVARS(VARIANT_BOOL);
int i;
- CHECKPTR(VarUI1FromBool);
/* Note that conversions from bool overflow! */
CONVERT(VarUI1FromBool, -1); EXPECT(255);
CONVERTRANGE(VarUI1FromBool, 0, 256);
{
CONVVARS(FLOAT);
- CHECKPTR(VarUI1FromR4);
CONVERT(VarUI1FromR4, -1.0f); EXPECT_OVERFLOW;
CONVERT(VarUI1FromR4, -0.51f); EXPECT_OVERFLOW;
CONVERT(VarUI1FromR4, -0.5f); EXPECT(0);
{
CONVVARS(DOUBLE);
- CHECKPTR(VarUI1FromR8);
CONVERT(VarUI1FromR8, -1.0); EXPECT_OVERFLOW;
CONVERT(VarUI1FromR8, -0.51); EXPECT_OVERFLOW;
CONVERT(VarUI1FromR8, -0.5); EXPECT(0);
{
CONVVARS(DATE);
- CHECKPTR(VarUI1FromDate);
CONVERT(VarUI1FromDate, -1.0); EXPECT_OVERFLOW;
CONVERT(VarUI1FromDate, 0.0); EXPECT(0);
CONVERT(VarUI1FromDate, 1.0); EXPECT(1);
{
CONVVARS(CY);
- CHECKPTR(VarUI1FromCy);
CONVERT_CY(VarUI1FromCy,-1); EXPECT_OVERFLOW;
CONVERT_CY(VarUI1FromCy,0); EXPECT(0);
CONVERT_CY(VarUI1FromCy,1); EXPECT(1);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarUI1FromDec);
-
CONVERT_BADDEC(VarUI1FromDec);
CONVERT_DEC(VarUI1FromDec,0,0x80,0,1); EXPECT_OVERFLOW;
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarUI1FromStr);
-
CONVERT_STR(VarUI1FromStr,NULL, 0); EXPECT_MISMATCH;
CONVERT_STR(VarUI1FromStr,"0", 0); EXPECT(0);
CONVERT_STR(VarUI1FromStr,"-1", 0); EXPECT_OVERFLOW;
CONVVARS(LCID);
VARIANTARG vSrc, vDst;
- CHECKPTR(VarUI1FromDisp);
-
/* FIXME
* Conversions from IDispatch should get the default 'value' property
* from the IDispatch pointer and return it. The following tests this.
SET_EXPECT(dispatch_invoke);
out = 10;
- hres = pVarUI1FromDisp(&dispatch.IDispatch_iface, in, &out);
+ hres = VarUI1FromDisp(&dispatch.IDispatch_iface, in, &out);
ok(broken(hres == DISP_E_BADVARTYPE) || hres == S_OK, "got 0x%08x\n", hres);
ok(broken(out == 10) || out == 1, "got %d\n", out);
CHECK_CALLED(dispatch_invoke);
SET_EXPECT(dispatch_invoke);
out = 10;
- hres = pVarUI1FromDisp(&dispatch.IDispatch_iface, in, &out);
+ hres = VarUI1FromDisp(&dispatch.IDispatch_iface, in, &out);
ok(hres == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hres);
ok(out == 10, "got %d\n", out);
CHECK_CALLED(dispatch_invoke);
CONVVARS(signed char);
int i;
- CHECKPTR(VarI2FromI1);
CONVERTRANGE(VarI2FromI1, -128, 128);
}
CONVVARS(LONG);
int i;
- CHECKPTR(VarI2FromI4);
CONVERT(VarI2FromI4, -32769); EXPECT_OVERFLOW;
CONVERTRANGE(VarI2FromI4, -32768, 32768);
CONVERT(VarI2FromI4, 32768); EXPECT_OVERFLOW;
{
CONVVARS(LONG64);
- CHECKPTR(VarI2FromI8);
CONVERT(VarI2FromI8, -32769); EXPECT_OVERFLOW;
CONVERT(VarI2FromI8, -32768); EXPECT(-32768);
CONVERT(VarI2FromI8, 32767); EXPECT(32767);
CONVVARS(BYTE);
int i;
- CHECKPTR(VarI2FromUI1);
CONVERTRANGE(VarI2FromUI1, 0, 256);
}
CONVVARS(USHORT);
int i;
- CHECKPTR(VarI2FromUI2);
CONVERTRANGE(VarI2FromUI2, 0, 32768);
CONVERT(VarI2FromUI2, 32768); EXPECT_OVERFLOW;
}
CONVVARS(ULONG);
int i;
- CHECKPTR(VarI2FromUI4);
CONVERTRANGE(VarI2FromUI4, 0, 32768);
CONVERT(VarI2FromUI4, 32768); EXPECT_OVERFLOW;
}
CONVVARS(ULONG64);
int i;
- CHECKPTR(VarI2FromUI8);
CONVERTRANGE(VarI2FromUI8, 0, 32768);
CONVERT(VarI2FromUI8, 32768); EXPECT_OVERFLOW;
}
CONVVARS(VARIANT_BOOL);
int i;
- CHECKPTR(VarI2FromBool);
CONVERTRANGE(VarI2FromBool, -32768, 32768);
}
{
CONVVARS(FLOAT);
- CHECKPTR(VarI2FromR4);
CONVERT(VarI2FromR4, -32769.0f); EXPECT_OVERFLOW;
CONVERT(VarI2FromR4, -32768.51f); EXPECT_OVERFLOW;
CONVERT(VarI2FromR4, -32768.5f); EXPECT(-32768);
{
CONVVARS(DOUBLE);
- CHECKPTR(VarI2FromR8);
CONVERT(VarI2FromR8, -32769.0); EXPECT_OVERFLOW;
CONVERT(VarI2FromR8, -32768.51); EXPECT_OVERFLOW;
CONVERT(VarI2FromR8, -32768.5); EXPECT(-32768);
{
CONVVARS(DATE);
- CHECKPTR(VarI2FromDate);
CONVERT(VarI2FromDate, -32769.0); EXPECT_OVERFLOW;
CONVERT(VarI2FromDate, -32768.0); EXPECT(-32768);
CONVERT(VarI2FromDate, -1.0); EXPECT(-1);
{
CONVVARS(CY);
- CHECKPTR(VarI2FromCy);
CONVERT_CY(VarI2FromCy,-32769); EXPECT_OVERFLOW;
CONVERT_CY(VarI2FromCy,-32768); EXPECT(32768);
CONVERT_CY(VarI2FromCy,-1); EXPECT(-1);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarI2FromDec);
-
CONVERT_BADDEC(VarI2FromDec);
CONVERT_DEC(VarI2FromDec,0,0x80,0,32769); EXPECT_OVERFLOW;
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarI2FromStr);
-
CONVERT_STR(VarI2FromStr,NULL, 0); EXPECT_MISMATCH;
CONVERT_STR(VarI2FromStr,"0", 0); EXPECT(0);
CONVERT_STR(VarI2FromStr,"-32769", 0); EXPECT_OVERFLOW;
CONVVARS(signed char);
int i;
- CHECKPTR(VarUI2FromI1);
OVERFLOWRANGE(VarUI2FromI1, -128, 0);
CONVERTRANGE(VarUI2FromI1, 0, 128);
}
CONVVARS(SHORT);
int i;
- CHECKPTR(VarUI2FromI2);
OVERFLOWRANGE(VarUI2FromI2, -32768, 0);
CONVERTRANGE(VarUI2FromI2, 0, 32768);
}
CONVVARS(LONG);
int i;
- CHECKPTR(VarUI2FromI4);
OVERFLOWRANGE(VarUI2FromI4, -32768, 0);
CONVERT(VarUI2FromI4, 0); EXPECT(0);
CONVERT(VarUI2FromI4, 65535); EXPECT(65535);
CONVVARS(LONG64);
int i;
- CHECKPTR(VarUI2FromI8);
OVERFLOWRANGE(VarUI2FromI8, -32768, 0);
CONVERT(VarUI2FromI8, 0); EXPECT(0);
CONVERT(VarUI2FromI8, 65535); EXPECT(65535);
CONVVARS(BYTE);
int i;
- CHECKPTR(VarUI2FromUI1);
CONVERTRANGE(VarUI2FromUI1, 0, 256);
}
{
CONVVARS(ULONG);
- CHECKPTR(VarUI2FromUI4);
CONVERT(VarUI2FromUI4, 0); EXPECT(0);
CONVERT(VarUI2FromUI4, 65535); EXPECT(65535);
CONVERT(VarUI2FromUI4, 65536); EXPECT_OVERFLOW;
{
CONVVARS(ULONG64);
- CHECKPTR(VarUI2FromUI8);
CONVERT(VarUI2FromUI8, 0); EXPECT(0);
CONVERT(VarUI2FromUI8, 65535); EXPECT(65535);
CONVERT(VarUI2FromUI8, 65536); EXPECT_OVERFLOW;
CONVVARS(VARIANT_BOOL);
int i;
- CHECKPTR(VarUI2FromBool);
CONVERT(VarUI2FromBool, -1); EXPECT(65535); /* Wraps! */
CONVERTRANGE(VarUI2FromBool, 0, 32768);
}
{
CONVVARS(FLOAT);
- CHECKPTR(VarUI2FromR4);
CONVERT(VarUI2FromR4, -1.0f); EXPECT_OVERFLOW;
CONVERT(VarUI2FromR4, -0.51f); EXPECT_OVERFLOW;
CONVERT(VarUI2FromR4, -0.5f); EXPECT(0);
{
CONVVARS(DOUBLE);
- CHECKPTR(VarUI2FromR8);
CONVERT(VarUI2FromR8, -1.0); EXPECT_OVERFLOW;
CONVERT(VarUI2FromR8, -0.51); EXPECT_OVERFLOW;
CONVERT(VarUI2FromR8, -0.5); EXPECT(0);
{
CONVVARS(DATE);
- CHECKPTR(VarUI2FromDate);
CONVERT(VarUI2FromDate, -1.0); EXPECT_OVERFLOW;
CONVERT(VarUI2FromDate, 0.0); EXPECT(0);
CONVERT(VarUI2FromDate, 1.0); EXPECT(1);
{
CONVVARS(CY);
- CHECKPTR(VarUI2FromCy);
CONVERT_CY(VarUI2FromCy,-1); EXPECT_OVERFLOW;
CONVERT_CY(VarUI2FromCy,0); EXPECT(0);
CONVERT_CY(VarUI2FromCy,1); EXPECT(1);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarUI2FromDec);
-
CONVERT_BADDEC(VarUI2FromDec);
CONVERT_DEC(VarUI2FromDec,0,0x80,0,1); EXPECT_OVERFLOW;
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarUI2FromStr);
-
CONVERT_STR(VarUI2FromStr,NULL, 0); EXPECT_MISMATCH;
CONVERT_STR(VarUI2FromStr,"0", 0); EXPECT(0);
CONVERT_STR(VarUI2FromStr,"-1", 0); EXPECT_OVERFLOW;
CONVVARS(signed char);
int i;
- CHECKPTR(VarI4FromI1);
CONVERTRANGE(VarI4FromI1, -128, 128);
}
CONVVARS(SHORT);
int i;
- CHECKPTR(VarI4FromI2);
CONVERTRANGE(VarI4FromI2, -32768, 32768);
}
{
CONVVARS(LONG64);
- CHECKPTR(VarI4FromI8);
- CHECKPTR(VarI4FromDec);
-
CONVERT(VarI4FromI8, -1); EXPECT(-1);
CONVERT(VarI4FromI8, 0); EXPECT(0);
CONVERT(VarI4FromI8, 1); EXPECT(1);
CONVVARS(BYTE);
int i;
- CHECKPTR(VarI4FromUI1);
CONVERTRANGE(VarI4FromUI1, 0, 256);
}
CONVVARS(USHORT);
int i;
- CHECKPTR(VarI4FromUI2);
CONVERTRANGE(VarI4FromUI2, 0, 65536);
}
{
CONVVARS(ULONG);
- CHECKPTR(VarI4FromUI4);
CONVERT(VarI4FromUI4, 0); EXPECT(0);
CONVERT(VarI4FromUI4, 1); EXPECT(1);
CONVERT(VarI4FromUI4, 2147483647); EXPECT(2147483647);
{
CONVVARS(ULONG64);
- CHECKPTR(VarI4FromUI8);
CONVERT(VarI4FromUI8, 0); EXPECT(0);
CONVERT(VarI4FromUI8, 1); EXPECT(1);
CONVERT(VarI4FromUI8, 2147483647); EXPECT(2147483647);
CONVVARS(VARIANT_BOOL);
int i;
- CHECKPTR(VarI4FromBool);
CONVERTRANGE(VarI4FromBool, -32768, 32768);
}
{
CONVVARS(FLOAT);
- CHECKPTR(VarI4FromR4);
-
/* min/max values are not exactly representable in a float */
CONVERT(VarI4FromR4, -1.0f); EXPECT(-1);
CONVERT(VarI4FromR4, 0.0f); EXPECT(0);
{
CONVVARS(DOUBLE);
- CHECKPTR(VarI4FromR8);
CONVERT(VarI4FromR8, -2147483649.0); EXPECT_OVERFLOW;
CONVERT(VarI4FromR8, -2147483648.51); EXPECT_OVERFLOW;
CONVERT(VarI4FromR8, -2147483648.5); EXPECT(-2147483647 - 1);
{
CONVVARS(DATE);
- CHECKPTR(VarI4FromDate);
CONVERT(VarI4FromDate, -2147483649.0); EXPECT_OVERFLOW;
CONVERT(VarI4FromDate, -2147483648.0); EXPECT(-2147483647 - 1);
CONVERT(VarI4FromDate, -1.0); EXPECT(-1);
{
CONVVARS(CY);
- CHECKPTR(VarI4FromCy);
CONVERT_CY(VarI4FromCy,-1); EXPECT(-1);
CONVERT_CY(VarI4FromCy,0); EXPECT(0);
CONVERT_CY(VarI4FromCy,1); EXPECT(1);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarI4FromDec);
-
CONVERT_BADDEC(VarI4FromDec);
CONVERT_DEC(VarI4FromDec,0,0x80,0,1); EXPECT(-1);
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarI4FromStr);
-
CONVERT_STR(VarI4FromStr,NULL,0); EXPECT_MISMATCH;
CONVERT_STR(VarI4FromStr,"0",0); EXPECT(0);
CONVERT_STR(VarI4FromStr,"-2147483649",0); EXPECT_OVERFLOW;
CONVVARS(signed char);
int i;
- CHECKPTR(VarUI4FromI1);
OVERFLOWRANGE(VarUI4FromI1, -127, 0);
CONVERTRANGE(VarUI4FromI1, 0, 128);
}
CONVVARS(SHORT);
int i;
- CHECKPTR(VarUI4FromI2);
OVERFLOWRANGE(VarUI4FromI2, -32768, 0);
CONVERTRANGE(VarUI4FromI2, 0, 32768);
}
CONVVARS(USHORT);
int i;
- CHECKPTR(VarUI4FromUI2);
CONVERTRANGE(VarUI4FromUI2, 0, 65536);
}
{
CONVVARS(LONG64);
- CHECKPTR(VarUI4FromI8);
CONVERT(VarUI4FromI8, -1); EXPECT_OVERFLOW;
CONVERT(VarUI4FromI8, 0); EXPECT(0);
CONVERT(VarUI4FromI8, 1); EXPECT(1);
CONVVARS(BYTE);
int i;
- CHECKPTR(VarUI4FromUI1);
CONVERTRANGE(VarUI4FromUI1, 0, 256);
}
{
CONVVARS(int);
- CHECKPTR(VarUI4FromI4);
CONVERT(VarUI4FromI4, -1); EXPECT_OVERFLOW;
CONVERT(VarUI4FromI4, 0); EXPECT(0);
CONVERT(VarUI4FromI4, 1); EXPECT(1);
{
CONVVARS(ULONG64);
- CHECKPTR(VarUI4FromUI8);
CONVERT(VarUI4FromUI8, 0); EXPECT(0);
CONVERT(VarUI4FromUI8, 1); EXPECT(1);
CONVERT(VarUI4FromI8, 4294967295ul); EXPECT(4294967295ul);
CONVVARS(VARIANT_BOOL);
int i;
- CHECKPTR(VarUI4FromBool);
CONVERTRANGE(VarUI4FromBool, -32768, 32768);
}
{
CONVVARS(FLOAT);
- CHECKPTR(VarUI4FromR4);
/* We can't test max values as they are not exactly representable in a float */
CONVERT(VarUI4FromR4, -1.0f); EXPECT_OVERFLOW;
CONVERT(VarUI4FromR4, -0.51f); EXPECT_OVERFLOW;
{
CONVVARS(DOUBLE);
- CHECKPTR(VarUI4FromR8);
CONVERT(VarUI4FromR8, -1.0); EXPECT_OVERFLOW;
CONVERT(VarUI4FromR4, -0.51f); EXPECT_OVERFLOW;
CONVERT(VarUI4FromR4, -0.5f); EXPECT(0);
{
CONVVARS(DOUBLE);
- CHECKPTR(VarUI4FromDate);
CONVERT(VarUI4FromDate, -1.0); EXPECT_OVERFLOW;
CONVERT(VarUI4FromDate, 0.0); EXPECT(0);
CONVERT(VarUI4FromDate, 1.0); EXPECT(1);
{
CONVVARS(CY);
- CHECKPTR(VarUI4FromCy);
CONVERT_CY(VarUI4FromCy,-1); EXPECT_OVERFLOW;
CONVERT_CY(VarUI4FromCy,0); EXPECT(0);
CONVERT_CY(VarUI4FromCy,1); EXPECT(1);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarUI4FromDec);
-
CONVERT_BADDEC(VarUI4FromDec);
CONVERT_DEC(VarUI4FromDec,0,0x80,0,1); EXPECT_OVERFLOW;
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarUI4FromStr);
-
CONVERT_STR(VarUI4FromStr,NULL,0); EXPECT_MISMATCH;
CONVERT_STR(VarUI4FromStr,"-1",0); EXPECT_OVERFLOW;
CONVERT_STR(VarUI4FromStr,"0",0); EXPECT(0);
CONVVARS(signed char);
int i;
- CHECKPTR(VarI8FromI1);
for (i = -128; i < 128; i++)
{
CONVERT(VarI8FromI1,i); EXPECTI8(i);
CONVVARS(BYTE);
int i;
- CHECKPTR(VarI8FromUI1);
for (i = 0; i < 256; i++)
{
CONVERT(VarI8FromUI1,i); EXPECTI8(i);
CONVVARS(SHORT);
int i;
- CHECKPTR(VarI8FromI2);
for (i = -32768; i < 32768; i++)
{
CONVERT(VarI8FromI2,i); EXPECTI8(i);
CONVVARS(USHORT);
int i;
- CHECKPTR(VarI8FromUI2);
for (i = -0; i < 65535; i++)
{
CONVERT(VarI8FromUI2,i); EXPECTI8(i);
{
CONVVARS(ULONG);
- CHECKPTR(VarI8FromUI4);
CONVERT(VarI8FromUI4, 0); EXPECTI8(0);
CONVERT(VarI8FromUI4, 1); EXPECTI8(1);
CONVERT(VarI8FromUI4, 4294967295ul); EXPECTI8(4294967295ul);
{
CONVVARS(FLOAT);
- CHECKPTR(VarI8FromR4);
-
CONVERT(VarI8FromR4, -128.0f); EXPECTI8(-128);
CONVERT(VarI8FromR4, -1.0f); EXPECTI8(-1);
CONVERT(VarI8FromR4, 0.0f); EXPECTI8(0);
{
CONVVARS(DOUBLE);
- CHECKPTR(VarI8FromR8);
CONVERT(VarI8FromR8, -128.0); EXPECTI8(-128);
CONVERT(VarI8FromR8, -1.0); EXPECTI8(-1);
CONVERT(VarI8FromR8, 0.0); EXPECTI8(0);
{
CONVVARS(DATE);
- CHECKPTR(VarI8FromDate);
CONVERT(VarI8FromDate, -128.0); EXPECTI8(-128);
CONVERT(VarI8FromDate, -1.0); EXPECTI8(-1);
CONVERT(VarI8FromDate, 0.0); EXPECTI8(0);
CONVVARS(VARIANT_BOOL);
int i;
- CHECKPTR(VarI8FromBool);
for (i = -32768; i < 32768; i++)
{
CONVERT(VarI8FromBool,i); EXPECTI8(i);
{
CONVVARS(ULONG64);
- CHECKPTR(VarI8FromUI8);
CONVERT(VarI8FromUI8, 0); EXPECTI8(0);
CONVERT(VarI8FromUI8, 1); EXPECTI8(1);
CONVERT_I8(VarI8FromUI8, 0x7fffffff, 0xffffffff); EXPECTI864(0x7fffffff, 0xffffffff);
{
CONVVARS(CY);
- CHECKPTR(VarI8FromCy);
CONVERT_CY(VarI8FromCy,-128); EXPECTI8(-129);
CONVERT_CY(VarI8FromCy,-1); EXPECTI8(-2);
CONVERT_CY(VarI8FromCy,0); EXPECTI8(0);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarI8FromDec);
-
CONVERT_BADDEC(VarI8FromDec);
CONVERT_DEC(VarI8FromDec,0,0x80,0,128); EXPECTI8(-128);
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarI8FromStr);
-
CONVERT_STR(VarI8FromStr,NULL,0); EXPECT_MISMATCH;
CONVERT_STR(VarI8FromStr,"0",0); EXPECTI8(0);
CONVERT_STR(VarI8FromStr,"-1",0); EXPECTI8(-1);
CONVVARS(signed char);
int i;
- CHECKPTR(VarUI8FromI1);
for (i = -128; i < 128; i++)
{
CONVERT(VarUI8FromI1,i);
CONVVARS(BYTE);
int i;
- CHECKPTR(VarUI8FromUI1);
for (i = 0; i < 256; i++)
{
CONVERT(VarUI8FromUI1,i); EXPECTI8(i);
CONVVARS(SHORT);
int i;
- CHECKPTR(VarUI8FromI2);
for (i = -32768; i < 32768; i++)
{
CONVERT(VarUI8FromI2,i);
CONVVARS(USHORT);
int i;
- CHECKPTR(VarUI8FromUI2);
for (i = 0; i < 65535; i++)
{
CONVERT(VarUI8FromUI2,i); EXPECTI8(i);
{
CONVVARS(ULONG);
- CHECKPTR(VarUI8FromUI4);
CONVERT(VarUI8FromUI4, 0); EXPECTI8(0);
CONVERT(VarUI8FromUI4, 0xffffffff); EXPECTI8(0xffffffff);
}
{
CONVVARS(FLOAT);
- CHECKPTR(VarUI8FromR4);
CONVERT(VarUI8FromR4, -1.0f); EXPECT_OVERFLOW;
CONVERT(VarUI8FromR4, 0.0f); EXPECTI8(0);
CONVERT(VarUI8FromR4, 1.0f); EXPECTI8(1);
{
CONVVARS(DOUBLE);
- CHECKPTR(VarUI8FromR8);
CONVERT(VarUI8FromR8, -1.0); EXPECT_OVERFLOW;
CONVERT(VarUI8FromR8, 0.0); EXPECTI8(0);
CONVERT(VarUI8FromR8, 1.0); EXPECTI8(1);
{
CONVVARS(DATE);
- CHECKPTR(VarUI8FromDate);
CONVERT(VarUI8FromDate, -1.0); EXPECT_OVERFLOW;
CONVERT(VarUI8FromDate, 0.0); EXPECTI8(0);
CONVERT(VarUI8FromDate, 1.0); EXPECTI8(1);
CONVVARS(VARIANT_BOOL);
int i;
- CHECKPTR(VarUI8FromBool);
for (i = -32768; i < 32768; i++)
{
CONVERT(VarUI8FromBool, i); EXPECTI8(i);
{
CONVVARS(LONG64);
- CHECKPTR(VarUI8FromI8);
CONVERT(VarUI8FromI8, -1); EXPECT_OVERFLOW;
CONVERT(VarUI8FromI8, 0); EXPECTI8(0);
CONVERT(VarUI8FromI8, 1); EXPECTI8(1);
{
CONVVARS(CY);
- CHECKPTR(VarUI8FromCy);
CONVERT_CY(VarUI8FromCy,-1); EXPECT_OVERFLOW;
CONVERT_CY(VarUI8FromCy,0); EXPECTI8(0);
CONVERT_CY(VarUI8FromCy,1); EXPECTI8(1);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarUI8FromDec);
-
CONVERT_BADDEC(VarUI8FromDec);
/* This returns 1 under native; Wine fixes this bug and returns overflow */
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarUI8FromStr);
-
CONVERT_STR(VarUI8FromStr,NULL,0); EXPECT_MISMATCH;
CONVERT_STR(VarUI8FromStr,"0",0); EXPECTI8(0);
CONVERT_STR(VarUI8FromStr,"-1",0); EXPECT_OVERFLOW;
CONVVARS(signed char);
int i;
- CHECKPTR(VarR4FromI1);
CONVERTRANGE(VarR4FromI1, -128, 128);
}
CONVVARS(BYTE);
int i;
- CHECKPTR(VarR4FromUI1);
CONVERTRANGE(VarR4FromUI1, 0, 256);
}
CONVVARS(SHORT);
int i;
- CHECKPTR(VarR4FromI2);
CONVERTRANGE(VarR4FromI2, -32768, 32768);
}
CONVVARS(USHORT);
int i;
- CHECKPTR(VarR4FromUI2);
CONVERTRANGE(VarR4FromUI2, 0, 65536);
}
{
CONVVARS(int);
- CHECKPTR(VarR4FromI4);
CONVERT(VarR4FromI4, -2147483647-1); EXPECT(-2147483648.0f);
CONVERT(VarR4FromI4, -1); EXPECT(-1.0f);
CONVERT(VarR4FromI4, 0); EXPECT(0.0f);
{
CONVVARS(unsigned int);
- CHECKPTR(VarR4FromUI4);
CONVERT(VarR4FromUI4, 0); EXPECT(0.0f);
CONVERT(VarR4FromUI4, 1); EXPECT(1.0f);
#if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
{
CONVVARS(FLOAT);
- CHECKPTR(VarR4FromR8);
CONVERT(VarR4FromR8, -1.0); EXPECT(-1.0f);
CONVERT(VarR4FromR8, 0.0); EXPECT(0.0f);
CONVERT(VarR4FromR8, 1.0); EXPECT(1.0f);
{
CONVVARS(VARIANT_BOOL);
- CHECKPTR(VarR4FromBool);
CONVERT(VarR4FromBool, VARIANT_TRUE); EXPECT(VARIANT_TRUE * 1.0f);
CONVERT(VarR4FromBool, VARIANT_FALSE); EXPECT(VARIANT_FALSE * 1.0f);
}
{
CONVVARS(CY);
- CHECKPTR(VarR4FromCy);
CONVERT_CY(VarR4FromCy,-32768); EXPECT(-32768.0f);
CONVERT_CY(VarR4FromCy,-1); EXPECT(-1.0f);
CONVERT_CY(VarR4FromCy,0); EXPECT(0.0f);
{
CONVVARS(LONG64);
- CHECKPTR(VarR4FromI8);
CONVERT(VarR4FromI8, -1); EXPECT(-1.0f);
CONVERT(VarR4FromI8, 0); EXPECT(0.0f);
CONVERT(VarR4FromI8, 1); EXPECT(1.0f);
{
CONVVARS(ULONG64);
- CHECKPTR(VarR4FromUI8);
CONVERT(VarR4FromUI8, 0); EXPECT(0.0f);
CONVERT(VarR4FromUI8, 1); EXPECT(1.0f);
}
{
CONVVARS(DECIMAL);
- CHECKPTR(VarR4FromDec);
-
CONVERT_BADDEC(VarR4FromDec);
CONVERT_DEC(VarR4FromDec,0,0x80,0,32768); EXPECT(-32768.0f);
{
CONVVARS(DATE);
- CHECKPTR(VarR4FromDate);
CONVERT(VarR4FromDate, -1.0); EXPECT(-1.0f);
CONVERT(VarR4FromDate, 0.0); EXPECT(0.0f);
CONVERT(VarR4FromDate, 1.0); EXPECT(1.0f);
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarR4FromStr);
-
CONVERT_STR(VarR4FromStr,NULL,0); EXPECT_MISMATCH;
CONVERT_STR(VarR4FromStr,"-1", 0); EXPECT(-1.0f);
CONVERT_STR(VarR4FromStr,"0", 0); EXPECT(0.0f);
CONVVARS(signed char);
int i;
- CHECKPTR(VarR8FromI1);
CONVERTRANGE(VarR8FromI1, -128, 128);
}
CONVVARS(BYTE);
int i;
- CHECKPTR(VarR8FromUI1);
CONVERTRANGE(VarR8FromUI1, 0, 256);
}
CONVVARS(SHORT);
int i;
- CHECKPTR(VarR8FromI2);
CONVERTRANGE(VarR8FromI2, -32768, 32768);
}
CONVVARS(USHORT);
int i;
- CHECKPTR(VarR8FromUI2);
CONVERTRANGE(VarR8FromUI2, 0, 65536);
}
{
CONVVARS(int);
- CHECKPTR(VarR8FromI4);
CONVERT(VarR8FromI4, -2147483647-1); EXPECT(-2147483648.0);
CONVERT(VarR8FromI4, -1); EXPECT(-1.0);
CONVERT(VarR8FromI4, 0); EXPECT(0.0);
{
CONVVARS(unsigned int);
- CHECKPTR(VarR8FromUI4);
CONVERT(VarR8FromUI4, 0); EXPECT(0.0);
CONVERT(VarR8FromUI4, 1); EXPECT(1.0);
CONVERT(VarR8FromUI4, 0xffffffff); EXPECT(4294967295.0);
{
CONVVARS(FLOAT);
- CHECKPTR(VarR8FromR4);
CONVERT(VarR8FromR4, -1.0f); EXPECT(-1.0);
CONVERT(VarR8FromR4, 0.0f); EXPECT(0.0);
CONVERT(VarR8FromR4, 1.0f); EXPECT(1.0);
{
CONVVARS(VARIANT_BOOL);
- CHECKPTR(VarR8FromBool);
CONVERT(VarR8FromBool, VARIANT_TRUE); EXPECT(VARIANT_TRUE * 1.0);
CONVERT(VarR8FromBool, VARIANT_FALSE); EXPECT(VARIANT_FALSE * 1.0);
}
{
CONVVARS(CY);
- CHECKPTR(VarR8FromCy);
CONVERT_CY(VarR8FromCy,-32769); EXPECT(-32769.0);
CONVERT_CY(VarR8FromCy,-32768); EXPECT(-32768.0);
CONVERT_CY(VarR8FromCy,-1); EXPECT(-1.0);
{
CONVVARS(LONG64);
- CHECKPTR(VarR8FromI8);
CONVERT(VarR8FromI8, -1); EXPECT(-1.0);
CONVERT(VarR8FromI8, 0); EXPECT(0.0);
CONVERT(VarR8FromI8, 1); EXPECT(1.0);
{
CONVVARS(ULONG64);
- CHECKPTR(VarR8FromUI8);
CONVERT(VarR8FromUI8, 0); EXPECT(0.0);
CONVERT(VarR8FromUI8, 1); EXPECT(1.0);
#if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
{
CONVVARS(DECIMAL);
- CHECKPTR(VarR8FromDec);
-
CONVERT_BADDEC(VarR8FromDec);
CONVERT_DEC(VarR8FromDec,0,0x80,0,32768); EXPECT(-32768.0);
{
CONVVARS(DATE);
- CHECKPTR(VarR8FromDate);
CONVERT(VarR8FromDate, -1.0); EXPECT(-1.0);
CONVERT(VarR8FromDate, -0.0); EXPECT(0.0);
CONVERT(VarR8FromDate, 1.0); EXPECT(1.0);
in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarR8FromStr);
-
CONVERT_STR(VarR8FromStr,NULL,0); EXPECT_MISMATCH;
CONVERT_STR(VarR8FromStr,"",0); EXPECT_MISMATCH;
CONVERT_STR(VarR8FromStr," ",0); EXPECT_MISMATCH;
#endif
}
-#define MATHRND(l, r) left = l; right = r; hres = pVarR8Round(left, right, &out)
+#define MATHRND(l, r) left = l; right = r; hres = VarR8Round(left, right, &out)
static void test_VarR8Round(void)
{
double left = 0.0, out;
int right;
- CHECKPTR(VarR8Round);
MATHRND(0.5432, 5); EXPECT(0.5432);
MATHRND(0.5432, 4); EXPECT(0.5432);
MATHRND(0.5432, 3); EXPECT(0.543);
CONVVARS(signed char);
int i;
- CHECKPTR(VarDateFromI1);
CONVERTRANGE(VarDateFromI1, -128, 128);
}
CONVVARS(BYTE);
int i;
- CHECKPTR(VarDateFromUI1);
CONVERTRANGE(VarDateFromUI1, 0, 256);
}
CONVVARS(SHORT);
int i;
- CHECKPTR(VarDateFromI2);
CONVERTRANGE(VarDateFromI2, -32768, 32768);
}
CONVVARS(USHORT);
int i;
- CHECKPTR(VarDateFromUI2);
CONVERTRANGE(VarDateFromUI2, 0, 65536);
}
{
CONVVARS(int);
- CHECKPTR(VarDateFromI4);
CONVERT(VarDateFromI4, DATE_MIN-1);
if (hres != DISP_E_TYPEMISMATCH) /* Early versions return this, incorrectly */
EXPECT_OVERFLOW;
{
CONVVARS(unsigned int);
- CHECKPTR(VarDateFromUI4);
CONVERT(VarDateFromUI4, 0); EXPECT(0.0);
CONVERT(VarDateFromUI4, 1); EXPECT(1.0);
CONVERT(VarDateFromUI4, DATE_MAX); EXPECT(DATE_MAX);
{
CONVVARS(FLOAT);
- CHECKPTR(VarDateFromR4);
CONVERT(VarDateFromR4, -1.0f); EXPECT(-1.0);
CONVERT(VarDateFromR4, 0.0f); EXPECT(0.0);
CONVERT(VarDateFromR4, 1.0f); EXPECT(1.0);
{
CONVVARS(double);
- CHECKPTR(VarDateFromR8);
CONVERT(VarDateFromR8, -1.0f); EXPECT(-1.0);
CONVERT(VarDateFromR8, 0.0f); EXPECT(0.0);
CONVERT(VarDateFromR8, 1.0f); EXPECT(1.0);
{
CONVVARS(VARIANT_BOOL);
- CHECKPTR(VarDateFromBool);
CONVERT(VarDateFromBool, VARIANT_TRUE); EXPECT(VARIANT_TRUE * 1.0);
CONVERT(VarDateFromBool, VARIANT_FALSE); EXPECT(VARIANT_FALSE * 1.0);
}
{
CONVVARS(CY);
- CHECKPTR(VarDateFromCy);
CONVERT_CY(VarDateFromCy,-32769); EXPECT(-32769.0);
CONVERT_CY(VarDateFromCy,-32768); EXPECT(-32768.0);
CONVERT_CY(VarDateFromCy,-1); EXPECT(-1.0);
{
CONVVARS(LONG64);
- CHECKPTR(VarDateFromI8);
CONVERT(VarDateFromI8, DATE_MIN-1); EXPECT_OVERFLOW;
CONVERT(VarDateFromI8, DATE_MIN); EXPECT(DATE_MIN);
CONVERT(VarDateFromI8, -1); EXPECT(-1.0);
{
CONVVARS(ULONG64);
- CHECKPTR(VarDateFromUI8);
CONVERT(VarDateFromUI8, 0); EXPECT(0.0);
CONVERT(VarDateFromUI8, 1); EXPECT(1.0);
CONVERT(VarDateFromUI8, DATE_MAX); EXPECT(DATE_MAX);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarDateFromDec);
-
CONVERT_BADDEC(VarDateFromDec);
CONVERT_DEC(VarDateFromDec,0,0x80,0,32768); EXPECT(-32768.0);
#define DFS(str) \
buff[0] = '\0'; out = 0.0; \
if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,sizeof(buff)/sizeof(WCHAR)); \
- hres = pVarDateFromStr(str ? buff : NULL,lcid,LOCALE_NOUSEROVERRIDE,&out)
+ hres = VarDateFromStr(str ? buff : NULL,lcid,LOCALE_NOUSEROVERRIDE,&out)
#define MKRELDATE(day,mth) st.wMonth = mth; st.wDay = day; \
- pSystemTimeToVariantTime(&st,&relative)
+ SystemTimeToVariantTime(&st,&relative)
static const char * const BadDateStrings[] =
{
lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
- CHECKPTR(VarDateFromStr);
- CHECKPTR(SystemTimeToVariantTime);
-
/* Some date formats are relative, so we need to find the current year */
GetSystemTime(&st);
st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
/* test a data with ideographic space */
out = 0.0;
- hres = pVarDateFromStr(with_ideographic_spaceW, lcid, LOCALE_NOUSEROVERRIDE, &out);
+ hres = VarDateFromStr(with_ideographic_spaceW, lcid, LOCALE_NOUSEROVERRIDE, &out);
EXPECT_DBL(40724.05594907407);
/* test a non-english data string */
CONVVARS(signed char);
int i;
- CHECKPTR(VarCyFromI1);
for (i = -128; i < 128; i++)
{
CONVERT(VarCyFromI1,i); EXPECTCY(i);
CONVVARS(BYTE);
int i;
- CHECKPTR(VarCyFromUI1);
for (i = 0; i < 256; i++)
{
CONVERT(VarCyFromUI1,i); EXPECTCY(i);
CONVVARS(SHORT);
int i;
- CHECKPTR(VarCyFromI2);
for (i = -16384; i < 16384; i++)
{
CONVERT(VarCyFromI2,i); EXPECTCY(i);
CONVVARS(int);
int i;
- CHECKPTR(VarCyFromUI2);
for (i = 0; i < 32768; i++)
{
CONVERT(VarCyFromUI2,i); EXPECTCY(i);
{
CONVVARS(int);
- CHECKPTR(VarCyFromI4);
CONVERT(VarCyFromI4, -1); EXPECTCY(-1);
CONVERT(VarCyFromI4, 0); EXPECTCY(0);
CONVERT(VarCyFromI4, 1); EXPECTCY(1);
{
CONVVARS(unsigned int);
- CHECKPTR(VarCyFromUI4);
CONVERT(VarCyFromUI4, 0); EXPECTCY(0);
CONVERT(VarCyFromUI4, 1); EXPECTCY(1);
CONVERT(VarCyFromUI4, 0x80000000); EXPECTCY64(5000, 0);
{
CONVVARS(FLOAT);
- CHECKPTR(VarCyFromR4);
CONVERT(VarCyFromR4, -1.0f); EXPECTCY(-1);
CONVERT(VarCyFromR4, 0.0f); EXPECTCY(0);
CONVERT(VarCyFromR4, 1.0f); EXPECTCY(1);
{
CONVVARS(DOUBLE);
- CHECKPTR(VarCyFromR8);
-
#if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
/* Test our rounding is exactly the same. This fails if the special x86
* code is taken out of VarCyFromR8.
CONVVARS(VARIANT_BOOL);
int i;
- CHECKPTR(VarCyFromBool);
for (i = -32768; i < 32768; i++)
{
CONVERT(VarCyFromBool, i); EXPECTCY(i);
{
CONVVARS(LONG64);
- CHECKPTR(VarCyFromI8);
CONVERT_I8(VarCyFromI8, -214749, 2728163227ul); EXPECT_OVERFLOW;
CONVERT_I8(VarCyFromI8, -214749, 2728163228ul); EXPECTCY64(2147483648ul,15808);
CONVERT(VarCyFromI8, -1); EXPECTCY(-1);
{
CONVVARS(ULONG64);
- CHECKPTR(VarCyFromUI8);
CONVERT(VarCyFromUI8, 0); EXPECTCY(0);
CONVERT(VarCyFromUI8, 1); EXPECTCY(1);
CONVERT_I8(VarCyFromUI8, 214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
{
CONVVARS(DECIMAL);
- CHECKPTR(VarCyFromDec);
-
CONVERT_BADDEC(VarCyFromDec);
CONVERT_DEC(VarCyFromDec,0,0x80,0,1); EXPECTCY(-1);
{
CONVVARS(DATE);
- CHECKPTR(VarCyFromDate);
-
#if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
CONVERT(VarCyFromR8, -461168601842738.7904); EXPECTCY64(0xbfffffff, 0xffffff23);
#endif
#define MATHVARS1 HRESULT hres; double left = 0.0; CY cyLeft, out
#define MATHVARS2 MATHVARS1; double right = 0.0; CY cyRight
-#define MATH1(func, l) left = (double)l; pVarCyFromR8(left, &cyLeft); hres = p##func(cyLeft, &out)
+#define MATH1(func, l) left = (double)l; VarCyFromR8(left, &cyLeft); hres = func(cyLeft, &out)
#define MATH2(func, l, r) left = (double)l; right = (double)r; \
- pVarCyFromR8(left, &cyLeft); pVarCyFromR8(right, &cyRight); \
- hres = p##func(cyLeft, cyRight, &out)
+ VarCyFromR8(left, &cyLeft); VarCyFromR8(right, &cyRight); \
+ hres = func(cyLeft, cyRight, &out)
static void test_VarCyAdd(void)
{
MATHVARS2;
- CHECKPTR(VarCyAdd);
MATH2(VarCyAdd, 0.5, 0.5); EXPECTCY(1);
MATH2(VarCyAdd, 0.5, -0.4); EXPECTCY(0.1);
MATH2(VarCyAdd, 0.5, -0.6); EXPECTCY(-0.1);
{
MATHVARS2;
- CHECKPTR(VarCyMul);
MATH2(VarCyMul, 534443.0, 0.0); EXPECTCY(0);
MATH2(VarCyMul, 0.5, 0.5); EXPECTCY(0.25);
MATH2(VarCyMul, 0.5, -0.4); EXPECTCY(-0.2);
{
MATHVARS2;
- CHECKPTR(VarCySub);
MATH2(VarCySub, 0.5, 0.5); EXPECTCY(0);
MATH2(VarCySub, 0.5, -0.4); EXPECTCY(0.9);
MATH2(VarCySub, 0.5, -0.6); EXPECTCY(1.1);
{
MATHVARS1;
- CHECKPTR(VarCyAbs);
MATH1(VarCyAbs, 0.5); EXPECTCY(0.5);
MATH1(VarCyAbs, -0.5); EXPECTCY(0.5);
MATH1(VarCyAbs, 922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
{
MATHVARS1;
- CHECKPTR(VarCyNeg);
MATH1(VarCyNeg, 0.5); EXPECTCY(-0.5);
MATH1(VarCyNeg, -0.5); EXPECTCY(0.5);
MATH1(VarCyNeg, 922337203685476.0); EXPECTCY64(2147483648ul,15808);
MATH1(VarCyNeg, -922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
}
-#define MATHMULI4(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
- hres = pVarCyMulI4(cyLeft, right, &out)
+#define MATHMULI4(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); \
+ hres = VarCyMulI4(cyLeft, right, &out)
static void test_VarCyMulI4(void)
{
MATHVARS1;
LONG right;
- CHECKPTR(VarCyMulI4);
MATHMULI4(534443.0, 0); EXPECTCY(0);
MATHMULI4(0.5, 1); EXPECTCY(0.5);
MATHMULI4(0.5, 2); EXPECTCY(1);
MATHMULI4(922337203685476.0, 2); EXPECT_OVERFLOW;
}
-#define MATHMULI8(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
- hres = pVarCyMulI8(cyLeft, right, &out)
+#define MATHMULI8(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); \
+ hres = VarCyMulI8(cyLeft, right, &out)
static void test_VarCyMulI8(void)
{
MATHVARS1;
LONG64 right;
- CHECKPTR(VarCyMulI8);
MATHMULI8(534443.0, 0); EXPECTCY(0);
MATHMULI8(0.5, 1); EXPECTCY(0.5);
MATHMULI8(0.5, 2); EXPECTCY(1);
MATHMULI8(922337203685476.0, 2); EXPECT_OVERFLOW;
}
-#define MATHCMP(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); pVarCyFromR8(right, &cyRight); \
- hres = pVarCyCmp(cyLeft, cyRight)
+#define MATHCMP(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); VarCyFromR8(right, &cyRight); \
+ hres = VarCyCmp(cyLeft, cyRight)
static void test_VarCyCmp(void)
{
double left = 0.0, right = 0.0;
CY cyLeft, cyRight;
- CHECKPTR(VarCyCmp);
MATHCMP(-1.0, -1.0); EXPECT_EQ;
MATHCMP(-1.0, 0.0); EXPECT_LT;
MATHCMP(-1.0, 1.0); EXPECT_LT;
MATHCMP(1.0, 2.0); EXPECT_LT;
}
-#define MATHCMPR8(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
- hres = pVarCyCmpR8(cyLeft, right);
+#define MATHCMPR8(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); \
+ hres = VarCyCmpR8(cyLeft, right);
static void test_VarCyCmpR8(void)
{
CY cyLeft;
double right;
- CHECKPTR(VarCyCmpR8);
MATHCMPR8(-1.0, -1.0); EXPECT_EQ;
MATHCMPR8(-1.0, 0.0); EXPECT_LT;
MATHCMPR8(-1.0, 1.0); EXPECT_LT;
}
#undef MATHRND
-#define MATHRND(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
- hres = pVarCyRound(cyLeft, right, &out)
+#define MATHRND(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); \
+ hres = VarCyRound(cyLeft, right, &out)
static void test_VarCyRound(void)
{
MATHVARS1;
int right;
- CHECKPTR(VarCyRound);
MATHRND(0.5432, 5); EXPECTCY(0.5432);
MATHRND(0.5432, 4); EXPECTCY(0.5432);
MATHRND(0.5432, 3); EXPECTCY(0.543);
MATHRND(1.5001, 0); EXPECTCY(2);
}
-#define MATHFIX(l) left = l; pVarCyFromR8(left, &cyLeft); \
- hres = pVarCyFix(cyLeft, &out)
+#define MATHFIX(l) left = l; VarCyFromR8(left, &cyLeft); \
+ hres = VarCyFix(cyLeft, &out)
static void test_VarCyFix(void)
{
MATHVARS1;
- CHECKPTR(VarCyFix);
MATHFIX(-1.0001); EXPECTCY(-1);
MATHFIX(-1.4999); EXPECTCY(-1);
MATHFIX(-1.5001); EXPECTCY(-1);
MATHFIX(1.9999); EXPECTCY(1);
}
-#define MATHINT(l) left = l; pVarCyFromR8(left, &cyLeft); \
- hres = pVarCyInt(cyLeft, &out)
+#define MATHINT(l) left = l; VarCyFromR8(left, &cyLeft); \
+ hres = VarCyInt(cyLeft, &out)
static void test_VarCyInt(void)
{
MATHVARS1;
- CHECKPTR(VarCyInt);
MATHINT(-1.0001); EXPECTCY(-2);
MATHINT(-1.4999); EXPECTCY(-2);
MATHINT(-1.5001); EXPECTCY(-2);
CONVVARS(signed char);
int i;
- CHECKPTR(VarDecFromI1);
for (i = -128; i < 128; i++)
{
CONVERT(VarDecFromI1,i); EXPECTDECI;
CONVVARS(SHORT);
int i;
- CHECKPTR(VarDecFromI2);
for (i = -32768; i < 32768; i++)
{
CONVERT(VarDecFromI2,i); EXPECTDECI;
CONVVARS(LONG);
int i;
- CHECKPTR(VarDecFromI4);
for (i = -32768; i < 32768; i++)
{
CONVERT(VarDecFromI4,i); EXPECTDECI;
CONVVARS(LONG64);
int i;
- CHECKPTR(VarDecFromI8);
for (i = -32768; i < 32768; i++)
{
CONVERT(VarDecFromI8,i); EXPECTDECI;
CONVVARS(BYTE);
int i;
- CHECKPTR(VarDecFromUI1);
for (i = 0; i < 256; i++)
{
CONVERT(VarDecFromUI1,i); EXPECTDECI;
CONVVARS(USHORT);
int i;
- CHECKPTR(VarDecFromUI2);
for (i = 0; i < 65536; i++)
{
CONVERT(VarDecFromUI2,i); EXPECTDECI;
CONVVARS(ULONG);
int i;
- CHECKPTR(VarDecFromUI4);
for (i = 0; i < 65536; i++)
{
CONVERT(VarDecFromUI4,i); EXPECTDECI;
CONVVARS(ULONG64);
int i;
- CHECKPTR(VarDecFromUI8);
for (i = 0; i < 65536; i++)
{
CONVERT(VarDecFromUI8,i); EXPECTDECI;
CONVVARS(SHORT);
int i;
- CHECKPTR(VarDecFromBool);
/* Test all possible type values. Note that the result is reduced to 0 or -1 */
for (i = -32768; i < 0; i++)
{
{
CONVVARS(float);
- CHECKPTR(VarDecFromR4);
-
CONVERT(VarDecFromR4,-0.6f); EXPECTDEC(1,0x80,0,6);
CONVERT(VarDecFromR4,-0.5f); EXPECTDEC(1,0x80,0,5);
CONVERT(VarDecFromR4,-0.4f); EXPECTDEC(1,0x80,0,4);
{
CONVVARS(double);
- CHECKPTR(VarDecFromR8);
-
CONVERT(VarDecFromR8,-0.6); EXPECTDEC(1,0x80,0,6);
CONVERT(VarDecFromR8,-0.5); EXPECTDEC(1,0x80,0,5);
CONVERT(VarDecFromR8,-0.4); EXPECTDEC(1,0x80,0,4);
{
CONVVARS(DATE);
- CHECKPTR(VarDecFromDate);
-
CONVERT(VarDecFromDate,-0.6); EXPECTDEC(1,0x80,0,6);
CONVERT(VarDecFromDate,-0.5); EXPECTDEC(1,0x80,0,5);
CONVERT(VarDecFromDate,-0.4); EXPECTDEC(1,0x80,0,4);
CONVVARS(LCID);
OLECHAR buff[128];
- CHECKPTR(VarDecFromStr);
-
in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
CONVERT_STR(VarDecFromStr,NULL,0); EXPECT_MISMATCH;
{
CONVVARS(CY);
- CHECKPTR(VarDecFromCy);
-
CONVERT_CY(VarDecFromCy, -1); EXPECTDEC(4,0x80,0,10000);
CONVERT_CY(VarDecFromCy, 0); EXPECTDEC(4,0,0,0);
CONVERT_CY(VarDecFromCy, 1); EXPECTDEC(4,0,0,10000);
#undef MATHVARS2
#define MATHVARS2 MATHVARS1; DECIMAL r
#undef MATH1
-#define MATH1(func) hres = p##func(&l, &out)
+#define MATH1(func) hres = func(&l, &out)
#undef MATH2
-#define MATH2(func) hres = p##func(&l, &r, &out)
+#define MATH2(func) hres = func(&l, &r, &out)
#undef MATH3
-#define MATH3(func) hres = p##func(&l, r)
+#define MATH3(func) hres = func(&l, r)
static void test_VarDecAbs(void)
{
MATHVARS1;
- CHECKPTR(VarDecAbs);
SETDEC(l,0,0x80,0,1); MATH1(VarDecAbs); EXPECTDEC(0,0,0,1);
SETDEC(l,0,0,0,0); MATH1(VarDecAbs); EXPECTDEC(0,0,0,0);
SETDEC(l,0,0x80,0,0); MATH1(VarDecAbs); EXPECTDEC(0,0,0,0);
{
MATHVARS1;
- CHECKPTR(VarDecNeg);
SETDEC(l,0,0x80,0,1); MATH1(VarDecNeg); EXPECTDEC(0,0,0,1);
SETDEC(l,0,0,0,0); MATH1(VarDecNeg); EXPECTDEC(0,0x80,0,0); /* '-0'! */
SETDEC(l,0,0x80,0,0); MATH1(VarDecNeg); EXPECTDEC(0,0,0,0);
{
MATHVARS2;
- CHECKPTR(VarDecAdd);
SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecAdd); EXPECTDEC(0,0,0,0);
SETDEC(l,0,0,0,0); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
{
MATHVARS2;
- CHECKPTR(VarDecSub);
SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecSub); EXPECTDECZERO();
SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecSub); EXPECTDEC(0,0x80,0,1);
SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecSub); EXPECTDECZERO();
{
MATHVARS2;
- CHECKPTR(VarDecMul);
SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecMul); EXPECTDEC(0,0,0,0);
SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,0); MATH2(VarDecMul); EXPECTDEC(0,0,0,0);
SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecMul); EXPECTDEC(0,0,0,0);
{
MATHVARS2;
- CHECKPTR(VarDecDiv);
/* identity divisions */
SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecDiv); EXPECTDEC(0,0,0,0);
SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecDiv); EXPECTDEC(0,0,0,1);
{
MATHVARS1;
- CHECKPTR(VarDecCmp);
-
SETDEC(l,0,0,0,1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_EQ;
SETDEC(l,0,0,0,1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
SETDEC(l,0,0,0,1); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
DECIMAL l;
double r;
- CHECKPTR(VarDecCmpR8);
-
SETDEC(l,0,0,0,1); r = 0.0; MATH3(VarDecCmpR8); EXPECT_GT;
SETDEC(l,0,0,0,1); r = 0.1; MATH3(VarDecCmpR8); EXPECT_GT;
SETDEC(l,0,0,0,1); r = -0.1; MATH3(VarDecCmpR8); EXPECT_GT;
HRESULT hres;
DECIMAL l, out;
- CHECKPTR(VarDecRound);
-
- CLEAR(out); SETDEC(l, 0, 0, 0, 1); hres = pVarDecRound(&l, 3, &out); EXPECTDEC(0, 0, 0, 1);
+ CLEAR(out); SETDEC(l, 0, 0, 0, 1); hres = VarDecRound(&l, 3, &out); EXPECTDEC(0, 0, 0, 1);
- CLEAR(out); SETDEC(l, 0, 0, 0, 1); hres = pVarDecRound(&l, 0, &out); EXPECTDEC(0, 0, 0, 1);
- CLEAR(out); SETDEC(l, 1, 0, 0, 1); hres = pVarDecRound(&l, 0, &out); EXPECTDEC(0, 0, 0, 0);
- CLEAR(out); SETDEC(l, 1, 0, 0, 1); hres = pVarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 1);
- CLEAR(out); SETDEC(l, 2, 0, 0, 11); hres = pVarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 1);
- CLEAR(out); SETDEC(l, 2, 0, 0, 15); hres = pVarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 2);
- CLEAR(out); SETDEC(l, 6, 0, 0, 550001); hres = pVarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 6);
+ CLEAR(out); SETDEC(l, 0, 0, 0, 1); hres = VarDecRound(&l, 0, &out); EXPECTDEC(0, 0, 0, 1);
+ CLEAR(out); SETDEC(l, 1, 0, 0, 1); hres = VarDecRound(&l, 0, &out); EXPECTDEC(0, 0, 0, 0);
+ CLEAR(out); SETDEC(l, 1, 0, 0, 1); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 1);
+ CLEAR(out); SETDEC(l, 2, 0, 0, 11); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 1);
+ CLEAR(out); SETDEC(l, 2, 0, 0, 15); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 2);
+ CLEAR(out); SETDEC(l, 6, 0, 0, 550001); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 6);
- CLEAR(out); SETDEC(l, 0, DECIMAL_NEG, 0, 1); hres = pVarDecRound(&l, 0, &out); EXPECTDEC(0, DECIMAL_NEG, 0, 1);
- CLEAR(out); SETDEC(l, 1, DECIMAL_NEG, 0, 1); hres = pVarDecRound(&l, 0, &out); EXPECTDEC(0, DECIMAL_NEG, 0, 0);
- CLEAR(out); SETDEC(l, 1, DECIMAL_NEG, 0, 1); hres = pVarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 1);
- CLEAR(out); SETDEC(l, 2, DECIMAL_NEG, 0, 11); hres = pVarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 1);
- CLEAR(out); SETDEC(l, 2, DECIMAL_NEG, 0, 15); hres = pVarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 2);
- CLEAR(out); SETDEC(l, 6, DECIMAL_NEG, 0, 550001); hres = pVarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 6);
+ CLEAR(out); SETDEC(l, 0, DECIMAL_NEG, 0, 1); hres = VarDecRound(&l, 0, &out); EXPECTDEC(0, DECIMAL_NEG, 0, 1);
+ CLEAR(out); SETDEC(l, 1, DECIMAL_NEG, 0, 1); hres = VarDecRound(&l, 0, &out); EXPECTDEC(0, DECIMAL_NEG, 0, 0);
+ CLEAR(out); SETDEC(l, 1, DECIMAL_NEG, 0, 1); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 1);
+ CLEAR(out); SETDEC(l, 2, DECIMAL_NEG, 0, 11); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 1);
+ CLEAR(out); SETDEC(l, 2, DECIMAL_NEG, 0, 15); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 2);
+ CLEAR(out); SETDEC(l, 6, DECIMAL_NEG, 0, 550001); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 6);
- CLEAR(out); SETDEC64(l, 0, 0, 0xffffffff, 0xffffffff, 0xffffffff); hres = pVarDecRound(&l, 0, &out); EXPECTDEC64(0, 0, 0xffffffff, 0xffffffff, 0xffffffff);
- CLEAR(out); SETDEC64(l, 28, 0, 0xffffffff, 0xffffffff, 0xffffffff); hres = pVarDecRound(&l, 0, &out); EXPECTDEC64(0, 0, 0, 0, 8);
- CLEAR(out); SETDEC64(l, 0, DECIMAL_NEG, 0xffffffff, 0xffffffff, 0xffffffff); hres = pVarDecRound(&l, 0, &out); EXPECTDEC64(0, DECIMAL_NEG, 0xffffffff, 0xffffffff, 0xffffffff);
- CLEAR(out); SETDEC64(l, 28, DECIMAL_NEG, 0xffffffff, 0xffffffff, 0xffffffff); hres = pVarDecRound(&l, 0, &out); EXPECTDEC64(0, DECIMAL_NEG, 0, 0, 8);
+ CLEAR(out); SETDEC64(l, 0, 0, 0xffffffff, 0xffffffff, 0xffffffff); hres = VarDecRound(&l, 0, &out); EXPECTDEC64(0, 0, 0xffffffff, 0xffffffff, 0xffffffff);
+ CLEAR(out); SETDEC64(l, 28, 0, 0xffffffff, 0xffffffff, 0xffffffff); hres = VarDecRound(&l, 0, &out); EXPECTDEC64(0, 0, 0, 0, 8);
+ CLEAR(out); SETDEC64(l, 0, DECIMAL_NEG, 0xffffffff, 0xffffffff, 0xffffffff); hres = VarDecRound(&l, 0, &out); EXPECTDEC64(0, DECIMAL_NEG, 0xffffffff, 0xffffffff, 0xffffffff);
+ CLEAR(out); SETDEC64(l, 28, DECIMAL_NEG, 0xffffffff, 0xffffffff, 0xffffffff); hres = VarDecRound(&l, 0, &out); EXPECTDEC64(0, DECIMAL_NEG, 0, 0, 8);
- CLEAR(out); SETDEC(l, 2, 0, 0, 0); hres = pVarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 0);
+ CLEAR(out); SETDEC(l, 2, 0, 0, 0); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 0);
}
/*
CONVVARS(signed char);
int i;
- CHECKPTR(VarBoolFromI1);
CONVERTRANGE(VarBoolFromI1, -128, 128);
}
CONVVARS(BYTE);
int i;
- CHECKPTR(VarBoolFromUI1);
CONVERTRANGE(VarBoolFromUI1, 0, 256);
}
CONVVARS(SHORT);
int i;
- CHECKPTR(VarBoolFromI2);
CONVERTRANGE(VarBoolFromI2, -32768, 32768);
}
CONVVARS(USHORT);
int i;
- CHECKPTR(VarBoolFromUI2);
CONVERTRANGE(VarBoolFromUI2, 0, 65536);
}
{
CONVVARS(int);
- CHECKPTR(VarBoolFromI4);
CONVERT(VarBoolFromI4, 0x80000000); EXPECT(VARIANT_TRUE);
CONVERT(VarBoolFromI4, -1); EXPECT(VARIANT_TRUE);
CONVERT(VarBoolFromI4, 0); EXPECT(VARIANT_FALSE);
{
CONVVARS(ULONG);
- CHECKPTR(VarBoolFromUI4);
CONVERT(VarBoolFromI4, 0); EXPECT(VARIANT_FALSE);
CONVERT(VarBoolFromI4, 1); EXPECT(VARIANT_TRUE);
CONVERT(VarBoolFromI4, 0x80000000); EXPECT(VARIANT_TRUE);
{
CONVVARS(FLOAT);
- CHECKPTR(VarBoolFromR4);
CONVERT(VarBoolFromR4, -1.0f); EXPECT(VARIANT_TRUE);
CONVERT(VarBoolFromR4, 0.0f); EXPECT(VARIANT_FALSE);
CONVERT(VarBoolFromR4, 1.0f); EXPECT(VARIANT_TRUE);
/* Hopefully we made the point with R4 above that rounding is
* irrelevant, so we'll skip that for R8 and Date
*/
- CHECKPTR(VarBoolFromR8);
CONVERT(VarBoolFromR8, -1.0); EXPECT(VARIANT_TRUE);
CONVERT(VarBoolFromR8, -0.0); EXPECT(VARIANT_FALSE);
CONVERT(VarBoolFromR8, 1.0); EXPECT(VARIANT_TRUE);
{
CONVVARS(CY);
- CHECKPTR(VarBoolFromCy);
CONVERT_CY(VarBoolFromCy, -32769); EXPECT(VARIANT_TRUE);
CONVERT_CY(VarBoolFromCy, -32768); EXPECT(VARIANT_TRUE);
CONVERT_CY(VarBoolFromCy, -1); EXPECT(VARIANT_TRUE);
{
CONVVARS(LONG64);
- CHECKPTR(VarBoolFromI8);
CONVERT(VarBoolFromI8, -1); EXPECT(VARIANT_TRUE);
CONVERT(VarBoolFromI8, 0); EXPECT(VARIANT_FALSE);
CONVERT(VarBoolFromI8, 1); EXPECT(VARIANT_TRUE);
{
CONVVARS(ULONG64);
- CHECKPTR(VarBoolFromUI8);
CONVERT(VarBoolFromUI8, 0); EXPECT(VARIANT_FALSE);
CONVERT(VarBoolFromUI8, 1); EXPECT(VARIANT_TRUE);
}
{
CONVVARS(DECIMAL);
- CHECKPTR(VarBoolFromDec);
CONVERT_BADDEC(VarBoolFromDec);
CONVERT_DEC(VarBoolFromDec,29,0,0,0); EXPECT_INVALID;
{
CONVVARS(DATE);
- CHECKPTR(VarBoolFromDate);
CONVERT(VarBoolFromDate, -1.0); EXPECT(VARIANT_TRUE);
CONVERT(VarBoolFromDate, -0.0); EXPECT(VARIANT_FALSE);
CONVERT(VarBoolFromDate, 1.0); EXPECT(VARIANT_TRUE);
CONVVARS(LCID);
OLECHAR buff[128];
- CHECKPTR(VarBoolFromStr);
-
in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
CONVERT_STR(VarBoolFromStr,NULL,0);
float f;
- CHECKPTR(VarBstrFromR4);
-
lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
lcid_spanish = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH), SORT_DEFAULT);
f = 654322.23456f;
- hres = pVarBstrFromR4(f, lcid, 0, &bstr);
+ hres = VarBstrFromR4(f, lcid, 0, &bstr);
ok(hres == S_OK, "got hres 0x%08x\n", hres);
if (bstr)
{
}
f = -0.0;
- hres = pVarBstrFromR4(f, lcid, 0, &bstr);
+ hres = VarBstrFromR4(f, lcid, 0, &bstr);
ok(hres == S_OK, "got hres 0x%08x\n", hres);
if (bstr)
{
/* The following tests that lcid is used for decimal separator even without LOCALE_USE_NLS */
f = 0.5;
- hres = pVarBstrFromR4(f, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
+ hres = VarBstrFromR4(f, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
ok(hres == S_OK, "got hres 0x%08x\n", hres);
if (bstr)
{
SysFreeString(bstr);
}
f = 0.5;
- hres = pVarBstrFromR4(f, lcid_spanish, LOCALE_NOUSEROVERRIDE, &bstr);
+ hres = VarBstrFromR4(f, lcid_spanish, LOCALE_NOUSEROVERRIDE, &bstr);
ok(hres == S_OK, "got hres 0x%08x\n", hres);
if (bstr)
{
BSTR bstr = NULL;
HRESULT hres;
- hres = pVarBstrFromDate(dt, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
+ hres = VarBstrFromDate(dt, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
if (bstr)
{
WideCharToMultiByte(CP_ACP, 0, bstr, -1, buff, sizeof(buff), 0, 0);
{
#define BSTR_DATE(dt,str) _BSTR_DATE(dt,str,__LINE__)
- CHECKPTR(VarBstrFromDate);
-
BSTR_DATE(0.0, "12:00:00 AM");
BSTR_DATE(3.34, "1/2/1900 8:09:36 AM");
BSTR_DATE(3339.34, "2/20/1909 8:09:36 AM");
S(l).Lo = b;
S(l).Hi = a;
- hr = pVarBstrFromCy(l, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
+ hr = VarBstrFromCy(l, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
ok(hr == S_OK, "got hr 0x%08x\n", hr);
if(bstr)
LCID en_us, sp;
- CHECKPTR(VarBstrFromCy);
-
en_us = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
sp = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_DEFAULT), SORT_DEFAULT);
DECIMAL dec;
SETDEC64(dec, scale, sign, hi, mid, lo);
- hr = pVarBstrFromDec(&dec, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
+ hr = VarBstrFromDec(&dec, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
ok_(__FILE__, line)(hr == S_OK, "got hr 0x%08x\n", hr);
if(bstr)
LCID en_us, sp;
- CHECKPTR(VarBstrFromDec);
-
en_us = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
sp = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_DEFAULT), SORT_DEFAULT);
}
#define _VARBSTRCMP(left,right,lcid,flags,result) \
- hres = pVarBstrCmp(left,right,lcid,flags); \
+ hres = VarBstrCmp(left,right,lcid,flags); \
ok(hres == result, "VarBstrCmp: expected " #result ", got hres=0x%x\n", hres)
#define VARBSTRCMP(left,right,flags,result) \
_VARBSTRCMP(left,right,lcid,flags,result)
static const char sbchr00[] = {0,0,0};
BSTR bstr, bstrempty, bstr2;
- CHECKPTR(VarBstrCmp);
-
lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
bstr = SysAllocString(sz);
bstrempty = SysAllocString(szempty);
BSTR str1, str2, res;
UINT len;
- CHECKPTR(VarBstrCat);
-
if (0)
{
/* Crash */
- pVarBstrCat(NULL, NULL, NULL);
+ VarBstrCat(NULL, NULL, NULL);
}
/* Concatenation of two NULL strings works */
- ret = pVarBstrCat(NULL, NULL, &res);
+ ret = VarBstrCat(NULL, NULL, &res);
ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
ok(res != NULL, "Expected a string\n");
ok(SysStringLen(res) == 0, "Expected a 0-length string\n");
str1 = SysAllocString(sz1);
/* Concatenation with one NULL arg */
- ret = pVarBstrCat(NULL, str1, &res);
+ ret = VarBstrCat(NULL, str1, &res);
ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
ok(res != NULL, "Expected a string\n");
ok(SysStringLen(res) == SysStringLen(str1), "Unexpected length\n");
ok(!memcmp(res, sz1, SysStringLen(str1)), "Unexpected value\n");
SysFreeString(res);
- ret = pVarBstrCat(str1, NULL, &res);
+ ret = VarBstrCat(str1, NULL, &res);
ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
ok(res != NULL, "Expected a string\n");
ok(SysStringLen(res) == SysStringLen(str1), "Unexpected length\n");
/* Concatenation of two zero-terminated strings */
str2 = SysAllocString(sz2);
- ret = pVarBstrCat(str1, str2, &res);
+ ret = VarBstrCat(str1, str2, &res);
ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
ok(res != NULL, "Expected a string\n");
ok(SysStringLen(res) == sizeof(sz1sz2) / sizeof(WCHAR) - 1,
str1 = SysAllocStringLen(s1, sizeof(s1) / sizeof(WCHAR));
str2 = SysAllocStringLen(s2, sizeof(s2) / sizeof(WCHAR));
- ret = pVarBstrCat(str1, str2, &res);
+ ret = VarBstrCat(str1, str2, &res);
ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
ok(res != NULL, "Expected a string\n");
ok(SysStringLen(res) == sizeof(s1s2) / sizeof(WCHAR),
len = SysStringLen(str2);
ok(len == (sizeof(str2A)-1)/sizeof(WCHAR), "got length %u\n", len);
- ret = pVarBstrCat(str1, str2, &res);
+ ret = VarBstrCat(str1, str2, &res);
ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
ok(res != NULL, "Expected a string\n");
len = (sizeof(str1A) + sizeof(str2A) - 2)/sizeof(WCHAR);
len = SysStringLen(str2);
ok(len == 0, "got length %u\n", len);
- ret = pVarBstrCat(str1, str2, &res);
+ ret = VarBstrCat(str1, str2, &res);
ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
ok(res != NULL, "Expected a string\n");
ok(SysStringLen(res) == 1, "got %d, expected 1\n", SysStringLen(res));
CUSTDATA ci;
unsigned i;
- CHECKPTR(ClearCustData);
-
ci.cCustData = NUM_CUST_ITEMS;
ci.prgCustData = CoTaskMemAlloc( sizeof(CUSTDATAITEM) * NUM_CUST_ITEMS );
for (i = 0; i < NUM_CUST_ITEMS; i++)
VariantInit(&ci.prgCustData[i].varValue);
- pClearCustData(&ci);
+ ClearCustData(&ci);
ok(!ci.cCustData && !ci.prgCustData, "ClearCustData didn't clear fields!\n");
}
projects / reactos.git / blobdiff