git.oblomov.eu Git - wine/blob - dlls/oleaut32/tests/vartype.c

   1 /*
   2  * Low level variant tests
   3  *
   4  * Copyright 2003 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "wine/test.h"
  22 #include "wine/unicode.h"
  23 #include "oleauto.h"
  24 #include <math.h>
  25
  26 /* Some Visual C++ versions choke on __uint64 to float conversions.
  27  * To fix this you need either VC++ 6.0 plus the processor pack
  28  * or Visual C++ >=7.0.
  29  */
  30 #ifndef _MSC_VER
  31 #  define HAS_UINT64_TO_FLOAT
  32 #else
  33 #  if _MSC_VER >= 1300
  34 #    define HAS_UINT64_TO_FLOAT
  35 #  else
  36 #    include <malloc.h>
  37 #    if defined(_mm_free)
  38 /*     _mm_free is defined if the Processor Pack has been installed */
  39 #      define HAS_UINT64_TO_FLOAT
  40 #    endif
  41
  42 #  endif
  43 #endif
  44
  45 static HMODULE hOleaut32;
  46
  47 /* Get a conversion function ptr, return if function not available */
  48 #define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
  49   if (!p##func) { \
  50     trace("function " # func " not available, not testing it\n"); return; }
  51
  52 /* Is a given function exported from oleaut32? */
  53 #define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
  54
  55 /* Have IRecordInfo data type? */
  56 #define HAVE_OLEAUT32_RECORD  HAVE_FUNC(SafeArraySetRecordInfo)
  57 /* Have DECIMAL data type with new error checking? */
  58 #define HAVE_OLEAUT32_DECIMAL HAVE_FUNC(VarDecAdd)
  59 /* Have CY data type? */
  60 #define HAVE_OLEAUT32_CY      HAVE_FUNC(VarCyAdd)
  61 /* Have I8/UI8 data type? */
  62 #define HAVE_OLEAUT32_I8      HAVE_FUNC(VarI8FromI1)
  63 /* Have proper locale conversions? */
  64 #define HAVE_OLEAUT32_LOCALES (HAVE_FUNC(GetVarConversionLocaleSetting) && HAVE_OLEAUT32_I8)
  65 /* Is this an ancient version with support for only I2/I4/R4/R8/DATE? */
  66 #define IS_ANCIENT (!HAVE_FUNC(VarI1FromI2))
  67 /* Is vt a type unavailable to ancient versions? */
  68 #define IS_MODERN_VTYPE(vt) (vt==VT_VARIANT||vt==VT_DECIMAL|| \
  69     vt==VT_I1||vt==VT_UI2||vt==VT_UI4||vt == VT_INT||vt == VT_UINT)
  70
  71 /* Macro for setting typ and initializing */
  72 /* First some dummy definitions*/
  73 int val_empty, val_null;
  74
  75 #define V_EMPTY(x) val_empty
  76 #define V_NULL(x) val_null
  77
  78 #define VARINIT( A, type, value)  V_VT(A) = VT##type; V##type(A) = value
  79
  80 /* Macro for VarCmp*/
  81
  82 #define VARCMP(left, ltype, lvalue, right, rtype, rvalue, lcid, flags) \
  83   VARINIT(left, ltype, lvalue); \
  84   VARINIT(right, rtype, rvalue); \
  85   hres = pVarCmp(left, right, lcid, flags)
  86
  87 /* Macros for converting and testing results */
  88 #define CONVVARS(typ) HRESULT hres; CONV_TYPE out; typ in
  89
  90 #define _EXPECTRES(res, x, fs) \
  91   ok((hres == S_OK && out == (CONV_TYPE)(x)) || ((HRESULT)res != S_OK && hres == (HRESULT)res), \
  92      "expected " #x ", got " fs "; hres=0x%08lx\n", out, hres)
  93 #define EXPECT(x)       EXPECTRES(S_OK, (x))
  94 #define EXPECT_OVERFLOW EXPECTRES(DISP_E_OVERFLOW, DISP_E_OVERFLOW)
  95 #define EXPECT_MISMATCH EXPECTRES(DISP_E_TYPEMISMATCH,DISP_E_TYPEMISMATCH)
  96 #define EXPECT_BADVAR   EXPECTRES(DISP_E_BADVARTYPE, DISP_E_BADVARTYPE)
  97 #define EXPECT_INVALID  EXPECTRES(E_INVALIDARG, E_INVALIDARG)
  98 #define EXPECT_LT       EXPECTRES(VARCMP_LT, VARCMP_LT)
  99 #define EXPECT_GT       EXPECTRES(VARCMP_GT, VARCMP_GT)
 100 #define EXPECT_EQ       EXPECTRES(VARCMP_EQ, VARCMP_EQ)
 101 #define EXPECT_DBL(x)   \
 102   ok(hres == S_OK && fabs(out-(x))<1e-14, "expected " #x ", got %16.16g; hres=0x%08lx\n", out, hres)
 103
 104 #define CONVERT(func, val) in = val; hres = p##func(in, &out)
 105 #define CONVERTRANGE(func,start,end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT(i); };
 106 #define OVERFLOWRANGE(func,start,end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT_OVERFLOW; };
 107
 108 #define CY_MULTIPLIER   10000
 109
 110 #define DATE_MIN -657434
 111 #define DATE_MAX 2958465
 112
 113 #define CONVERT_I8(func,hi,lo) in = hi; in = (in << 32) | lo; hres = p##func(in, &out)
 114
 115 #define CONVERT_CY(func,val) in.int64 = (LONGLONG)(val * CY_MULTIPLIER); hres = p##func(in, &out)
 116
 117 #define CONVERT_CY64(func,hi,lo) S(in).Hi = hi; S(in).Lo = lo; in.int64 *= CY_MULTIPLIER; hres = p##func(in, &out)
 118
 119 #define SETDEC(dec, scl, sgn, hi, lo) S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \
 120   dec.Hi32 = (ULONG)hi; U1(dec).Lo64 = (ULONG64)lo
 121
 122 #define SETDEC64(dec, scl, sgn, hi, mid, lo) S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \
 123   dec.Hi32 = (ULONG)hi; S1(U1(dec)).Mid32 = mid; S1(U1(dec)).Lo32 = lo;
 124
 125 #define CONVERT_DEC(func,scl,sgn,hi,lo) SETDEC(in,scl,sgn,hi,lo); hres = p##func(&in, &out)
 126
 127 #define CONVERT_DEC64(func,scl,sgn,hi,mid,lo) SETDEC64(in,scl,sgn,hi,mid,lo); hres = p##func(&in, &out)
 128
 129 #define CONVERT_BADDEC(func) \
 130   if (HAVE_OLEAUT32_DECIMAL) \
 131   { \
 132     CONVERT_DEC(func,29,0,0,0);   EXPECT_INVALID; \
 133     CONVERT_DEC(func,0,0x1,0,0);  EXPECT_INVALID; \
 134     CONVERT_DEC(func,0,0x40,0,0); EXPECT_INVALID; \
 135     CONVERT_DEC(func,0,0x7f,0,0); EXPECT_INVALID; \
 136   }
 137
 138 #define CONVERT_STR(func,str,flags) \
 139   SetLastError(0); \
 140   if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,sizeof(buff)/sizeof(WCHAR)); \
 141   hres = p##func(str ? buff : NULL,in,flags,&out)
 142
 143 #define COPYTEST(val, vt, srcval, dstval, srcref, dstref, fs) do { \
 144   HRESULT hres; VARIANTARG vSrc, vDst; CONV_TYPE in = val; \
 145   VariantInit(&vSrc); VariantInit(&vDst); \
 146   V_VT(&vSrc) = vt; srcval = in; \
 147   hres = VariantCopy(&vDst, &vSrc); \
 148   ok(hres == S_OK && V_VT(&vDst) == vt && dstval == in, \
 149      "copy hres 0x%lX, type %d, value (" fs ") " fs "\n", hres, V_VT(&vDst), val, dstval); \
 150   V_VT(&vSrc) = vt|VT_BYREF; srcref = &in; \
 151   hres = VariantCopy(&vDst, &vSrc); \
 152   ok(hres == S_OK && V_VT(&vDst) == (vt|VT_BYREF) && dstref == &in, \
 153      "ref hres 0x%lX, type %d, ref (%p) %p\n", hres, V_VT(&vDst), &in, dstref); \
 154   hres = VariantCopyInd(&vDst, &vSrc); \
 155   ok(hres == S_OK && V_VT(&vDst) == vt && dstval == in, \
 156      "ind hres 0x%lX, type %d, value (" fs ") " fs "\n", hres, V_VT(&vDst), val, dstval); \
 157   } while(0)
 158
 159 #define CHANGETYPEEX(typ) hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, typ)
 160
 161 #define TYPETEST(typ,res,fs) CHANGETYPEEX(typ); \
 162   ok(hres == S_OK && V_VT(&vDst) == typ && (CONV_TYPE)res == in, \
 163      "hres=0x%lX, type=%d (should be %d(" #typ ")), value=" fs " (should be " fs ")\n", \
 164       hres, V_VT(&vDst), typ, (CONV_TYPE)res, in);
 165 #define TYPETESTI8(typ,res) CHANGETYPEEX(typ); \
 166   ok(hres == S_OK && V_VT(&vDst) == typ && (CONV_TYPE)res == in, \
 167      "hres=0x%lX, type=%d (should be %d(" #typ ")), value=%d (should be 1)\n", \
 168       hres, V_VT(&vDst), typ, (int)res);
 169 #define BADVAR(typ)   CHANGETYPEEX(typ); out = (CONV_TYPE)hres; EXPECT_BADVAR
 170 #define MISMATCH(typ) CHANGETYPEEX(typ); out = (CONV_TYPE)hres; EXPECT_MISMATCH
 171
 172 #define INITIAL_TYPETEST(vt, val, fs) \
 173   VariantInit(&vSrc); \
 174   VariantInit(&vDst); \
 175   V_VT(&vSrc) = vt; \
 176   (val(&vSrc)) = in; \
 177   if (!IS_ANCIENT) { \
 178     TYPETEST(VT_I1, V_I1(&vDst), fs); \
 179     TYPETEST(VT_UI2, V_UI2(&vDst), fs); \
 180     TYPETEST(VT_UI4, V_UI4(&vDst), fs); \
 181     TYPETEST(VT_INT, V_INT(&vDst), fs); \
 182     TYPETEST(VT_UINT, V_UINT(&vDst), fs); \
 183   } else {  \
 184     BADVAR(VT_I1); BADVAR(VT_UI2); BADVAR(VT_UI4); \
 185     BADVAR(VT_INT); BADVAR(VT_UINT); \
 186   } \
 187   TYPETEST(VT_UI1, V_UI1(&vDst), fs); \
 188   TYPETEST(VT_I2, V_I2(&vDst), fs); \
 189   TYPETEST(VT_I4, V_I4(&vDst), fs); \
 190   TYPETEST(VT_R4, V_R4(&vDst), fs); \
 191   TYPETEST(VT_R8, V_R8(&vDst), fs); \
 192   TYPETEST(VT_DATE, V_DATE(&vDst), fs); \
 193   if (HAVE_OLEAUT32_I8) \
 194   { \
 195     TYPETEST(VT_I8, V_I8(&vDst), fs); \
 196     TYPETEST(VT_UI8, V_UI8(&vDst), fs); \
 197   }
 198 #define NEGATIVE_TYPETEST(vt, val, fs, vtneg, valneg) \
 199   in = -in; \
 200   VariantInit(&vSrc); \
 201   VariantInit(&vDst); \
 202   V_VT(&vSrc) = vt; \
 203   (val(&vSrc)) = in; \
 204   if (!IS_ANCIENT) { \
 205     TYPETEST(vtneg, valneg(&vDst), fs); \
 206   }
 207
 208 #define INITIAL_TYPETESTI8(vt, val) \
 209   VariantInit(&vSrc); \
 210   VariantInit(&vDst); \
 211   V_VT(&vSrc) = vt; \
 212   (val(&vSrc)) = in; \
 213   TYPETESTI8(VT_I1, V_I1(&vDst)); \
 214   TYPETESTI8(VT_UI1, V_UI1(&vDst)); \
 215   TYPETESTI8(VT_I2, V_I2(&vDst)); \
 216   TYPETESTI8(VT_UI2, V_UI2(&vDst)); \
 217   TYPETESTI8(VT_I4, V_I4(&vDst)); \
 218   TYPETESTI8(VT_UI4, V_UI4(&vDst)); \
 219   TYPETESTI8(VT_INT, V_INT(&vDst)); \
 220   TYPETESTI8(VT_UINT, V_UINT(&vDst)); \
 221   TYPETESTI8(VT_R4, V_R4(&vDst)); \
 222   TYPETESTI8(VT_R8, V_R8(&vDst)); \
 223   TYPETESTI8(VT_DATE, V_DATE(&vDst)); \
 224   TYPETESTI8(VT_I8, V_I8(&vDst)); \
 225   TYPETESTI8(VT_UI8, V_UI8(&vDst))
 226
 227 #define COMMON_TYPETEST \
 228   hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_BOOL); \
 229   ok(hres == S_OK && V_VT(&vDst) == VT_BOOL && \
 230      (V_BOOL(&vDst) == VARIANT_TRUE || (V_VT(&vSrc) == VT_BOOL && V_BOOL(&vDst) == 1)), \
 231      "->VT_BOOL hres=0x%lX, type=%d (should be VT_BOOL), value %d (should be VARIANT_TRUE)\n", \
 232      hres, V_VT(&vDst), V_BOOL(&vDst)); \
 233   if (HAVE_OLEAUT32_CY) \
 234   { \
 235     hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_CY); \
 236     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == CY_MULTIPLIER, \
 237        "->VT_CY hres=0x%lX, type=%d (should be VT_CY), value (%08lx,%08lx) (should be CY_MULTIPLIER)\n", \
 238        hres, V_VT(&vDst), S(V_CY(&vDst)).Hi, S(V_CY(&vDst)).Lo); \
 239   } \
 240   if (V_VT(&vSrc) != VT_DATE) \
 241   { \
 242     hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_BSTR); \
 243     ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && \
 244        V_BSTR(&vDst) && V_BSTR(&vDst)[0] == '1' && V_BSTR(&vDst)[1] == '\0', \
 245        "->VT_BSTR hres=0x%lX, type=%d (should be VT_BSTR), *bstr='%c'\n", \
 246        hres, V_VT(&vDst), V_BSTR(&vDst) ? *V_BSTR(&vDst) : '?'); \
 247   } \
 248   if (HAVE_OLEAUT32_DECIMAL) \
 249   { \
 250     hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_DECIMAL); \
 251     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && \
 252        S(U(V_DECIMAL(&vDst))).sign == 0 && S(U(V_DECIMAL(&vDst))).scale == 0 && \
 253        V_DECIMAL(&vDst).Hi32 == 0 && U1(V_DECIMAL(&vDst)).Lo64 == (ULONGLONG)in, \
 254        "->VT_DECIMAL hres=0x%lX, type=%d (should be VT_DECIMAL), sign=%d, scale=%d, hi=%lu, lo=(%8lx %8lx),\n", \
 255        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign, S(U(V_DECIMAL(&vDst))).scale, \
 256        V_DECIMAL(&vDst).Hi32, S1(U1(V_DECIMAL(&vDst))).Mid32, S1(U1(V_DECIMAL(&vDst))).Lo32); \
 257   } \
 258   hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_EMPTY); \
 259   ok(hres == S_OK && V_VT(&vDst) == VT_EMPTY, "->VT_EMPTY hres=0x%lX, type=%d (should be VT_EMPTY)\n", hres, V_VT(&vDst)); \
 260   hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_NULL); \
 261   ok(hres == S_OK && V_VT(&vDst) == VT_NULL, "->VT_NULL hres=0x%lX, type=%d (should be VT_NULL)\n", hres, V_VT(&vDst)); \
 262   MISMATCH(VT_DISPATCH); \
 263   MISMATCH(VT_ERROR); \
 264   MISMATCH(VT_UNKNOWN); \
 265   if (!IS_ANCIENT) { MISMATCH(VT_VARIANT); } else { BADVAR(VT_VARIANT); } \
 266   if (HAVE_OLEAUT32_RECORD) \
 267   { \
 268     MISMATCH(VT_RECORD); \
 269   } \
 270   BADVAR(VT_VOID); \
 271   BADVAR(VT_HRESULT); \
 272   BADVAR(VT_SAFEARRAY); \
 273   BADVAR(VT_CARRAY); \
 274   BADVAR(VT_USERDEFINED); \
 275   BADVAR(VT_LPSTR); \
 276   BADVAR(VT_LPWSTR); \
 277   BADVAR(VT_PTR); \
 278   BADVAR(VT_INT_PTR); \
 279   BADVAR(VT_UINT_PTR); \
 280   BADVAR(VT_FILETIME); \
 281   BADVAR(VT_BLOB); \
 282   BADVAR(VT_STREAM); \
 283   BADVAR(VT_STORAGE); \
 284   BADVAR(VT_STREAMED_OBJECT); \
 285   BADVAR(VT_STORED_OBJECT); \
 286   BADVAR(VT_BLOB_OBJECT); \
 287   BADVAR(VT_CF); \
 288   BADVAR(VT_CLSID); \
 289   BADVAR(VT_BSTR_BLOB)
 290
 291 /* Early versions of oleaut32 are missing many functions */
 292 static HRESULT (WINAPI *pVarI1FromUI1)(BYTE,signed char*);
 293 static HRESULT (WINAPI *pVarI1FromI2)(SHORT,signed char*);
 294 static HRESULT (WINAPI *pVarI1FromI4)(LONG,signed char*);
 295 static HRESULT (WINAPI *pVarI1FromR4)(FLOAT,signed char*);
 296 static HRESULT (WINAPI *pVarI1FromR8)(double,signed char*);
 297 static HRESULT (WINAPI *pVarI1FromDate)(DATE,signed char*);
 298 static HRESULT (WINAPI *pVarI1FromCy)(CY,signed char*);
 299 static HRESULT (WINAPI *pVarI1FromStr)(OLECHAR*,LCID,ULONG,signed char*);
 300 static HRESULT (WINAPI *pVarI1FromBool)(VARIANT_BOOL,signed char*);
 301 static HRESULT (WINAPI *pVarI1FromUI2)(USHORT,signed char*);
 302 static HRESULT (WINAPI *pVarI1FromUI4)(ULONG,signed char*);
 303 static HRESULT (WINAPI *pVarI1FromDec)(DECIMAL*,signed char*);
 304 static HRESULT (WINAPI *pVarI1FromI8)(LONG64,signed char*);
 305 static HRESULT (WINAPI *pVarI1FromUI8)(ULONG64,signed char*);
 306 static HRESULT (WINAPI *pVarUI1FromI2)(SHORT,BYTE*);
 307 static HRESULT (WINAPI *pVarUI1FromI4)(LONG,BYTE*);
 308 static HRESULT (WINAPI *pVarUI1FromR4)(FLOAT,BYTE*);
 309 static HRESULT (WINAPI *pVarUI1FromR8)(double,BYTE*);
 310 static HRESULT (WINAPI *pVarUI1FromCy)(CY,BYTE*);
 311 static HRESULT (WINAPI *pVarUI1FromDate)(DATE,BYTE*);
 312 static HRESULT (WINAPI *pVarUI1FromStr)(OLECHAR*,LCID,ULONG,BYTE*);
 313 static HRESULT (WINAPI *pVarUI1FromBool)(VARIANT_BOOL,BYTE*);
 314 static HRESULT (WINAPI *pVarUI1FromI1)(signed char,BYTE*);
 315 static HRESULT (WINAPI *pVarUI1FromUI2)(USHORT,BYTE*);
 316 static HRESULT (WINAPI *pVarUI1FromUI4)(ULONG,BYTE*);
 317 static HRESULT (WINAPI *pVarUI1FromDec)(DECIMAL*,BYTE*);
 318 static HRESULT (WINAPI *pVarUI1FromI8)(LONG64,BYTE*);
 319 static HRESULT (WINAPI *pVarUI1FromUI8)(ULONG64,BYTE*);
 320 static HRESULT (WINAPI *pVarUI1FromDisp)(IDispatch*,LCID,BYTE*);
 321
 322 static HRESULT (WINAPI *pVarI2FromUI1)(BYTE,SHORT*);
 323 static HRESULT (WINAPI *pVarI2FromI4)(LONG,SHORT*);
 324 static HRESULT (WINAPI *pVarI2FromR4)(FLOAT,SHORT*);
 325 static HRESULT (WINAPI *pVarI2FromR8)(double,SHORT*);
 326 static HRESULT (WINAPI *pVarI2FromCy)(CY,SHORT*);
 327 static HRESULT (WINAPI *pVarI2FromDate)(DATE,SHORT*);
 328 static HRESULT (WINAPI *pVarI2FromStr)(OLECHAR*,LCID,ULONG,SHORT*);
 329 static HRESULT (WINAPI *pVarI2FromBool)(VARIANT_BOOL,SHORT*);
 330 static HRESULT (WINAPI *pVarI2FromI1)(signed char,SHORT*);
 331 static HRESULT (WINAPI *pVarI2FromUI2)(USHORT,SHORT*);
 332 static HRESULT (WINAPI *pVarI2FromUI4)(ULONG,SHORT*);
 333 static HRESULT (WINAPI *pVarI2FromDec)(DECIMAL*,SHORT*);
 334 static HRESULT (WINAPI *pVarI2FromI8)(LONG64,SHORT*);
 335 static HRESULT (WINAPI *pVarI2FromUI8)(ULONG64,SHORT*);
 336 static HRESULT (WINAPI *pVarUI2FromUI1)(BYTE,USHORT*);
 337 static HRESULT (WINAPI *pVarUI2FromI2)(SHORT,USHORT*);
 338 static HRESULT (WINAPI *pVarUI2FromI4)(LONG,USHORT*);
 339 static HRESULT (WINAPI *pVarUI2FromR4)(FLOAT,USHORT*);
 340 static HRESULT (WINAPI *pVarUI2FromR8)(double,USHORT*);
 341 static HRESULT (WINAPI *pVarUI2FromDate)(DATE,USHORT*);
 342 static HRESULT (WINAPI *pVarUI2FromCy)(CY,USHORT*);
 343 static HRESULT (WINAPI *pVarUI2FromStr)(OLECHAR*,LCID,ULONG,USHORT*);
 344 static HRESULT (WINAPI *pVarUI2FromBool)(VARIANT_BOOL,USHORT*);
 345 static HRESULT (WINAPI *pVarUI2FromI1)(signed char,USHORT*);
 346 static HRESULT (WINAPI *pVarUI2FromUI4)(ULONG,USHORT*);
 347 static HRESULT (WINAPI *pVarUI2FromDec)(DECIMAL*,USHORT*);
 348 static HRESULT (WINAPI *pVarUI2FromI8)(LONG64,USHORT*);
 349 static HRESULT (WINAPI *pVarUI2FromUI8)(ULONG64,USHORT*);
 350
 351 static HRESULT (WINAPI *pVarI4FromUI1)(BYTE,LONG*);
 352 static HRESULT (WINAPI *pVarI4FromI2)(SHORT,LONG*);
 353 static HRESULT (WINAPI *pVarI4FromR4)(FLOAT,LONG*);
 354 static HRESULT (WINAPI *pVarI4FromR8)(DOUBLE,LONG*);
 355 static HRESULT (WINAPI *pVarI4FromCy)(CY,LONG*);
 356 static HRESULT (WINAPI *pVarI4FromDate)(DATE,LONG*);
 357 static HRESULT (WINAPI *pVarI4FromStr)(OLECHAR*,LCID,ULONG,LONG*);
 358 static HRESULT (WINAPI *pVarI4FromBool)(VARIANT_BOOL,LONG*);
 359 static HRESULT (WINAPI *pVarI4FromI1)(signed char,LONG*);
 360 static HRESULT (WINAPI *pVarI4FromUI2)(USHORT,LONG*);
 361 static HRESULT (WINAPI *pVarI4FromUI4)(ULONG,LONG*);
 362 static HRESULT (WINAPI *pVarI4FromDec)(DECIMAL*,LONG*);
 363 static HRESULT (WINAPI *pVarI4FromI8)(LONG64,LONG*);
 364 static HRESULT (WINAPI *pVarI4FromUI8)(ULONG64,LONG*);
 365 static HRESULT (WINAPI *pVarUI4FromUI1)(BYTE,ULONG*);
 366 static HRESULT (WINAPI *pVarUI4FromI2)(SHORT,ULONG*);
 367 static HRESULT (WINAPI *pVarUI4FromI4)(LONG,ULONG*);
 368 static HRESULT (WINAPI *pVarUI4FromR4)(FLOAT,ULONG*);
 369 static HRESULT (WINAPI *pVarUI4FromR8)(DOUBLE,ULONG*);
 370 static HRESULT (WINAPI *pVarUI4FromDate)(DATE,ULONG*);
 371 static HRESULT (WINAPI *pVarUI4FromCy)(CY,ULONG*);
 372 static HRESULT (WINAPI *pVarUI4FromStr)(OLECHAR*,LCID,ULONG,ULONG*);
 373 static HRESULT (WINAPI *pVarUI4FromBool)(VARIANT_BOOL,ULONG*);
 374 static HRESULT (WINAPI *pVarUI4FromI1)(signed char,ULONG*);
 375 static HRESULT (WINAPI *pVarUI4FromUI2)(USHORT,ULONG*);
 376 static HRESULT (WINAPI *pVarUI4FromDec)(DECIMAL*,ULONG*);
 377 static HRESULT (WINAPI *pVarUI4FromI8)(LONG64,ULONG*);
 378 static HRESULT (WINAPI *pVarUI4FromUI8)(ULONG64,ULONG*);
 379
 380 static HRESULT (WINAPI *pVarI8FromUI1)(BYTE,LONG64*);
 381 static HRESULT (WINAPI *pVarI8FromI2)(SHORT,LONG64*);
 382 static HRESULT (WINAPI *pVarI8FromR4)(FLOAT,LONG64*);
 383 static HRESULT (WINAPI *pVarI8FromR8)(double,LONG64*);
 384 static HRESULT (WINAPI *pVarI8FromCy)(CY,LONG64*);
 385 static HRESULT (WINAPI *pVarI8FromDate)(DATE,LONG64*);
 386 static HRESULT (WINAPI *pVarI8FromStr)(OLECHAR*,LCID,ULONG,LONG64*);
 387 static HRESULT (WINAPI *pVarI8FromBool)(VARIANT_BOOL,LONG64*);
 388 static HRESULT (WINAPI *pVarI8FromI1)(signed char,LONG64*);
 389 static HRESULT (WINAPI *pVarI8FromUI2)(USHORT,LONG64*);
 390 static HRESULT (WINAPI *pVarI8FromUI4)(ULONG,LONG64*);
 391 static HRESULT (WINAPI *pVarI8FromDec)(DECIMAL*,LONG64*);
 392 static HRESULT (WINAPI *pVarI8FromUI8)(ULONG64,LONG64*);
 393 static HRESULT (WINAPI *pVarUI8FromI8)(LONG64,ULONG64*);
 394 static HRESULT (WINAPI *pVarUI8FromUI1)(BYTE,ULONG64*);
 395 static HRESULT (WINAPI *pVarUI8FromI2)(SHORT,ULONG64*);
 396 static HRESULT (WINAPI *pVarUI8FromR4)(FLOAT,ULONG64*);
 397 static HRESULT (WINAPI *pVarUI8FromR8)(double,ULONG64*);
 398 static HRESULT (WINAPI *pVarUI8FromCy)(CY,ULONG64*);
 399 static HRESULT (WINAPI *pVarUI8FromDate)(DATE,ULONG64*);
 400 static HRESULT (WINAPI *pVarUI8FromStr)(OLECHAR*,LCID,ULONG,ULONG64*);
 401 static HRESULT (WINAPI *pVarUI8FromBool)(VARIANT_BOOL,ULONG64*);
 402 static HRESULT (WINAPI *pVarUI8FromI1)(signed char,ULONG64*);
 403 static HRESULT (WINAPI *pVarUI8FromUI2)(USHORT,ULONG64*);
 404 static HRESULT (WINAPI *pVarUI8FromUI4)(ULONG,ULONG64*);
 405 static HRESULT (WINAPI *pVarUI8FromDec)(DECIMAL*,ULONG64*);
 406
 407 static HRESULT (WINAPI *pVarR4FromUI1)(BYTE,float*);
 408 static HRESULT (WINAPI *pVarR4FromI2)(SHORT,float*);
 409 static HRESULT (WINAPI *pVarR4FromI4)(LONG,float*);
 410 static HRESULT (WINAPI *pVarR4FromR8)(double,float*);
 411 static HRESULT (WINAPI *pVarR4FromCy)(CY,float*);
 412 static HRESULT (WINAPI *pVarR4FromDate)(DATE,float*);
 413 static HRESULT (WINAPI *pVarR4FromStr)(OLECHAR*,LCID,ULONG,float*);
 414 static HRESULT (WINAPI *pVarR4FromBool)(VARIANT_BOOL,float*);
 415 static HRESULT (WINAPI *pVarR4FromI1)(signed char,float*);
 416 static HRESULT (WINAPI *pVarR4FromUI2)(USHORT,float*);
 417 static HRESULT (WINAPI *pVarR4FromUI4)(ULONG,float*);
 418 static HRESULT (WINAPI *pVarR4FromDec)(DECIMAL*,float*);
 419 static HRESULT (WINAPI *pVarR4FromI8)(LONG64,float*);
 420 static HRESULT (WINAPI *pVarR4FromUI8)(ULONG64,float*);
 421
 422 static HRESULT (WINAPI *pVarR8FromUI1)(BYTE,double*);
 423 static HRESULT (WINAPI *pVarR8FromI2)(SHORT,double*);
 424 static HRESULT (WINAPI *pVarR8FromI4)(LONG,double*);
 425 static HRESULT (WINAPI *pVarR8FromR4)(FLOAT,double*);
 426 static HRESULT (WINAPI *pVarR8FromCy)(CY,double*);
 427 static HRESULT (WINAPI *pVarR8FromDate)(DATE,double*);
 428 static HRESULT (WINAPI *pVarR8FromStr)(OLECHAR*,LCID,ULONG,double*);
 429 static HRESULT (WINAPI *pVarR8FromBool)(VARIANT_BOOL,double*);
 430 static HRESULT (WINAPI *pVarR8FromI1)(signed char,double*);
 431 static HRESULT (WINAPI *pVarR8FromUI2)(USHORT,double*);
 432 static HRESULT (WINAPI *pVarR8FromUI4)(ULONG,double*);
 433 static HRESULT (WINAPI *pVarR8FromDec)(DECIMAL*,double*);
 434 static HRESULT (WINAPI *pVarR8FromI8)(LONG64,double*);
 435 static HRESULT (WINAPI *pVarR8FromUI8)(ULONG64,double*);
 436 static HRESULT (WINAPI *pVarR8Round)(double,int,double*);
 437
 438 static HRESULT (WINAPI *pVarDateFromUI1)(BYTE,DATE*);
 439 static HRESULT (WINAPI *pVarDateFromI2)(SHORT,DATE*);
 440 static HRESULT (WINAPI *pVarDateFromI4)(LONG,DATE*);
 441 static HRESULT (WINAPI *pVarDateFromR4)(FLOAT,DATE*);
 442 static HRESULT (WINAPI *pVarDateFromCy)(CY,DATE*);
 443 static HRESULT (WINAPI *pVarDateFromR8)(double,DATE*);
 444 static HRESULT (WINAPI *pVarDateFromStr)(OLECHAR*,LCID,ULONG,DATE*);
 445 static HRESULT (WINAPI *pVarDateFromBool)(VARIANT_BOOL,DATE*);
 446 static HRESULT (WINAPI *pVarDateFromI1)(signed char,DATE*);
 447 static HRESULT (WINAPI *pVarDateFromUI2)(USHORT,DATE*);
 448 static HRESULT (WINAPI *pVarDateFromUI4)(ULONG,DATE*);
 449 static HRESULT (WINAPI *pVarDateFromDec)(DECIMAL*,DATE*);
 450 static HRESULT (WINAPI *pVarDateFromI8)(LONG64,DATE*);
 451 static HRESULT (WINAPI *pVarDateFromUI8)(ULONG64,DATE*);
 452
 453 static HRESULT (WINAPI *pVarCyFromUI1)(BYTE,CY*);
 454 static HRESULT (WINAPI *pVarCyFromI2)(SHORT,CY*);
 455 static HRESULT (WINAPI *pVarCyFromI4)(LONG,CY*);
 456 static HRESULT (WINAPI *pVarCyFromR4)(FLOAT,CY*);
 457 static HRESULT (WINAPI *pVarCyFromR8)(double,CY*);
 458 static HRESULT (WINAPI *pVarCyFromDate)(DATE,CY*);
 459 static HRESULT (WINAPI *pVarCyFromBool)(VARIANT_BOOL,CY*);
 460 static HRESULT (WINAPI *pVarCyFromI1)(signed char,CY*);
 461 static HRESULT (WINAPI *pVarCyFromUI2)(USHORT,CY*);
 462 static HRESULT (WINAPI *pVarCyFromUI4)(ULONG,CY*);
 463 static HRESULT (WINAPI *pVarCyFromDec)(DECIMAL*,CY*);
 464 static HRESULT (WINAPI *pVarCyFromI8)(LONG64,CY*);
 465 static HRESULT (WINAPI *pVarCyFromUI8)(ULONG64,CY*);
 466 static HRESULT (WINAPI *pVarCyAdd)(const CY,const CY,CY*);
 467 static HRESULT (WINAPI *pVarCyMul)(const CY,const CY,CY*);
 468 static HRESULT (WINAPI *pVarCyMulI4)(const CY,LONG,CY*);
 469 static HRESULT (WINAPI *pVarCySub)(const CY,const CY,CY*);
 470 static HRESULT (WINAPI *pVarCyAbs)(const CY,CY*);
 471 static HRESULT (WINAPI *pVarCyFix)(const CY,CY*);
 472 static HRESULT (WINAPI *pVarCyInt)(const CY,CY*);
 473 static HRESULT (WINAPI *pVarCyNeg)(const CY,CY*);
 474 static HRESULT (WINAPI *pVarCyRound)(const CY,int,CY*);
 475 static HRESULT (WINAPI *pVarCyCmp)(const CY,const CY);
 476 static HRESULT (WINAPI *pVarCyCmpR8)(const CY,double);
 477 static HRESULT (WINAPI *pVarCyMulI8)(const CY,LONG64,CY*);
 478
 479 static HRESULT (WINAPI *pVarDecFromUI1)(BYTE,DECIMAL*);
 480 static HRESULT (WINAPI *pVarDecFromI2)(SHORT,DECIMAL*);
 481 static HRESULT (WINAPI *pVarDecFromI4)(LONG,DECIMAL*);
 482 static HRESULT (WINAPI *pVarDecFromI8)(LONG64,DECIMAL*);
 483 static HRESULT (WINAPI *pVarDecFromR4)(FLOAT,DECIMAL*);
 484 static HRESULT (WINAPI *pVarDecFromR8)(DOUBLE,DECIMAL*);
 485 static HRESULT (WINAPI *pVarDecFromDate)(DATE,DECIMAL*);
 486 static HRESULT (WINAPI *pVarDecFromStr)(OLECHAR*,LCID,ULONG,DECIMAL*);
 487 static HRESULT (WINAPI *pVarDecFromBool)(VARIANT_BOOL,DECIMAL*);
 488 static HRESULT (WINAPI *pVarDecFromI1)(signed char,DECIMAL*);
 489 static HRESULT (WINAPI *pVarDecFromUI2)(USHORT,DECIMAL*);
 490 static HRESULT (WINAPI *pVarDecFromUI4)(ULONG,DECIMAL*);
 491 static HRESULT (WINAPI *pVarDecFromUI8)(ULONG64,DECIMAL*);
 492 static HRESULT (WINAPI *pVarDecFromCy)(CY,DECIMAL*);
 493 static HRESULT (WINAPI *pVarDecAbs)(const DECIMAL*,DECIMAL*);
 494 static HRESULT (WINAPI *pVarDecAdd)(const DECIMAL*,const DECIMAL*,DECIMAL*);
 495 static HRESULT (WINAPI *pVarDecSub)(const DECIMAL*,const DECIMAL*,DECIMAL*);
 496 static HRESULT (WINAPI *pVarDecMul)(const DECIMAL*,const DECIMAL*,DECIMAL*);
 497 static HRESULT (WINAPI *pVarDecDiv)(const DECIMAL*,const DECIMAL*,DECIMAL*);
 498 static HRESULT (WINAPI *pVarDecCmp)(const DECIMAL*,const DECIMAL*);
 499 static HRESULT (WINAPI *pVarDecNeg)(const DECIMAL*,DECIMAL*);
 500
 501 static HRESULT (WINAPI *pVarBoolFromUI1)(BYTE,VARIANT_BOOL*);
 502 static HRESULT (WINAPI *pVarBoolFromI2)(SHORT,VARIANT_BOOL*);
 503 static HRESULT (WINAPI *pVarBoolFromI4)(LONG,VARIANT_BOOL*);
 504 static HRESULT (WINAPI *pVarBoolFromR4)(FLOAT,VARIANT_BOOL*);
 505 static HRESULT (WINAPI *pVarBoolFromR8)(DOUBLE,VARIANT_BOOL*);
 506 static HRESULT (WINAPI *pVarBoolFromDate)(DATE,VARIANT_BOOL*);
 507 static HRESULT (WINAPI *pVarBoolFromCy)(CY,VARIANT_BOOL*);
 508 static HRESULT (WINAPI *pVarBoolFromStr)(OLECHAR*,LCID,ULONG,VARIANT_BOOL*);
 509 static HRESULT (WINAPI *pVarBoolFromI1)(signed char,VARIANT_BOOL*);
 510 static HRESULT (WINAPI *pVarBoolFromUI2)(USHORT,VARIANT_BOOL*);
 511 static HRESULT (WINAPI *pVarBoolFromUI4)(ULONG,VARIANT_BOOL*);
 512 static HRESULT (WINAPI *pVarBoolFromDec)(DECIMAL*,VARIANT_BOOL*);
 513 static HRESULT (WINAPI *pVarBoolFromI8)(LONG64,VARIANT_BOOL*);
 514 static HRESULT (WINAPI *pVarBoolFromUI8)(ULONG64,VARIANT_BOOL*);
 515
 516 static HRESULT (WINAPI *pVarBstrFromR4)(FLOAT,LCID,ULONG,BSTR*);
 517 static HRESULT (WINAPI *pVarBstrFromDate)(DATE,LCID,ULONG,BSTR*);
 518 static HRESULT (WINAPI *pVarBstrFromDec)(DECIMAL*,LCID,ULONG,BSTR*);
 519
 520 static HRESULT (WINAPI *pVarCmp)(LPVARIANT,LPVARIANT,LCID,ULONG);
 521
 522 static INT (WINAPI *pSystemTimeToVariantTime)(LPSYSTEMTIME,double*);
 523 static void (WINAPI *pClearCustData)(LPCUSTDATA);
 524
 525 /* Internal representation of a BSTR */
 526 typedef struct tagINTERNAL_BSTR
 527 {
 528   DWORD   dwLen;
 529   OLECHAR szString[1];
 530 } INTERNAL_BSTR, *LPINTERNAL_BSTR;
 531
 532 typedef struct
 533 {
 534   const IDispatchVtbl *lpVtbl;
 535   LONG ref;
 536   VARTYPE vt;
 537   BOOL bFailInvoke;
 538 } DummyDispatch;
 539
 540 static DummyDispatch dispatch;
 541
 542 static ULONG WINAPI DummyDispatch_AddRef(LPDISPATCH iface)
 543 {
 544   trace("AddRef(%p)\n", iface);
 545   return InterlockedIncrement(&((DummyDispatch*)iface)->ref);
 546 }
 547
 548 static ULONG WINAPI DummyDispatch_Release(LPDISPATCH iface)
 549 {
 550   trace("Release(%p)\n", iface);
 551   return InterlockedDecrement(&((DummyDispatch*)iface)->ref);
 552 }
 553
 554 static HRESULT WINAPI DummyDispatch_QueryInterface(LPDISPATCH iface,
 555                                                    REFIID riid,
 556                                                    void** ppvObject)
 557 {
 558   trace("QueryInterface(%p)\n", iface);
 559   if (ppvObject)
 560   {
 561     *ppvObject = NULL;
 562     if (IsEqualIID(riid, &IID_IDispatch))
 563     {
 564       trace("Asked for IID_IDispatch\n");
 565       *ppvObject = iface;
 566     }
 567     else if (IsEqualIID(riid, &IID_IUnknown))
 568     {
 569       trace("Asked for IID_IUnknown\n");
 570       *ppvObject = iface;
 571     }
 572     if (*ppvObject)
 573     {
 574       DummyDispatch_AddRef((IDispatch*)*ppvObject);
 575       return S_OK;
 576     }
 577   }
 578   return E_NOINTERFACE;
 579 }
 580
 581 static HRESULT WINAPI DummyDispatch_Invoke(LPDISPATCH iface,
 582                                            DISPID dispIdMember, REFIID riid,
 583                                            LCID lcid, WORD wFlags,
 584                                            DISPPARAMS *pDispParams,
 585                                            VARIANT *pVarResult,
 586                                            EXCEPINFO *pExcepInfo,
 587                                            UINT *puArgErr)
 588 {
 589   trace("Invoke(%p)\n", iface);
 590   ok(wFlags == DISPATCH_PROPERTYGET, "Flags wrong\n");
 591   ok(pDispParams->cArgs == 0, "Property get has args\n");
 592
 593   if (dispatch.bFailInvoke)
 594     return E_OUTOFMEMORY;
 595
 596   memset(pVarResult, 0, sizeof(*pVarResult));
 597   V_VT(pVarResult) = dispatch.vt;
 598   return S_OK;
 599 }
 600
 601 static const IDispatchVtbl DummyDispatch_VTable =
 602 {
 603   DummyDispatch_QueryInterface,
 604   DummyDispatch_AddRef,
 605   DummyDispatch_Release,
 606   NULL,
 607   NULL,
 608   NULL,
 609   DummyDispatch_Invoke
 610 };
 611
 612 static DummyDispatch dispatch = { &DummyDispatch_VTable, 1, 0, 0 };
 613
 614 /*
 615  * VT_I1/VT_UI1
 616  */
 617
 618 #undef CONV_TYPE
 619 #define CONV_TYPE signed char
 620 #undef EXPECTRES
 621 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%d")
 622
 623 static void test_VarI1FromI2(void)
 624 {
 625   CONVVARS(SHORT);
 626   int i;
 627
 628   CHECKPTR(VarI1FromI2);
 629   OVERFLOWRANGE(VarI1FromI2, -32768, -128);
 630   CONVERTRANGE(VarI1FromI2, -128, 128);
 631   OVERFLOWRANGE(VarI1FromI2, 129, 32768);
 632 }
 633
 634 static void test_VarI1FromI4(void)
 635 {
 636   CONVVARS(LONG);
 637   int i;
 638
 639   CHECKPTR(VarI1FromI4);
 640   CONVERT(VarI1FromI4, -129); EXPECT_OVERFLOW;
 641   CONVERTRANGE(VarI1FromI4, -128, 128);
 642   CONVERT(VarI1FromI4, 128);  EXPECT_OVERFLOW;
 643 }
 644
 645 static void test_VarI1FromI8(void)
 646 {
 647   CONVVARS(LONG64);
 648   int i;
 649
 650   CHECKPTR(VarI1FromI8);
 651   CONVERT(VarI1FromI8, -129);   EXPECT_OVERFLOW;
 652   CONVERTRANGE(VarI1FromI8, -127, 128);
 653   CONVERT(VarI1FromI8, 128);    EXPECT_OVERFLOW;
 654 }
 655
 656 static void test_VarI1FromUI1(void)
 657 {
 658   CONVVARS(BYTE);
 659   int i;
 660
 661   CHECKPTR(VarI1FromUI1);
 662   CONVERTRANGE(VarI1FromUI1, 0, 127);
 663   OVERFLOWRANGE(VarI1FromUI1, 128, 255);
 664 }
 665
 666 static void test_VarI1FromUI2(void)
 667 {
 668   CONVVARS(USHORT);
 669   int i;
 670
 671   CHECKPTR(VarI1FromUI2);
 672   CONVERTRANGE(VarI1FromUI2, 0, 127);
 673   OVERFLOWRANGE(VarI1FromUI2, 128, 32768);
 674 }
 675
 676 static void test_VarI1FromUI4(void)
 677 {
 678   CONVVARS(ULONG);
 679   int i;
 680
 681   CHECKPTR(VarI1FromUI4);
 682   CONVERTRANGE(VarI1FromUI4, 0, 127);
 683   CONVERT(VarI1FromUI4, 128); EXPECT_OVERFLOW;
 684 }
 685
 686 static void test_VarI1FromUI8(void)
 687 {
 688   CONVVARS(ULONG64);
 689   int i;
 690
 691   CHECKPTR(VarI1FromUI8);
 692   CONVERTRANGE(VarI1FromUI8, 0, 127);
 693   CONVERT(VarI1FromUI8, 128); EXPECT_OVERFLOW;
 694 }
 695
 696 static void test_VarI1FromBool(void)
 697 {
 698   CONVVARS(VARIANT_BOOL);
 699   int i;
 700
 701   CHECKPTR(VarI1FromBool);
 702   /* Note that conversions from bool wrap around! */
 703   CONVERT(VarI1FromBool, -129);  EXPECT(127);
 704   CONVERTRANGE(VarI1FromBool, -128, 128);
 705   CONVERT(VarI1FromBool, 128); EXPECT(-128);
 706 }
 707
 708 static void test_VarI1FromR4(void)
 709 {
 710   CONVVARS(FLOAT);
 711
 712   CHECKPTR(VarI1FromR4);
 713   CONVERT(VarI1FromR4, -129.0f); EXPECT_OVERFLOW;
 714   CONVERT(VarI1FromR4, -128.0f); EXPECT(-128);
 715   CONVERT(VarI1FromR4, -1.0f);   EXPECT(-1);
 716   CONVERT(VarI1FromR4, 0.0f);    EXPECT(0);
 717   CONVERT(VarI1FromR4, 1.0f);    EXPECT(1);
 718   CONVERT(VarI1FromR4, 127.0f);  EXPECT(127);
 719   CONVERT(VarI1FromR4, 128.0f);  EXPECT_OVERFLOW;
 720
 721   CONVERT(VarI1FromR4, -1.5f); EXPECT(-2);
 722   CONVERT(VarI1FromR4, -0.6f); EXPECT(-1);
 723   CONVERT(VarI1FromR4, -0.5f); EXPECT(0);
 724   CONVERT(VarI1FromR4, -0.4f); EXPECT(0);
 725   CONVERT(VarI1FromR4, 0.4f);  EXPECT(0);
 726   CONVERT(VarI1FromR4, 0.5f);  EXPECT(0);
 727   CONVERT(VarI1FromR4, 0.6f);  EXPECT(1);
 728   CONVERT(VarI1FromR4, 1.5f);  EXPECT(2);
 729 }
 730
 731 static void test_VarI1FromR8(void)
 732 {
 733   CONVVARS(DOUBLE);
 734
 735   CHECKPTR(VarI1FromR8);
 736   CONVERT(VarI1FromR8, -129.0); EXPECT_OVERFLOW;
 737   CONVERT(VarI1FromR8, -128.0); EXPECT(-128);
 738   CONVERT(VarI1FromR8, -1.0);   EXPECT(-1);
 739   CONVERT(VarI1FromR8, 0.0);    EXPECT(0);
 740   CONVERT(VarI1FromR8, 1.0);    EXPECT(1);
 741   CONVERT(VarI1FromR8, 127.0);  EXPECT(127);
 742   CONVERT(VarI1FromR8, 128.0);  EXPECT_OVERFLOW;
 743
 744   CONVERT(VarI1FromR8, -1.5); EXPECT(-2);
 745   CONVERT(VarI1FromR8, -0.6); EXPECT(-1);
 746   CONVERT(VarI1FromR8, -0.5); EXPECT(0);
 747   CONVERT(VarI1FromR8, -0.4); EXPECT(0);
 748   CONVERT(VarI1FromR8, 0.4);  EXPECT(0);
 749   CONVERT(VarI1FromR8, 0.5);  EXPECT(0);
 750   CONVERT(VarI1FromR8, 0.6);  EXPECT(1);
 751   CONVERT(VarI1FromR8, 1.5);  EXPECT(2);
 752 }
 753
 754 static void test_VarI1FromDate(void)
 755 {
 756   CONVVARS(DATE);
 757
 758   CHECKPTR(VarI1FromDate);
 759   CONVERT(VarI1FromDate, -129.0); EXPECT_OVERFLOW;
 760   CONVERT(VarI1FromDate, -128.0); EXPECT(-128);
 761   CONVERT(VarI1FromDate, -1.0);   EXPECT(-1);
 762   CONVERT(VarI1FromDate, 0.0);    EXPECT(0);
 763   CONVERT(VarI1FromDate, 1.0);    EXPECT(1);
 764   CONVERT(VarI1FromDate, 127.0);  EXPECT(127);
 765   CONVERT(VarI1FromDate, 128.0);  EXPECT_OVERFLOW;
 766
 767   CONVERT(VarI1FromDate, -1.5); EXPECT(-2);
 768   CONVERT(VarI1FromDate, -0.6); EXPECT(-1);
 769   CONVERT(VarI1FromDate, -0.5); EXPECT(0);
 770   CONVERT(VarI1FromDate, -0.4); EXPECT(0);
 771   CONVERT(VarI1FromDate, 0.4);  EXPECT(0);
 772   CONVERT(VarI1FromDate, 0.5);  EXPECT(0);
 773   CONVERT(VarI1FromDate, 0.6);  EXPECT(1);
 774   CONVERT(VarI1FromDate, 1.5);  EXPECT(2);
 775 }
 776
 777 static void test_VarI1FromCy(void)
 778 {
 779   CONVVARS(CY);
 780
 781   CHECKPTR(VarI1FromCy);
 782   CONVERT_CY(VarI1FromCy,-129); EXPECT_OVERFLOW;
 783   CONVERT_CY(VarI1FromCy,-128); EXPECT(128);
 784   CONVERT_CY(VarI1FromCy,-1);   EXPECT(-1);
 785   CONVERT_CY(VarI1FromCy,0);    EXPECT(0);
 786   CONVERT_CY(VarI1FromCy,1);    EXPECT(1);
 787   CONVERT_CY(VarI1FromCy,127);  EXPECT(127);
 788   CONVERT_CY(VarI1FromCy,128);  EXPECT_OVERFLOW;
 789
 790   CONVERT_CY(VarI1FromCy,-1.5); EXPECT(-2);
 791   CONVERT_CY(VarI1FromCy,-0.6); EXPECT(-1);
 792   CONVERT_CY(VarI1FromCy,-0.5); EXPECT(0);
 793   CONVERT_CY(VarI1FromCy,-0.4); EXPECT(0);
 794   CONVERT_CY(VarI1FromCy,0.4);  EXPECT(0);
 795   CONVERT_CY(VarI1FromCy,0.5);  EXPECT(0);
 796   CONVERT_CY(VarI1FromCy,0.6);  EXPECT(1);
 797   CONVERT_CY(VarI1FromCy,1.5);  EXPECT(2);
 798 }
 799
 800 static void test_VarI1FromDec(void)
 801 {
 802   CONVVARS(DECIMAL);
 803
 804   CHECKPTR(VarI1FromDec);
 805
 806   CONVERT_BADDEC(VarI1FromDec);
 807
 808   CONVERT_DEC(VarI1FromDec,0,0x80,0,129); EXPECT_OVERFLOW;
 809   CONVERT_DEC(VarI1FromDec,0,0x80,0,128); EXPECT(-128);
 810   CONVERT_DEC(VarI1FromDec,0,0x80,0,1);   EXPECT(-1);
 811   CONVERT_DEC(VarI1FromDec,0,0,0,0);      EXPECT(0);
 812   CONVERT_DEC(VarI1FromDec,0,0,0,1);      EXPECT(1);
 813   CONVERT_DEC(VarI1FromDec,0,0,0,127);    EXPECT(127);
 814   CONVERT_DEC(VarI1FromDec,0,0,0,128);    EXPECT_OVERFLOW;
 815
 816   CONVERT_DEC(VarI1FromDec,2,0x80,0,12800); EXPECT(-128);
 817   CONVERT_DEC(VarI1FromDec,2,0,0,12700);    EXPECT(127);
 818 }
 819
 820 static void test_VarI1FromStr(void)
 821 {
 822   CONVVARS(LCID);
 823   OLECHAR buff[128];
 824
 825   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
 826
 827   CHECKPTR(VarI1FromStr);
 828
 829   CONVERT_STR(VarI1FromStr,NULL, 0);   EXPECT_MISMATCH;
 830   CONVERT_STR(VarI1FromStr,"0", 0);    EXPECT(0);
 831   CONVERT_STR(VarI1FromStr,"-129", 0); EXPECT_OVERFLOW;
 832   CONVERT_STR(VarI1FromStr,"-128", 0); EXPECT(-128);
 833   CONVERT_STR(VarI1FromStr,"127", 0);  EXPECT(127);
 834   CONVERT_STR(VarI1FromStr,"128", 0);  EXPECT_OVERFLOW;
 835
 836   CONVERT_STR(VarI1FromStr,"-1.5", 0); EXPECT(-2);
 837   CONVERT_STR(VarI1FromStr,"-0.6", 0); EXPECT(-1);
 838   CONVERT_STR(VarI1FromStr,"-0.5", 0); EXPECT(0);
 839   CONVERT_STR(VarI1FromStr,"-0.4", 0); EXPECT(0);
 840   CONVERT_STR(VarI1FromStr,"0.4", 0);  EXPECT(0);
 841   CONVERT_STR(VarI1FromStr,"0.5", 0);  EXPECT(0);
 842   CONVERT_STR(VarI1FromStr,"0.6", 0);  EXPECT(1);
 843   CONVERT_STR(VarI1FromStr,"1.5", 0);  EXPECT(2);
 844 }
 845
 846 static void test_VarI1Copy(void)
 847 {
 848   if (!IS_ANCIENT)
 849   {
 850       COPYTEST(1, VT_I1, V_I1(&vSrc), V_I1(&vDst), V_I1REF(&vSrc), V_I1REF(&vDst), "%d");
 851   }
 852 }
 853
 854 static void test_VarI1ChangeTypeEx(void)
 855 {
 856   CONVVARS(CONV_TYPE);
 857   VARIANTARG vSrc, vDst;
 858
 859   in = 1;
 860
 861   if (!IS_ANCIENT)
 862   {
 863       INITIAL_TYPETEST(VT_I1, V_I1, "%d");
 864       COMMON_TYPETEST;
 865       NEGATIVE_TYPETEST(VT_I1, V_I1, "%d", VT_UI1, V_UI1);
 866   }
 867 }
 868
 869 #undef CONV_TYPE
 870 #define CONV_TYPE BYTE
 871
 872 static void test_VarUI1FromI1(void)
 873 {
 874   CONVVARS(signed char);
 875   int i;
 876
 877   CHECKPTR(VarUI1FromI1);
 878   OVERFLOWRANGE(VarUI1FromI1, -128, 0);
 879   CONVERTRANGE(VarUI1FromI1, 0, 128);
 880 }
 881
 882 static void test_VarUI1FromI2(void)
 883 {
 884   CONVVARS(SHORT);
 885   int i;
 886
 887   CHECKPTR(VarUI1FromI2);
 888   OVERFLOWRANGE(VarUI1FromI2, -32768, 0);
 889   CONVERTRANGE(VarUI1FromI2, 0, 256);
 890   OVERFLOWRANGE(VarUI1FromI2, 256, 32768);
 891 }
 892
 893 static void test_VarUI1FromI4(void)
 894 {
 895   CONVVARS(LONG);
 896   int i;
 897
 898   CHECKPTR(VarUI1FromI4);
 899   CONVERT(VarUI1FromI4, -1);  EXPECT_OVERFLOW;
 900   CONVERTRANGE(VarUI1FromI4, 0, 256);
 901   CONVERT(VarUI1FromI4, 256); EXPECT_OVERFLOW;
 902 }
 903
 904 static void test_VarUI1FromI8(void)
 905 {
 906   CONVVARS(LONG64);
 907   int i;
 908
 909   CHECKPTR(VarUI1FromI8);
 910   CONVERT(VarUI1FromI8, -1);  EXPECT_OVERFLOW;
 911   CONVERTRANGE(VarUI1FromI8, 0, 256);
 912   CONVERT(VarUI1FromI8, 256); EXPECT_OVERFLOW;
 913 }
 914
 915 static void test_VarUI1FromUI2(void)
 916 {
 917   CONVVARS(USHORT);
 918   int i;
 919
 920   CHECKPTR(VarUI1FromUI2);
 921   CONVERTRANGE(VarUI1FromUI2, 0, 256);
 922   OVERFLOWRANGE(VarUI1FromUI2, 256, 65536);
 923 }
 924
 925 static void test_VarUI1FromUI4(void)
 926 {
 927   CONVVARS(ULONG);
 928   int i;
 929
 930   CHECKPTR(VarUI1FromUI4);
 931   CONVERTRANGE(VarUI1FromUI4, 0, 256);
 932   CONVERT(VarUI1FromUI4, 256); EXPECT_OVERFLOW;
 933 }
 934
 935 static void test_VarUI1FromUI8(void)
 936 {
 937   CONVVARS(ULONG64);
 938   int i;
 939
 940   CHECKPTR(VarUI1FromUI8);
 941   CONVERTRANGE(VarUI1FromUI8, 0, 256);
 942   CONVERT(VarUI1FromUI8, 256); EXPECT_OVERFLOW;
 943 }
 944
 945 static void test_VarUI1FromBool(void)
 946 {
 947   CONVVARS(VARIANT_BOOL);
 948   int i;
 949
 950   CHECKPTR(VarUI1FromBool);
 951   /* Note that conversions from bool overflow! */
 952   CONVERT(VarUI1FromBool, -1); EXPECT(255);
 953   CONVERTRANGE(VarUI1FromBool, 0, 256);
 954   CONVERT(VarUI1FromBool, 256); EXPECT(0);
 955 }
 956
 957 static void test_VarUI1FromR4(void)
 958 {
 959   CONVVARS(FLOAT);
 960
 961   CHECKPTR(VarUI1FromR4);
 962   CONVERT(VarUI1FromR4, -1.0f);  EXPECT_OVERFLOW;
 963   CONVERT(VarUI1FromR4, 0.0f);   EXPECT(0);
 964   CONVERT(VarUI1FromR4, 1.0f);   EXPECT(1);
 965   CONVERT(VarUI1FromR4, 255.0f); EXPECT(255);
 966   CONVERT(VarUI1FromR4, 256.0f); EXPECT_OVERFLOW;
 967
 968   /* Rounding */
 969   CONVERT(VarUI1FromR4, -1.5f); EXPECT_OVERFLOW;
 970   CONVERT(VarUI1FromR4, -0.6f); EXPECT_OVERFLOW;
 971   CONVERT(VarUI1FromR4, -0.5f); EXPECT(0);
 972   CONVERT(VarUI1FromR4, -0.4f); EXPECT(0);
 973   CONVERT(VarUI1FromR4, 0.4f);  EXPECT(0);
 974   CONVERT(VarUI1FromR4, 0.5f);  EXPECT(0);
 975   CONVERT(VarUI1FromR4, 0.6f);  EXPECT(1);
 976   CONVERT(VarUI1FromR4, 1.5f);  EXPECT(2);
 977 }
 978
 979 static void test_VarUI1FromR8(void)
 980 {
 981   CONVVARS(DOUBLE);
 982
 983   CHECKPTR(VarUI1FromR8);
 984   CONVERT(VarUI1FromR8, -1.0);  EXPECT_OVERFLOW;
 985   CONVERT(VarUI1FromR8, 0.0);   EXPECT(0);
 986   CONVERT(VarUI1FromR8, 1.0);   EXPECT(1);
 987   CONVERT(VarUI1FromR8, 255.0); EXPECT(255);
 988   CONVERT(VarUI1FromR8, 256.0); EXPECT_OVERFLOW;
 989
 990   /* Rounding */
 991   CONVERT(VarUI1FromR8, -1.5); EXPECT_OVERFLOW;
 992   CONVERT(VarUI1FromR8, -0.6); EXPECT_OVERFLOW;
 993   CONVERT(VarUI1FromR8, -0.5); EXPECT(0);
 994   CONVERT(VarUI1FromR8, -0.4); EXPECT(0);
 995   CONVERT(VarUI1FromR8, 0.4);  EXPECT(0);
 996   CONVERT(VarUI1FromR8, 0.5);  EXPECT(0);
 997   CONVERT(VarUI1FromR8, 0.6);  EXPECT(1);
 998   CONVERT(VarUI1FromR8, 1.5);  EXPECT(2);
 999 }
1000
1001 static void test_VarUI1FromDate(void)
1002 {
1003   CONVVARS(DATE);
1004
1005   CHECKPTR(VarUI1FromDate);
1006   CONVERT(VarUI1FromDate, -1.0);  EXPECT_OVERFLOW;
1007   CONVERT(VarUI1FromDate, 0.0);   EXPECT(0);
1008   CONVERT(VarUI1FromDate, 1.0);   EXPECT(1);
1009   CONVERT(VarUI1FromDate, 255.0); EXPECT(255);
1010   CONVERT(VarUI1FromDate, 256.0); EXPECT_OVERFLOW;
1011
1012   /* Rounding */
1013   CONVERT(VarUI1FromDate, -1.5); EXPECT_OVERFLOW;
1014   CONVERT(VarUI1FromDate, -0.6); EXPECT_OVERFLOW;
1015   CONVERT(VarUI1FromDate, -0.5); EXPECT(0);
1016   CONVERT(VarUI1FromDate, -0.4); EXPECT(0);
1017   CONVERT(VarUI1FromDate, 0.4);  EXPECT(0);
1018   CONVERT(VarUI1FromDate, 0.5);  EXPECT(0);
1019   CONVERT(VarUI1FromDate, 0.6);  EXPECT(1);
1020   CONVERT(VarUI1FromDate, 1.5);  EXPECT(2);
1021 }
1022
1023 static void test_VarUI1FromCy(void)
1024 {
1025   CONVVARS(CY);
1026
1027   CHECKPTR(VarUI1FromCy);
1028   CONVERT_CY(VarUI1FromCy,-1);  EXPECT_OVERFLOW;
1029   CONVERT_CY(VarUI1FromCy,0);   EXPECT(0);
1030   CONVERT_CY(VarUI1FromCy,1);   EXPECT(1);
1031   CONVERT_CY(VarUI1FromCy,255); EXPECT(255);
1032   CONVERT_CY(VarUI1FromCy,256); EXPECT_OVERFLOW;
1033
1034   /* Rounding */
1035   CONVERT_CY(VarUI1FromCy,-1.5); EXPECT_OVERFLOW;
1036   CONVERT_CY(VarUI1FromCy,-0.6); EXPECT_OVERFLOW;
1037   CONVERT_CY(VarUI1FromCy,-0.5); EXPECT(0);
1038   CONVERT_CY(VarUI1FromCy,-0.4); EXPECT(0);
1039   CONVERT_CY(VarUI1FromCy,0.4);  EXPECT(0);
1040   CONVERT_CY(VarUI1FromCy,0.5);  EXPECT(0);
1041   CONVERT_CY(VarUI1FromCy,0.6);  EXPECT(1);
1042   CONVERT_CY(VarUI1FromCy,1.5);  EXPECT(2);
1043 }
1044
1045 static void test_VarUI1FromDec(void)
1046 {
1047   CONVVARS(DECIMAL);
1048
1049   CHECKPTR(VarUI1FromDec);
1050
1051   CONVERT_BADDEC(VarUI1FromDec);
1052
1053   CONVERT_DEC(VarUI1FromDec,0,0x80,0,1); EXPECT_OVERFLOW;
1054   CONVERT_DEC(VarUI1FromDec,0,0,0,0);    EXPECT(0);
1055   CONVERT_DEC(VarUI1FromDec,0,0,0,1);    EXPECT(1);
1056   CONVERT_DEC(VarUI1FromDec,0,0,0,255);  EXPECT(255);
1057   CONVERT_DEC(VarUI1FromDec,0,0,0,256);  EXPECT_OVERFLOW;
1058
1059   CONVERT_DEC(VarUI1FromDec,2,0x80,0,100); EXPECT_OVERFLOW;
1060   CONVERT_DEC(VarUI1FromDec,2,0,0,25500);  EXPECT(255);
1061 }
1062
1063 static void test_VarUI1FromStr(void)
1064 {
1065   CONVVARS(LCID);
1066   OLECHAR buff[128];
1067
1068   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1069
1070   CHECKPTR(VarUI1FromStr);
1071
1072   CONVERT_STR(VarUI1FromStr,NULL, 0);   EXPECT_MISMATCH;
1073   CONVERT_STR(VarUI1FromStr,"0", 0);    EXPECT(0);
1074   CONVERT_STR(VarUI1FromStr,"-1", 0);   EXPECT_OVERFLOW;
1075   CONVERT_STR(VarUI1FromStr,"255", 0);  EXPECT(255);
1076   CONVERT_STR(VarUI1FromStr,"256", 0);  EXPECT_OVERFLOW;
1077
1078   /* Rounding */
1079   CONVERT_STR(VarUI1FromStr,"-1.5", 0); EXPECT_OVERFLOW;
1080   CONVERT_STR(VarUI1FromStr,"-0.6", 0); EXPECT_OVERFLOW;
1081   CONVERT_STR(VarUI1FromStr,"-0.5", 0); EXPECT(0);
1082   CONVERT_STR(VarUI1FromStr,"-0.4", 0); EXPECT(0);
1083   CONVERT_STR(VarUI1FromStr,"0.4", 0);  EXPECT(0);
1084   CONVERT_STR(VarUI1FromStr,"0.5", 0);  EXPECT(0);
1085   CONVERT_STR(VarUI1FromStr,"0.6", 0);  EXPECT(1);
1086   CONVERT_STR(VarUI1FromStr,"1.5", 0);  EXPECT(2);
1087 }
1088
1089 static void test_VarUI1FromDisp(void)
1090 {
1091   CONVVARS(LCID);
1092   VARIANTARG vSrc, vDst;
1093
1094   CHECKPTR(VarUI1FromDisp);
1095
1096   /* FIXME
1097    * Conversions from IDispatch should get the default 'value' property
1098    * from the IDispatch pointer and return it. The following tests this.
1099    * However, I can't get these tests to return a valid value under native
1100    * oleaut32, regardless of the value returned in response to the Invoke()
1101    * call (early versions of oleaut32 call AddRef/Release, but not Invoke.
1102    * I'm obviously missing something, as these conversions work fine
1103    * when called through VBA on an object to get its default value property.
1104    *
1105    * Should this test be corrected so that it works under native it should be
1106    * generalised and the remaining types checked as well.
1107    */
1108   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1109
1110   VariantInit(&vSrc);
1111   VariantInit(&vDst);
1112
1113   V_VT(&vSrc) = VT_DISPATCH;
1114   V_DISPATCH(&vSrc) = (IDispatch*)&dispatch;
1115   dispatch.vt = VT_UI1;
1116   dispatch.bFailInvoke = FALSE;
1117
1118   hres = VarUI1FromDisp((IDispatch*)&dispatch, in, &out);
1119   trace("0x%08lx\n", hres);
1120
1121   hres = VariantChangeTypeEx(&vDst, &vSrc, in, 0, VT_UI1);
1122   trace("0x%08lx\n", hres);
1123
1124   dispatch.bFailInvoke = TRUE;
1125
1126   hres = VarUI1FromDisp((IDispatch*)&dispatch, in, &out);
1127   trace("0x%08lx\n", hres);
1128
1129   hres = VariantChangeTypeEx(&vDst, &vSrc, in, 0, VT_UI1);
1130   trace("0x%08lx\n", hres);
1131 }
1132
1133 static void test_VarUI1Copy(void)
1134 {
1135   COPYTEST(1, VT_UI1, V_UI1(&vSrc), V_UI1(&vDst), V_UI1REF(&vSrc), V_UI1REF(&vDst), "%d");
1136 }
1137
1138 static void test_VarUI1ChangeTypeEx(void)
1139 {
1140   CONVVARS(CONV_TYPE);
1141   VARIANTARG vSrc, vDst;
1142
1143   in = 1;
1144
1145   INITIAL_TYPETEST(VT_UI1, V_UI1, "%d");
1146   COMMON_TYPETEST;
1147   NEGATIVE_TYPETEST(VT_UI1, V_UI1, "%d", VT_I1, V_I1);
1148 }
1149
1150 /*
1151  * VT_I2/VT_UI2
1152  */
1153
1154 #undef CONV_TYPE
1155 #define CONV_TYPE SHORT
1156 #undef EXPECTRES
1157 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%d")
1158
1159 static void test_VarI2FromI1(void)
1160 {
1161   CONVVARS(signed char);
1162   int i;
1163
1164   CHECKPTR(VarI2FromI1);
1165   CONVERTRANGE(VarI2FromI1, -128, 128);
1166 }
1167
1168 static void test_VarI2FromI4(void)
1169 {
1170   CONVVARS(LONG);
1171   int i;
1172
1173   CHECKPTR(VarI2FromI4);
1174   CONVERT(VarI2FromI4, -32769); EXPECT_OVERFLOW;
1175   CONVERTRANGE(VarI2FromI4, -32768, 32768);
1176   CONVERT(VarI2FromI4, 32768);  EXPECT_OVERFLOW;
1177 }
1178
1179 static void test_VarI2FromI8(void)
1180 {
1181   CONVVARS(LONG64);
1182
1183   CHECKPTR(VarI2FromI8);
1184   CONVERT(VarI2FromI8, -32769); EXPECT_OVERFLOW;
1185   CONVERT(VarI2FromI8, -32768); EXPECT(-32768);
1186   CONVERT(VarI2FromI8, 32767);  EXPECT(32767);
1187   CONVERT(VarI2FromI8, 32768);  EXPECT_OVERFLOW;
1188 }
1189
1190 static void test_VarI2FromUI1(void)
1191 {
1192   CONVVARS(BYTE);
1193   int i;
1194
1195   CHECKPTR(VarI2FromUI1);
1196   CONVERTRANGE(VarI2FromUI1, 0, 256);
1197 }
1198
1199 static void test_VarI2FromUI2(void)
1200 {
1201   CONVVARS(USHORT);
1202   int i;
1203
1204   CHECKPTR(VarI2FromUI2);
1205   CONVERTRANGE(VarI2FromUI2, 0, 32768);
1206   CONVERT(VarI2FromUI2, 32768); EXPECT_OVERFLOW;
1207 }
1208
1209 static void test_VarI2FromUI4(void)
1210 {
1211   CONVVARS(ULONG);
1212   int i;
1213
1214   CHECKPTR(VarI2FromUI4);
1215   CONVERTRANGE(VarI2FromUI4, 0, 32768);
1216   CONVERT(VarI2FromUI4, 32768); EXPECT_OVERFLOW;
1217 }
1218
1219 static void test_VarI2FromUI8(void)
1220 {
1221   CONVVARS(ULONG64);
1222   int i;
1223
1224   CHECKPTR(VarI2FromUI8);
1225   CONVERTRANGE(VarI2FromUI8, 0, 32768);
1226   CONVERT(VarI2FromUI8, 32768); EXPECT_OVERFLOW;
1227 }
1228
1229 static void test_VarI2FromBool(void)
1230 {
1231   CONVVARS(VARIANT_BOOL);
1232   int i;
1233
1234   CHECKPTR(VarI2FromBool);
1235   CONVERTRANGE(VarI2FromBool, -32768, 32768);
1236 }
1237
1238 static void test_VarI2FromR4(void)
1239 {
1240   CONVVARS(FLOAT);
1241
1242   CHECKPTR(VarI2FromR4);
1243   CONVERT(VarI2FromR4, -32769.0f); EXPECT_OVERFLOW;
1244   CONVERT(VarI2FromR4, -32768.0f); EXPECT(-32768);
1245   CONVERT(VarI2FromR4, -1.0f);     EXPECT(-1);
1246   CONVERT(VarI2FromR4, 0.0f);      EXPECT(0);
1247   CONVERT(VarI2FromR4, 1.0f);      EXPECT(1);
1248   CONVERT(VarI2FromR4, 32767.0f);  EXPECT(32767);
1249   CONVERT(VarI2FromR4, 32768.0f);  EXPECT_OVERFLOW;
1250
1251   /* Rounding */
1252   CONVERT(VarI2FromR4, -1.5f); EXPECT(-2);
1253   CONVERT(VarI2FromR4, -0.6f); EXPECT(-1);
1254   CONVERT(VarI2FromR4, -0.5f); EXPECT(0);
1255   CONVERT(VarI2FromR4, -0.4f); EXPECT(0);
1256   CONVERT(VarI2FromR4, 0.4f);  EXPECT(0);
1257   CONVERT(VarI2FromR4, 0.5f);  EXPECT(0);
1258   CONVERT(VarI2FromR4, 0.6f);  EXPECT(1);
1259   CONVERT(VarI2FromR4, 1.5f);  EXPECT(2);
1260 }
1261
1262 static void test_VarI2FromR8(void)
1263 {
1264   CONVVARS(DOUBLE);
1265
1266   CHECKPTR(VarI2FromR8);
1267   CONVERT(VarI2FromR8, -32769.0); EXPECT_OVERFLOW;
1268   CONVERT(VarI2FromR8, -32768.0); EXPECT(-32768);
1269   CONVERT(VarI2FromR8, -1.0);     EXPECT(-1);
1270   CONVERT(VarI2FromR8, 0.0);      EXPECT(0);
1271   CONVERT(VarI2FromR8, 1.0);      EXPECT(1);
1272   CONVERT(VarI2FromR8, 32767.0);  EXPECT(32767);
1273   CONVERT(VarI2FromR8, 32768.0);  EXPECT_OVERFLOW;
1274
1275   /* Rounding */
1276   CONVERT(VarI2FromR8, -1.5); EXPECT(-2);
1277   CONVERT(VarI2FromR8, -0.6); EXPECT(-1);
1278   CONVERT(VarI2FromR8, -0.5); EXPECT(0);
1279   CONVERT(VarI2FromR8, -0.4); EXPECT(0);
1280   CONVERT(VarI2FromR8, 0.4);  EXPECT(0);
1281   CONVERT(VarI2FromR8, 0.5);  EXPECT(0);
1282   CONVERT(VarI2FromR8, 0.6);  EXPECT(1);
1283   CONVERT(VarI2FromR8, 1.5);  EXPECT(2);
1284 }
1285
1286 static void test_VarI2FromDate(void)
1287 {
1288   CONVVARS(DATE);
1289
1290   CHECKPTR(VarI2FromDate);
1291   CONVERT(VarI2FromDate, -32769.0); EXPECT_OVERFLOW;
1292   CONVERT(VarI2FromDate, -32768.0); EXPECT(-32768);
1293   CONVERT(VarI2FromDate, -1.0);   EXPECT(-1);
1294   CONVERT(VarI2FromDate, 0.0);    EXPECT(0);
1295   CONVERT(VarI2FromDate, 1.0);    EXPECT(1);
1296   CONVERT(VarI2FromDate, 32767.0);  EXPECT(32767);
1297   CONVERT(VarI2FromDate, 32768.0);  EXPECT_OVERFLOW;
1298
1299   /* Rounding */
1300   CONVERT(VarI2FromDate, -1.5); EXPECT(-2);
1301   CONVERT(VarI2FromDate, -0.6); EXPECT(-1);
1302   CONVERT(VarI2FromDate, -0.5); EXPECT(0);
1303   CONVERT(VarI2FromDate, -0.4); EXPECT(0);
1304   CONVERT(VarI2FromDate, 0.4);  EXPECT(0);
1305   CONVERT(VarI2FromDate, 0.5);  EXPECT(0);
1306   CONVERT(VarI2FromDate, 0.6);  EXPECT(1);
1307   CONVERT(VarI2FromDate, 1.5);  EXPECT(2);
1308 }
1309
1310 static void test_VarI2FromCy(void)
1311 {
1312   CONVVARS(CY);
1313
1314   CHECKPTR(VarI2FromCy);
1315   CONVERT_CY(VarI2FromCy,-32769); EXPECT_OVERFLOW;
1316   CONVERT_CY(VarI2FromCy,-32768); EXPECT(32768);
1317   CONVERT_CY(VarI2FromCy,-1);     EXPECT(-1);
1318   CONVERT_CY(VarI2FromCy,0);      EXPECT(0);
1319   CONVERT_CY(VarI2FromCy,1);      EXPECT(1);
1320   CONVERT_CY(VarI2FromCy,32767);  EXPECT(32767);
1321   CONVERT_CY(VarI2FromCy,32768);  EXPECT_OVERFLOW;
1322
1323   /* Rounding */
1324   CONVERT_CY(VarI2FromCy,-1.5); EXPECT(-2);
1325   CONVERT_CY(VarI2FromCy,-0.6); EXPECT(-1);
1326   CONVERT_CY(VarI2FromCy,-0.5); EXPECT(0);
1327   CONVERT_CY(VarI2FromCy,-0.4); EXPECT(0);
1328   CONVERT_CY(VarI2FromCy,0.4);  EXPECT(0);
1329   CONVERT_CY(VarI2FromCy,0.5);  EXPECT(0);
1330   CONVERT_CY(VarI2FromCy,0.6);  EXPECT(1);
1331   CONVERT_CY(VarI2FromCy,1.5);  EXPECT(2);
1332 }
1333
1334 static void test_VarI2FromDec(void)
1335 {
1336   CONVVARS(DECIMAL);
1337
1338   CHECKPTR(VarI2FromDec);
1339
1340   CONVERT_BADDEC(VarI2FromDec);
1341
1342   CONVERT_DEC(VarI2FromDec,0,0x80,0,32769); EXPECT_OVERFLOW;
1343   CONVERT_DEC(VarI2FromDec,0,0x80,0,32768); EXPECT(-32768);
1344   CONVERT_DEC(VarI2FromDec,0,0x80,0,1);     EXPECT(-1);
1345   CONVERT_DEC(VarI2FromDec,0,0,0,0);        EXPECT(0);
1346   CONVERT_DEC(VarI2FromDec,0,0,0,1);        EXPECT(1);
1347   CONVERT_DEC(VarI2FromDec,0,0,0,32767);    EXPECT(32767);
1348   CONVERT_DEC(VarI2FromDec,0,0,0,32768);    EXPECT_OVERFLOW;
1349
1350   CONVERT_DEC(VarI2FromDec,2,0x80,0,3276800); EXPECT(-32768);
1351   CONVERT_DEC(VarI2FromDec,2,0,0,3276700);    EXPECT(32767);
1352   CONVERT_DEC(VarI2FromDec,2,0,0,3276800);    EXPECT_OVERFLOW;
1353 }
1354
1355 static void test_VarI2FromStr(void)
1356 {
1357   CONVVARS(LCID);
1358   OLECHAR buff[128];
1359
1360   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1361
1362   CHECKPTR(VarI2FromStr);
1363
1364   CONVERT_STR(VarI2FromStr,NULL, 0);     EXPECT_MISMATCH;
1365   CONVERT_STR(VarI2FromStr,"0", 0);      EXPECT(0);
1366   CONVERT_STR(VarI2FromStr,"-32769", 0); EXPECT_OVERFLOW;
1367   CONVERT_STR(VarI2FromStr,"-32768", 0); EXPECT(-32768);
1368   CONVERT_STR(VarI2FromStr,"32767", 0);  EXPECT(32767);
1369   CONVERT_STR(VarI2FromStr,"32768", 0);  EXPECT_OVERFLOW;
1370
1371   /* Rounding */
1372   CONVERT_STR(VarI2FromStr,"-1.5", 0); EXPECT(-2);
1373   CONVERT_STR(VarI2FromStr,"-0.6", 0); EXPECT(-1);
1374   CONVERT_STR(VarI2FromStr,"-0.5", 0); EXPECT(0);
1375   CONVERT_STR(VarI2FromStr,"-0.4", 0); EXPECT(0);
1376   CONVERT_STR(VarI2FromStr,"0.4", 0);  EXPECT(0);
1377   CONVERT_STR(VarI2FromStr,"0.5", 0);  EXPECT(0);
1378   CONVERT_STR(VarI2FromStr,"0.6", 0);  EXPECT(1);
1379   CONVERT_STR(VarI2FromStr,"1.5", 0);  EXPECT(2);
1380 }
1381
1382 static void test_VarI2Copy(void)
1383 {
1384   COPYTEST(1, VT_I2, V_I2(&vSrc), V_I2(&vDst), V_I2REF(&vSrc), V_I2REF(&vDst), "%d");
1385 }
1386
1387 static void test_VarI2ChangeTypeEx(void)
1388 {
1389   CONVVARS(CONV_TYPE);
1390   VARIANTARG vSrc, vDst;
1391
1392   in = 1;
1393
1394   INITIAL_TYPETEST(VT_I2, V_I2, "%d");
1395   COMMON_TYPETEST;
1396   NEGATIVE_TYPETEST(VT_I2, V_I2, "%d", VT_UI2, V_UI2);
1397 }
1398
1399 #undef CONV_TYPE
1400 #define CONV_TYPE USHORT
1401
1402 static void test_VarUI2FromI1(void)
1403 {
1404   CONVVARS(signed char);
1405   int i;
1406
1407   CHECKPTR(VarUI2FromI1);
1408   OVERFLOWRANGE(VarUI2FromI1, -128, 0);
1409   CONVERTRANGE(VarUI2FromI1, 0, 128);
1410 }
1411
1412 static void test_VarUI2FromI2(void)
1413 {
1414   CONVVARS(SHORT);
1415   int i;
1416
1417   CHECKPTR(VarUI2FromI2);
1418   OVERFLOWRANGE(VarUI2FromI2, -32768, 0);
1419   CONVERTRANGE(VarUI2FromI2, 0, 32768);
1420 }
1421
1422 static void test_VarUI2FromI4(void)
1423 {
1424   CONVVARS(LONG);
1425   int i;
1426
1427   CHECKPTR(VarUI2FromI4);
1428   OVERFLOWRANGE(VarUI2FromI4, -32768, 0);
1429   CONVERT(VarUI2FromI4, 0);     EXPECT(0);
1430   CONVERT(VarUI2FromI4, 65535); EXPECT(65535);
1431   CONVERT(VarUI2FromI4, 65536); EXPECT_OVERFLOW;
1432 }
1433
1434 static void test_VarUI2FromI8(void)
1435 {
1436   CONVVARS(LONG64);
1437   int i;
1438
1439   CHECKPTR(VarUI2FromI8);
1440   OVERFLOWRANGE(VarUI2FromI8, -32768, 0);
1441   CONVERT(VarUI2FromI8, 0);     EXPECT(0);
1442   CONVERT(VarUI2FromI8, 65535); EXPECT(65535);
1443   CONVERT(VarUI2FromI8, 65536); EXPECT_OVERFLOW;
1444 }
1445
1446 static void test_VarUI2FromUI1(void)
1447 {
1448   CONVVARS(BYTE);
1449   int i;
1450
1451   CHECKPTR(VarUI2FromUI1);
1452   CONVERTRANGE(VarUI2FromUI1, 0, 256);
1453 }
1454
1455 static void test_VarUI2FromUI4(void)
1456 {
1457   CONVVARS(ULONG);
1458
1459   CHECKPTR(VarUI2FromUI4);
1460   CONVERT(VarUI2FromUI4, 0);     EXPECT(0);
1461   CONVERT(VarUI2FromUI4, 65535); EXPECT(65535);
1462   CONVERT(VarUI2FromUI4, 65536); EXPECT_OVERFLOW;
1463 }
1464
1465 static void test_VarUI2FromUI8(void)
1466 {
1467   CONVVARS(ULONG64);
1468
1469   CHECKPTR(VarUI2FromUI8);
1470   CONVERT(VarUI2FromUI8, 0);     EXPECT(0);
1471   CONVERT(VarUI2FromUI8, 65535); EXPECT(65535);
1472   CONVERT(VarUI2FromUI8, 65536); EXPECT_OVERFLOW;
1473 }
1474
1475 static void test_VarUI2FromBool(void)
1476 {
1477   CONVVARS(VARIANT_BOOL);
1478   int i;
1479
1480   CHECKPTR(VarUI2FromBool);
1481   CONVERT(VarUI2FromBool, -1); EXPECT(65535); /* Wraps! */
1482   CONVERTRANGE(VarUI2FromBool, 0, 32768);
1483 }
1484
1485 static void test_VarUI2FromR4(void)
1486 {
1487   CONVVARS(FLOAT);
1488
1489   CHECKPTR(VarUI2FromR4);
1490   CONVERT(VarUI2FromR4, -1.0f);    EXPECT_OVERFLOW;
1491   CONVERT(VarUI2FromR4, 0.0f);     EXPECT(0);
1492   CONVERT(VarUI2FromR4, 1.0f);     EXPECT(1);
1493   CONVERT(VarUI2FromR4, 65535.0f); EXPECT(65535);
1494   CONVERT(VarUI2FromR4, 65536.0f); EXPECT_OVERFLOW;
1495
1496   /* Rounding */
1497   CONVERT(VarUI2FromR4, -1.5f); EXPECT_OVERFLOW;
1498   CONVERT(VarUI2FromR4, -0.6f); EXPECT_OVERFLOW;
1499   CONVERT(VarUI2FromR4, -0.5f); EXPECT(0);
1500   CONVERT(VarUI2FromR4, -0.4f); EXPECT(0);
1501   CONVERT(VarUI2FromR4, 0.4f);  EXPECT(0);
1502   CONVERT(VarUI2FromR4, 0.5f);  EXPECT(0);
1503   CONVERT(VarUI2FromR4, 0.6f);  EXPECT(1);
1504   CONVERT(VarUI2FromR4, 1.5f);  EXPECT(2);
1505 }
1506
1507 static void test_VarUI2FromR8(void)
1508 {
1509   CONVVARS(DOUBLE);
1510
1511   CHECKPTR(VarUI2FromR8);
1512   CONVERT(VarUI2FromR8, -1.0);    EXPECT_OVERFLOW;
1513   CONVERT(VarUI2FromR8, 0.0);     EXPECT(0);
1514   CONVERT(VarUI2FromR8, 1.0);     EXPECT(1);
1515   CONVERT(VarUI2FromR8, 65535.0); EXPECT(65535);
1516   CONVERT(VarUI2FromR8, 65536.0); EXPECT_OVERFLOW;
1517
1518   /* Rounding */
1519   CONVERT(VarUI2FromR8, -1.5); EXPECT_OVERFLOW;
1520   CONVERT(VarUI2FromR8, -0.6); EXPECT_OVERFLOW;
1521   CONVERT(VarUI2FromR8, -0.5); EXPECT(0);
1522   CONVERT(VarUI2FromR8, -0.4); EXPECT(0);
1523   CONVERT(VarUI2FromR8, 0.4);  EXPECT(0);
1524   CONVERT(VarUI2FromR8, 0.5);  EXPECT(0);
1525   CONVERT(VarUI2FromR8, 0.6);  EXPECT(1);
1526   CONVERT(VarUI2FromR8, 1.5);  EXPECT(2);
1527 }
1528
1529 static void test_VarUI2FromDate(void)
1530 {
1531   CONVVARS(DATE);
1532
1533   CHECKPTR(VarUI2FromDate);
1534   CONVERT(VarUI2FromDate, -1.0);    EXPECT_OVERFLOW;
1535   CONVERT(VarUI2FromDate, 0.0);     EXPECT(0);
1536   CONVERT(VarUI2FromDate, 1.0);     EXPECT(1);
1537   CONVERT(VarUI2FromDate, 65535.0); EXPECT(65535);
1538   CONVERT(VarUI2FromDate, 65536.0); EXPECT_OVERFLOW;
1539
1540   /* Rounding */
1541   CONVERT(VarUI2FromDate, -1.5); EXPECT_OVERFLOW;
1542   CONVERT(VarUI2FromDate, -0.6); EXPECT_OVERFLOW;
1543   CONVERT(VarUI2FromDate, -0.5); EXPECT(0);
1544   CONVERT(VarUI2FromDate, -0.4); EXPECT(0);
1545   CONVERT(VarUI2FromDate, 0.4);  EXPECT(0);
1546   CONVERT(VarUI2FromDate, 0.5);  EXPECT(0);
1547   CONVERT(VarUI2FromDate, 0.6);  EXPECT(1);
1548   CONVERT(VarUI2FromDate, 1.5);  EXPECT(2);
1549 }
1550
1551 static void test_VarUI2FromCy(void)
1552 {
1553   CONVVARS(CY);
1554
1555   CHECKPTR(VarUI2FromCy);
1556   CONVERT_CY(VarUI2FromCy,-1);    EXPECT_OVERFLOW;
1557   CONVERT_CY(VarUI2FromCy,0);     EXPECT(0);
1558   CONVERT_CY(VarUI2FromCy,1);     EXPECT(1);
1559   CONVERT_CY(VarUI2FromCy,65535); EXPECT(65535);
1560   CONVERT_CY(VarUI2FromCy,65536); EXPECT_OVERFLOW;
1561
1562   /* Rounding */
1563   CONVERT_CY(VarUI2FromCy,-1.5); EXPECT_OVERFLOW;
1564   CONVERT_CY(VarUI2FromCy,-0.6); EXPECT_OVERFLOW;
1565   CONVERT_CY(VarUI2FromCy,-0.5); EXPECT(0);
1566   CONVERT_CY(VarUI2FromCy,-0.4); EXPECT(0);
1567   CONVERT_CY(VarUI2FromCy,0.4);  EXPECT(0);
1568   CONVERT_CY(VarUI2FromCy,0.5);  EXPECT(0);
1569   CONVERT_CY(VarUI2FromCy,0.6);  EXPECT(1);
1570   CONVERT_CY(VarUI2FromCy,1.5);  EXPECT(2);
1571 }
1572
1573 static void test_VarUI2FromDec(void)
1574 {
1575   CONVVARS(DECIMAL);
1576
1577   CHECKPTR(VarUI2FromDec);
1578
1579   CONVERT_BADDEC(VarUI2FromDec);
1580
1581   CONVERT_DEC(VarUI2FromDec,0,0x80,0,1);  EXPECT_OVERFLOW;
1582   CONVERT_DEC(VarUI2FromDec,0,0,0,0);     EXPECT(0);
1583   CONVERT_DEC(VarUI2FromDec,0,0,0,1);     EXPECT(1);
1584   CONVERT_DEC(VarUI2FromDec,0,0,0,65535); EXPECT(65535);
1585   CONVERT_DEC(VarUI2FromDec,0,0,0,65536); EXPECT_OVERFLOW;
1586
1587   CONVERT_DEC(VarUI2FromDec,2,0x80,0,100);  EXPECT_OVERFLOW;
1588   CONVERT_DEC(VarUI2FromDec,2,0,0,6553500); EXPECT(65535);
1589   CONVERT_DEC(VarUI2FromDec,2,0,0,6553600); EXPECT_OVERFLOW;
1590 }
1591
1592 static void test_VarUI2FromStr(void)
1593 {
1594   CONVVARS(LCID);
1595   OLECHAR buff[128];
1596
1597   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1598
1599   CHECKPTR(VarUI2FromStr);
1600
1601   CONVERT_STR(VarUI2FromStr,NULL, 0);    EXPECT_MISMATCH;
1602   CONVERT_STR(VarUI2FromStr,"0", 0);     EXPECT(0);
1603   CONVERT_STR(VarUI2FromStr,"-1", 0);    EXPECT_OVERFLOW;
1604   CONVERT_STR(VarUI2FromStr,"65535", 0); EXPECT(65535);
1605   CONVERT_STR(VarUI2FromStr,"65536", 0); EXPECT_OVERFLOW;
1606
1607   /* Rounding */
1608   CONVERT_STR(VarUI2FromStr,"-1.5", 0); EXPECT_OVERFLOW;
1609   CONVERT_STR(VarUI2FromStr,"-0.6", 0); EXPECT_OVERFLOW;
1610   CONVERT_STR(VarUI2FromStr,"-0.5", 0); EXPECT(0);
1611   CONVERT_STR(VarUI2FromStr,"-0.4", 0); EXPECT(0);
1612   CONVERT_STR(VarUI2FromStr,"0.4", 0);  EXPECT(0);
1613   CONVERT_STR(VarUI2FromStr,"0.5", 0);  EXPECT(0);
1614   CONVERT_STR(VarUI2FromStr,"0.6", 0);  EXPECT(1);
1615   CONVERT_STR(VarUI2FromStr,"1.5", 0);  EXPECT(2);
1616 }
1617
1618 static void test_VarUI2Copy(void)
1619 {
1620   if (!IS_ANCIENT)
1621   {
1622       COPYTEST(1, VT_UI2, V_UI2(&vSrc), V_UI2(&vDst), V_UI2REF(&vSrc), V_UI2REF(&vDst), "%d");
1623   }
1624 }
1625
1626 static void test_VarUI2ChangeTypeEx(void)
1627 {
1628   CONVVARS(CONV_TYPE);
1629   VARIANTARG vSrc, vDst;
1630
1631   in = 1;
1632
1633   if (!IS_ANCIENT)
1634   {
1635     INITIAL_TYPETEST(VT_UI2, V_UI2, "%d");
1636     COMMON_TYPETEST;
1637     NEGATIVE_TYPETEST(VT_UI2, V_UI2, "%d", VT_I2, V_I2);
1638   }
1639 }
1640
1641 /*
1642  * VT_I4/VT_UI4
1643  */
1644
1645 #undef CONV_TYPE
1646 #define CONV_TYPE LONG
1647 #undef EXPECTRES
1648 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%ld")
1649
1650
1651 static void test_VarI4FromI1(void)
1652 {
1653   CONVVARS(signed char);
1654   int i;
1655
1656   CHECKPTR(VarI4FromI1);
1657   CONVERTRANGE(VarI4FromI1, -128, 128);
1658 }
1659
1660 static void test_VarI4FromI2(void)
1661 {
1662   CONVVARS(SHORT);
1663   int i;
1664
1665   CHECKPTR(VarI4FromI2);
1666   CONVERTRANGE(VarI4FromI2, -32768, 32768);
1667 }
1668
1669 static void test_VarI4FromI8(void)
1670 {
1671   CONVVARS(LONG64);
1672
1673   CHECKPTR(VarI4FromI8);
1674   CHECKPTR(VarI4FromDec);
1675
1676   CONVERT(VarI4FromI8, -1);                   EXPECT(-1);
1677   CONVERT(VarI4FromI8, 0);                    EXPECT(0);
1678   CONVERT(VarI4FromI8, 1);                    EXPECT(1);
1679
1680   CONVERT_I8(VarI4FromI8, -1, 2147483647ul); EXPECT_OVERFLOW;
1681   CONVERT_I8(VarI4FromI8, -1, 2147483648ul); EXPECT(-2147483647 - 1);
1682   CONVERT_I8(VarI4FromI8, 0, 2147483647ul);  EXPECT(2147483647);
1683   CONVERT_I8(VarI4FromI8, 0, 2147483648ul);  EXPECT_OVERFLOW;
1684 }
1685
1686 static void test_VarI4FromUI1(void)
1687 {
1688   CONVVARS(BYTE);
1689   int i;
1690
1691   CHECKPTR(VarI4FromUI1);
1692   CONVERTRANGE(VarI4FromUI1, 0, 256);
1693 }
1694
1695 static void test_VarI4FromUI2(void)
1696 {
1697   CONVVARS(USHORT);
1698   int i;
1699
1700   CHECKPTR(VarI4FromUI2);
1701   CONVERTRANGE(VarI4FromUI2, 0, 65536);
1702 }
1703
1704 static void test_VarI4FromUI4(void)
1705 {
1706   CONVVARS(ULONG);
1707
1708   CHECKPTR(VarI4FromUI4);
1709   CONVERT(VarI4FromUI4, 0);            EXPECT(0);
1710   CONVERT(VarI4FromUI4, 1);            EXPECT(1);
1711   CONVERT(VarI4FromUI4, 2147483647);   EXPECT(2147483647);
1712   CONVERT(VarI4FromUI4, 2147483648ul); EXPECT_OVERFLOW;
1713 }
1714
1715 static void test_VarI4FromUI8(void)
1716 {
1717   CONVVARS(ULONG64);
1718
1719   CHECKPTR(VarI4FromUI8);
1720   CONVERT(VarI4FromUI8, 0);             EXPECT(0);
1721   CONVERT(VarI4FromUI8, 1);             EXPECT(1);
1722   CONVERT(VarI4FromUI8, 2147483647);    EXPECT(2147483647);
1723   CONVERT(VarI4FromUI8, 2147483648ul);  EXPECT_OVERFLOW;
1724 }
1725
1726 static void test_VarI4FromBool(void)
1727 {
1728   CONVVARS(VARIANT_BOOL);
1729   int i;
1730
1731   CHECKPTR(VarI4FromBool);
1732   CONVERTRANGE(VarI4FromBool, -32768, 32768);
1733 }
1734
1735 static void test_VarI4FromR4(void)
1736 {
1737   CONVVARS(FLOAT);
1738
1739   CHECKPTR(VarI4FromR4);
1740
1741   /* min/max values are not exactly representable in a float */
1742   CONVERT(VarI4FromR4, -1.0f); EXPECT(-1);
1743   CONVERT(VarI4FromR4, 0.0f);  EXPECT(0);
1744   CONVERT(VarI4FromR4, 1.0f);  EXPECT(1);
1745
1746   CONVERT(VarI4FromR4, -1.5f); EXPECT(-2);
1747   CONVERT(VarI4FromR4, -0.6f); EXPECT(-1);
1748   CONVERT(VarI4FromR4, -0.5f); EXPECT(0);
1749   CONVERT(VarI4FromR4, -0.4f); EXPECT(0);
1750   CONVERT(VarI4FromR4, 0.4f);  EXPECT(0);
1751   CONVERT(VarI4FromR4, 0.5f);  EXPECT(0);
1752   CONVERT(VarI4FromR4, 0.6f);  EXPECT(1);
1753   CONVERT(VarI4FromR4, 1.5f);  EXPECT(2);
1754 }
1755
1756 static void test_VarI4FromR8(void)
1757 {
1758   CONVVARS(DOUBLE);
1759
1760   CHECKPTR(VarI4FromR8);
1761   CONVERT(VarI4FromR8, -2147483649.0); EXPECT_OVERFLOW;
1762   CONVERT(VarI4FromR8, -2147483648.0); EXPECT(-2147483647 - 1);
1763   CONVERT(VarI4FromR8, -1.0);          EXPECT(-1);
1764   CONVERT(VarI4FromR8, 0.0);           EXPECT(0);
1765   CONVERT(VarI4FromR8, 1.0);           EXPECT(1);
1766   CONVERT(VarI4FromR8, 2147483647.0);  EXPECT(2147483647);
1767   CONVERT(VarI4FromR8, 2147483648.0);  EXPECT_OVERFLOW;
1768
1769   CONVERT(VarI4FromR8, -1.5); EXPECT(-2);
1770   CONVERT(VarI4FromR8, -0.6); EXPECT(-1);
1771   CONVERT(VarI4FromR8, -0.5); EXPECT(0);
1772   CONVERT(VarI4FromR8, -0.4); EXPECT(0);
1773   CONVERT(VarI4FromR8, 0.4);  EXPECT(0);
1774   CONVERT(VarI4FromR8, 0.5);  EXPECT(0);
1775   CONVERT(VarI4FromR8, 0.6);  EXPECT(1);
1776   CONVERT(VarI4FromR8, 1.5);  EXPECT(2);
1777 }
1778
1779 static void test_VarI4FromDate(void)
1780 {
1781   CONVVARS(DATE);
1782
1783   CHECKPTR(VarI4FromDate);
1784   CONVERT(VarI4FromDate, -2147483649.0); EXPECT_OVERFLOW;
1785   CONVERT(VarI4FromDate, -2147483648.0); EXPECT(-2147483647 - 1);
1786   CONVERT(VarI4FromDate, -1.0);          EXPECT(-1);
1787   CONVERT(VarI4FromDate, 0.0);           EXPECT(0);
1788   CONVERT(VarI4FromDate, 1.0);           EXPECT(1);
1789   CONVERT(VarI4FromDate, 2147483647.0);  EXPECT(2147483647);
1790   CONVERT(VarI4FromDate, 2147483648.0);  EXPECT_OVERFLOW;
1791
1792   CONVERT(VarI4FromDate, -1.5); EXPECT(-2);
1793   CONVERT(VarI4FromDate, -0.6); EXPECT(-1);
1794   CONVERT(VarI4FromDate, -0.5); EXPECT(0);
1795   CONVERT(VarI4FromDate, -0.4); EXPECT(0);
1796   CONVERT(VarI4FromDate, 0.4);  EXPECT(0);
1797   CONVERT(VarI4FromDate, 0.5);  EXPECT(0);
1798   CONVERT(VarI4FromDate, 0.6);  EXPECT(1);
1799   CONVERT(VarI4FromDate, 1.5);  EXPECT(2);
1800 }
1801
1802 static void test_VarI4FromCy(void)
1803 {
1804   CONVVARS(CY);
1805
1806   CHECKPTR(VarI4FromCy);
1807   CONVERT_CY(VarI4FromCy,-1); EXPECT(-1);
1808   CONVERT_CY(VarI4FromCy,0);  EXPECT(0);
1809   CONVERT_CY(VarI4FromCy,1);  EXPECT(1);
1810
1811   CONVERT_CY64(VarI4FromCy,-1,2147483647ul); EXPECT_OVERFLOW;
1812   CONVERT_CY64(VarI4FromCy,-1,2147483648ul); EXPECT(-2147483647 - 1);
1813   CONVERT_CY64(VarI4FromCy,0,2147483647ul);  EXPECT(2147483647ul);
1814   CONVERT_CY64(VarI4FromCy,0,2147483648ul);  EXPECT_OVERFLOW;
1815
1816   CONVERT_CY(VarI4FromCy,-1.5); EXPECT(-2);
1817   CONVERT_CY(VarI4FromCy,-0.6); EXPECT(-1);
1818   CONVERT_CY(VarI4FromCy,-0.5); EXPECT(0);
1819   CONVERT_CY(VarI4FromCy,-0.4); EXPECT(0);
1820   CONVERT_CY(VarI4FromCy,0.4);  EXPECT(0);
1821   CONVERT_CY(VarI4FromCy,0.5);  EXPECT(0);
1822   CONVERT_CY(VarI4FromCy,0.6);  EXPECT(1);
1823   CONVERT_CY(VarI4FromCy,1.5);  EXPECT(2);
1824 }
1825
1826 static void test_VarI4FromDec(void)
1827 {
1828   CONVVARS(DECIMAL);
1829
1830   CHECKPTR(VarI4FromDec);
1831
1832   CONVERT_BADDEC(VarI4FromDec);
1833
1834   CONVERT_DEC(VarI4FromDec,0,0x80,0,1); EXPECT(-1);
1835   CONVERT_DEC(VarI4FromDec,0,0,0,0);    EXPECT(0);
1836   CONVERT_DEC(VarI4FromDec,0,0,0,1);    EXPECT(1);
1837
1838   CONVERT_DEC64(VarI4FromDec,0,0x80,0,0,2147483649ul);  EXPECT_OVERFLOW;
1839   CONVERT_DEC64(VarI4FromDec,0,0x80,0,0,2147483648ul);  EXPECT(-2147483647 - 1);
1840   CONVERT_DEC64(VarI4FromDec,0,0,0,0,2147483647ul);     EXPECT(2147483647ul);
1841   CONVERT_DEC64(VarI4FromDec,0,0,0,0,2147483648ul);     EXPECT_OVERFLOW;
1842
1843   CONVERT_DEC64(VarI4FromDec,2,0x80,0,50,100);       EXPECT_OVERFLOW;
1844   CONVERT_DEC64(VarI4FromDec,2,0x80,0,50,0);         EXPECT(-2147483647 - 1);
1845   CONVERT_DEC64(VarI4FromDec,2,0,0,49,4294967196ul); EXPECT(2147483647);
1846   CONVERT_DEC64(VarI4FromDec,2,0,0,50,0);            EXPECT_OVERFLOW;
1847 }
1848
1849 static void test_VarI4FromStr(void)
1850 {
1851   CONVVARS(LCID);
1852   OLECHAR buff[128];
1853
1854   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1855
1856   CHECKPTR(VarI4FromStr);
1857
1858   CONVERT_STR(VarI4FromStr,NULL,0);          EXPECT_MISMATCH;
1859   CONVERT_STR(VarI4FromStr,"0",0);           EXPECT(0);
1860   CONVERT_STR(VarI4FromStr,"-2147483649",0); EXPECT_OVERFLOW;
1861   CONVERT_STR(VarI4FromStr,"-2147483648",0); EXPECT(-2147483647 -1);
1862   CONVERT_STR(VarI4FromStr,"2147483647",0);  EXPECT(2147483647);
1863   CONVERT_STR(VarI4FromStr,"2147483648",0);  EXPECT_OVERFLOW;
1864
1865   /* Rounding */
1866   CONVERT_STR(VarI4FromStr,"-1.5",0); EXPECT(-2);
1867   CONVERT_STR(VarI4FromStr,"-0.6",0); EXPECT(-1);
1868   CONVERT_STR(VarI4FromStr,"-0.5",0); EXPECT(0);
1869   CONVERT_STR(VarI4FromStr,"-0.4",0); EXPECT(0);
1870   CONVERT_STR(VarI4FromStr,"0.4",0);  EXPECT(0);
1871   CONVERT_STR(VarI4FromStr,"0.5",0);  EXPECT(0);
1872   CONVERT_STR(VarI4FromStr,"0.6",0);  EXPECT(1);
1873   CONVERT_STR(VarI4FromStr,"1.5",0);  EXPECT(2);
1874 }
1875
1876 static void test_VarI4Copy(void)
1877 {
1878   COPYTEST(1l, VT_I4, V_I4(&vSrc), V_I4(&vDst), V_I4REF(&vSrc), V_I4REF(&vDst), "%ld");
1879 }
1880
1881 static void test_VarI4ChangeTypeEx(void)
1882 {
1883   CONVVARS(CONV_TYPE);
1884   VARIANTARG vSrc, vDst;
1885
1886   in = 1;
1887
1888   INITIAL_TYPETEST(VT_I4, V_I4, "%ld");
1889   COMMON_TYPETEST;
1890   NEGATIVE_TYPETEST(VT_I4, V_I4, "%ld", VT_UI4, V_UI4);
1891 }
1892
1893 #undef CONV_TYPE
1894 #define CONV_TYPE ULONG
1895 #undef EXPECTRES
1896 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%lu")
1897
1898 static void test_VarUI4FromI1(void)
1899 {
1900   CONVVARS(signed char);
1901   int i;
1902
1903   CHECKPTR(VarUI4FromI1);
1904   OVERFLOWRANGE(VarUI4FromI1, -127, 0);
1905   CONVERTRANGE(VarUI4FromI1, 0, 128);
1906 }
1907
1908 static void test_VarUI4FromI2(void)
1909 {
1910   CONVVARS(SHORT);
1911   int i;
1912
1913   CHECKPTR(VarUI4FromI2);
1914   OVERFLOWRANGE(VarUI4FromI2, -32768, 0);
1915   CONVERTRANGE(VarUI4FromI2, 0, 32768);
1916 }
1917
1918 static void test_VarUI4FromUI2(void)
1919 {
1920   CONVVARS(USHORT);
1921   int i;
1922
1923   CHECKPTR(VarUI4FromUI2);
1924   CONVERTRANGE(VarUI4FromUI2, 0, 65536);
1925 }
1926
1927 static void test_VarUI4FromI8(void)
1928 {
1929   CONVVARS(LONG64);
1930
1931   CHECKPTR(VarUI4FromI8);
1932   CONVERT(VarUI4FromI8, -1);           EXPECT_OVERFLOW;
1933   CONVERT(VarUI4FromI8, 0);            EXPECT(0);
1934   CONVERT(VarUI4FromI8, 1);            EXPECT(1);
1935   CONVERT(VarUI4FromI8, 4294967295ul); EXPECT(4294967295ul);
1936   CONVERT_I8(VarUI4FromI8, 1, 0);      EXPECT_OVERFLOW;
1937 }
1938
1939 static void test_VarUI4FromUI1(void)
1940 {
1941   CONVVARS(BYTE);
1942   int i;
1943
1944   CHECKPTR(VarUI4FromUI1);
1945   CONVERTRANGE(VarUI4FromUI1, 0, 256);
1946 }
1947
1948 static void test_VarUI4FromI4(void)
1949 {
1950   CONVVARS(int);
1951
1952   CHECKPTR(VarUI4FromI4);
1953   CONVERT(VarUI4FromI4, -1);         EXPECT_OVERFLOW;
1954   CONVERT(VarUI4FromI4, 0);          EXPECT(0);
1955   CONVERT(VarUI4FromI4, 1);          EXPECT(1);
1956   CONVERT(VarUI4FromI4, 2147483647); EXPECT(2147483647);
1957 }
1958
1959 static void test_VarUI4FromUI8(void)
1960 {
1961   CONVVARS(ULONG64);
1962
1963   CHECKPTR(VarUI4FromUI8);
1964   CONVERT(VarUI4FromUI8, 0);           EXPECT(0);
1965   CONVERT(VarUI4FromUI8, 1);           EXPECT(1);
1966   CONVERT(VarUI4FromI8, 4294967295ul); EXPECT(4294967295ul);
1967   CONVERT_I8(VarUI4FromI8, 1, 0);      EXPECT_OVERFLOW;
1968 }
1969
1970 static void test_VarUI4FromBool(void)
1971 {
1972   CONVVARS(VARIANT_BOOL);
1973   int i;
1974
1975   CHECKPTR(VarUI4FromBool);
1976   CONVERTRANGE(VarUI4FromBool, -32768, 32768);
1977 }
1978
1979 static void test_VarUI4FromR4(void)
1980 {
1981   CONVVARS(FLOAT);
1982
1983   CHECKPTR(VarUI4FromR4);
1984   /* We can't test max values as they are not exactly representable in a float */
1985   CONVERT(VarUI4FromR4, -1.0f); EXPECT_OVERFLOW;
1986   CONVERT(VarUI4FromR4, 0.0f);  EXPECT(0);
1987   CONVERT(VarUI4FromR4, 1.0f);  EXPECT(1);
1988
1989   CONVERT(VarUI4FromR4, -1.5f); EXPECT_OVERFLOW;
1990   CONVERT(VarUI4FromR4, -0.6f); EXPECT_OVERFLOW;
1991   CONVERT(VarUI4FromR4, -0.5f); EXPECT(0);
1992   CONVERT(VarUI4FromR4, -0.4f); EXPECT(0);
1993   CONVERT(VarUI4FromR4, 0.4f);  EXPECT(0);
1994   CONVERT(VarUI4FromR4, 0.5f);  EXPECT(0);
1995   CONVERT(VarUI4FromR4, 0.6f);  EXPECT(1);
1996   CONVERT(VarUI4FromR4, 1.5f);  EXPECT(2);
1997
1998 }
1999
2000 static void test_VarUI4FromR8(void)
2001 {
2002   CONVVARS(DOUBLE);
2003
2004   CHECKPTR(VarUI4FromR8);
2005   CONVERT(VarUI4FromR8, -1.0);         EXPECT_OVERFLOW;
2006   CONVERT(VarUI4FromR8, 0.0);          EXPECT(0);
2007   CONVERT(VarUI4FromR8, 1.0);          EXPECT(1);
2008   CONVERT(VarUI4FromR8, 4294967295.0); EXPECT(4294967295ul);
2009   CONVERT(VarUI4FromR8, 4294967296.0); EXPECT_OVERFLOW;
2010
2011   CONVERT(VarUI4FromR8, -1.5); EXPECT_OVERFLOW;
2012   CONVERT(VarUI4FromR8, -0.6); EXPECT_OVERFLOW;
2013   CONVERT(VarUI4FromR8, -0.5); EXPECT(0);
2014   CONVERT(VarUI4FromR8, -0.4); EXPECT(0);
2015   CONVERT(VarUI4FromR8, 0.4);  EXPECT(0);
2016   CONVERT(VarUI4FromR8, 0.5);  EXPECT(0);
2017   CONVERT(VarUI4FromR8, 0.6);  EXPECT(1);
2018   CONVERT(VarUI4FromR8, 1.5);  EXPECT(2);
2019 }
2020
2021 static void test_VarUI4FromDate(void)
2022 {
2023   CONVVARS(DOUBLE);
2024
2025   CHECKPTR(VarUI4FromDate);
2026   CONVERT(VarUI4FromDate, -1.0);         EXPECT_OVERFLOW;
2027   CONVERT(VarUI4FromDate, 0.0);          EXPECT(0);
2028   CONVERT(VarUI4FromDate, 1.0);          EXPECT(1);
2029   CONVERT(VarUI4FromDate, 4294967295.0); EXPECT(4294967295ul);
2030   CONVERT(VarUI4FromDate, 4294967296.0); EXPECT_OVERFLOW;
2031
2032   CONVERT(VarUI4FromDate, -1.5); EXPECT_OVERFLOW;
2033   CONVERT(VarUI4FromDate, -0.6); EXPECT_OVERFLOW;
2034   CONVERT(VarUI4FromDate, -0.5); EXPECT(0);
2035   CONVERT(VarUI4FromDate, -0.4); EXPECT(0);
2036   CONVERT(VarUI4FromDate, 0.4);  EXPECT(0);
2037   CONVERT(VarUI4FromDate, 0.5);  EXPECT(0);
2038   CONVERT(VarUI4FromDate, 0.6);  EXPECT(1);
2039   CONVERT(VarUI4FromDate, 1.5);  EXPECT(2);
2040 }
2041
2042 static void test_VarUI4FromCy(void)
2043 {
2044   CONVVARS(CY);
2045
2046   CHECKPTR(VarUI4FromCy);
2047   CONVERT_CY(VarUI4FromCy,-1);               EXPECT_OVERFLOW;
2048   CONVERT_CY(VarUI4FromCy,0);                EXPECT(0);
2049   CONVERT_CY(VarUI4FromCy,1);                EXPECT(1);
2050   CONVERT_CY64(VarUI4FromCy,0,4294967295ul); EXPECT(4294967295ul);
2051   CONVERT_CY64(VarUI4FromCy,1,0);            EXPECT_OVERFLOW;
2052
2053   CONVERT_CY(VarUI4FromCy,-1.5); EXPECT_OVERFLOW;
2054   CONVERT_CY(VarUI4FromCy,-0.6); EXPECT_OVERFLOW;
2055   CONVERT_CY(VarUI4FromCy,-0.5); EXPECT(0);
2056   CONVERT_CY(VarUI4FromCy,-0.4); EXPECT(0);
2057   CONVERT_CY(VarUI4FromCy,0.4);  EXPECT(0);
2058   CONVERT_CY(VarUI4FromCy,0.5);  EXPECT(0);
2059   CONVERT_CY(VarUI4FromCy,0.6);  EXPECT(1);
2060   CONVERT_CY(VarUI4FromCy,1.5);  EXPECT(2);
2061 }
2062
2063 static void test_VarUI4FromDec(void)
2064 {
2065   CONVVARS(DECIMAL);
2066
2067   CHECKPTR(VarUI4FromDec);
2068
2069   CONVERT_BADDEC(VarUI4FromDec);
2070
2071   CONVERT_DEC(VarUI4FromDec,0,0x80,0,1);              EXPECT_OVERFLOW;
2072   CONVERT_DEC(VarUI4FromDec,0,0,0,0);                 EXPECT(0);
2073   CONVERT_DEC(VarUI4FromDec,0,0,0,1);                 EXPECT(1);
2074   CONVERT_DEC64(VarUI4FromDec,0,0,0,0,4294967295ul);  EXPECT(4294967295ul);
2075   CONVERT_DEC64(VarUI4FromDec,0,0,0,1,0);             EXPECT_OVERFLOW;
2076
2077   CONVERT_DEC64(VarUI4FromDec,2,0,0,99,4294967196ul); EXPECT(4294967295ul);
2078   CONVERT_DEC64(VarUI4FromDec,2,0,0,100,0);           EXPECT_OVERFLOW;
2079 }
2080
2081 static void test_VarUI4FromStr(void)
2082 {
2083   CONVVARS(LCID);
2084   OLECHAR buff[128];
2085
2086   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2087
2088   CHECKPTR(VarUI4FromStr);
2089
2090   CONVERT_STR(VarUI4FromStr,NULL,0);         EXPECT_MISMATCH;
2091   CONVERT_STR(VarUI4FromStr,"-1",0);         EXPECT_OVERFLOW;
2092   CONVERT_STR(VarUI4FromStr,"0",0);          EXPECT(0);
2093   CONVERT_STR(VarUI4FromStr,"4294967295",0); EXPECT(4294967295ul);
2094   CONVERT_STR(VarUI4FromStr,"4294967296",0); EXPECT_OVERFLOW;
2095
2096   /* Rounding */
2097   CONVERT_STR(VarUI4FromStr,"-1.5",0); EXPECT_OVERFLOW;
2098   CONVERT_STR(VarUI4FromStr,"-0.6",0); EXPECT_OVERFLOW;
2099   CONVERT_STR(VarUI4FromStr,"-0.5",0); EXPECT(0);
2100   CONVERT_STR(VarUI4FromStr,"-0.4",0); EXPECT(0);
2101   CONVERT_STR(VarUI4FromStr,"0.4",0);  EXPECT(0);
2102   CONVERT_STR(VarUI4FromStr,"0.5",0);  EXPECT(0);
2103   CONVERT_STR(VarUI4FromStr,"0.6",0);  EXPECT(1);
2104   CONVERT_STR(VarUI4FromStr,"1.5",0);  EXPECT(2);
2105 }
2106
2107 static void test_VarUI4Copy(void)
2108 {
2109   if (!IS_ANCIENT)
2110   {
2111       COPYTEST(1ul, VT_UI4, V_UI4(&vSrc), V_UI4(&vDst), V_UI4REF(&vSrc), V_UI4REF(&vDst), "%lu");
2112   }
2113 }
2114
2115 static void test_VarUI4ChangeTypeEx(void)
2116 {
2117   CONVVARS(CONV_TYPE);
2118   VARIANTARG vSrc, vDst;
2119
2120   in = 1;
2121
2122   if (!IS_ANCIENT)
2123   {
2124     INITIAL_TYPETEST(VT_UI4, V_UI4, "%lu");
2125     COMMON_TYPETEST;
2126     NEGATIVE_TYPETEST(VT_UI4, V_UI4, "%lu", VT_I4, V_I4);
2127   }
2128 }
2129
2130 /*
2131  * VT_I8/VT_UI8
2132  */
2133
2134 #undef CONV_TYPE
2135 #define CONV_TYPE LONG64
2136 #undef EXPECTRES
2137 #define EXPECTRES(res, x) \
2138   ok(hres == S_OK || ((HRESULT)res != S_OK && hres == (HRESULT)res), \
2139      "expected hres " #x ", got hres=0x%08lx\n", hres)
2140
2141 #define EXPECTI8(x) \
2142   ok((hres == S_OK && out == (CONV_TYPE)(x)), \
2143      "expected " #x "(%lu,%lu), got (%lu,%lu); hres=0x%08lx\n", \
2144       (ULONG)((LONG64)(x) >> 32), (ULONG)((x) & 0xffffffff), \
2145       (ULONG)(out >> 32), (ULONG)(out & 0xffffffff), hres)
2146
2147 #define EXPECTI864(x,y) \
2148   ok(hres == S_OK && (out >> 32) == (CONV_TYPE)(x) && (out & 0xffffffff) == (CONV_TYPE)(y), \
2149      "expected " #x "(%lu,%lu), got (%lu,%lu); hres=0x%08lx\n", \
2150       (ULONG)(x), (ULONG)(y), \
2151       (ULONG)(out >> 32), (ULONG)(out & 0xffffffff), hres)
2152
2153 static void test_VarI8FromI1(void)
2154 {
2155   CONVVARS(signed char);
2156   int i;
2157
2158   CHECKPTR(VarI8FromI1);
2159   for (i = -128; i < 128; i++)
2160   {
2161     CONVERT(VarI8FromI1,i); EXPECTI8(i);
2162   }
2163 }
2164
2165 static void test_VarI8FromUI1(void)
2166 {
2167   CONVVARS(BYTE);
2168   int i;
2169
2170   CHECKPTR(VarI8FromUI1);
2171   for (i = 0; i < 256; i++)
2172   {
2173     CONVERT(VarI8FromUI1,i); EXPECTI8(i);
2174   }
2175 }
2176
2177 static void test_VarI8FromI2(void)
2178 {
2179   CONVVARS(SHORT);
2180   int i;
2181
2182   CHECKPTR(VarI8FromI2);
2183   for (i = -32768; i < 32768; i++)
2184   {
2185     CONVERT(VarI8FromI2,i); EXPECTI8(i);
2186   }
2187 }
2188
2189 static void test_VarI8FromUI2(void)
2190 {
2191   CONVVARS(USHORT);
2192   int i;
2193
2194   CHECKPTR(VarI8FromUI2);
2195   for (i = -0; i < 65535; i++)
2196   {
2197     CONVERT(VarI8FromUI2,i); EXPECTI8(i);
2198   }
2199 }
2200
2201 static void test_VarI8FromUI4(void)
2202 {
2203   CONVVARS(ULONG);
2204
2205   CHECKPTR(VarI8FromUI4);
2206   CONVERT(VarI8FromUI4, 0);            EXPECTI8(0);
2207   CONVERT(VarI8FromUI4, 1);            EXPECTI8(1);
2208   CONVERT(VarI8FromUI4, 4294967295ul); EXPECTI8(4294967295ul);
2209 }
2210
2211 static void test_VarI8FromR4(void)
2212 {
2213   CONVVARS(FLOAT);
2214
2215   CHECKPTR(VarI8FromR4);
2216
2217   CONVERT(VarI8FromR4, -128.0f); EXPECTI8(-128);
2218   CONVERT(VarI8FromR4, -1.0f);   EXPECTI8(-1);
2219   CONVERT(VarI8FromR4, 0.0f);    EXPECTI8(0);
2220   CONVERT(VarI8FromR4, 1.0f);    EXPECTI8(1);
2221   CONVERT(VarI8FromR4, 127.0f);  EXPECTI8(127);
2222
2223   CONVERT(VarI8FromR4, -1.5f); EXPECTI8(-2);
2224   CONVERT(VarI8FromR4, -0.6f); EXPECTI8(-1);
2225   CONVERT(VarI8FromR4, -0.5f); EXPECTI8(0);
2226   CONVERT(VarI8FromR4, -0.4f); EXPECTI8(0);
2227   CONVERT(VarI8FromR4, 0.4f);  EXPECTI8(0);
2228   CONVERT(VarI8FromR4, 0.5f);  EXPECTI8(0);
2229   CONVERT(VarI8FromR4, 0.6f);  EXPECTI8(1);
2230   CONVERT(VarI8FromR4, 1.5f);  EXPECTI8(2);
2231 }
2232
2233 static void test_VarI8FromR8(void)
2234 {
2235   CONVVARS(DOUBLE);
2236
2237   CHECKPTR(VarI8FromR8);
2238   CONVERT(VarI8FromR8, -128.0); EXPECTI8(-128);
2239   CONVERT(VarI8FromR8, -1.0);   EXPECTI8(-1);
2240   CONVERT(VarI8FromR8, 0.0);    EXPECTI8(0);
2241   CONVERT(VarI8FromR8, 1.0);    EXPECTI8(1);
2242   CONVERT(VarI8FromR8, 127.0);  EXPECTI8(127);
2243
2244   CONVERT(VarI8FromR8, -1.5); EXPECTI8(-2);
2245   CONVERT(VarI8FromR8, -0.6); EXPECTI8(-1);
2246   CONVERT(VarI8FromR8, -0.5); EXPECTI8(0);
2247   CONVERT(VarI8FromR8, -0.4); EXPECTI8(0);
2248   CONVERT(VarI8FromR8, 0.4);  EXPECTI8(0);
2249   CONVERT(VarI8FromR8, 0.5);  EXPECTI8(0);
2250   CONVERT(VarI8FromR8, 0.6);  EXPECTI8(1);
2251   CONVERT(VarI8FromR8, 1.5);  EXPECTI8(2);
2252 }
2253
2254 static void test_VarI8FromDate(void)
2255 {
2256   CONVVARS(DATE);
2257
2258   CHECKPTR(VarI8FromDate);
2259   CONVERT(VarI8FromDate, -128.0); EXPECTI8(-128);
2260   CONVERT(VarI8FromDate, -1.0);   EXPECTI8(-1);
2261   CONVERT(VarI8FromDate, 0.0);    EXPECTI8(0);
2262   CONVERT(VarI8FromDate, 1.0);    EXPECTI8(1);
2263   CONVERT(VarI8FromDate, 127.0);  EXPECTI8(127);
2264
2265   CONVERT(VarI8FromDate, -1.5); EXPECTI8(-2);
2266   CONVERT(VarI8FromDate, -0.6); EXPECTI8(-1);
2267   CONVERT(VarI8FromDate, -0.5); EXPECTI8(0);
2268   CONVERT(VarI8FromDate, -0.4); EXPECTI8(0);
2269   CONVERT(VarI8FromDate, 0.4);  EXPECTI8(0);
2270   CONVERT(VarI8FromDate, 0.5);  EXPECTI8(0);
2271   CONVERT(VarI8FromDate, 0.6);  EXPECTI8(1);
2272   CONVERT(VarI8FromDate, 1.5);  EXPECTI8(2);
2273 }
2274
2275 static void test_VarI8FromBool(void)
2276 {
2277   CONVVARS(VARIANT_BOOL);
2278   int i;
2279
2280   CHECKPTR(VarI8FromBool);
2281   for (i = -32768; i < 32768; i++)
2282   {
2283     CONVERT(VarI8FromBool,i); EXPECTI8(i);
2284   }
2285 }
2286
2287 static void test_VarI8FromUI8(void)
2288 {
2289   CONVVARS(ULONG64);
2290
2291   CHECKPTR(VarI8FromUI8);
2292   CONVERT(VarI8FromUI8, 0); EXPECTI8(0);
2293   CONVERT(VarI8FromUI8, 1); EXPECTI8(1);
2294   CONVERT_I8(VarI8FromUI8, 0x7fffffff, 0xffffffff); EXPECTI864(0x7fffffff, 0xffffffff);
2295   CONVERT_I8(VarI8FromUI8, 0x80000000, 0);          EXPECT_OVERFLOW;
2296 }
2297
2298 static void test_VarI8FromCy(void)
2299 {
2300   CONVVARS(CY);
2301
2302   CHECKPTR(VarI8FromCy);
2303   CONVERT_CY(VarI8FromCy,-128); EXPECTI8(-129);
2304   CONVERT_CY(VarI8FromCy,-1);   EXPECTI8(-2);
2305   CONVERT_CY(VarI8FromCy,0);    EXPECTI8(0);
2306   CONVERT_CY(VarI8FromCy,1);    EXPECTI8(1);
2307   CONVERT_CY(VarI8FromCy,127);  EXPECTI8(127);
2308
2309   CONVERT_CY(VarI8FromCy,-1.5); EXPECTI8(-2);
2310   CONVERT_CY(VarI8FromCy,-0.6); EXPECTI8(-1);
2311   CONVERT_CY(VarI8FromCy,-0.5); EXPECTI8(-1);
2312   CONVERT_CY(VarI8FromCy,-0.4); EXPECTI8(-1);
2313   CONVERT_CY(VarI8FromCy,0.4);  EXPECTI8(0);
2314   CONVERT_CY(VarI8FromCy,0.5);  EXPECTI8(0);
2315   CONVERT_CY(VarI8FromCy,0.6);  EXPECTI8(1);
2316   CONVERT_CY(VarI8FromCy,1.5);  EXPECTI8(2);
2317 }
2318
2319 static void test_VarI8FromDec(void)
2320 {
2321   CONVVARS(DECIMAL);
2322
2323   CHECKPTR(VarI8FromDec);
2324
2325   CONVERT_BADDEC(VarI8FromDec);
2326
2327   CONVERT_DEC(VarI8FromDec,0,0x80,0,128); EXPECTI8(-128);
2328   CONVERT_DEC(VarI8FromDec,0,0x80,0,1);   EXPECTI8(-1);
2329   CONVERT_DEC(VarI8FromDec,0,0,0,0);      EXPECTI8(0);
2330   CONVERT_DEC(VarI8FromDec,0,0,0,1);      EXPECTI8(1);
2331   CONVERT_DEC(VarI8FromDec,0,0,0,127);    EXPECTI8(127);
2332
2333   CONVERT_DEC(VarI8FromDec,2,0x80,0,12700); EXPECTI8(-127);
2334   CONVERT_DEC(VarI8FromDec,2,0,0,12700);    EXPECTI8(127);
2335 }
2336
2337 static void test_VarI8FromStr(void)
2338 {
2339   CONVVARS(LCID);
2340   OLECHAR buff[128];
2341
2342   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2343
2344   CHECKPTR(VarI8FromStr);
2345
2346   CONVERT_STR(VarI8FromStr,NULL,0);         EXPECT_MISMATCH;
2347   CONVERT_STR(VarI8FromStr,"0",0);          EXPECTI8(0);
2348   CONVERT_STR(VarI8FromStr,"-1",0);         EXPECTI8(-1);
2349   CONVERT_STR(VarI8FromStr,"2147483647",0); EXPECTI8(2147483647);
2350
2351   CONVERT_STR(VarI8FromStr,"-1.5",0); EXPECTI8(-2);
2352   CONVERT_STR(VarI8FromStr,"-0.6",0); EXPECTI8(-1);
2353   CONVERT_STR(VarI8FromStr,"-0.5",0); EXPECTI8(0);
2354   CONVERT_STR(VarI8FromStr,"-0.4",0); EXPECTI8(0);
2355   CONVERT_STR(VarI8FromStr,"0.4",0);  EXPECTI8(0);
2356   CONVERT_STR(VarI8FromStr,"0.5",0);  EXPECTI8(0);
2357   CONVERT_STR(VarI8FromStr,"0.6",0);  EXPECTI8(1);
2358   CONVERT_STR(VarI8FromStr,"1.5",0);  EXPECTI8(2);
2359 }
2360
2361 static void test_VarI8Copy(void)
2362 {
2363   HRESULT hres;
2364   VARIANTARG vSrc, vDst;
2365   LONGLONG in = 1;
2366
2367   if (!HAVE_OLEAUT32_I8)
2368     return;
2369
2370   VariantInit(&vSrc);
2371   VariantInit(&vDst);
2372   V_VT(&vSrc) = VT_I8;
2373   V_I8(&vSrc) = in;
2374   hres = VariantCopy(&vDst, &vSrc);
2375   ok(hres == S_OK && V_VT(&vDst) == VT_I8 && V_I8(&vDst) == in,
2376      "copy hres 0x%lX, type %d, value (%x%08x) %x%08x\n",
2377      hres, V_VT(&vDst), (UINT)(in >> 32), (UINT)in, (UINT)(V_I8(&vDst) >> 32), (UINT)V_I8(&vDst) );
2378   V_VT(&vSrc) = VT_I8|VT_BYREF;
2379   V_I8REF(&vSrc) = &in;
2380   hres = VariantCopy(&vDst, &vSrc);
2381   ok(hres == S_OK && V_VT(&vDst) == (VT_I8|VT_BYREF) && V_I8REF(&vDst) == &in,
2382      "ref hres 0x%lX, type %d, ref (%p) %p\n", hres, V_VT(&vDst), &in, V_I8REF(&vDst));
2383   hres = VariantCopyInd(&vDst, &vSrc);
2384   ok(hres == S_OK && V_VT(&vDst) == VT_I8 && V_I8(&vDst) == in,
2385      "copy hres 0x%lX, type %d, value (%x%08x) %x%08x\n",
2386      hres, V_VT(&vDst), (UINT)(in >> 32), (UINT)in, (UINT)(V_I8(&vDst) >> 32), (UINT)V_I8(&vDst) );
2387 }
2388
2389 static void test_VarI8ChangeTypeEx(void)
2390 {
2391   CONVVARS(CONV_TYPE);
2392   VARIANTARG vSrc, vDst;
2393
2394   if (!HAVE_OLEAUT32_I8)
2395     return;
2396
2397   in = 1;
2398
2399   INITIAL_TYPETESTI8(VT_I8, V_I8);
2400   COMMON_TYPETEST;
2401 }
2402
2403 /* Adapt the test macros to UI8 */
2404 #undef CONV_TYPE
2405 #define CONV_TYPE ULONG64
2406
2407 static void test_VarUI8FromI1(void)
2408 {
2409   CONVVARS(signed char);
2410   int i;
2411
2412   CHECKPTR(VarUI8FromI1);
2413   for (i = -128; i < 128; i++)
2414   {
2415     CONVERT(VarUI8FromI1,i);
2416     if (i < 0)
2417       EXPECT_OVERFLOW;
2418     else
2419       EXPECTI8(i);
2420   }
2421 }
2422
2423 static void test_VarUI8FromUI1(void)
2424 {
2425   CONVVARS(BYTE);
2426   int i;
2427
2428   CHECKPTR(VarUI8FromUI1);
2429   for (i = 0; i < 256; i++)
2430   {
2431     CONVERT(VarUI8FromUI1,i); EXPECTI8(i);
2432   }
2433 }
2434
2435 static void test_VarUI8FromI2(void)
2436 {
2437   CONVVARS(SHORT);
2438   int i;
2439
2440   CHECKPTR(VarUI8FromI2);
2441   for (i = -32768; i < 32768; i++)
2442   {
2443     CONVERT(VarUI8FromI2,i);
2444     if (i < 0)
2445       EXPECT_OVERFLOW;
2446     else
2447       EXPECTI8(i);
2448   }
2449 }
2450
2451 static void test_VarUI8FromUI2(void)
2452 {
2453   CONVVARS(USHORT);
2454   int i;
2455
2456   CHECKPTR(VarUI8FromUI2);
2457   for (i = 0; i < 65535; i++)
2458   {
2459     CONVERT(VarUI8FromUI2,i); EXPECTI8(i);
2460   }
2461 }
2462
2463 static void test_VarUI8FromUI4(void)
2464 {
2465   CONVVARS(ULONG);
2466
2467   CHECKPTR(VarUI8FromUI4);
2468   CONVERT(VarUI8FromUI4, 0); EXPECTI8(0);
2469   CONVERT(VarUI8FromUI4, 0xffffffff); EXPECTI8(0xffffffff);
2470 }
2471
2472 static void test_VarUI8FromR4(void)
2473 {
2474   CONVVARS(FLOAT);
2475
2476   CHECKPTR(VarUI8FromR4);
2477   CONVERT(VarUI8FromR4, -1.0f);  EXPECT_OVERFLOW;
2478   CONVERT(VarUI8FromR4, 0.0f);   EXPECTI8(0);
2479   CONVERT(VarUI8FromR4, 1.0f);   EXPECTI8(1);
2480   CONVERT(VarUI8FromR4, 255.0f); EXPECTI8(255);
2481
2482   CONVERT(VarUI8FromR4, -1.5f); EXPECT_OVERFLOW;
2483   CONVERT(VarUI8FromR4, -0.6f); EXPECT_OVERFLOW;
2484   CONVERT(VarUI8FromR4, -0.5f); EXPECTI8(0);
2485   CONVERT(VarUI8FromR4, -0.4f); EXPECTI8(0);
2486   CONVERT(VarUI8FromR4, 0.4f);  EXPECTI8(0);
2487   CONVERT(VarUI8FromR4, 0.5f);  EXPECTI8(0);
2488   CONVERT(VarUI8FromR4, 0.6f);  EXPECTI8(1);
2489   CONVERT(VarUI8FromR4, 1.5f);  EXPECTI8(2);
2490 }
2491
2492 static void test_VarUI8FromR8(void)
2493 {
2494   CONVVARS(DOUBLE);
2495
2496   CHECKPTR(VarUI8FromR8);
2497   CONVERT(VarUI8FromR8, -1.0);  EXPECT_OVERFLOW;
2498   CONVERT(VarUI8FromR8, 0.0);   EXPECTI8(0);
2499   CONVERT(VarUI8FromR8, 1.0);   EXPECTI8(1);
2500   CONVERT(VarUI8FromR8, 255.0); EXPECTI8(255);
2501
2502   CONVERT(VarUI8FromR8, -1.5); EXPECT_OVERFLOW;
2503   CONVERT(VarUI8FromR8, -0.6); EXPECT_OVERFLOW;
2504   CONVERT(VarUI8FromR8, -0.5); EXPECTI8(0);
2505   CONVERT(VarUI8FromR8, -0.4); EXPECTI8(0);
2506   CONVERT(VarUI8FromR8, 0.4);  EXPECTI8(0);
2507   CONVERT(VarUI8FromR8, 0.5);  EXPECTI8(0);
2508   CONVERT(VarUI8FromR8, 0.6);  EXPECTI8(1);
2509   CONVERT(VarUI8FromR8, 1.5);  EXPECTI8(2);
2510 }
2511
2512 static void test_VarUI8FromDate(void)
2513 {
2514   CONVVARS(DATE);
2515
2516   CHECKPTR(VarUI8FromDate);
2517   CONVERT(VarUI8FromDate, -1.0);  EXPECT_OVERFLOW;
2518   CONVERT(VarUI8FromDate, 0.0);   EXPECTI8(0);
2519   CONVERT(VarUI8FromDate, 1.0);   EXPECTI8(1);
2520   CONVERT(VarUI8FromDate, 255.0); EXPECTI8(255);
2521
2522   CONVERT(VarUI8FromDate, -1.5); EXPECT_OVERFLOW;
2523   CONVERT(VarUI8FromDate, -0.6); EXPECT_OVERFLOW;
2524   CONVERT(VarUI8FromDate, -0.5); EXPECTI8(0);
2525   CONVERT(VarUI8FromDate, -0.4); EXPECTI8(0);
2526   CONVERT(VarUI8FromDate, 0.4);  EXPECTI8(0);
2527   CONVERT(VarUI8FromDate, 0.5);  EXPECTI8(0);
2528   CONVERT(VarUI8FromDate, 0.6);  EXPECTI8(1);
2529   CONVERT(VarUI8FromDate, 1.5);  EXPECTI8(2);
2530 }
2531
2532 static void test_VarUI8FromBool(void)
2533 {
2534   CONVVARS(VARIANT_BOOL);
2535   int i;
2536
2537   CHECKPTR(VarUI8FromBool);
2538   CONVERTRANGE(VarUI8FromBool, -32768, 32768);
2539 }
2540
2541 static void test_VarUI8FromI8(void)
2542 {
2543   CONVVARS(LONG64);
2544
2545   CHECKPTR(VarUI8FromI8);
2546   CONVERT(VarUI8FromI8, -1); EXPECT_OVERFLOW;
2547   CONVERT(VarUI8FromI8, 0);  EXPECTI8(0);
2548   CONVERT(VarUI8FromI8, 1);  EXPECTI8(1);
2549 }
2550
2551 static void test_VarUI8FromCy(void)
2552 {
2553   CONVVARS(CY);
2554
2555   CHECKPTR(VarUI8FromCy);
2556   CONVERT_CY(VarUI8FromCy,-1);  EXPECT_OVERFLOW;
2557   CONVERT_CY(VarUI8FromCy,0);   EXPECTI8(0);
2558   CONVERT_CY(VarUI8FromCy,1);   EXPECTI8(1);
2559   CONVERT_CY(VarUI8FromCy,255); EXPECTI8(255);
2560
2561   CONVERT_CY(VarUI8FromCy,-1.5); EXPECT_OVERFLOW;
2562   CONVERT_CY(VarUI8FromCy,-0.6); EXPECT_OVERFLOW;
2563   CONVERT_CY(VarUI8FromCy,-0.5); EXPECTI8(0);
2564   CONVERT_CY(VarUI8FromCy,-0.4); EXPECTI8(0);
2565   CONVERT_CY(VarUI8FromCy,0.4);  EXPECTI8(0);
2566   CONVERT_CY(VarUI8FromCy,0.5);  EXPECTI8(0);
2567   CONVERT_CY(VarUI8FromCy,0.6);  EXPECTI8(1);
2568   CONVERT_CY(VarUI8FromCy,1.5);  EXPECTI8(2);
2569 }
2570
2571 static void test_VarUI8FromDec(void)
2572 {
2573   CONVVARS(DECIMAL);
2574
2575   CHECKPTR(VarUI8FromDec);
2576
2577   CONVERT_BADDEC(VarUI8FromDec);
2578
2579 #if 0
2580   /* This returns 1 under native; Wine fixes this bug and returns overflow */
2581   CONVERT_DEC(VarUI8FromDec,0,0x80,0,1);
2582 #endif
2583   CONVERT_DEC(VarUI8FromDec,0,0,0,0);   EXPECTI8(0);
2584   CONVERT_DEC(VarUI8FromDec,0,0,0,1);   EXPECTI8(1);
2585   CONVERT_DEC(VarUI8FromDec,0,0,0,255); EXPECTI8(255);
2586
2587   CONVERT_DEC(VarUI8FromDec,2,0x80,0,100); EXPECT_OVERFLOW;
2588   CONVERT_DEC(VarUI8FromDec,2,0,0,25500);  EXPECTI8(255);
2589 }
2590
2591 static void test_VarUI8FromStr(void)
2592 {
2593   CONVVARS(LCID);
2594   OLECHAR buff[128];
2595
2596   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2597
2598   CHECKPTR(VarUI8FromStr);
2599
2600   CONVERT_STR(VarUI8FromStr,NULL,0);         EXPECT_MISMATCH;
2601   CONVERT_STR(VarUI8FromStr,"0",0);          EXPECTI8(0);
2602   CONVERT_STR(VarUI8FromStr,"-1",0);         EXPECT_OVERFLOW;
2603   CONVERT_STR(VarUI8FromStr,"2147483647",0); EXPECTI8(2147483647);
2604
2605   CONVERT_STR(VarUI8FromStr,"-1.5",0); EXPECT_OVERFLOW;
2606   CONVERT_STR(VarUI8FromStr,"-0.6",0); EXPECT_OVERFLOW;
2607   CONVERT_STR(VarUI8FromStr,"-0.5",0); EXPECTI8(0);
2608   CONVERT_STR(VarUI8FromStr,"-0.4",0); EXPECTI8(0);
2609   CONVERT_STR(VarUI8FromStr,"0.4",0);  EXPECTI8(0);
2610   CONVERT_STR(VarUI8FromStr,"0.5",0);  EXPECTI8(0);
2611   CONVERT_STR(VarUI8FromStr,"0.6",0);  EXPECTI8(1);
2612   CONVERT_STR(VarUI8FromStr,"1.5",0);  EXPECTI8(2);
2613 }
2614
2615 static void test_VarUI8Copy(void)
2616 {
2617   HRESULT hres;
2618   VARIANTARG vSrc, vDst;
2619   ULONGLONG in = 1;
2620
2621   if (!HAVE_OLEAUT32_I8)
2622     return;
2623
2624   VariantInit(&vSrc);
2625   VariantInit(&vDst);
2626   V_VT(&vSrc) = VT_UI8;
2627   V_UI8(&vSrc) = in;
2628   hres = VariantCopy(&vDst, &vSrc);
2629   ok(hres == S_OK && V_VT(&vDst) == VT_UI8 && V_UI8(&vDst) == in,
2630      "copy hres 0x%lX, type %d, value (%x%08x) %x%08x\n",
2631      hres, V_VT(&vDst), (UINT)(in >> 32), (UINT)in, (UINT)(V_UI8(&vDst) >> 32), (UINT)V_UI8(&vDst) );
2632   V_VT(&vSrc) = VT_UI8|VT_BYREF;
2633   V_UI8REF(&vSrc) = &in;
2634   hres = VariantCopy(&vDst, &vSrc);
2635   ok(hres == S_OK && V_VT(&vDst) == (VT_UI8|VT_BYREF) && V_UI8REF(&vDst) == &in,
2636      "ref hres 0x%lX, type %d, ref (%p) %p\n", hres, V_VT(&vDst), &in, V_UI8REF(&vDst));
2637   hres = VariantCopyInd(&vDst, &vSrc);
2638   ok(hres == S_OK && V_VT(&vDst) == VT_UI8 && V_UI8(&vDst) == in,
2639      "copy hres 0x%lX, type %d, value (%x%08x) %x%08x\n",
2640      hres, V_VT(&vDst), (UINT)(in >> 32), (UINT)in, (UINT)(V_UI8(&vDst) >> 32), (UINT)V_UI8(&vDst) );
2641 }
2642
2643 static void test_VarUI8ChangeTypeEx(void)
2644 {
2645   CONVVARS(CONV_TYPE);
2646   VARIANTARG vSrc, vDst;
2647
2648   if (!HAVE_OLEAUT32_I8)
2649     return;
2650
2651   in = 1;
2652
2653   INITIAL_TYPETESTI8(VT_UI8, V_UI8);
2654   COMMON_TYPETEST;
2655 }
2656
2657 /*
2658  * VT_R4
2659  */
2660
2661 #undef CONV_TYPE
2662 #define CONV_TYPE float
2663 #undef EXPECTRES
2664 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%15.15f")
2665
2666 static void test_VarR4FromI1(void)
2667 {
2668   CONVVARS(signed char);
2669   int i;
2670
2671   CHECKPTR(VarR4FromI1);
2672   CONVERTRANGE(VarR4FromI1, -128, 128);
2673 }
2674
2675 static void test_VarR4FromUI1(void)
2676 {
2677   CONVVARS(BYTE);
2678   int i;
2679
2680   CHECKPTR(VarR4FromUI1);
2681   CONVERTRANGE(VarR4FromUI1, 0, 256);
2682 }
2683
2684 static void test_VarR4FromI2(void)
2685 {
2686   CONVVARS(SHORT);
2687   int i;
2688
2689   CHECKPTR(VarR4FromI2);
2690   CONVERTRANGE(VarR4FromI2, -32768, 32768);
2691 }
2692
2693 static void test_VarR4FromUI2(void)
2694 {
2695   CONVVARS(USHORT);
2696   int i;
2697
2698   CHECKPTR(VarR4FromUI2);
2699   CONVERTRANGE(VarR4FromUI2, 0, 65536);
2700 }
2701
2702 static void test_VarR4FromI4(void)
2703 {
2704   CONVVARS(int);
2705
2706   CHECKPTR(VarR4FromI4);
2707   CONVERT(VarR4FromI4, -2147483647-1); EXPECT(-2147483648.0f);
2708   CONVERT(VarR4FromI4, -1);            EXPECT(-1.0f);
2709   CONVERT(VarR4FromI4, 0);             EXPECT(0.0f);
2710   CONVERT(VarR4FromI4, 1);             EXPECT(1.0f);
2711   CONVERT(VarR4FromI4, 2147483647);    EXPECT(2147483647.0f);
2712 }
2713
2714 static void test_VarR4FromUI4(void)
2715 {
2716   CONVVARS(unsigned int);
2717
2718   CHECKPTR(VarR4FromUI4);
2719   CONVERT(VarR4FromUI4, 0);          EXPECT(0.0f);
2720   CONVERT(VarR4FromUI4, 1);          EXPECT(1.0f);
2721 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
2722   CONVERT(VarR4FromUI4, 0xffffffff); EXPECT(4294967296.0f);
2723 #endif
2724 }
2725
2726 static void test_VarR4FromR8(void)
2727 {
2728   CONVVARS(FLOAT);
2729
2730   CHECKPTR(VarR4FromR8);
2731   CONVERT(VarR4FromR8, -1.0); EXPECT(-1.0f);
2732   CONVERT(VarR4FromR8, 0.0); EXPECT(0.0f);
2733   CONVERT(VarR4FromR8, 1.0); EXPECT(1.0f);
2734   CONVERT(VarR4FromR8, 1.5); EXPECT(1.5f);
2735
2736   /* Skip rounding tests - no rounding is done */
2737 }
2738
2739 static void test_VarR4FromBool(void)
2740 {
2741   CONVVARS(VARIANT_BOOL);
2742
2743   CHECKPTR(VarR4FromBool);
2744   CONVERT(VarR4FromBool, VARIANT_TRUE);  EXPECT(VARIANT_TRUE * 1.0f);
2745   CONVERT(VarR4FromBool, VARIANT_FALSE); EXPECT(VARIANT_FALSE * 1.0f);
2746 }
2747
2748 static void test_VarR4FromCy(void)
2749 {
2750   CONVVARS(CY);
2751
2752   CHECKPTR(VarR4FromCy);
2753   CONVERT_CY(VarR4FromCy,-32768); EXPECT(-32768.0f);
2754   CONVERT_CY(VarR4FromCy,-1);     EXPECT(-1.0f);
2755   CONVERT_CY(VarR4FromCy,0);      EXPECT(0.0f);
2756   CONVERT_CY(VarR4FromCy,1);      EXPECT(1.0f);
2757   CONVERT_CY(VarR4FromCy,32768);  EXPECT(32768.0f);
2758
2759   CONVERT_CY(VarR4FromCy,-1.5); EXPECT(-1.5f);
2760   CONVERT_CY(VarR4FromCy,-0.6); EXPECT(-0.6f);
2761   CONVERT_CY(VarR4FromCy,-0.5); EXPECT(-0.5f);
2762   CONVERT_CY(VarR4FromCy,-0.4); EXPECT(-0.4f);
2763   CONVERT_CY(VarR4FromCy,0.4);  EXPECT(0.4f);
2764   CONVERT_CY(VarR4FromCy,0.5);  EXPECT(0.5f);
2765   CONVERT_CY(VarR4FromCy,0.6);  EXPECT(0.6f);
2766   CONVERT_CY(VarR4FromCy,1.5);  EXPECT(1.5f);
2767 }
2768
2769 static void test_VarR4FromI8(void)
2770 {
2771   CONVVARS(LONG64);
2772
2773   CHECKPTR(VarR4FromI8);
2774   CONVERT(VarR4FromI8, -1); EXPECT(-1.0f);
2775   CONVERT(VarR4FromI8, 0);  EXPECT(0.0f);
2776   CONVERT(VarR4FromI8, 1);  EXPECT(1.0f);
2777 }
2778
2779 static void test_VarR4FromUI8(void)
2780 {
2781   CONVVARS(ULONG64);
2782
2783   CHECKPTR(VarR4FromUI8);
2784   CONVERT(VarR4FromUI8, 0); EXPECT(0.0f);
2785   CONVERT(VarR4FromUI8, 1); EXPECT(1.0f);
2786 }
2787
2788 static void test_VarR4FromDec(void)
2789 {
2790   CONVVARS(DECIMAL);
2791
2792   CHECKPTR(VarR4FromDec);
2793
2794   CONVERT_BADDEC(VarR4FromDec);
2795
2796   CONVERT_DEC(VarR4FromDec,0,0x80,0,32768); EXPECT(-32768.0f);
2797   CONVERT_DEC(VarR4FromDec,0,0x80,0,1);     EXPECT(-1.0f);
2798   CONVERT_DEC(VarR4FromDec,0,0,0,0);        EXPECT(0.0f);
2799   CONVERT_DEC(VarR4FromDec,0,0,0,1);        EXPECT(1.0f);
2800   CONVERT_DEC(VarR4FromDec,0,0,0,32767);    EXPECT(32767.0f);
2801
2802   CONVERT_DEC(VarR4FromDec,2,0x80,0,3276800); EXPECT(-32768.0f);
2803   CONVERT_DEC(VarR4FromDec,2,0,0,3276700);    EXPECT(32767.0f);
2804
2805   CONVERT_DEC(VarR4FromDec,0,0,1,0);        EXPECT(18446744073709551616.0f);
2806 }
2807
2808 static void test_VarR4FromDate(void)
2809 {
2810   CONVVARS(DATE);
2811
2812   CHECKPTR(VarR4FromDate);
2813   CONVERT(VarR4FromDate, -1.0); EXPECT(-1.0f);
2814   CONVERT(VarR4FromDate, 0.0);  EXPECT(0.0f);
2815   CONVERT(VarR4FromDate, 1.0);  EXPECT(1.0f);
2816 }
2817
2818 static void test_VarR4FromStr(void)
2819 {
2820   CONVVARS(LCID);
2821   OLECHAR buff[128];
2822
2823   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2824
2825   CHECKPTR(VarR4FromStr);
2826
2827   CONVERT_STR(VarR4FromStr,NULL,0);    EXPECT_MISMATCH;
2828   CONVERT_STR(VarR4FromStr,"-1", 0);   EXPECT(-1.0f);
2829   CONVERT_STR(VarR4FromStr,"0", 0);    EXPECT(0.0f);
2830   CONVERT_STR(VarR4FromStr,"1", 0);    EXPECT(1.0f);
2831
2832   CONVERT_STR(VarR4FromStr,"-1.5",0); EXPECT(-1.5f);
2833   CONVERT_STR(VarR4FromStr,"-0.6",0); EXPECT(-0.6f);
2834   CONVERT_STR(VarR4FromStr,"-0.5",0); EXPECT(-0.5f);
2835   CONVERT_STR(VarR4FromStr,"-0.4",0); EXPECT(-0.4f);
2836   CONVERT_STR(VarR4FromStr,"0.4",0);  EXPECT(0.4f);
2837   CONVERT_STR(VarR4FromStr,"0.5",0);  EXPECT(0.5f);
2838   CONVERT_STR(VarR4FromStr,"0.6",0);  EXPECT(0.6f);
2839   CONVERT_STR(VarR4FromStr,"1.5",0);  EXPECT(1.5f);
2840 }
2841
2842 static void test_VarR4Copy(void)
2843 {
2844   COPYTEST(77665544.0f, VT_R4, V_R4(&vSrc), V_R4(&vDst), V_R4REF(&vSrc),V_R4REF(&vDst), "%15.15f");
2845 }
2846
2847 static void test_VarR4ChangeTypeEx(void)
2848 {
2849 #ifdef HAS_UINT64_TO_FLOAT
2850   CONVVARS(CONV_TYPE);
2851   VARIANTARG vSrc, vDst;
2852
2853   in = 1.0f;
2854
2855   INITIAL_TYPETEST(VT_R4, V_R4, "%f");
2856   COMMON_TYPETEST;
2857 #endif
2858 }
2859
2860 /*
2861  * VT_R8
2862  */
2863
2864 #undef CONV_TYPE
2865 #define CONV_TYPE double
2866 #undef EXPECTRES
2867 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%15.15f")
2868
2869 static void test_VarR8FromI1(void)
2870 {
2871   CONVVARS(signed char);
2872   int i;
2873
2874   CHECKPTR(VarR8FromI1);
2875   CONVERTRANGE(VarR8FromI1, -128, 128);
2876 }
2877
2878 static void test_VarR8FromUI1(void)
2879 {
2880   CONVVARS(BYTE);
2881   int i;
2882
2883   CHECKPTR(VarR8FromUI1);
2884   CONVERTRANGE(VarR8FromUI1, 0, 256);
2885 }
2886
2887 static void test_VarR8FromI2(void)
2888 {
2889   CONVVARS(SHORT);
2890   int i;
2891
2892   CHECKPTR(VarR8FromI2);
2893   CONVERTRANGE(VarR8FromI2, -32768, 32768);
2894 }
2895
2896 static void test_VarR8FromUI2(void)
2897 {
2898   CONVVARS(USHORT);
2899   int i;
2900
2901   CHECKPTR(VarR8FromUI2);
2902   CONVERTRANGE(VarR8FromUI2, 0, 65536);
2903 }
2904
2905 static void test_VarR8FromI4(void)
2906 {
2907   CONVVARS(int);
2908
2909   CHECKPTR(VarR8FromI4);
2910   CONVERT(VarR8FromI4, -2147483647-1); EXPECT(-2147483648.0);
2911   CONVERT(VarR8FromI4, -1);            EXPECT(-1.0);
2912   CONVERT(VarR8FromI4, 0);             EXPECT(0.0);
2913   CONVERT(VarR8FromI4, 1);             EXPECT(1.0);
2914   CONVERT(VarR8FromI4, 0x7fffffff);    EXPECT(2147483647.0);
2915 }
2916
2917 static void test_VarR8FromUI4(void)
2918 {
2919   CONVVARS(unsigned int);
2920
2921   CHECKPTR(VarR8FromUI4);
2922   CONVERT(VarR8FromUI4, 0);          EXPECT(0.0);
2923   CONVERT(VarR8FromUI4, 1);          EXPECT(1.0);
2924   CONVERT(VarR8FromUI4, 0xffffffff); EXPECT(4294967295.0);
2925 }
2926
2927 static void test_VarR8FromR4(void)
2928 {
2929   CONVVARS(FLOAT);
2930
2931   CHECKPTR(VarR8FromR4);
2932   CONVERT(VarR8FromR4, -1.0f); EXPECT(-1.0);
2933   CONVERT(VarR8FromR4, 0.0f);  EXPECT(0.0);
2934   CONVERT(VarR8FromR4, 1.0f);  EXPECT(1.0);
2935   CONVERT(VarR8FromR4, 1.5f);  EXPECT(1.5);
2936
2937   /* Skip rounding tests - no rounding is done */
2938 }
2939
2940 static void test_VarR8FromBool(void)
2941 {
2942   CONVVARS(VARIANT_BOOL);
2943
2944   CHECKPTR(VarR8FromBool);
2945   CONVERT(VarR8FromBool, VARIANT_TRUE);  EXPECT(VARIANT_TRUE * 1.0);
2946   CONVERT(VarR8FromBool, VARIANT_FALSE); EXPECT(VARIANT_FALSE * 1.0);
2947 }
2948
2949 static void test_VarR8FromCy(void)
2950 {
2951   CONVVARS(CY);
2952
2953   CHECKPTR(VarR8FromCy);
2954   CONVERT_CY(VarR8FromCy,-32769); EXPECT(-32769.0);
2955   CONVERT_CY(VarR8FromCy,-32768); EXPECT(-32768.0);
2956   CONVERT_CY(VarR8FromCy,-1);     EXPECT(-1.0);
2957   CONVERT_CY(VarR8FromCy,0);      EXPECT(0.0);
2958   CONVERT_CY(VarR8FromCy,1);      EXPECT(1.0);
2959   CONVERT_CY(VarR8FromCy,32767);  EXPECT(32767.0);
2960   CONVERT_CY(VarR8FromCy,32768);  EXPECT(32768.0);
2961
2962   CONVERT_CY(VarR8FromCy,-1.5); EXPECT(-1.5);
2963   CONVERT_CY(VarR8FromCy,-0.6); EXPECT(-0.6);
2964   CONVERT_CY(VarR8FromCy,-0.5); EXPECT(-0.5);
2965   CONVERT_CY(VarR8FromCy,-0.4); EXPECT(-0.4);
2966   CONVERT_CY(VarR8FromCy,0.4);  EXPECT(0.4);
2967   CONVERT_CY(VarR8FromCy,0.5);  EXPECT(0.5);
2968   CONVERT_CY(VarR8FromCy,0.6);  EXPECT(0.6);
2969   CONVERT_CY(VarR8FromCy,1.5);  EXPECT(1.5);
2970 }
2971
2972 static void test_VarR8FromI8(void)
2973 {
2974   CONVVARS(LONG64);
2975
2976   CHECKPTR(VarR8FromI8);
2977   CONVERT(VarR8FromI8, -1); EXPECT(-1.0);
2978   CONVERT(VarR8FromI8, 0);  EXPECT(0.0);
2979   CONVERT(VarR8FromI8, 1);  EXPECT(1.0);
2980 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
2981   CONVERT_I8(VarR8FromI8, 0x7fffffff,0xffffffff); EXPECT(9223372036854775808.0);
2982 #endif
2983 }
2984
2985 static void test_VarR8FromUI8(void)
2986 {
2987   CONVVARS(ULONG64);
2988
2989   CHECKPTR(VarR8FromUI8);
2990   CONVERT(VarR8FromUI8, 0); EXPECT(0.0);
2991   CONVERT(VarR8FromUI8, 1); EXPECT(1.0);
2992 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
2993   CONVERT_I8(VarR8FromUI8, 0x80000000,0); EXPECT(9223372036854775808.0);
2994 #endif
2995 }
2996
2997 static void test_VarR8FromDec(void)
2998 {
2999   CONVVARS(DECIMAL);
3000
3001   CHECKPTR(VarR8FromDec);
3002
3003   CONVERT_BADDEC(VarR8FromDec);
3004
3005   CONVERT_DEC(VarR8FromDec,0,0x80,0,32768); EXPECT(-32768.0);
3006   CONVERT_DEC(VarR8FromDec,0,0x80,0,1);     EXPECT(-1.0);
3007   CONVERT_DEC(VarR8FromDec,0,0,0,0);        EXPECT(0.0);
3008   CONVERT_DEC(VarR8FromDec,0,0,0,1);        EXPECT(1.0);
3009   CONVERT_DEC(VarR8FromDec,0,0,0,32767);    EXPECT(32767.0);
3010
3011   CONVERT_DEC(VarR8FromDec,2,0x80,0,3276800); EXPECT(-32768.0);
3012   CONVERT_DEC(VarR8FromDec,2,0,0,3276700);    EXPECT(32767.0);
3013
3014   CONVERT_DEC(VarR8FromDec,0,0,1,0);        EXPECT(18446744073709551616.0);
3015 }
3016
3017 static void test_VarR8FromDate(void)
3018 {
3019   CONVVARS(DATE);
3020
3021   CHECKPTR(VarR8FromDate);
3022   CONVERT(VarR8FromDate, -1.0); EXPECT(-1.0);
3023   CONVERT(VarR8FromDate, -0.0); EXPECT(0.0);
3024   CONVERT(VarR8FromDate, 1.0);  EXPECT(1.0);
3025 }
3026
3027 static void test_VarR8FromStr(void)
3028 {
3029   CONVVARS(LCID);
3030   OLECHAR buff[128];
3031
3032   in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
3033
3034   CHECKPTR(VarR8FromStr);
3035
3036   CONVERT_STR(VarR8FromStr,NULL,0);   EXPECT_MISMATCH;
3037   CONVERT_STR(VarR8FromStr,"",0);     EXPECT_MISMATCH;
3038   CONVERT_STR(VarR8FromStr," ",0);    EXPECT_MISMATCH;
3039
3040   CONVERT_STR(VarR8FromStr,"0",0);    EXPECT(0.0);
3041   CONVERT_STR(VarR8FromStr,"-1.5",0); EXPECT(-1.5);
3042   CONVERT_STR(VarR8FromStr,"-0.6",0); EXPECT(-0.6);
3043   CONVERT_STR(VarR8FromStr,"-0.5",0); EXPECT(-0.5);
3044   CONVERT_STR(VarR8FromStr,"-0.4",0); EXPECT(-0.4);
3045   CONVERT_STR(VarR8FromStr,"0.4",0);  EXPECT(0.4);
3046   CONVERT_STR(VarR8FromStr,"0.5",0);  EXPECT(0.5);
3047   CONVERT_STR(VarR8FromStr,"0.6",0);  EXPECT(0.6);
3048   CONVERT_STR(VarR8FromStr,"1.5",0);  EXPECT(1.5);
3049
3050   /* We already have exhaustive tests for number parsing, so skip those tests here */
3051 }
3052
3053 static void test_VarR8Copy(void)
3054 {
3055   COPYTEST(77665544.0, VT_R8, V_R8(&vSrc), V_R8(&vDst), V_R8REF(&vSrc),V_R8REF(&vDst), "%16.16g");
3056 }
3057
3058 static void test_VarR8ChangeTypeEx(void)
3059 {
3060 #ifdef HAS_UINT64_TO_FLOAT
3061   CONVVARS(CONV_TYPE);
3062   VARIANTARG vSrc, vDst;
3063
3064   in = 1.0;
3065
3066   INITIAL_TYPETEST(VT_R8, V_R8, "%g");
3067   COMMON_TYPETEST;
3068 #endif
3069 }
3070
3071 #define MATHRND(l, r) left = l; right = r; hres = pVarR8Round(left, right, &out)
3072
3073 static void test_VarR8Round(void)
3074 {
3075   HRESULT hres;
3076   double left = 0.0, out;
3077   int right;
3078
3079   CHECKPTR(VarR8Round);
3080   MATHRND(0.5432, 5);  EXPECT(0.5432);
3081   MATHRND(0.5432, 4);  EXPECT(0.5432);
3082   MATHRND(0.5432, 3);  EXPECT(0.543);
3083   MATHRND(0.5432, 2);  EXPECT(0.54);
3084   MATHRND(0.5432, 1);  EXPECT(0.5);
3085   MATHRND(0.5532, 0);  EXPECT(1);
3086   MATHRND(0.5532, -1); EXPECT_INVALID;
3087
3088   MATHRND(0.5568, 5);  EXPECT(0.5568);
3089   MATHRND(0.5568, 4);  EXPECT(0.5568);
3090   MATHRND(0.5568, 3);  EXPECT(0.557);
3091   MATHRND(0.5568, 2);  EXPECT(0.56);
3092   MATHRND(0.5568, 1);  EXPECT(0.6);
3093   MATHRND(0.5568, 0);  EXPECT(1);
3094   MATHRND(0.5568, -1); EXPECT_INVALID;
3095
3096   MATHRND(0.4999, 0); EXPECT(0);
3097   MATHRND(0.5000, 0); EXPECT(0);
3098   MATHRND(0.5001, 0); EXPECT(1);
3099   MATHRND(1.4999, 0); EXPECT(1);
3100   MATHRND(1.5000, 0); EXPECT(2);
3101   MATHRND(1.5001, 0); EXPECT(2);
3102 }
3103
3104 /*
3105  * VT_DATE
3106  */
3107
3108 #undef CONV_TYPE
3109 #define CONV_TYPE DATE
3110
3111 static void test_VarDateFromI1(void)
3112 {
3113   CONVVARS(signed char);
3114   int i;
3115
3116   CHECKPTR(VarDateFromI1);
3117   CONVERTRANGE(VarDateFromI1, -128, 128);
3118 }
3119
3120 static void test_VarDateFromUI1(void)
3121 {
3122   CONVVARS(BYTE);
3123   int i;
3124
3125   CHECKPTR(VarDateFromUI1);
3126   CONVERTRANGE(VarDateFromUI1, 0, 256);
3127 }
3128
3129 static void test_VarDateFromI2(void)
3130 {
3131   CONVVARS(SHORT);
3132   int i;
3133
3134   CHECKPTR(VarDateFromI2);
3135   CONVERTRANGE(VarDateFromI2, -32768, 32768);
3136 }
3137
3138 static void test_VarDateFromUI2(void)
3139 {
3140   CONVVARS(USHORT);
3141   int i;
3142
3143   CHECKPTR(VarDateFromUI2);
3144   CONVERTRANGE(VarDateFromUI2, 0, 65536);
3145 }
3146
3147 static void test_VarDateFromI4(void)
3148 {
3149   CONVVARS(int);
3150
3151   CHECKPTR(VarDateFromI4);
3152   CONVERT(VarDateFromI4, DATE_MIN-1);
3153   if (hres != DISP_E_TYPEMISMATCH) /* Early versions return this, incorrectly */
3154     EXPECT_OVERFLOW;
3155   CONVERT(VarDateFromI4, DATE_MIN);   EXPECT(DATE_MIN);
3156   CONVERT(VarDateFromI4, -1);         EXPECT(-1.0);
3157   CONVERT(VarDateFromI4, 0);          EXPECT(0.0);
3158   CONVERT(VarDateFromI4, 1);          EXPECT(1.0);
3159   CONVERT(VarDateFromI4, DATE_MAX);   EXPECT(DATE_MAX);
3160   CONVERT(VarDateFromI4, DATE_MAX+1);
3161   if (hres != DISP_E_TYPEMISMATCH) /* Early versions return this, incorrectly */
3162     EXPECT_OVERFLOW;
3163 }
3164
3165 static void test_VarDateFromUI4(void)
3166 {
3167   CONVVARS(unsigned int);
3168
3169   CHECKPTR(VarDateFromUI4);
3170   CONVERT(VarDateFromUI4, 0);          EXPECT(0.0);
3171   CONVERT(VarDateFromUI4, 1);          EXPECT(1.0);
3172   CONVERT(VarDateFromUI4, DATE_MAX);   EXPECT(DATE_MAX);
3173   CONVERT(VarDateFromUI4, DATE_MAX+1);
3174   if (hres != DISP_E_TYPEMISMATCH) /* Early versions return this, incorrectly */
3175     EXPECT_OVERFLOW;
3176 }
3177
3178 static void test_VarDateFromR4(void)
3179 {
3180   CONVVARS(FLOAT);
3181
3182   CHECKPTR(VarDateFromR4);
3183   CONVERT(VarDateFromR4, -1.0f); EXPECT(-1.0);
3184   CONVERT(VarDateFromR4, 0.0f);  EXPECT(0.0);
3185   CONVERT(VarDateFromR4, 1.0f);  EXPECT(1.0);
3186   CONVERT(VarDateFromR4, 1.5f);  EXPECT(1.5);
3187 }
3188
3189 static void test_VarDateFromR8(void)
3190 {
3191   CONVVARS(double);
3192
3193   CHECKPTR(VarDateFromR8);
3194   CONVERT(VarDateFromR8, -1.0f); EXPECT(-1.0);
3195   CONVERT(VarDateFromR8, 0.0f);  EXPECT(0.0);
3196   CONVERT(VarDateFromR8, 1.0f);  EXPECT(1.0);
3197   CONVERT(VarDateFromR8, 1.5f);  EXPECT(1.5);
3198 }
3199
3200 static void test_VarDateFromBool(void)
3201 {
3202   CONVVARS(VARIANT_BOOL);
3203
3204   CHECKPTR(VarDateFromBool);
3205   CONVERT(VarDateFromBool, VARIANT_TRUE);  EXPECT(VARIANT_TRUE * 1.0);
3206   CONVERT(VarDateFromBool, VARIANT_FALSE); EXPECT(VARIANT_FALSE * 1.0);
3207 }
3208
3209 static void test_VarDateFromCy(void)
3210 {
3211   CONVVARS(CY);
3212
3213   CHECKPTR(VarDateFromCy);
3214   CONVERT_CY(VarDateFromCy,-32769); EXPECT(-32769.0);
3215   CONVERT_CY(VarDateFromCy,-32768); EXPECT(-32768.0);
3216   CONVERT_CY(VarDateFromCy,-1);     EXPECT(-1.0);
3217   CONVERT_CY(VarDateFromCy,0);      EXPECT(0.0);
3218   CONVERT_CY(VarDateFromCy,1);      EXPECT(1.0);
3219   CONVERT_CY(VarDateFromCy,32767);  EXPECT(32767.0);
3220   CONVERT_CY(VarDateFromCy,32768);  EXPECT(32768.0);
3221
3222   CONVERT_CY(VarDateFromCy,-1.5); EXPECT(-1.5);
3223   CONVERT_CY(VarDateFromCy,-0.6); EXPECT(-0.6);
3224   CONVERT_CY(VarDateFromCy,-0.5); EXPECT(-0.5);
3225   CONVERT_CY(VarDateFromCy,-0.4); EXPECT(-0.4);
3226   CONVERT_CY(VarDateFromCy,0.4);  EXPECT(0.4);
3227   CONVERT_CY(VarDateFromCy,0.5);  EXPECT(0.5);
3228   CONVERT_CY(VarDateFromCy,0.6);  EXPECT(0.6);
3229   CONVERT_CY(VarDateFromCy,1.5);  EXPECT(1.5);
3230 }
3231
3232 static void test_VarDateFromI8(void)
3233 {
3234   CONVVARS(LONG64);
3235
3236   CHECKPTR(VarDateFromI8);
3237   CONVERT(VarDateFromI8, DATE_MIN-1); EXPECT_OVERFLOW;
3238   CONVERT(VarDateFromI8, DATE_MIN);   EXPECT(DATE_MIN);
3239   CONVERT(VarDateFromI8, -1);         EXPECT(-1.0);
3240   CONVERT(VarDateFromI8, 0);          EXPECT(0.0);
3241   CONVERT(VarDateFromI8, 1);          EXPECT(1.0);
3242   CONVERT(VarDateFromI8, DATE_MAX);   EXPECT(DATE_MAX);
3243   CONVERT(VarDateFromI8, DATE_MAX+1); EXPECT_OVERFLOW;
3244 }
3245
3246 static void test_VarDateFromUI8(void)
3247 {
3248   CONVVARS(ULONG64);
3249
3250   CHECKPTR(VarDateFromUI8);
3251   CONVERT(VarDateFromUI8, 0);          EXPECT(0.0);
3252   CONVERT(VarDateFromUI8, 1);          EXPECT(1.0);
3253   CONVERT(VarDateFromUI8, DATE_MAX);   EXPECT(DATE_MAX);
3254   CONVERT(VarDateFromUI8, DATE_MAX+1); EXPECT_OVERFLOW;
3255 }
3256
3257 static void test_VarDateFromDec(void)
3258 {
3259   CONVVARS(DECIMAL);
3260
3261   CHECKPTR(VarDateFromDec);
3262
3263   CONVERT_BADDEC(VarDateFromDec);
3264
3265   CONVERT_DEC(VarDateFromDec,0,0x80,0,32768); EXPECT(-32768.0);
3266   CONVERT_DEC(VarDateFromDec,0,0x80,0,1);     EXPECT(-1.0);
3267   CONVERT_DEC(VarDateFromDec,0,0,0,0);        EXPECT(0.0);
3268   CONVERT_DEC(VarDateFromDec,0,0,0,1);        EXPECT(1.0);
3269   CONVERT_DEC(VarDateFromDec,0,0,0,32767);    EXPECT(32767.0);
3270
3271   CONVERT_DEC(VarDateFromDec,2,0x80,0,3276800); EXPECT(-32768.0);
3272   CONVERT_DEC(VarDateFromDec,2,0,0,3276700);    EXPECT(32767.0);
3273 }
3274
3275 #define DFS(str) \
3276   buff[0] = '\0'; out = 0.0; \
3277   if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,sizeof(buff)/sizeof(WCHAR)); \
3278   hres = pVarDateFromStr(str ? buff : NULL,lcid,LOCALE_NOUSEROVERRIDE,&out)
3279
3280 #define MKRELDATE(day,mth) st.wMonth = mth; st.wDay = day; \
3281   pSystemTimeToVariantTime(&st,&relative)
3282
3283 static const char *BadDateStrings[] =
3284 {
3285   "True", "False", /* Plain text */
3286   "0.", ".0", "-1.1", "1.1-", /* Partial specifications */
3287   "1;2;3", "1*2*3", "1@2@3", "1#2#3", "(1:2)","<1:2>","1|2|3", /* Bad chars */
3288   "0", "1", /* 1 element */
3289   "0.60", "24.00", "0:60", "24:00", "1 2 am", "1 am 2", /* 2 elements */
3290   "1.5 2", "1 5.2", "2 32 3", "1 2 am 3", /* 3 elements */
3291   "1 2.3 4", "1.2.3 4", "1 2.3.4", "1.2 3.4", "1.2.3.4", "1 2 3 4",
3292   "1 am 2 3.4", "1 2 am 3.4", "1.2 3 am 4", "1.2 3 4 am", /* 4 elements */
3293   "1.2.3.4.5", "1.2.3.4 5", "1.2.3 4.5", "1.2 3.4.5", "1.2 3.4 5", "1.2 3 4.5",
3294   "1 2.3.4.5", "1 2.3.4 5", "1 2.3 4.5", "1 2.3 4 5", "1 2 3.4 5", "1 2 3 4 5",
3295   "1.2.3 4 am 5", "1.2.3 4 5 am", "1.2 3 am 4 5",
3296   "1.2 3 4 am 5", "1.2 3 4 5 am", "1 am 2 3.4.5", "1 2 am 3.4.5",
3297   "1 am 2 3 4.5", "1 2 am 3 4.5", "1 2 3 am 4.5", /* 5 elements */
3298   /* 6 elements */
3299   "1.2.3.4.5.6", "1.2.3.4.5 6", "1.2.3.4 5.6", "1.2.3.4 5 6", "1.2.3 4.5.6",
3300   "1.2.3 4.5 6", "1.2.3 4 5.6", "1.2 3.4.5.6", "1.2 3.4.5 6", "1.2 3.4 5.6",
3301   "1.2 3.4 5 6", "1.2 3 4.5.6", "1.2 3 4.5 6", "1.2 3 4 5.6", "1.2 3 4 5 6",
3302   "1 2.3.4.5.6", "1 2.3.4.5 6", "1 2.3.4 5.6", "1 2.3.4 5 6", "1 2.3 4.5.6",
3303 #if 0
3304   /* following throws an exception on winME */
3305   "1 2.3 4.5 6", "1 2.3 4 5.6", "1 2.3 4 5 6", "1 2 3.4.5.6", "1 2 3.4.5 6",
3306 #endif
3307   "1 2 3.4 5.6", "1 2 3.4 5 6", "1 2 3 4.5 6", "1 2 3 4 5.6", "1 2 3 4 5 6",
3308 #if 0
3309   /* following throws an exception on winME */
3310   "1.2.3 4 am 5 6", "1.2.3 4 5 am 6", "1.2.3 4 5 6 am", "1 am 2 3 4.5.6",
3311 #endif
3312   "1 2 am 3 4.5.6", "1 2 3 am 4.5.6"
3313 };
3314
3315 static void test_VarDateFromStr(void)
3316 {
3317   LCID lcid;
3318   DATE out, relative;
3319   HRESULT hres;
3320   SYSTEMTIME st;
3321   OLECHAR buff[128];
3322   size_t i;
3323
3324   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
3325
3326   CHECKPTR(VarDateFromStr);
3327   CHECKPTR(SystemTimeToVariantTime);
3328
3329   /* Some date formats are relative, so we need to find the cuurent year */
3330   GetSystemTime(&st);
3331   st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
3332   DFS(NULL); EXPECT_MISMATCH;
3333
3334   /* Floating point number are not recognised */
3335   DFS("0.0");
3336   if (hres == S_OK)
3337     EXPECT_DBL(0.0); /* Very old versions accept this string */
3338   else
3339     EXPECT_MISMATCH;
3340
3341   /* 1 element - can only be a time, and only if it has am/pm */
3342   DFS("1 am"); EXPECT_DBL(0.04166666666666666);
3343   /* 2 elements */
3344   /* A decimal point is treated as a time separator.
3345    * The following are converted as hours/minutes.
3346    */
3347   DFS("0.1");  EXPECT_DBL(0.0006944444444444445);
3348   DFS("0.40"); EXPECT_DBL(0.02777777777777778);
3349   DFS("2.5");  EXPECT_DBL(0.08680555555555555);
3350   /* A colon acts as a decimal point */
3351   DFS("0:1");  EXPECT_DBL(0.0006944444444444445);
3352   DFS("0:20"); EXPECT_DBL(0.01388888888888889);
3353   DFS("0:40"); EXPECT_DBL(0.02777777777777778);
3354   DFS("3:5");  EXPECT_DBL(0.1284722222222222);
3355   /* Check the am/pm limits */
3356   DFS("00:00 AM"); EXPECT_DBL(0.0);
3357   DFS("00:00 a");  EXPECT_DBL(0.0);
3358   DFS("12:59 AM"); EXPECT_DBL(0.04097222222222222);
3359   DFS("12:59 A");  EXPECT_DBL(0.04097222222222222);
3360   DFS("00:00 pm"); EXPECT_DBL(0.5);
3361   DFS("00:00 p");  EXPECT_DBL(0.5);
3362   DFS("12:59 pm"); EXPECT_DBL(0.5409722222222222);
3363   DFS("12:59 p");  EXPECT_DBL(0.5409722222222222);
3364   /* AM/PM is ignored if hours > 12 */
3365   DFS("13:00 AM"); EXPECT_DBL(0.5416666666666666);
3366   DFS("13:00 PM"); EXPECT_DBL(0.5416666666666666);
3367
3368   /* Space, dash and slash all indicate a date format. */
3369   /* If both numbers are valid month values => month/day of current year */
3370   DFS("1 2"); MKRELDATE(2,1); EXPECT_DBL(relative);
3371   DFS("2 1"); MKRELDATE(1,2); EXPECT_DBL(relative);
3372   /* one number not valid month, is a valid day, other number valid month:
3373    * that number becomes the day.
3374    */
3375   DFS("14 1");   MKRELDATE(14,1); EXPECT_DBL(relative);
3376   DFS("1 14");   EXPECT_DBL(relative);
3377   /* If the numbers can't be day/month, they are assumed to be year/month */
3378   DFS("30 2");   EXPECT_DBL(10990.0);
3379   DFS("2 30");   EXPECT_DBL(10990.0);
3380   DFS("32 49");  EXPECT_MISMATCH; /* Can't be any format */
3381   DFS("0 49");   EXPECT_MISMATCH; /* Can't be any format */
3382   /* If a month name is given the other number is the day */
3383   DFS("Jan 2");  MKRELDATE(2,1); EXPECT_DBL(relative);
3384   DFS("2 Jan");  EXPECT_DBL(relative);
3385   /* Unless it can't be, in which case it becomes the year */
3386   DFS("Jan 35"); EXPECT_DBL(12785.0);
3387   DFS("35 Jan"); EXPECT_DBL(12785.0);
3388   DFS("Jan-35"); EXPECT_DBL(12785.0);
3389   DFS("35-Jan"); EXPECT_DBL(12785.0);
3390   DFS("Jan/35"); EXPECT_DBL(12785.0);
3391   DFS("35/Jan"); EXPECT_DBL(12785.0);
3392   /* 3 elements */
3393   /* 3 numbers and time separator => h:m:s */
3394   DFS("0.1.0");  EXPECT_DBL(0.0006944444444444445);
3395   DFS("1.5.2");  EXPECT_DBL(0.04516203703703704);
3396   /* 3 numbers => picks date giving preference to lcid format */
3397   DFS("1 2 3");  EXPECT_DBL(37623.0);
3398   DFS("14 2 3"); EXPECT_DBL(41673.0);
3399   DFS("2 14 3"); EXPECT_DBL(37666.0);
3400   DFS("2 3 14"); EXPECT_DBL(41673.0);
3401   DFS("32 2 3"); EXPECT_DBL(11722.0);
3402   DFS("2 3 32"); EXPECT_DBL(11722.0);
3403   DFS("1 2 29"); EXPECT_DBL(47120.0);
3404   /* After 30, two digit dates are expected to be in the 1900's */
3405   DFS("1 2 30"); EXPECT_DBL(10960.0);
3406   DFS("1 2 31"); EXPECT_DBL(11325.0);
3407   DFS("3 am 1 2"); MKRELDATE(2,1); relative += 0.125; EXPECT_DBL(relative);
3408   DFS("1 2 3 am"); EXPECT_DBL(relative);
3409
3410   /* 4 elements -interpreted as 2 digit date & time */
3411   DFS("1.2 3 4");   MKRELDATE(4,3); relative += 0.04305555556; EXPECT_DBL(relative);
3412   DFS("3 4 1.2");   EXPECT_DBL(relative);
3413   /* 5 elements - interpreted as 2 & 3 digit date/times */
3414   DFS("1.2.3 4 5"); MKRELDATE(5,4); relative += 0.04309027778; EXPECT_DBL(relative);
3415   DFS("1.2 3 4 5"); EXPECT_DBL(38415.04305555556);
3416 #if 0
3417   /* following throws an exception on winME */
3418   DFS("1 2 3.4.5"); MKRELDATE(2,1); relative += 0.12783564815; EXPECT_DBL(relative);
3419 #endif
3420   DFS("1 2 3 4.5"); EXPECT_DBL(37623.17013888889);
3421   /* 6 elements - interpreted as 3 digit date/times */
3422   DFS("1.2.3 4 5 6"); EXPECT_DBL(38812.04309027778);
3423   DFS("1 2 3 4.5.6"); EXPECT_DBL(37623.17020833334);
3424
3425   for (i = 0; i < sizeof(BadDateStrings)/sizeof(char*); i++)
3426   {
3427     DFS(BadDateStrings[i]); EXPECT_MISMATCH;
3428   }
3429
3430   /* Some normal-ish strings */
3431   DFS("2 January, 1970"); EXPECT_DBL(25570.0);
3432   DFS("2 January 1970");  EXPECT_DBL(25570.0);
3433   DFS("2 Jan 1970");      EXPECT_DBL(25570.0);
3434   DFS("2/Jan/1970");      EXPECT_DBL(25570.0);
3435   DFS("2-Jan-1970");      EXPECT_DBL(25570.0);
3436   DFS("1 2 1970");        EXPECT_DBL(25570.0);
3437   DFS("1/2/1970");        EXPECT_DBL(25570.0);
3438   DFS("1-2-1970");        EXPECT_DBL(25570.0);
3439   /* Native fails "1999 January 3, 9AM". I consider that a bug in native */
3440 }
3441
3442 static void test_VarDateCopy(void)
3443 {
3444   COPYTEST(77665544.0, VT_DATE, V_DATE(&vSrc), V_DATE(&vDst), V_DATEREF(&vSrc),
3445            V_DATEREF(&vDst), "%16.16g");
3446 }
3447
3448 static const char* wtoascii(LPWSTR lpszIn)
3449 {
3450     static char buff[256];
3451     WideCharToMultiByte(CP_ACP, 0, lpszIn, -1, buff, sizeof(buff), NULL, NULL);
3452     return buff;
3453 }
3454
3455 static void test_VarDateChangeTypeEx(void)
3456 {
3457   static const WCHAR sz25570[] = {
3458     '1','/','2','/','1','9','7','0','\0' };
3459   static const WCHAR sz25570_2[] = {
3460           '1','/','2','/','7','0','\0' };
3461   static const WCHAR sz25570Nls[] = {
3462     '1','/','2','/','1','9','7','0',' ','1','2',':','0','0',':','0','0',' ','A','M','\0' };
3463   CONVVARS(CONV_TYPE);
3464   VARIANTARG vSrc, vDst;
3465   LCID lcid;
3466
3467   in = 1.0;
3468
3469 #ifdef HAS_UINT64_TO_FLOAT
3470   INITIAL_TYPETEST(VT_DATE, V_DATE, "%g");
3471   COMMON_TYPETEST;
3472 #endif
3473
3474   V_VT(&vDst) = VT_EMPTY;
3475   V_VT(&vSrc) = VT_DATE;
3476   V_DATE(&vSrc) = 25570.0;
3477   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
3478
3479   hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, VARIANT_NOUSEROVERRIDE, VT_BSTR);
3480   ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && V_BSTR(&vDst) &&
3481           (!strcmpW(V_BSTR(&vDst), sz25570) || !strcmpW(V_BSTR(&vDst), sz25570_2)),
3482           "hres=0x%lX, type=%d (should be VT_BSTR), *bstr=%s\n",
3483           hres, V_VT(&vDst), V_BSTR(&vDst) ? wtoascii(V_BSTR(&vDst)) : "?");
3484
3485   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
3486   if (HAVE_OLEAUT32_LOCALES)
3487   {
3488     hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, VARIANT_NOUSEROVERRIDE|VARIANT_USE_NLS, VT_BSTR);
3489     ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && V_BSTR(&vDst) && !strcmpW(V_BSTR(&vDst), sz25570Nls),
3490             "hres=0x%lX, type=%d (should be VT_BSTR), *bstr=%s\n",
3491             hres, V_VT(&vDst), V_BSTR(&vDst) ? wtoascii(V_BSTR(&vDst)) : "?");
3492   }
3493 }
3494
3495 /*
3496  * VT_CY
3497  */
3498
3499 #undef CONV_TYPE
3500 #define CONV_TYPE CY
3501 #undef EXPECTRES
3502 #define EXPECTRES(res, x) \
3503   ok(hres == S_OK || ((HRESULT)res != S_OK && hres == (HRESULT)res), \
3504      "expected hres " #x ", got hres=0x%08lx\n", hres)
3505
3506 #define EXPECTCY(x) \
3507   ok((hres == S_OK && out.int64 == (LONGLONG)(x*CY_MULTIPLIER)), \
3508      "expected " #x "*CY_MULTIPLIER, got (%8lx %8lx); hres=0x%08lx\n", S(out).Hi, S(out).Lo, hres)
3509
3510 #define EXPECTCY64(x,y) \
3511   ok(hres == S_OK && S(out).Hi == (long)x && S(out).Lo == y, \
3512      "expected " #x #y "(%lu,%lu), got (%lu,%lu); hres=0x%08lx\n", \
3513       (ULONG)(x), (ULONG)(y), S(out).Hi, S(out).Lo, hres)
3514
3515 static void test_VarCyFromI1(void)
3516 {
3517   CONVVARS(signed char);
3518   int i;
3519
3520   CHECKPTR(VarCyFromI1);
3521   for (i = -128; i < 128; i++)
3522   {
3523     CONVERT(VarCyFromI1,i); EXPECTCY(i);
3524   }
3525 }
3526
3527 static void test_VarCyFromUI1(void)
3528 {
3529   CONVVARS(BYTE);
3530   int i;
3531
3532   CHECKPTR(VarCyFromUI1);
3533   for (i = 0; i < 256; i++)
3534   {
3535     CONVERT(VarCyFromUI1,i); EXPECTCY(i);
3536   }
3537 }
3538
3539 static void test_VarCyFromI2(void)
3540 {
3541   CONVVARS(SHORT);
3542   int i;
3543
3544   CHECKPTR(VarCyFromI2);
3545   for (i = -16384; i < 16384; i++)
3546   {
3547     CONVERT(VarCyFromI2,i); EXPECTCY(i);
3548   }
3549 }
3550
3551 static void test_VarCyFromUI2(void)
3552 {
3553   CONVVARS(int);
3554   int i;
3555
3556   CHECKPTR(VarCyFromUI2);
3557   for (i = 0; i < 32768; i++)
3558   {
3559     CONVERT(VarCyFromUI2,i); EXPECTCY(i);
3560   }
3561 }
3562
3563 static void test_VarCyFromI4(void)
3564 {
3565   CONVVARS(int);
3566
3567   CHECKPTR(VarCyFromI4);
3568   CONVERT(VarCyFromI4, -1);         EXPECTCY(-1);
3569   CONVERT(VarCyFromI4, 0);          EXPECTCY(0);
3570   CONVERT(VarCyFromI4, 1);          EXPECTCY(1);
3571   CONVERT(VarCyFromI4, 0x7fffffff); EXPECTCY64(0x1387, 0xffffd8f0);
3572   CONVERT(VarCyFromI4, 0x80000000); EXPECTCY64(0xffffec78, 0);
3573 }
3574
3575 static void test_VarCyFromUI4(void)
3576 {
3577   CONVVARS(unsigned int);
3578
3579   CHECKPTR(VarCyFromUI4);
3580   CONVERT(VarCyFromUI4, 0); EXPECTCY(0);
3581   CONVERT(VarCyFromUI4, 1); EXPECTCY(1);
3582   CONVERT(VarCyFromUI4, 0x80000000); EXPECTCY64(5000, 0);
3583 }
3584
3585 static void test_VarCyFromR4(void)
3586 {
3587   CONVVARS(FLOAT);
3588
3589   CHECKPTR(VarCyFromR4);
3590   CONVERT(VarCyFromR4, -1.0f); EXPECTCY(-1);
3591   CONVERT(VarCyFromR4, 0.0f);  EXPECTCY(0);
3592   CONVERT(VarCyFromR4, 1.0f);  EXPECTCY(1);
3593   CONVERT(VarCyFromR4, 1.5f);  EXPECTCY(1.5);
3594
3595   CONVERT(VarCyFromR4, -1.5f);     EXPECTCY(-1.5);
3596   CONVERT(VarCyFromR4, -0.6f);     EXPECTCY(-0.6);
3597   CONVERT(VarCyFromR4, -0.5f);     EXPECTCY(-0.5);
3598   CONVERT(VarCyFromR4, -0.4f);     EXPECTCY(-0.4);
3599   CONVERT(VarCyFromR4, 0.4f);      EXPECTCY(0.4);
3600   CONVERT(VarCyFromR4, 0.5f);      EXPECTCY(0.5);
3601   CONVERT(VarCyFromR4, 0.6f);      EXPECTCY(0.6);
3602   CONVERT(VarCyFromR4, 1.5f);      EXPECTCY(1.5);
3603   CONVERT(VarCyFromR4, 1.00009f);  EXPECTCY(1.0001);
3604   CONVERT(VarCyFromR4, -1.00001f); EXPECTCY(-1);
3605   CONVERT(VarCyFromR4, -1.00005f); EXPECTCY(-1);
3606   CONVERT(VarCyFromR4, -0.00009f); EXPECTCY(-0.0001);
3607   CONVERT(VarCyFromR4, -0.00005f); EXPECTCY(0);
3608   CONVERT(VarCyFromR4, -0.00001f); EXPECTCY(0);
3609   CONVERT(VarCyFromR4, 0.00001f);  EXPECTCY(0);
3610   CONVERT(VarCyFromR4, 0.00005f);  EXPECTCY(0);
3611   CONVERT(VarCyFromR4, 0.00009f);  EXPECTCY(0.0001);
3612   CONVERT(VarCyFromR4, -1.00001f); EXPECTCY(-1);
3613   CONVERT(VarCyFromR4, -1.00005f); EXPECTCY(-1);
3614   CONVERT(VarCyFromR4, -1.00009f); EXPECTCY(-1.0001);
3615 }
3616
3617 static void test_VarCyFromR8(void)
3618 {
3619   CONVVARS(DOUBLE);
3620
3621   CHECKPTR(VarCyFromR8);
3622
3623 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
3624   /* Test our rounding is exactly the same. This fails if the special x86
3625    * code is taken out of VarCyFromR8.
3626    */
3627   CONVERT(VarCyFromR8, -461168601842738.7904); EXPECTCY64(0xbfffffff, 0xffffff23);
3628 #endif
3629
3630   CONVERT(VarCyFromR8, -4611686018427388416.1); EXPECT_OVERFLOW;
3631   CONVERT(VarCyFromR8, -1.0);                   EXPECTCY(-1);
3632   CONVERT(VarCyFromR8, -0.0);                   EXPECTCY(0);
3633   CONVERT(VarCyFromR8, 1.0);                    EXPECTCY(1);
3634   CONVERT(VarCyFromR8, 4611686018427387648.0);  EXPECT_OVERFLOW;
3635
3636   /* Rounding */
3637   CONVERT(VarCyFromR8, -1.5f);     EXPECTCY(-1.5);
3638   CONVERT(VarCyFromR8, -0.6f);     EXPECTCY(-0.6);
3639   CONVERT(VarCyFromR8, -0.5f);     EXPECTCY(-0.5);
3640   CONVERT(VarCyFromR8, -0.4f);     EXPECTCY(-0.4);
3641   CONVERT(VarCyFromR8, 0.4f);      EXPECTCY(0.4);
3642   CONVERT(VarCyFromR8, 0.5f);      EXPECTCY(0.5);
3643   CONVERT(VarCyFromR8, 0.6f);      EXPECTCY(0.6);
3644   CONVERT(VarCyFromR8, 1.5f);      EXPECTCY(1.5);
3645   CONVERT(VarCyFromR8, 1.00009f);  EXPECTCY(1.0001);
3646   CONVERT(VarCyFromR8, -1.00001f); EXPECTCY(-1);
3647   CONVERT(VarCyFromR8, -1.00005f); EXPECTCY(-1);
3648   CONVERT(VarCyFromR8, -0.00009f); EXPECTCY(-0.0001);
3649   CONVERT(VarCyFromR8, -0.00005f); EXPECTCY(0);
3650   CONVERT(VarCyFromR8, -0.00001f); EXPECTCY(0);
3651   CONVERT(VarCyFromR8, 0.00001f);  EXPECTCY(0);
3652   CONVERT(VarCyFromR8, 0.00005f);  EXPECTCY(0);
3653   CONVERT(VarCyFromR8, 0.00009f);  EXPECTCY(0.0001);
3654   CONVERT(VarCyFromR8, -1.00001f); EXPECTCY(-1);
3655   CONVERT(VarCyFromR8, -1.00005f); EXPECTCY(-1);
3656   CONVERT(VarCyFromR8, -1.00009f); EXPECTCY(-1.0001);
3657 }
3658
3659 static void test_VarCyFromBool(void)
3660 {
3661   CONVVARS(VARIANT_BOOL);
3662   int i;
3663
3664   CHECKPTR(VarCyFromBool);
3665   for (i = -32768; i < 32768; i++)
3666   {
3667     CONVERT(VarCyFromBool, i);  EXPECTCY(i);
3668   }
3669 }
3670
3671 static void test_VarCyFromI8(void)
3672 {
3673   CONVVARS(LONG64);
3674
3675   CHECKPTR(VarCyFromI8);
3676   CONVERT_I8(VarCyFromI8, -214749, 2728163227ul);   EXPECT_OVERFLOW;
3677   CONVERT_I8(VarCyFromI8, -214749, 2728163228ul);   EXPECTCY64(2147483648ul,15808);
3678   CONVERT(VarCyFromI8, -1); EXPECTCY(-1);
3679   CONVERT(VarCyFromI8, 0);  EXPECTCY(0);
3680   CONVERT(VarCyFromI8, 1);  EXPECTCY(1);
3681   CONVERT_I8(VarCyFromI8, 214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
3682   CONVERT_I8(VarCyFromI8, 214748, 1566804069); EXPECT_OVERFLOW;
3683 }
3684
3685 static void test_VarCyFromUI8(void)
3686 {
3687   CONVVARS(ULONG64);
3688
3689   CHECKPTR(VarCyFromUI8);
3690   CONVERT(VarCyFromUI8, 0); EXPECTCY(0);
3691   CONVERT(VarCyFromUI8, 1); EXPECTCY(1);
3692   CONVERT_I8(VarCyFromUI8, 214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
3693   CONVERT_I8(VarCyFromUI8, 214748, 1566804069); EXPECT_OVERFLOW;
3694 }
3695
3696 static void test_VarCyFromDec(void)
3697 {
3698   CONVVARS(DECIMAL);
3699
3700   CHECKPTR(VarCyFromDec);
3701
3702   CONVERT_BADDEC(VarCyFromDec);
3703
3704   CONVERT_DEC(VarCyFromDec,0,0x80,0,1); EXPECTCY(-1);
3705   CONVERT_DEC(VarCyFromDec,0,0,0,0);    EXPECTCY(0);
3706   CONVERT_DEC(VarCyFromDec,0,0,0,1);    EXPECTCY(1);
3707
3708   CONVERT_DEC64(VarCyFromDec,0,0,0,214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
3709   CONVERT_DEC64(VarCyFromDec,0,0,0,214748, 1566804069); EXPECT_OVERFLOW;
3710
3711   CONVERT_DEC(VarCyFromDec,2,0,0,100);     EXPECTCY(1);
3712   CONVERT_DEC(VarCyFromDec,2,0x80,0,100);  EXPECTCY(-1);
3713   CONVERT_DEC(VarCyFromDec,2,0x80,0,1);    EXPECTCY(-0.01);
3714   CONVERT_DEC(VarCyFromDec,2,0,0,1);       EXPECTCY(0.01);
3715   CONVERT_DEC(VarCyFromDec,2,0x80,0,1);    EXPECTCY(-0.01);
3716   CONVERT_DEC(VarCyFromDec,2,0,0,999);     EXPECTCY(9.99);
3717   CONVERT_DEC(VarCyFromDec,2,0x80,0,999);  EXPECTCY(-9.99);
3718   CONVERT_DEC(VarCyFromDec,2,0,0,1500);    EXPECTCY(15);
3719   CONVERT_DEC(VarCyFromDec,2,0x80,0,1500); EXPECTCY(-15);
3720 }
3721
3722 static void test_VarCyFromDate(void)
3723 {
3724   CONVVARS(DATE);
3725
3726   CHECKPTR(VarCyFromDate);
3727
3728 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
3729   CONVERT(VarCyFromR8, -461168601842738.7904); EXPECTCY64(0xbfffffff, 0xffffff23);
3730 #endif
3731
3732   CONVERT(VarCyFromDate, -1.0); EXPECTCY(-1);
3733   CONVERT(VarCyFromDate, -0.0); EXPECTCY(0);
3734   CONVERT(VarCyFromDate, 1.0);  EXPECTCY(1);
3735   CONVERT(VarCyFromDate, -4611686018427388416.1); EXPECT_OVERFLOW;
3736   CONVERT(VarCyFromDate, 4611686018427387648.0);  EXPECT_OVERFLOW;
3737
3738   /* Rounding */
3739   CONVERT(VarCyFromDate, -1.5f);     EXPECTCY(-1.5);
3740   CONVERT(VarCyFromDate, -0.6f);     EXPECTCY(-0.6);
3741   CONVERT(VarCyFromDate, -0.5f);     EXPECTCY(-0.5);
3742   CONVERT(VarCyFromDate, -0.4f);     EXPECTCY(-0.4);
3743   CONVERT(VarCyFromDate, 0.4f);      EXPECTCY(0.4);
3744   CONVERT(VarCyFromDate, 0.5f);      EXPECTCY(0.5);
3745   CONVERT(VarCyFromDate, 0.6f);      EXPECTCY(0.6);
3746   CONVERT(VarCyFromDate, 1.5f);      EXPECTCY(1.5);
3747   CONVERT(VarCyFromDate, 1.00009f);  EXPECTCY(1.0001);
3748   CONVERT(VarCyFromDate, -1.00001f); EXPECTCY(-1);
3749   CONVERT(VarCyFromDate, -1.00005f); EXPECTCY(-1);
3750   CONVERT(VarCyFromDate, -0.00009f); EXPECTCY(-0.0001);
3751   CONVERT(VarCyFromDate, -0.00005f); EXPECTCY(0);
3752   CONVERT(VarCyFromDate, -0.00001f); EXPECTCY(0);
3753   CONVERT(VarCyFromDate, 0.00001f);  EXPECTCY(0);
3754   CONVERT(VarCyFromDate, 0.00005f);  EXPECTCY(0);
3755   CONVERT(VarCyFromDate, 0.00009f);  EXPECTCY(0.0001);
3756   CONVERT(VarCyFromDate, -1.00001f); EXPECTCY(-1);
3757   CONVERT(VarCyFromDate, -1.00005f); EXPECTCY(-1);
3758   CONVERT(VarCyFromDate, -1.00009f); EXPECTCY(-1.0001);
3759 }
3760
3761 #define MATHVARS1 HRESULT hres; double left = 0.0; CY cyLeft, out
3762 #define MATHVARS2 MATHVARS1; double right = 0.0; CY cyRight
3763 #define MATH1(func, l) left = (double)l; pVarCyFromR8(left, &cyLeft); hres = p##func(cyLeft, &out)
3764 #define MATH2(func, l, r) left = (double)l; right = (double)r; \
3765   pVarCyFromR8(left, &cyLeft); pVarCyFromR8(right, &cyRight); \
3766   hres = p##func(cyLeft, cyRight, &out)
3767
3768 static void test_VarCyAdd(void)
3769 {
3770   MATHVARS2;
3771
3772   CHECKPTR(VarCyAdd);
3773   MATH2(VarCyAdd, 0.5, 0.5);   EXPECTCY(1);
3774   MATH2(VarCyAdd, 0.5, -0.4);  EXPECTCY(0.1);
3775   MATH2(VarCyAdd, 0.5, -0.6);  EXPECTCY(-0.1);
3776   MATH2(VarCyAdd, -0.5, -0.5); EXPECTCY(-1);
3777   MATH2(VarCyAdd, -922337203685476.0, -922337203685476.0); EXPECT_OVERFLOW;
3778   MATH2(VarCyAdd, -922337203685476.0, 922337203685476.0);  EXPECTCY(0);
3779   MATH2(VarCyAdd, 922337203685476.0, -922337203685476.0);  EXPECTCY(0);
3780   MATH2(VarCyAdd, 922337203685476.0, 922337203685476.0);   EXPECT_OVERFLOW;
3781 }
3782
3783 static void test_VarCyMul(void)
3784 {
3785   MATHVARS2;
3786
3787   CHECKPTR(VarCyMul);
3788   MATH2(VarCyMul, 534443.0, 0.0); EXPECTCY(0);
3789   MATH2(VarCyMul, 0.5, 0.5);      EXPECTCY(0.25);
3790   MATH2(VarCyMul, 0.5, -0.4);     EXPECTCY(-0.2);
3791   MATH2(VarCyMul, 0.5, -0.6);     EXPECTCY(-0.3);
3792   MATH2(VarCyMul, -0.5, -0.5);    EXPECTCY(0.25);
3793   MATH2(VarCyMul, 922337203685476.0, 20000); EXPECT_OVERFLOW;
3794 }
3795
3796 static void test_VarCySub(void)
3797 {
3798   MATHVARS2;
3799
3800   CHECKPTR(VarCySub);
3801   MATH2(VarCySub, 0.5, 0.5);   EXPECTCY(0);
3802   MATH2(VarCySub, 0.5, -0.4);  EXPECTCY(0.9);
3803   MATH2(VarCySub, 0.5, -0.6);  EXPECTCY(1.1);
3804   MATH2(VarCySub, -0.5, -0.5); EXPECTCY(0);
3805   MATH2(VarCySub, -922337203685476.0, -922337203685476.0); EXPECTCY(0);
3806   MATH2(VarCySub, -922337203685476.0, 922337203685476.0);  EXPECT_OVERFLOW;
3807   MATH2(VarCySub, 922337203685476.0, -922337203685476.0);  EXPECT_OVERFLOW;
3808   MATH2(VarCySub, 922337203685476.0, 922337203685476.0);   EXPECTCY(0);
3809 }
3810
3811 static void test_VarCyAbs(void)
3812 {
3813   MATHVARS1;
3814
3815   CHECKPTR(VarCyAbs);
3816   MATH1(VarCyAbs, 0.5);  EXPECTCY(0.5);
3817   MATH1(VarCyAbs, -0.5); EXPECTCY(0.5);
3818   MATH1(VarCyAbs, 922337203685476.0);  EXPECTCY64(2147483647ul,4294951488ul);
3819   MATH1(VarCyAbs, -922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
3820 }
3821
3822 static void test_VarCyNeg(void)
3823 {
3824   MATHVARS1;
3825
3826   CHECKPTR(VarCyNeg);
3827   MATH1(VarCyNeg, 0.5); EXPECTCY(-0.5);
3828   MATH1(VarCyNeg, -0.5); EXPECTCY(0.5);
3829   MATH1(VarCyNeg, 922337203685476.0);  EXPECTCY64(2147483648ul,15808);
3830   MATH1(VarCyNeg, -922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
3831 }
3832
3833 #define MATHMULI4(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
3834   hres = pVarCyMulI4(cyLeft, right, &out)
3835
3836 static void test_VarCyMulI4(void)
3837 {
3838   MATHVARS1;
3839   LONG right;
3840
3841   CHECKPTR(VarCyMulI4);
3842   MATHMULI4(534443.0, 0); EXPECTCY(0);
3843   MATHMULI4(0.5, 1);      EXPECTCY(0.5);
3844   MATHMULI4(0.5, 2);      EXPECTCY(1);
3845   MATHMULI4(922337203685476.0, 1); EXPECTCY64(2147483647ul,4294951488ul);
3846   MATHMULI4(922337203685476.0, 2); EXPECT_OVERFLOW;
3847 }
3848
3849 #define MATHMULI8(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
3850   hres = pVarCyMulI8(cyLeft, right, &out)
3851
3852 static void test_VarCyMulI8(void)
3853 {
3854   MATHVARS1;
3855   LONG64 right;
3856
3857   CHECKPTR(VarCyMulI8);
3858   MATHMULI8(534443.0, 0); EXPECTCY(0);
3859   MATHMULI8(0.5, 1);      EXPECTCY(0.5);
3860   MATHMULI8(0.5, 2);      EXPECTCY(1);
3861   MATHMULI8(922337203685476.0, 1); EXPECTCY64(2147483647ul,4294951488ul);
3862   MATHMULI8(922337203685476.0, 2); EXPECT_OVERFLOW;
3863 }
3864
3865 #define MATHCMP(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); pVarCyFromR8(right, &cyRight); \
3866   hres = pVarCyCmp(cyLeft, cyRight); out.int64 = hres
3867
3868 static void test_VarCyCmp(void)
3869 {
3870   MATHVARS2;
3871
3872   CHECKPTR(VarCyCmp);
3873   MATHCMP(-1.0, -1.0); EXPECT_EQ;
3874   MATHCMP(-1.0, 0.0);  EXPECT_LT;
3875   MATHCMP(-1.0, 1.0);  EXPECT_LT;
3876   MATHCMP(-1.0, 2.0);  EXPECT_LT;
3877   MATHCMP(0.0, 1.0);   EXPECT_LT;
3878   MATHCMP(0.0, 0.0);   EXPECT_EQ;
3879   MATHCMP(0.0, -1.0);  EXPECT_GT;
3880   MATHCMP(1.0, -1.0);  EXPECT_GT;
3881   MATHCMP(1.0, 0.0);   EXPECT_GT;
3882   MATHCMP(1.0, 1.0);   EXPECT_EQ;
3883   MATHCMP(1.0, 2.0);   EXPECT_LT;
3884 }
3885
3886 #define MATHCMPR8(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
3887   hres = pVarCyCmpR8(cyLeft, right); out.int64 = hres
3888
3889 static void test_VarCyCmpR8(void)
3890 {
3891   MATHVARS1;
3892   double right;
3893
3894   CHECKPTR(VarCyCmpR8);
3895   MATHCMPR8(-1.0, -1.0); EXPECT_EQ;
3896   MATHCMPR8(-1.0, 0.0);  EXPECT_LT;
3897   MATHCMPR8(-1.0, 1.0);  EXPECT_LT;
3898   MATHCMPR8(-1.0, 2.0);  EXPECT_LT;
3899   MATHCMPR8(0.0, 1.0);   EXPECT_LT;
3900   MATHCMPR8(0.0, 0.0);   EXPECT_EQ;
3901   MATHCMPR8(0.0, -1.0);  EXPECT_GT;
3902   MATHCMPR8(1.0, -1.0);  EXPECT_GT;
3903   MATHCMPR8(1.0, 0.0);   EXPECT_GT;
3904   MATHCMPR8(1.0, 1.0);   EXPECT_EQ;
3905   MATHCMPR8(1.0, 2.0);   EXPECT_LT;
3906 }
3907
3908 #undef MATHRND
3909 #define MATHRND(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
3910   hres = pVarCyRound(cyLeft, right, &out)
3911
3912 static void test_VarCyRound(void)
3913 {
3914   MATHVARS1;
3915   int right;
3916
3917   CHECKPTR(VarCyRound);
3918   MATHRND(0.5432, 5);  EXPECTCY(0.5432);
3919   MATHRND(0.5432, 4);  EXPECTCY(0.5432);
3920   MATHRND(0.5432, 3);  EXPECTCY(0.543);
3921   MATHRND(0.5432, 2);  EXPECTCY(0.54);
3922   MATHRND(0.5432, 1);  EXPECTCY(0.5);
3923   MATHRND(0.5532, 0);  EXPECTCY(1);
3924   MATHRND(0.5532, -1); EXPECT_INVALID;
3925
3926   MATHRND(0.5568, 5);  EXPECTCY(0.5568);
3927   MATHRND(0.5568, 4);  EXPECTCY(0.5568);
3928   MATHRND(0.5568, 3);  EXPECTCY(0.557);
3929   MATHRND(0.5568, 2);  EXPECTCY(0.56);
3930   MATHRND(0.5568, 1);  EXPECTCY(0.6);
3931   MATHRND(0.5568, 0);  EXPECTCY(1);
3932   MATHRND(0.5568, -1); EXPECT_INVALID;
3933
3934   MATHRND(0.4999, 0); EXPECTCY(0);
3935   MATHRND(0.5000, 0); EXPECTCY(0);
3936   MATHRND(0.5001, 0); EXPECTCY(1);
3937   MATHRND(1.4999, 0); EXPECTCY(1);
3938   MATHRND(1.5000, 0); EXPECTCY(2);
3939   MATHRND(1.5001, 0); EXPECTCY(2);
3940 }
3941
3942 #define MATHFIX(l) left = l; pVarCyFromR8(left, &cyLeft); \
3943   hres = pVarCyFix(cyLeft, &out)
3944
3945 static void test_VarCyFix(void)
3946 {
3947   MATHVARS1;
3948
3949   CHECKPTR(VarCyFix);
3950   MATHFIX(-1.0001); EXPECTCY(-1);
3951   MATHFIX(-1.4999); EXPECTCY(-1);
3952   MATHFIX(-1.5001); EXPECTCY(-1);
3953   MATHFIX(-1.9999); EXPECTCY(-1);
3954   MATHFIX(-0.0001); EXPECTCY(0);
3955   MATHFIX(-0.4999); EXPECTCY(0);
3956   MATHFIX(-0.5001); EXPECTCY(0);
3957   MATHFIX(-0.9999); EXPECTCY(0);
3958   MATHFIX(0.0001);  EXPECTCY(0);
3959   MATHFIX(0.4999);  EXPECTCY(0);
3960   MATHFIX(0.5001);  EXPECTCY(0);
3961   MATHFIX(0.9999);  EXPECTCY(0);
3962   MATHFIX(1.0001);  EXPECTCY(1);
3963   MATHFIX(1.4999);  EXPECTCY(1);
3964   MATHFIX(1.5001);  EXPECTCY(1);
3965   MATHFIX(1.9999);  EXPECTCY(1);
3966 }
3967
3968 #define MATHINT(l) left = l; pVarCyFromR8(left, &cyLeft); \
3969   hres = pVarCyInt(cyLeft, &out)
3970
3971 static void test_VarCyInt(void)
3972 {
3973   MATHVARS1;
3974
3975   CHECKPTR(VarCyInt);
3976   MATHINT(-1.0001); EXPECTCY(-2);
3977   MATHINT(-1.4999); EXPECTCY(-2);
3978   MATHINT(-1.5001); EXPECTCY(-2);
3979   MATHINT(-1.9999); EXPECTCY(-2);
3980   MATHINT(-0.0001); EXPECTCY(-1);
3981   MATHINT(-0.4999); EXPECTCY(-1);
3982   MATHINT(-0.5001); EXPECTCY(-1);
3983   MATHINT(-0.9999); EXPECTCY(-1);
3984   MATHINT(0.0001);  EXPECTCY(0);
3985   MATHINT(0.4999);  EXPECTCY(0);
3986   MATHINT(0.5001);  EXPECTCY(0);
3987   MATHINT(0.9999);  EXPECTCY(0);
3988   MATHINT(1.0001);  EXPECTCY(1);
3989   MATHINT(1.4999);  EXPECTCY(1);
3990   MATHINT(1.5001);  EXPECTCY(1);
3991   MATHINT(1.9999);  EXPECTCY(1);
3992 }
3993
3994 /*
3995  * VT_DECIMAL
3996  */
3997
3998 #undef CONV_TYPE
3999 #define CONV_TYPE DECIMAL
4000 #undef EXPECTRES
4001 #define EXPECTRES(res, x) \
4002   ok(hres == S_OK || ((HRESULT)res != S_OK && hres == (HRESULT)res), \
4003      "expected hres " #x ", got hres=0x%08lx\n", hres)
4004
4005 #define EXPECTDEC(scl, sgn, hi, lo) ok(hres == S_OK && \
4006   S(U(out)).scale == (BYTE)(scl) && S(U(out)).sign == (BYTE)(sgn) && \
4007   out.Hi32 == (ULONG)(hi) && U1(out).Lo64 == (ULONG64)(lo), \
4008   "expected (%d,%d,%d,(%lx %lx)), got (%d,%d,%ld,(%lx %lx)) hres 0x%08lx\n", \
4009   scl, sgn, hi, (LONG)((LONG64)(lo) >> 32), (LONG)((lo) & 0xffffffff), S(U(out)).scale, \
4010   S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)
4011
4012 #define EXPECTDEC64(scl, sgn, hi, mid, lo) ok(hres == S_OK && \
4013   S(U(out)).scale == (BYTE)(scl) && S(U(out)).sign == (BYTE)(sgn) && \
4014   out.Hi32 == (ULONG)(hi) && S1(U1(out)).Mid32 == (ULONG)(mid) && \
4015   S1(U1(out)).Lo32 == (ULONG)(lo), \
4016   "expected (%d,%d,%d,(%lx %lx)), got (%d,%d,%ld,(%lx %lx)) hres 0x%08lx\n", \
4017   scl, sgn, hi, (LONG)(mid), (LONG)(lo), S(U(out)).scale, \
4018   S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)
4019
4020 #define EXPECTDECI if (i < 0) EXPECTDEC(0, 0x80, 0, -i); else EXPECTDEC(0, 0, 0, i)
4021
4022 static void test_VarDecFromI1(void)
4023 {
4024   CONVVARS(signed char);
4025   int i;
4026
4027   CHECKPTR(VarDecFromI1);
4028   for (i = -128; i < 128; i++)
4029   {
4030     CONVERT(VarDecFromI1,i); EXPECTDECI;
4031   }
4032 }
4033
4034 static void test_VarDecFromI2(void)
4035 {
4036   CONVVARS(SHORT);
4037   int i;
4038
4039   CHECKPTR(VarDecFromI2);
4040   for (i = -32768; i < 32768; i++)
4041   {
4042     CONVERT(VarDecFromI2,i); EXPECTDECI;
4043   }
4044 }
4045
4046 static void test_VarDecFromI4(void)
4047 {
4048   CONVVARS(LONG);
4049   int i;
4050
4051   CHECKPTR(VarDecFromI4);
4052   for (i = -32768; i < 32768; i++)
4053   {
4054     CONVERT(VarDecFromI4,i); EXPECTDECI;
4055   }
4056 }
4057
4058 static void test_VarDecFromI8(void)
4059 {
4060   CONVVARS(LONG64);
4061   int i;
4062
4063   CHECKPTR(VarDecFromI8);
4064   for (i = -32768; i < 32768; i++)
4065   {
4066     CONVERT(VarDecFromI8,i); EXPECTDECI;
4067   }
4068 }
4069
4070 static void test_VarDecFromUI1(void)
4071 {
4072   CONVVARS(BYTE);
4073   int i;
4074
4075   CHECKPTR(VarDecFromUI1);
4076   for (i = 0; i < 256; i++)
4077   {
4078     CONVERT(VarDecFromUI1,i); EXPECTDECI;
4079   }
4080 }
4081
4082 static void test_VarDecFromUI2(void)
4083 {
4084   CONVVARS(USHORT);
4085   int i;
4086
4087   CHECKPTR(VarDecFromUI2);
4088   for (i = 0; i < 65536; i++)
4089   {
4090     CONVERT(VarDecFromUI2,i); EXPECTDECI;
4091   }
4092 }
4093
4094 static void test_VarDecFromUI4(void)
4095 {
4096   CONVVARS(ULONG);
4097   int i;
4098
4099   CHECKPTR(VarDecFromUI4);
4100   for (i = 0; i < 65536; i++)
4101   {
4102     CONVERT(VarDecFromUI4,i); EXPECTDECI;
4103   }
4104 }
4105
4106 static void test_VarDecFromUI8(void)
4107 {
4108   CONVVARS(ULONG64);
4109   int i;
4110
4111   CHECKPTR(VarDecFromUI8);
4112   for (i = 0; i < 65536; i++)
4113   {
4114     CONVERT(VarDecFromUI8,i); EXPECTDECI;
4115   }
4116 }
4117
4118 static void test_VarDecFromBool(void)
4119 {
4120   CONVVARS(SHORT);
4121   int i;
4122
4123   CHECKPTR(VarDecFromBool);
4124   /* Test all possible type values. Note that the result is reduced to 0 or -1 */
4125   for (i = -32768; i < 0; i++)
4126   {
4127     CONVERT(VarDecFromBool,i);
4128     if (i)
4129       EXPECTDEC(0,0x80,0,1);
4130     else
4131       EXPECTDEC(0,0,0,0);
4132   }
4133 }
4134
4135 static void test_VarDecFromR4(void)
4136 {
4137   CONVVARS(float);
4138
4139   CHECKPTR(VarDecFromR4);
4140
4141   CONVERT(VarDecFromR4,-0.6f); EXPECTDEC(1,0x80,0,6);
4142   CONVERT(VarDecFromR4,-0.5f); EXPECTDEC(1,0x80,0,5);
4143   CONVERT(VarDecFromR4,-0.4f); EXPECTDEC(1,0x80,0,4);
4144   CONVERT(VarDecFromR4,0.0f);  EXPECTDEC(0,0,0,0);
4145   CONVERT(VarDecFromR4,0.4f);  EXPECTDEC(1,0,0,4);
4146   CONVERT(VarDecFromR4,0.5f);  EXPECTDEC(1,0,0,5);
4147   CONVERT(VarDecFromR4,0.6f);  EXPECTDEC(1,0,0,6);
4148 }
4149
4150 static void test_VarDecFromR8(void)
4151 {
4152   CONVVARS(double);
4153
4154   CHECKPTR(VarDecFromR8);
4155
4156   CONVERT(VarDecFromR8,-0.6); EXPECTDEC(1,0x80,0,6);
4157   CONVERT(VarDecFromR8,-0.5); EXPECTDEC(1,0x80,0,5);
4158   CONVERT(VarDecFromR8,-0.4); EXPECTDEC(1,0x80,0,4);
4159   CONVERT(VarDecFromR8,0.0);  EXPECTDEC(0,0,0,0);
4160   CONVERT(VarDecFromR8,0.4);  EXPECTDEC(1,0,0,4);
4161   CONVERT(VarDecFromR8,0.5);  EXPECTDEC(1,0,0,5);
4162   CONVERT(VarDecFromR8,0.6);  EXPECTDEC(1,0,0,6);
4163 }
4164
4165 static void test_VarDecFromDate(void)
4166 {
4167   CONVVARS(DATE);
4168
4169   CHECKPTR(VarDecFromDate);
4170
4171   CONVERT(VarDecFromDate,-0.6); EXPECTDEC(1,0x80,0,6);
4172   CONVERT(VarDecFromDate,-0.5); EXPECTDEC(1,0x80,0,5);
4173   CONVERT(VarDecFromDate,-0.4); EXPECTDEC(1,0x80,0,4);
4174   CONVERT(VarDecFromDate,0.0);  EXPECTDEC(0,0,0,0);
4175   CONVERT(VarDecFromDate,0.4);  EXPECTDEC(1,0,0,4);
4176   CONVERT(VarDecFromDate,0.5);  EXPECTDEC(1,0,0,5);
4177   CONVERT(VarDecFromDate,0.6);  EXPECTDEC(1,0,0,6);
4178 }
4179
4180 static void test_VarDecFromStr(void)
4181 {
4182   CONVVARS(LCID);
4183   OLECHAR buff[128];
4184
4185   CHECKPTR(VarDecFromStr);
4186
4187   in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4188
4189   CONVERT_STR(VarDecFromStr,NULL,0);                       EXPECT_MISMATCH;
4190   CONVERT_STR(VarDecFromStr,"-1",  LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0x80,0,1);
4191   CONVERT_STR(VarDecFromStr,"0",   LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,0,0);
4192   CONVERT_STR(VarDecFromStr,"1",   LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,0,1);
4193   CONVERT_STR(VarDecFromStr,"0.5", LOCALE_NOUSEROVERRIDE); EXPECTDEC(1,0,0,5);
4194   CONVERT_STR(VarDecFromStr,"4294967296", LOCALE_NOUSEROVERRIDE); EXPECTDEC64(0,0,0,1,0);
4195   CONVERT_STR(VarDecFromStr,"18446744073709551616", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,1,0);
4196   CONVERT_STR(VarDecFromStr,"4294967296.0", LOCALE_NOUSEROVERRIDE); EXPECTDEC64(0,0,0,1,0);
4197   CONVERT_STR(VarDecFromStr,"18446744073709551616.0", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,1,0);
4198 }
4199
4200 static void test_VarDecFromCy(void)
4201 {
4202   CONVVARS(CY);
4203
4204   CHECKPTR(VarDecFromCy);
4205
4206   CONVERT_CY(VarDecFromCy, -1);  EXPECTDEC(4,0x80,0,10000);
4207   CONVERT_CY(VarDecFromCy, 0);   EXPECTDEC(4,0,0,0);
4208   CONVERT_CY(VarDecFromCy, 1);   EXPECTDEC(4,0,0,10000);
4209   CONVERT_CY(VarDecFromCy, 0.5); EXPECTDEC(4,0,0,5000);
4210 }
4211
4212 #undef MATHVARS1
4213 #define MATHVARS1 HRESULT hres; DECIMAL l, out
4214 #undef MATHVARS2
4215 #define MATHVARS2 MATHVARS1; DECIMAL r
4216 #undef MATH1
4217 #define MATH1(func) hres = p##func(&l, &out)
4218 #undef MATH2
4219 #define MATH2(func) hres = p##func(&l, &r, &out)
4220
4221 static void test_VarDecAbs(void)
4222 {
4223   MATHVARS1;
4224
4225   CHECKPTR(VarDecAbs);
4226   SETDEC(l,0,0x80,0,1);  MATH1(VarDecAbs); EXPECTDEC(0,0,0,1);
4227   SETDEC(l,0,0,0,0);     MATH1(VarDecAbs); EXPECTDEC(0,0,0,0);
4228   SETDEC(l,0,0x80,0,0);  MATH1(VarDecAbs); EXPECTDEC(0,0,0,0);
4229   SETDEC(l,0,0,0,1);     MATH1(VarDecAbs); EXPECTDEC(0,0,0,1);
4230
4231   /* Doesn't check for invalid input */
4232   SETDEC(l,0,0x7f,0,1);  MATH1(VarDecAbs); EXPECTDEC(0,0x7f,0,1);
4233   SETDEC(l,0,0x80,29,1); MATH1(VarDecAbs); EXPECTDEC(0,0,29,1);
4234 }
4235
4236 static void test_VarDecNeg(void)
4237 {
4238   MATHVARS1;
4239
4240   CHECKPTR(VarDecNeg);
4241   SETDEC(l,0,0x80,0,1); MATH1(VarDecNeg); EXPECTDEC(0,0,0,1);
4242   SETDEC(l,0,0,0,0);    MATH1(VarDecNeg); EXPECTDEC(0,0x80,0,0); /* '-0'! */
4243   SETDEC(l,0,0x80,0,0); MATH1(VarDecNeg); EXPECTDEC(0,0,0,0);
4244   SETDEC(l,0,0,0,1);    MATH1(VarDecNeg); EXPECTDEC(0,0x80,0,1);
4245
4246   /* Doesn't check for invalid input */
4247   SETDEC(l,0,0x7f,0,1);  MATH1(VarDecNeg); EXPECTDEC(0,0xff,0,1);
4248   SETDEC(l,0,0x80,29,1); MATH1(VarDecNeg); EXPECTDEC(0,0,29,1);
4249   SETDEC(l,0,0,29,1);    MATH1(VarDecNeg); EXPECTDEC(0,0x80,29,1);
4250 }
4251
4252 static void test_VarDecAdd(void)
4253 {
4254   MATHVARS2;
4255
4256   CHECKPTR(VarDecAdd);
4257   SETDEC(l,0,0,0,0);    SETDEC(r,0,0,0,0);    MATH2(VarDecAdd); EXPECTDEC(0,0,0,0);
4258   SETDEC(l,0,0,0,0);    SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
4259   SETDEC(l,0,0,0,0);    SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
4260
4261   SETDEC(l,0,0,0,1);    SETDEC(r,0,0,0,0);    MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
4262   SETDEC(l,0,0,0,1);    SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC(0,0,0,2);
4263   SETDEC(l,0,0,0,1);    SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,0); /* '-0'! */
4264   SETDEC(l,0,0,0,1);    SETDEC(r,0,0x80,0,2); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
4265
4266   SETDEC(l,0,0x80,0,0); SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
4267   SETDEC(l,0,0x80,0,1); SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC(0,0,0,0);
4268   SETDEC(l,0,0x80,0,1); SETDEC(r,0,0,0,2);    MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
4269   SETDEC(l,0,0x80,0,1); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,2);
4270   SETDEC(l,0,0x80,0,2); SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
4271
4272   SETDEC(l,0,0,0,0xffffffff); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,0xfffffffe);
4273   SETDEC(l,0,0,0,0xffffffff); SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC(0,0,0,(ULONG64)1 << 32);
4274   SETDEC(l,0,0,0,0xffffffff); SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC(0,0,0,(ULONG64)1 << 32);
4275
4276   SETDEC64(l,0,0,0,0xffffffff,0); SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC64(0,0,0,0xffffffff,1);
4277   SETDEC64(l,0,0,0,0xffffffff,0); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
4278   EXPECTDEC64(0,0,0,0xfffffffe,0xffffffff);
4279
4280   SETDEC64(l,0,0,0,0xffffffff,0xffffffff); SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC(0,0,1,0);
4281   SETDEC64(l,0,0,0,0xffffffff,0xffffffff); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
4282   EXPECTDEC64(0,0,0,0xffffffff,0xfffffffe);
4283
4284   SETDEC(l,0,0,0xffffffff,0); SETDEC(r,0,0,0,1);    MATH2(VarDecAdd); EXPECTDEC(0,0,0xffffffff,1);
4285   SETDEC(l,0,0,0xffffffff,0); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
4286   EXPECTDEC64(0,0,0xfffffffe,0xffffffff,0xffffffff);
4287
4288   SETDEC64(l,0,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
4289   EXPECTDEC64(0,0,0xffffffff,0xffffffff,0xfffffffe);
4290   SETDEC64(l,0,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r,0,0,0,1); MATH2(VarDecAdd);
4291   ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%ld,(%8lx,%8lx)x) hres 0x%08lx\n",
4292      S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4293
4294   /* Promotes to the highest scale, so here the results are in the scale of 2 */
4295   SETDEC(l,2,0,0,0);   SETDEC(r,0,0,0,0); MATH2(VarDecAdd); EXPECTDEC(2,0,0,0);
4296   SETDEC(l,2,0,0,100); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(2,0,0,200);
4297 }
4298
4299 static void test_VarDecSub(void)
4300 {
4301   MATHVARS2;
4302
4303   CHECKPTR(VarDecSub);
4304   SETDEC(l,0,0,0,0);    SETDEC(r,0,0,0,0);    MATH2(VarDecSub); EXPECTDEC(0,0x80,0,0);
4305   SETDEC(l,0,0,0,0);    SETDEC(r,0,0,0,1);    MATH2(VarDecSub); EXPECTDEC(0,0x80,0,1);
4306   SETDEC(l,0,0,0,1);    SETDEC(r,0,0,0,1);    MATH2(VarDecSub); EXPECTDEC(0,0x80,0,0);
4307   SETDEC(l,0,0,0,1);    SETDEC(r,0,0x80,0,1); MATH2(VarDecSub); EXPECTDEC(0,0,0,2);
4308 }
4309
4310 static void test_VarDecMul(void)
4311 {
4312   MATHVARS2;
4313
4314   CHECKPTR(VarDecMul);
4315   SETDEC(l,0,0,0,0);    SETDEC(r,0,0,0,0);  MATH2(VarDecMul);   EXPECTDEC(0,0,0,0);
4316   SETDEC(l,0,0,0,1);    SETDEC(r,0,0,0,0);  MATH2(VarDecMul);   EXPECTDEC(0,0,0,0);
4317   SETDEC(l,0,0,0,0);    SETDEC(r,0,0,0,1);  MATH2(VarDecMul);   EXPECTDEC(0,0,0,0);
4318   SETDEC(l,0,0,0,1);    SETDEC(r,0,0,0,1);  MATH2(VarDecMul);   EXPECTDEC(0,0,0,1);
4319   SETDEC(l,0,0,0,45000);SETDEC(r,0,0,0,2);  MATH2(VarDecMul);   EXPECTDEC(0,0,0,90000);
4320   SETDEC(l,0,0,0,2);    SETDEC(r,0,0,0,45000);  MATH2(VarDecMul);   EXPECTDEC(0,0,0,90000);
4321
4322   SETDEC(l,0,0x80,0,2); SETDEC(r,0,0,0,2);  MATH2(VarDecMul);   EXPECTDEC(0,0x80,0,4);
4323   SETDEC(l,0,0,0,2);    SETDEC(r,0,0x80,0,2);  MATH2(VarDecMul);   EXPECTDEC(0,0x80,0,4);
4324   SETDEC(l,0,0x80,0,2); SETDEC(r,0,0x80,0,2);  MATH2(VarDecMul);   EXPECTDEC(0,0,0,4);
4325
4326   SETDEC(l,4,0,0,2);    SETDEC(r,0,0,0,2);  MATH2(VarDecMul);   EXPECTDEC(4,0,0,4);
4327   SETDEC(l,0,0,0,2);    SETDEC(r,3,0,0,2);  MATH2(VarDecMul);   EXPECTDEC(3,0,0,4);
4328   SETDEC(l,4,0,0,2);    SETDEC(r,3,0,0,2);  MATH2(VarDecMul);   EXPECTDEC(7,0,0,4);
4329   /* this last one shows that native oleaut32 does *not* gratuitously seize opportunities
4330      to reduce the scale if possible - the canonical result for the expected value is (6,0,0,1)
4331    */
4332   SETDEC(l,4,0,0,5);    SETDEC(r,3,0,0,2);  MATH2(VarDecMul);   EXPECTDEC(7,0,0,10);
4333
4334   SETDEC64(l,0,0,0,0xFFFFFFFF,0xFFFFFFFF);    SETDEC(r,0,0,0,2);  MATH2(VarDecMul);   EXPECTDEC64(0,0,1,0xFFFFFFFF,0xFFFFFFFE);
4335   SETDEC(l,0,0,0,2);    SETDEC64(r,0,0,0,0xFFFFFFFF,0xFFFFFFFF);  MATH2(VarDecMul);   EXPECTDEC64(0,0,1,0xFFFFFFFF,0xFFFFFFFE);
4336   SETDEC(l,0,0,1,1);    SETDEC(r,0,0,0,0x80000000);  MATH2(VarDecMul);   EXPECTDEC(0,0,0x80000000,0x80000000);
4337   SETDEC(l,0,0,0,0x80000000);    SETDEC(r,0,0,1,1);  MATH2(VarDecMul);   EXPECTDEC(0,0,0x80000000,0x80000000);
4338
4339   /* near-overflow, used as a reference */
4340   SETDEC64(l,0,0,0,0xFFFFFFFF,0xFFFFFFFF);    SETDEC(r,0,0,0,2000000000);  MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4341   /* actual overflow - right operand is 10 times the previous value */
4342   SETDEC64(l,0,0,0,0xFFFFFFFF,0xFFFFFFFF);    SETDEC64(r,0,0,0,4,0xA817C800);  MATH2(VarDecMul);
4343   ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%ld,(%8lx,%8lx)x) hres 0x%08lx\n",
4344      S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4345   /* here, native oleaut32 has an opportunity to avert the overflow, by reducing the scale of the result  */
4346   SETDEC64(l,1,0,0,0xFFFFFFFF,0xFFFFFFFF);    SETDEC64(r,0,0,0,4,0xA817C800);  MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4347
4348   /* near-overflow, used as a reference */
4349   SETDEC64(l,0,0,1,0xFFFFFFFF,0xFFFFFFFE);    SETDEC(r,0,0,0,1000000000);  MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4350   /* actual overflow - right operand is 10 times the previous value */
4351   SETDEC64(l,0,0,1,0xFFFFFFFF,0xFFFFFFFE);    SETDEC64(r,0,0,0,2,0x540BE400);  MATH2(VarDecMul);
4352   ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%ld,(%8lx,%8lx)x) hres 0x%08lx\n",
4353      S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4354   /* here, native oleaut32 has an opportunity to avert the overflow, by reducing the scale of the result  */
4355   SETDEC64(l,1,0,1,0xFFFFFFFF,0xFFFFFFFE);    SETDEC64(r,0,0,0,2,0x540BE400);  MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4356
4357   /* this one shows that native oleaut32 is willing to lose significant digits in order to avert an overflow */
4358   SETDEC64(l,2,0,0,0xFFFFFFFF,0xFFFFFFFF);    SETDEC64(r,0,0,0,9,0x502F9001);  MATH2(VarDecMul);EXPECTDEC64(1,0,0xee6b2800,0x19999998,0xab2e719a);
4359 }
4360
4361 static void test_VarDecDiv(void)
4362 {
4363   MATHVARS2;
4364
4365   CHECKPTR(VarDecDiv);
4366   /* identity divisions */
4367   SETDEC(l,0,0,0,0);    SETDEC(r,0,0,0,1);  MATH2(VarDecDiv);   EXPECTDEC(0,0,0,0);
4368   SETDEC(l,0,0,0,1);    SETDEC(r,0,0,0,1);  MATH2(VarDecDiv);   EXPECTDEC(0,0,0,1);
4369   SETDEC(l,1,0,0,1);    SETDEC(r,0,0,0,1);  MATH2(VarDecDiv);   EXPECTDEC(1,0,0,1);
4370
4371   /* exact divisions */
4372   SETDEC(l,0,0,0,45);    SETDEC(r,0,0,0,9);  MATH2(VarDecDiv);   EXPECTDEC(0,0,0,5);
4373   SETDEC(l,1,0,0,45);    SETDEC(r,0,0,0,9);  MATH2(VarDecDiv);   EXPECTDEC(1,0,0,5);
4374   SETDEC(l,0,0,0,45);    SETDEC(r,1,0,0,9);  MATH2(VarDecDiv);   EXPECTDEC(0,0,0,50);
4375   SETDEC(l,1,0,0,45);    SETDEC(r,2,0,0,9);  MATH2(VarDecDiv);   EXPECTDEC(0,0,0,50);
4376   /* these last three results suggest that native oleaut32 scales both operands down to zero
4377      before the division, but does *not* try to scale the result, even if it is possible -
4378      analogous to multiplication behavior
4379    */
4380   SETDEC(l,1,0,0,45);    SETDEC(r,1,0,0,9);  MATH2(VarDecDiv);   EXPECTDEC(0,0,0,5);
4381   SETDEC(l,2,0,0,450);    SETDEC(r,1,0,0,9);  MATH2(VarDecDiv);   EXPECTDEC(1,0,0,50);
4382
4383   /* inexact divisions */
4384   SETDEC(l,0,0,0,1);    SETDEC(r,0,0,0,3);  MATH2(VarDecDiv);   EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4385   SETDEC(l,1,0,0,1);    SETDEC(r,0,0,0,3);  MATH2(VarDecDiv);   EXPECTDEC64(28,0,18070036,0x35458014,0x4d555555);
4386   SETDEC(l,0,0,0,1);    SETDEC(r,1,0,0,3);  MATH2(VarDecDiv);   EXPECTDEC64(28,0,1807003620,0xcf2607ee,0x35555555);
4387   SETDEC(l,1,0,0,1);    SETDEC(r,2,0,0,3);  MATH2(VarDecDiv);   EXPECTDEC64(28,0,1807003620,0xcf2607ee,0x35555555);
4388   SETDEC(l,1,0,0,1);    SETDEC(r,1,0,0,3);  MATH2(VarDecDiv);   EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4389   SETDEC(l,2,0,0,10);    SETDEC(r,1,0,0,3);  MATH2(VarDecDiv);  EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4390
4391   /* this one shows that native oleaut32 rounds up the result */
4392   SETDEC(l,0,0,0,2);    SETDEC(r,0,0,0,3);  MATH2(VarDecDiv);   EXPECTDEC64(28,0,361400724,0x296e0196,0x0aaaaaab);
4393
4394   /* sign tests */
4395   SETDEC(l,0,0x80,0,45);    SETDEC(r,0,0,0,9);  MATH2(VarDecDiv);   EXPECTDEC(0,0x80,0,5);
4396   SETDEC(l,0,0,0,45);       SETDEC(r,0,0x80,0,9);  MATH2(VarDecDiv);EXPECTDEC(0,0x80,0,5);
4397   SETDEC(l,0,0x80,0,45);    SETDEC(r,0,0x80,0,9);  MATH2(VarDecDiv);EXPECTDEC(0,0,0,5);
4398
4399   /* oddballs */
4400   SETDEC(l,0,0,0,0);    SETDEC(r,0,0,0,0);  MATH2(VarDecDiv);/* indeterminate */
4401   ok(hres == DISP_E_DIVBYZERO,"Expected division-by-zero, got (%d,%d,%ld,(%8lx,%8lx)x) hres 0x%08lx\n",
4402      S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4403   SETDEC(l,0,0,0,1);    SETDEC(r,0,0,0,0);  MATH2(VarDecDiv);/* division by zero */
4404   ok(hres == DISP_E_DIVBYZERO,"Expected division-by-zero, got (%d,%d,%ld,(%8lx,%8lx)x) hres 0x%08lx\n",
4405      S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4406
4407 }
4408
4409 static void test_VarDecCmp(void)
4410 {
4411   MATHVARS1;
4412
4413   CHECKPTR(VarDecCmp);
4414   SETDEC(l,0,0,0,1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_EQ;
4415   SETDEC(l,0,0,0,1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
4416   SETDEC(l,0,0,0,0); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4417 }
4418
4419 /*
4420  * VT_BOOL
4421  */
4422
4423 #undef CONV_TYPE
4424 #define CONV_TYPE VARIANT_BOOL
4425 #undef _EXPECTRES
4426 #define _EXPECTRES(res, x, fs) \
4427   ok((hres == S_OK && out == (CONV_TYPE)(x)) || ((HRESULT)res != S_OK && hres == (HRESULT)res), \
4428      "expected " #x ", got " fs "; hres=0x%08lx\n", out, hres)
4429 #undef EXPECTRES
4430 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%d")
4431 #undef CONVERTRANGE
4432 #define CONVERTRANGE(func,start,end) for (i = start; i < end; i++) { \
4433   CONVERT(func, i); if (i) { EXPECT(VARIANT_TRUE); } else { EXPECT(VARIANT_FALSE); } }
4434
4435 static void test_VarBoolFromI1(void)
4436 {
4437   CONVVARS(signed char);
4438   int i;
4439
4440   CHECKPTR(VarBoolFromI1);
4441   CONVERTRANGE(VarBoolFromI1, -128, 128);
4442 }
4443
4444 static void test_VarBoolFromUI1(void)
4445 {
4446   CONVVARS(BYTE);
4447   int i;
4448
4449   CHECKPTR(VarBoolFromUI1);
4450   CONVERTRANGE(VarBoolFromUI1, 0, 256);
4451 }
4452
4453 static void test_VarBoolFromI2(void)
4454 {
4455   CONVVARS(SHORT);
4456   int i;
4457
4458   CHECKPTR(VarBoolFromI2);
4459   CONVERTRANGE(VarBoolFromI2, -32768, 32768);
4460 }
4461
4462 static void test_VarBoolFromUI2(void)
4463 {
4464   CONVVARS(USHORT);
4465   int i;
4466
4467   CHECKPTR(VarBoolFromUI2);
4468   CONVERTRANGE(VarBoolFromUI2, 0, 65536);
4469 }
4470
4471 static void test_VarBoolFromI4(void)
4472 {
4473   CONVVARS(int);
4474
4475   CHECKPTR(VarBoolFromI4);
4476   CONVERT(VarBoolFromI4, 0x80000000); EXPECT(VARIANT_TRUE);
4477   CONVERT(VarBoolFromI4, -1);         EXPECT(VARIANT_TRUE);
4478   CONVERT(VarBoolFromI4, 0);          EXPECT(VARIANT_FALSE);
4479   CONVERT(VarBoolFromI4, 1);          EXPECT(VARIANT_TRUE);
4480   CONVERT(VarBoolFromI4, 0x7fffffff); EXPECT(VARIANT_TRUE);
4481 }
4482
4483 static void test_VarBoolFromUI4(void)
4484 {
4485   CONVVARS(ULONG);
4486
4487   CHECKPTR(VarBoolFromUI4);
4488   CONVERT(VarBoolFromI4, 0);          EXPECT(VARIANT_FALSE);
4489   CONVERT(VarBoolFromI4, 1);          EXPECT(VARIANT_TRUE);
4490   CONVERT(VarBoolFromI4, 0x80000000); EXPECT(VARIANT_TRUE);
4491 }
4492
4493 static void test_VarBoolFromR4(void)
4494 {
4495   CONVVARS(FLOAT);
4496
4497   CHECKPTR(VarBoolFromR4);
4498   CONVERT(VarBoolFromR4, -1.0f); EXPECT(VARIANT_TRUE);
4499   CONVERT(VarBoolFromR4, 0.0f);  EXPECT(VARIANT_FALSE);
4500   CONVERT(VarBoolFromR4, 1.0f);  EXPECT(VARIANT_TRUE);
4501   CONVERT(VarBoolFromR4, 1.5f);  EXPECT(VARIANT_TRUE);
4502
4503   /* Rounding */
4504   CONVERT(VarBoolFromR4, -1.5f); EXPECT(VARIANT_TRUE);
4505   CONVERT(VarBoolFromR4, -0.6f); EXPECT(VARIANT_TRUE);
4506   CONVERT(VarBoolFromR4, -0.5f); EXPECT(VARIANT_TRUE);
4507   CONVERT(VarBoolFromR4, -0.4f); EXPECT(VARIANT_TRUE);
4508   CONVERT(VarBoolFromR4, 0.4f);  EXPECT(VARIANT_TRUE);
4509   CONVERT(VarBoolFromR4, 0.5f);  EXPECT(VARIANT_TRUE);
4510   CONVERT(VarBoolFromR4, 0.6f);  EXPECT(VARIANT_TRUE);
4511   CONVERT(VarBoolFromR4, 1.5f);  EXPECT(VARIANT_TRUE);
4512 }
4513
4514 static void test_VarBoolFromR8(void)
4515 {
4516   CONVVARS(DOUBLE);
4517
4518   /* Hopefully we made the point with R4 above that rounding is
4519    * irrelevant, so we'll skip that for R8 and Date
4520    */
4521   CHECKPTR(VarBoolFromR8);
4522   CONVERT(VarBoolFromR8, -1.0); EXPECT(VARIANT_TRUE);
4523   CONVERT(VarBoolFromR8, -0.0); EXPECT(VARIANT_FALSE);
4524   CONVERT(VarBoolFromR8, 1.0);  EXPECT(VARIANT_TRUE);
4525 }
4526
4527 static void test_VarBoolFromCy(void)
4528 {
4529   CONVVARS(CY);
4530
4531   CHECKPTR(VarBoolFromCy);
4532   CONVERT_CY(VarBoolFromCy, -32769); EXPECT(VARIANT_TRUE);
4533   CONVERT_CY(VarBoolFromCy, -32768); EXPECT(VARIANT_TRUE);
4534   CONVERT_CY(VarBoolFromCy, -1);     EXPECT(VARIANT_TRUE);
4535   CONVERT_CY(VarBoolFromCy, 0);      EXPECT(VARIANT_FALSE);
4536   CONVERT_CY(VarBoolFromCy, 1);      EXPECT(VARIANT_TRUE);
4537   CONVERT_CY(VarBoolFromCy, 32767);  EXPECT(VARIANT_TRUE);
4538   CONVERT_CY(VarBoolFromCy, 32768);  EXPECT(VARIANT_TRUE);
4539 }
4540
4541 static void test_VarBoolFromI8(void)
4542 {
4543   CONVVARS(LONG64);
4544
4545   CHECKPTR(VarBoolFromI8);
4546   CONVERT(VarBoolFromI8, -1); EXPECT(VARIANT_TRUE);
4547   CONVERT(VarBoolFromI8, 0);  EXPECT(VARIANT_FALSE);
4548   CONVERT(VarBoolFromI8, 1);  EXPECT(VARIANT_TRUE);
4549 }
4550
4551 static void test_VarBoolFromUI8(void)
4552 {
4553   CONVVARS(ULONG64);
4554
4555   CHECKPTR(VarBoolFromUI8);
4556   CONVERT(VarBoolFromUI8, 0); EXPECT(VARIANT_FALSE);
4557   CONVERT(VarBoolFromUI8, 1); EXPECT(VARIANT_TRUE);
4558 }
4559
4560 static void test_VarBoolFromDec(void)
4561 {
4562   CONVVARS(DECIMAL);
4563
4564   CHECKPTR(VarBoolFromDec);
4565   CONVERT_BADDEC(VarBoolFromDec);
4566
4567   if (HAVE_OLEAUT32_DECIMAL)
4568   {
4569     /* Early versions of oleaut32 don't catch these errors */
4570     CONVERT_DEC(VarBoolFromDec,29,0,0,0);   EXPECT_INVALID;
4571     CONVERT_DEC(VarBoolFromDec,0,0x1,0,0);  EXPECT_INVALID;
4572     CONVERT_DEC(VarBoolFromDec,0,0x40,0,0); EXPECT_INVALID;
4573     CONVERT_DEC(VarBoolFromDec,0,0x7f,0,0); EXPECT_INVALID;
4574   }
4575
4576   CONVERT_DEC(VarBoolFromDec,0,0x80,0,1); EXPECT(VARIANT_TRUE);
4577   CONVERT_DEC(VarBoolFromDec,0,0,0,0);    EXPECT(VARIANT_FALSE);
4578   CONVERT_DEC(VarBoolFromDec,0,0,0,1);    EXPECT(VARIANT_TRUE);
4579   CONVERT_DEC(VarBoolFromDec,0,0,1,0);    EXPECT(VARIANT_TRUE);
4580
4581   CONVERT_DEC(VarBoolFromDec,2,0,0,CY_MULTIPLIER);    EXPECT(VARIANT_TRUE);
4582   CONVERT_DEC(VarBoolFromDec,2,0x80,0,CY_MULTIPLIER); EXPECT(VARIANT_TRUE);
4583 }
4584
4585 static void test_VarBoolFromDate(void)
4586 {
4587   CONVVARS(DATE);
4588
4589   CHECKPTR(VarBoolFromDate);
4590   CONVERT(VarBoolFromDate, -1.0); EXPECT(VARIANT_TRUE);
4591   CONVERT(VarBoolFromDate, -0.0); EXPECT(VARIANT_FALSE);
4592   CONVERT(VarBoolFromDate, 1.0);  EXPECT(VARIANT_TRUE);
4593 }
4594
4595 static void test_VarBoolFromStr(void)
4596 {
4597   CONVVARS(LCID);
4598   OLECHAR buff[128];
4599
4600   CHECKPTR(VarBoolFromStr);
4601
4602   in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4603
4604   CONVERT_STR(VarBoolFromStr,NULL,0);
4605   if (hres != E_INVALIDARG)
4606     EXPECT_MISMATCH;
4607
4608   /* #FALSE# and #TRUE# Are always accepted */
4609   CONVERT_STR(VarBoolFromStr,"#FALSE#",0); EXPECT(VARIANT_FALSE);
4610   CONVERT_STR(VarBoolFromStr,"#TRUE#",0);  EXPECT(VARIANT_TRUE);
4611
4612   /* Match of #FALSE# and #TRUE# is case sensitive */
4613   CONVERT_STR(VarBoolFromStr,"#False#",0); EXPECT_MISMATCH;
4614   /* But match against English is not */
4615   CONVERT_STR(VarBoolFromStr,"false",0);   EXPECT(VARIANT_FALSE);
4616   CONVERT_STR(VarBoolFromStr,"False",0);   EXPECT(VARIANT_FALSE);
4617   /* On/Off and yes/no are not acceptable inputs, with any flags set */
4618   CONVERT_STR(VarBoolFromStr,"On",0xffffffff);  EXPECT_MISMATCH;
4619   CONVERT_STR(VarBoolFromStr,"Yes",0xffffffff); EXPECT_MISMATCH;
4620
4621   /* Change the LCID. This doesn't make any difference for text,unless we ask
4622    * to check local boolean text with the VARIANT_LOCALBOOL flag. */
4623   in = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
4624
4625   /* #FALSE# and #TRUE# are accepted in all locales */
4626   CONVERT_STR(VarBoolFromStr,"#FALSE#",0); EXPECT(VARIANT_FALSE);
4627   CONVERT_STR(VarBoolFromStr,"#TRUE#",0);  EXPECT(VARIANT_TRUE);
4628   CONVERT_STR(VarBoolFromStr,"#FALSE#",VARIANT_LOCALBOOL); EXPECT(VARIANT_FALSE);
4629   CONVERT_STR(VarBoolFromStr,"#TRUE#",VARIANT_LOCALBOOL);  EXPECT(VARIANT_TRUE);
4630
4631   /* English is accepted regardless of the locale */
4632   CONVERT_STR(VarBoolFromStr,"false",0); EXPECT(VARIANT_FALSE);
4633   /* And is still not case sensitive */
4634   CONVERT_STR(VarBoolFromStr,"False",0); EXPECT(VARIANT_FALSE);
4635
4636   if (HAVE_OLEAUT32_LOCALES)
4637   {
4638     /* French is rejected without VARIANT_LOCALBOOL */
4639     CONVERT_STR(VarBoolFromStr,"faux",0); EXPECT_MISMATCH;
4640     /* But accepted if this flag is given */
4641     CONVERT_STR(VarBoolFromStr,"faux",VARIANT_LOCALBOOL); EXPECT(VARIANT_FALSE);
4642     /* Regardless of case - from this we assume locale text comparisons ignore case */
4643     CONVERT_STR(VarBoolFromStr,"Faux",VARIANT_LOCALBOOL); EXPECT(VARIANT_FALSE);
4644
4645     /* Changing the locale prevents the localised text from being compared -
4646      * this demonstrates that only the indicated LCID and English are searched */
4647     in = MAKELCID(MAKELANGID(LANG_POLISH, SUBLANG_DEFAULT), SORT_DEFAULT);
4648     CONVERT_STR(VarBoolFromStr,"faux",VARIANT_LOCALBOOL); EXPECT_MISMATCH;
4649   }
4650
4651   /* Numeric strings are read as 0 or non-0 */
4652   CONVERT_STR(VarBoolFromStr,"0",0);  EXPECT(VARIANT_FALSE);
4653   CONVERT_STR(VarBoolFromStr,"-1",0); EXPECT(VARIANT_TRUE);
4654   CONVERT_STR(VarBoolFromStr,"+1",0); EXPECT(VARIANT_TRUE);
4655
4656   if (HAVE_OLEAUT32_LOCALES)
4657   {
4658     /* Numeric strings are read as floating point numbers. The line below fails
4659      * because '.' is not a valid decimal separator for Polish numbers */
4660     CONVERT_STR(VarBoolFromStr,"0.1",0); EXPECT_MISMATCH;
4661   }
4662
4663   /* Changing the lcid back to US English reads the r8 correctly */
4664   in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4665   CONVERT_STR(VarBoolFromStr,"0.1",0); EXPECT(VARIANT_TRUE);
4666 }
4667
4668 static void test_VarBoolCopy(void)
4669 {
4670   COPYTEST(1, VT_BOOL, V_BOOL(&vSrc), V_BOOL(&vDst), V_BOOLREF(&vSrc), V_BOOLREF(&vDst), "%d");
4671 }
4672
4673 #define BOOL_STR(flags, str) hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, flags, VT_BSTR); \
4674   ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && \
4675      V_BSTR(&vDst) && !memcmp(V_BSTR(&vDst), str, sizeof(str)), \
4676      "hres=0x%lX, type=%d (should be VT_BSTR), *bstr='%c'\n", \
4677      hres, V_VT(&vDst), V_BSTR(&vDst) ? *V_BSTR(&vDst) : '?')
4678
4679 static void test_VarBoolChangeTypeEx(void)
4680 {
4681   static const WCHAR szTrue[] = { 'T','r','u','e','\0' };
4682   static const WCHAR szFalse[] = { 'F','a','l','s','e','\0' };
4683   static const WCHAR szFaux[] = { 'F','a','u','x','\0' };
4684   CONVVARS(CONV_TYPE);
4685   VARIANTARG vSrc, vDst;
4686   LCID lcid;
4687
4688   in = 1;
4689
4690   INITIAL_TYPETEST(VT_BOOL, V_BOOL, "%d");
4691   COMMON_TYPETEST;
4692
4693   /* The common tests convert to a number. Try the different flags */
4694   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4695
4696   V_VT(&vSrc) = VT_BOOL;
4697   V_BOOL(&vSrc) = 1;
4698
4699   if (!IS_ANCIENT)
4700   {
4701       BOOL_STR(VARIANT_ALPHABOOL, szTrue);
4702       V_BOOL(&vSrc) = 0;
4703       BOOL_STR(VARIANT_ALPHABOOL, szFalse);
4704   }
4705
4706   if (HAVE_OLEAUT32_LOCALES)
4707   {
4708     lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
4709
4710     /* VARIANT_ALPHABOOL is always English */
4711     BOOL_STR(VARIANT_ALPHABOOL, szFalse);
4712     /* VARIANT_LOCALBOOL uses the localised text */
4713     BOOL_STR(VARIANT_LOCALBOOL, szFaux);
4714     /* Both flags together acts as VARIANT_LOCALBOOL */
4715     BOOL_STR(VARIANT_ALPHABOOL|VARIANT_LOCALBOOL, szFaux);
4716   }
4717 }
4718
4719 #undef EXPECT_LT
4720 #undef EXPECT_GT
4721 #undef EXPECT_EQ
4722 #undef EXPECT_NULL
4723 #undef EXPECTRES
4724 #define EXPECTRES(res) ok(hres == res, "expected " #res ", got hres=0x%08lx\n", hres)
4725 #define EXPECT_LT       EXPECTRES(VARCMP_LT)
4726 #define EXPECT_GT       EXPECTRES(VARCMP_GT)
4727 #define EXPECT_EQ       EXPECTRES(VARCMP_EQ)
4728 #define EXPECT_NULL     EXPECTRES(VARCMP_NULL)
4729
4730 static void test_VarCmp(void)
4731 {
4732     HRESULT hres;
4733     VARIANTARG left, right;
4734     LCID lcid;
4735     WCHAR szvalNULL[] = { '0',0 };
4736     WCHAR szval100[] = { '1','0','0',0 };
4737     WCHAR szval101[] = { '1','0','1',0 };
4738     BSTR bzvalNULL, bzval100, bzval101;
4739
4740     lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
4741     bzvalNULL=SysAllocString(szvalNULL);
4742     bzval100=SysAllocString(szval100);
4743     bzval101=SysAllocString(szval101);
4744     CHECKPTR(VarCmp);
4745     VARCMP(&left, _DATE,   25570.0, &right, _DATE,   25570.0, lcid, 0); EXPECT_EQ;
4746     VARCMP(&left, _DATE,   25570.0, &right, _DATE,   25571.0, lcid, 0); EXPECT_LT;
4747     VARCMP(&left, _DATE,   25571.0, &right, _DATE,   25570.0, lcid, 0); EXPECT_GT;
4748     VARCMP(&left, _DATE,   25570.0, &right, _EMPTY,        0, lcid, 0); EXPECT_GT;
4749     VARCMP(&left, _DATE,   25570.0, &right, _NULL,         0, lcid, 0); EXPECT_NULL;
4750     VARCMP(&left, _I2,           2, &right, _I2,           2, lcid, 0); EXPECT_EQ;
4751     VARCMP(&left, _I2,           1, &right, _I2,           2, lcid, 0); EXPECT_LT;
4752     VARCMP(&left, _I2,           2, &right, _I2,           1, lcid, 0); EXPECT_GT;
4753     VARCMP(&left, _I2,           2, &right, _EMPTY,        1, lcid, 0); EXPECT_GT;
4754     VARCMP(&left, _I2,           2, &right, _NULL,          1, lcid, 0); EXPECT_NULL;
4755     VARCMP(&left, _BSTR,      NULL, &right, _EMPTY,        0, lcid, 0); EXPECT_EQ;
4756     VARCMP(&left, _EMPTY,        0, &right, _BSTR,      NULL, lcid, 0); EXPECT_EQ;
4757     VARCMP(&left, _EMPTY,        0, &right, _BSTR,  bzval100, lcid, 0); EXPECT_LT;
4758     VARCMP(&left, _BSTR, bzvalNULL, &right, _EMPTY,        0, lcid, 0); EXPECT_GT;
4759     VARCMP(&left, _BSTR, bzvalNULL, &right, _NULL,         0, lcid, 0); EXPECT_NULL;
4760     VARCMP(&left, _BSTR, bzvalNULL, &right, _I2,           0, lcid, 0); EXPECT_GT;
4761     VARCMP(&left, _BSTR, bzvalNULL, &right, _NULL,         0, lcid, 0); EXPECT_NULL;
4762     VARCMP(&left, _BSTR,  bzval100, &right, _BSTR,  bzval100, lcid, 0); EXPECT_EQ;
4763     VARCMP(&left, _BSTR,  bzval100, &right, _BSTR,  bzval101, lcid, 0); EXPECT_LT;
4764     VARCMP(&left, _BSTR,  bzval101, &right, _BSTR,  bzval100, lcid, 0); EXPECT_GT;
4765     VARCMP(&left, _BSTR,  bzval100, &right, _I2,         100, lcid, 0); EXPECT_GT;
4766     VARCMP(&left, _BSTR,  bzval100, &right, _I2,         101, lcid, 0); EXPECT_GT;
4767     VARCMP(&left, _BSTR,  bzval100, &right, _I2,         101, lcid, 0); EXPECT_GT;
4768     VARCMP(&left, _I2,         100, &right, _BSTR,  bzval100, lcid, 0); EXPECT_LT;
4769     VARCMP(&left, _BSTR, (BSTR)100, &right, _I2,         100, lcid, 0); EXPECT_GT;
4770     SysFreeString(szval101);
4771     SysFreeString(szval100);
4772     SysFreeString(szvalNULL);
4773 }
4774
4775 /*
4776  * BSTR
4777  */
4778
4779 static void test_VarBstrFromR4(void)
4780 {
4781   static const WCHAR szNative[] = { '6','5','4','3','2','2','.','3','\0' };
4782   static const WCHAR szZero[] = {'0', '\0'};
4783   static const WCHAR szOneHalf_English[] = { '0','.','5','\0' };    /* uses period */
4784   static const WCHAR szOneHalf_Spanish[] = { '0',',','5','\0' };    /* uses comma */
4785   LCID lcid;
4786   LCID lcid_spanish;
4787   HRESULT hres;
4788   BSTR bstr = NULL;
4789
4790   float f;
4791
4792   CHECKPTR(VarBstrFromR4);
4793
4794   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4795   lcid_spanish = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH), SORT_DEFAULT);
4796   f = 654322.23456f;
4797   hres = pVarBstrFromR4(f, lcid, 0, &bstr);
4798   ok(hres == S_OK, "got hres 0x%08lx\n", hres);
4799   if (bstr)
4800   {
4801     todo_wine {
4802     /* MSDN states that rounding of R4/R8 is dependent on the underlying
4803      * bit pattern of the number and so is architecture dependent. In this
4804      * case Wine returns .2 (which is more correct) and Native returns .3
4805      */
4806     ok(memcmp(bstr, szNative, sizeof(szNative)) == 0, "string different\n");
4807     }
4808   }
4809
4810   f = -1e-400;    /* deliberately cause underflow */
4811   hres = pVarBstrFromR4(f, lcid, 0, &bstr);
4812   ok(hres == S_OK, "got hres 0x%08lx\n", hres);
4813   if (bstr)
4814   {
4815     ok(memcmp(bstr, szZero, sizeof(szZero)) == 0, "negative zero (got %s)\n", wtoascii(bstr));
4816   }
4817
4818   /* The following tests that lcid is used for decimal separator even without LOCALE_USE_NLS */
4819   f = 0.5;
4820   hres = pVarBstrFromR4(f, lcid, 0, &bstr);
4821   ok(hres == S_OK, "got hres 0x%08lx\n", hres);
4822   if (bstr)
4823   {
4824     ok(memcmp(bstr, szOneHalf_English, sizeof(szOneHalf_English)) == 0, "English locale failed (got %s)\n", wtoascii(bstr));
4825   }
4826   f = 0.5;
4827   hres = pVarBstrFromR4(f, lcid_spanish, 0, &bstr);
4828   ok(hres == S_OK, "got hres 0x%08lx\n", hres);
4829   if (bstr)
4830   {
4831     ok(memcmp(bstr, szOneHalf_Spanish, sizeof(szOneHalf_Spanish)) == 0, "Spanish locale failed (got %s)\n", wtoascii(bstr));
4832   }
4833 }
4834
4835 #define BSTR_DATE(dt,str) SysFreeString(bstr); bstr = NULL; \
4836   hres = pVarBstrFromDate(dt,lcid,LOCALE_NOUSEROVERRIDE,&bstr); \
4837   if (bstr) WideCharToMultiByte(CP_ACP, 0, bstr, -1, buff, sizeof(buff), 0, 0); \
4838   else buff[0] = 0; \
4839   ok(hres == S_OK && !strcmp(str,buff), "Expected '%s', got '%s', hres = 0x%08lx\n", \
4840      str, buff, hres)
4841
4842 static void test_VarBstrFromDate(void)
4843 {
4844   char buff[256];
4845   LCID lcid;
4846   HRESULT hres;
4847   BSTR bstr = NULL;
4848
4849   CHECKPTR(VarBstrFromDate);
4850   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
4851
4852   BSTR_DATE(0.0, "12:00:00 AM");
4853   BSTR_DATE(3.34, "1/2/1900 8:09:36 AM");
4854   BSTR_DATE(3339.34, "2/20/1909 8:09:36 AM");
4855   BSTR_DATE(365.00, "12/30/1900");
4856   BSTR_DATE(365.25, "12/30/1900 6:00:00 AM");
4857   BSTR_DATE(1461.0, "12/31/1903");
4858   BSTR_DATE(1461.5, "12/31/1903 12:00:00 PM");
4859 }
4860
4861 #define BSTR_DEC(l, a, b, c, d, e) \
4862   SETDEC(l, a,b,c,d);\
4863   hres = VarBstrFromDec(&l, lcid, 0, &bstr);\
4864   ok(hres == S_OK, "got hres 0x%08lx\n", hres);\
4865   if (hres== S_OK && bstr)\
4866   {\
4867     ok(lstrcmpW(bstr, e) == 0, "invalid number (got %s)\n", wtoascii(bstr));\
4868   }
4869
4870 #define BSTR_DEC64(l, a, b, c, x, d, e) \
4871   SETDEC64(l, a,b,c,x,d);\
4872   hres = VarBstrFromDec(&l, lcid, 0, &bstr);\
4873   ok(hres == S_OK, "got hres 0x%08lx\n", hres);\
4874   if (hres== S_OK && bstr)\
4875   {\
4876     ok(lstrcmpW(bstr, e) == 0, "invalid number (got %s)\n", wtoascii(bstr));\
4877   }
4878
4879 static void test_VarBstrFromDec(void)
4880 {
4881   LCID lcid;
4882   HRESULT hres;
4883   BSTR bstr = NULL;
4884   DECIMAL l;
4885
4886   static const WCHAR szZero[] = {'0', '\0'};
4887   static const WCHAR szOne[] = {'1', '\0'};
4888   static const WCHAR szOnePointFive[] = {'1','.','5','\0'};
4889   static const WCHAR szMinusOnePointFive[] = {'-','1','.','5','\0'};
4890   static const WCHAR szBigNum1[] = {'4','2','9','4','9','6','7','2','9','5','\0'};    /* (1 << 32) - 1 */
4891   static const WCHAR szBigNum2[] = {'4','2','9','4','9','6','7','2','9','6','\0'};    /* (1 << 32) */
4892   static const WCHAR szBigNum3[] = {'1','8','4','4','6','7','4','4','0','7','3','7','0','9','5','5','1','6','1','5','\0'};    /* (1 << 64) - 1 */
4893   static const WCHAR szBigNum4[] = {'1','8','4','4','6','7','4','4','0','7','3','7','0','9','5','5','1','6','1','6','\0'};    /* (1 << 64) */
4894   static const WCHAR szBigNum5[] = {'7','9','2','2','8','1','6','2','5','1','4','2','6','4','3','3','7','5','9','3','5','4','3','9','5','0','3','3','5','\0'};    /* (1 << 96) - 1 */
4895   static const WCHAR szBigScale1[] = {'0','.','0','0','0','0','0','0','0','0','0','1','\0'};    /* 1 * 10^-10 */
4896   static const WCHAR szBigScale2[] = {'7','9','2','2','8','1','6','2','5','1','4','2','6','4','3','3','7','5','9','.','3','5','4','3','9','5','0','3','3','5','\0'};    /* ((1 << 96) - 1) * 10^-10 */
4897   static const WCHAR szBigScale3[] = {'7','.','9','2','2','8','1','6','2','5','1','4','2','6','4','3','3','7','5','9','3','5','4','3','9','5','0','3','3','5','\0'};    /* ((1 << 96) - 1) * 10^-28 */
4898
4899   static const WCHAR szSmallNumber_English[] = {'0','.','0','0','0','9','\0'};
4900   static const WCHAR szSmallNumber_Spanish[] = {'0',',','0','0','0','9','\0'};
4901
4902   CHECKPTR(VarBstrFromDec);
4903   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
4904
4905   /* check zero */
4906   BSTR_DEC(l, 0,0,0,0, szZero);
4907
4908   /* check one */
4909   BSTR_DEC(l, 0,0,0,1, szOne);
4910   BSTR_DEC(l, 1,0,0,10,szOne);
4911   BSTR_DEC(l, 2,0,0,100,szOne);
4912   BSTR_DEC(l, 3,0,0,1000,szOne);
4913
4914   /* check one point five */
4915   BSTR_DEC(l, 1,0,0,15, szOnePointFive);
4916   BSTR_DEC(l, 2,0,0,150, szOnePointFive);
4917   BSTR_DEC(l, 3,0,0,1500, szOnePointFive);
4918
4919   /* check minus one point five */
4920   BSTR_DEC(l, 1,0x80,0,15, szMinusOnePointFive);
4921
4922   /* check bignum (1) */
4923   BSTR_DEC(l, 0,0,0,0xffffffff, szBigNum1);
4924
4925   /* check bignum (2) */
4926   BSTR_DEC64(l, 0,0,0,1,0, szBigNum2);
4927
4928   /* check bignum (3) */
4929   BSTR_DEC64(l, 0,0,0,0xffffffff,0xffffffff, szBigNum3);
4930
4931   /* check bignum (4) */
4932   BSTR_DEC(l, 0,0,1,0, szBigNum4);
4933
4934   /* check bignum (5) */
4935   BSTR_DEC64(l, 0,0,0xffffffff,0xffffffff,0xffffffff, szBigNum5);
4936
4937   /* check bigscale (1) */
4938   BSTR_DEC(l, 10,0,0,1, szBigScale1);
4939
4940   /* check bigscale (2) */
4941   BSTR_DEC64(l, 10,0,0xffffffffUL,0xffffffff,0xffffffff, szBigScale2);
4942
4943   /* check bigscale (3) */
4944   BSTR_DEC64(l, 28,0,0xffffffffUL,0xffffffff,0xffffffff, szBigScale3);
4945
4946   /* check leading zeros and decimal sep. for English locale */
4947   BSTR_DEC(l, 4,0,0,9, szSmallNumber_English);
4948   BSTR_DEC(l, 5,0,0,90, szSmallNumber_English);
4949   BSTR_DEC(l, 6,0,0,900, szSmallNumber_English);
4950   BSTR_DEC(l, 7,0,0,9000, szSmallNumber_English);
4951
4952   lcid = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_DEFAULT), SORT_DEFAULT);
4953
4954   /* check leading zeros and decimal sep. for Spanish locale */
4955   BSTR_DEC(l, 4,0,0,9, szSmallNumber_Spanish);
4956   BSTR_DEC(l, 5,0,0,90, szSmallNumber_Spanish);
4957   BSTR_DEC(l, 6,0,0,900, szSmallNumber_Spanish);
4958   BSTR_DEC(l, 7,0,0,9000, szSmallNumber_Spanish);
4959 }
4960 #undef BSTR_DEC
4961 #undef BSTR_DEC64
4962
4963 /* Get the internal representation of a BSTR */
4964 static inline LPINTERNAL_BSTR Get(const BSTR lpszString)
4965 {
4966   return lpszString ? (LPINTERNAL_BSTR)((char*)lpszString - sizeof(DWORD)) : NULL;
4967 }
4968
4969 static inline BSTR GetBSTR(const LPINTERNAL_BSTR bstr)
4970 {
4971   return (BSTR)bstr->szString;
4972 }
4973
4974 static void test_SysStringLen(void)
4975 {
4976   INTERNAL_BSTR bstr;
4977   BSTR str = GetBSTR(&bstr);
4978
4979   bstr.dwLen = 0;
4980   ok (SysStringLen(str) == 0, "Expected dwLen 0, got %d\n", SysStringLen(str));
4981   bstr.dwLen = 2;
4982   ok (SysStringLen(str) == 1, "Expected dwLen 1, got %d\n", SysStringLen(str));
4983 }
4984
4985 static void test_SysStringByteLen(void)
4986 {
4987   INTERNAL_BSTR bstr;
4988   BSTR str = GetBSTR(&bstr);
4989
4990   bstr.dwLen = 0;
4991   ok (SysStringByteLen(str) == 0, "Expected dwLen 0, got %d\n", SysStringLen(str));
4992   bstr.dwLen = 2;
4993   ok (SysStringByteLen(str) == 2, "Expected dwLen 2, got %d\n", SysStringByteLen(str));
4994 }
4995
4996 static void test_SysAllocString(void)
4997 {
4998   const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
4999   BSTR str;
5000
5001   str = SysAllocString(NULL);
5002   ok (str == NULL, "Expected NULL, got %p\n", str);
5003
5004   str = SysAllocString(szTest);
5005   ok (str != NULL, "Expected non-NULL\n");
5006   if (str)
5007   {
5008     LPINTERNAL_BSTR bstr = Get(str);
5009
5010     ok (bstr->dwLen == 8, "Expected 8, got %ld\n", bstr->dwLen);
5011     ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5012     SysFreeString(str);
5013   }
5014 }
5015
5016 static void test_SysAllocStringLen(void)
5017 {
5018   const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
5019   BSTR str;
5020
5021   /* Very early native dlls do not limit the size of strings, so skip this test */
5022 #if 0
5023   str = SysAllocStringLen(szTest, 0x80000000);
5024   todo_wine {
5025   ok (str == NULL, "Expected NULL, got %p\n", str);
5026   }
5027 #endif
5028
5029   str = SysAllocStringLen(NULL, 0);
5030   ok (str != NULL, "Expected non-NULL\n");
5031   if (str)
5032   {
5033     LPINTERNAL_BSTR bstr = Get(str);
5034
5035     ok (bstr->dwLen == 0, "Expected 0, got %ld\n", bstr->dwLen);
5036     ok (!bstr->szString[0], "String not empty\n");
5037     SysFreeString(str);
5038   }
5039
5040   str = SysAllocStringLen(szTest, 4);
5041   ok (str != NULL, "Expected non-NULL\n");
5042   if (str)
5043   {
5044     LPINTERNAL_BSTR bstr = Get(str);
5045
5046     ok (bstr->dwLen == 8, "Expected 8, got %ld\n", bstr->dwLen);
5047     ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5048     SysFreeString(str);
5049   }
5050 }
5051
5052 static void test_SysAllocStringByteLen(void)
5053 {
5054   const OLECHAR szTest[10] = { 'T','e','s','t','\0' };
5055   const CHAR szTestA[6] = { 'T','e','s','t','\0','?' };
5056   BSTR str;
5057
5058   str = SysAllocStringByteLen(szTestA, 0x80000000);
5059   ok (str == NULL, "Expected NULL, got %p\n", str);
5060
5061   str = SysAllocStringByteLen(NULL, 0);
5062   ok (str != NULL, "Expected non-NULL\n");
5063   if (str)
5064   {
5065     LPINTERNAL_BSTR bstr = Get(str);
5066
5067     ok (bstr->dwLen == 0, "Expected 0, got %ld\n", bstr->dwLen);
5068     ok (!bstr->szString[0], "String not empty\n");
5069     SysFreeString(str);
5070   }
5071
5072   str = SysAllocStringByteLen(szTestA, 4);
5073   ok (str != NULL, "Expected non-NULL\n");
5074   if (str)
5075   {
5076     LPINTERNAL_BSTR bstr = Get(str);
5077
5078     ok (bstr->dwLen == 4, "Expected 4, got %ld\n", bstr->dwLen);
5079     ok (!lstrcmpA((LPCSTR)bstr->szString, szTestA), "String different\n");
5080     SysFreeString(str);
5081   }
5082
5083   /* Odd lengths are allocated rounded up, but truncated at the right position */
5084   str = SysAllocStringByteLen(szTestA, 3);
5085   ok (str != NULL, "Expected non-NULL\n");
5086   if (str)
5087   {
5088     const CHAR szTestTruncA[4] = { 'T','e','s','\0' };
5089     LPINTERNAL_BSTR bstr = Get(str);
5090
5091     ok (bstr->dwLen == 3, "Expected 3, got %ld\n", bstr->dwLen);
5092     ok (!lstrcmpA((LPCSTR)bstr->szString, szTestTruncA), "String different\n");
5093     SysFreeString(str);
5094   }
5095
5096   str = SysAllocStringByteLen((LPCSTR)szTest, 8);
5097   ok (str != NULL, "Expected non-NULL\n");
5098   if (str)
5099   {
5100     LPINTERNAL_BSTR bstr = Get(str);
5101
5102     ok (bstr->dwLen == 8, "Expected 8, got %ld\n", bstr->dwLen);
5103     ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5104     SysFreeString(str);
5105   }
5106 }
5107
5108 static void test_SysReAllocString(void)
5109 {
5110   const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
5111   const OLECHAR szSmaller[2] = { 'x','\0' };
5112   const OLECHAR szLarger[7] = { 'L','a','r','g','e','r','\0' };
5113   BSTR str;
5114
5115   str = SysAllocStringLen(szTest, 4);
5116   ok (str != NULL, "Expected non-NULL\n");
5117   if (str)
5118   {
5119     LPINTERNAL_BSTR bstr;
5120     BSTR oldstr = str;
5121     int changed;
5122
5123     bstr = Get(str);
5124     ok (bstr->dwLen == 8, "Expected 8, got %ld\n", bstr->dwLen);
5125     ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5126
5127     changed = SysReAllocString(&str, szSmaller);
5128     ok (changed == 1, "Expected 1, got %d\n", changed);
5129     ok (str == oldstr, "Created new string\n");
5130     bstr = Get(str);
5131     ok (bstr->dwLen == 2, "Expected 2, got %ld\n", bstr->dwLen);
5132     ok (!lstrcmpW(bstr->szString, szSmaller), "String different\n");
5133
5134     oldstr = str;
5135     changed = SysReAllocString(&str, szLarger);
5136     ok (changed == 1, "Expected 1, got %d\n", changed);
5137     /* Early versions always make new strings rather than resizing */
5138     /* ok (str == oldstr, "Created new string\n"); */
5139     bstr = Get(str);
5140     ok (bstr->dwLen == 12, "Expected 12, got %ld\n", bstr->dwLen);
5141     ok (!lstrcmpW(bstr->szString, szLarger), "String different\n");
5142
5143     SysFreeString(str);
5144   }
5145 }
5146
5147 static void test_SysReAllocStringLen(void)
5148 {
5149   const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
5150   const OLECHAR szSmaller[2] = { 'x','\0' };
5151   const OLECHAR szLarger[7] = { 'L','a','r','g','e','r','\0' };
5152   BSTR str;
5153
5154   str = SysAllocStringLen(szTest, 4);
5155   ok (str != NULL, "Expected non-NULL\n");
5156   if (str)
5157   {
5158     LPINTERNAL_BSTR bstr;
5159     BSTR oldstr = str;
5160     int changed;
5161
5162     bstr = Get(str);
5163     ok (bstr->dwLen == 8, "Expected 8, got %ld\n", bstr->dwLen);
5164     ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5165
5166     changed = SysReAllocStringLen(&str, szSmaller, 1);
5167     ok (changed == 1, "Expected 1, got %d\n", changed);
5168     ok (str == oldstr, "Created new string\n");
5169     bstr = Get(str);
5170     ok (bstr->dwLen == 2, "Expected 2, got %ld\n", bstr->dwLen);
5171     ok (!lstrcmpW(bstr->szString, szSmaller), "String different\n");
5172
5173     oldstr = str;
5174     changed = SysReAllocStringLen(&str, szLarger, 6);
5175     ok (changed == 1, "Expected 1, got %d\n", changed);
5176     /* Early versions always make new strings rather than resizing */
5177     /* ok (str == oldstr, "Created new string\n"); */
5178     bstr = Get(str);
5179     ok (bstr->dwLen == 12, "Expected 12, got %ld\n", bstr->dwLen);
5180     ok (!lstrcmpW(bstr->szString, szLarger), "String different\n");
5181
5182     changed = SysReAllocStringLen(&str, str, 6);
5183     ok (changed == 1, "Expected 1, got %d\n", changed);
5184
5185     SysFreeString(str);
5186   }
5187 }
5188
5189 static void test_BstrCopy(void)
5190 {
5191   const CHAR szTestA[6] = { 'T','e','s','t','\0','?' };
5192   const CHAR szTestTruncA[4] = { 'T','e','s','\0' };
5193   LPINTERNAL_BSTR bstr;
5194   BSTR str;
5195   HRESULT hres;
5196   VARIANT vt1, vt2;
5197
5198   str = SysAllocStringByteLen(szTestA, 3);
5199   ok (str != NULL, "Expected non-NULL\n");
5200   if (str)
5201   {
5202     V_VT(&vt1) = VT_BSTR;
5203     V_BSTR(&vt1) = str;
5204     V_VT(&vt2) = VT_EMPTY;
5205     hres = VariantCopy(&vt2, &vt1);
5206     ok (hres == S_OK,"Failed to copy binary bstring with hres 0x%08lx\n", hres);
5207     bstr = Get(V_BSTR(&vt2));
5208     ok (bstr->dwLen == 3, "Expected 3, got %ld\n", bstr->dwLen);
5209     ok (!lstrcmpA((LPCSTR)bstr->szString, szTestTruncA), "String different\n");
5210   }
5211 }
5212
5213 /* IUnknown */
5214
5215 static void test_IUnknownClear(void)
5216 {
5217   HRESULT hres;
5218   VARIANTARG v;
5219   DummyDispatch u = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5220   IUnknown* pu = (IUnknown*)&u;
5221
5222   /* Test that IUnknown_Release is called on by-value */
5223   V_VT(&v) = VT_UNKNOWN;
5224   V_UNKNOWN(&v) = (IUnknown*)&u;
5225   hres = VariantClear(&v);
5226   ok(hres == S_OK && u.ref == 0 && V_VT(&v) == VT_EMPTY,
5227      "clear unknown: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5228      S_OK, 0, VT_EMPTY, hres, u.ref, V_VT(&v));
5229
5230   /* But not when clearing a by-reference*/
5231   u.ref = 1;
5232   V_VT(&v) = VT_UNKNOWN|VT_BYREF;
5233   V_UNKNOWNREF(&v) = &pu;
5234   hres = VariantClear(&v);
5235   ok(hres == S_OK && u.ref == 1 && V_VT(&v) == VT_EMPTY,
5236      "clear dispatch: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5237      S_OK, 1, VT_EMPTY, hres, u.ref, V_VT(&v));
5238 }
5239
5240 static void test_IUnknownCopy(void)
5241 {
5242   HRESULT hres;
5243   VARIANTARG vSrc, vDst;
5244   DummyDispatch u = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5245   IUnknown* pu = (IUnknown*)&u;
5246
5247   /* AddRef is called on by-value copy */
5248   VariantInit(&vDst);
5249   V_VT(&vSrc) = VT_UNKNOWN;
5250   V_UNKNOWN(&vSrc) = pu;
5251   hres = VariantCopy(&vDst, &vSrc);
5252   ok(hres == S_OK && u.ref == 2 && V_VT(&vDst) == VT_UNKNOWN,
5253      "copy unknown: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5254      S_OK, 2, VT_EMPTY, hres, u.ref, V_VT(&vDst));
5255
5256   /* AddRef is skipped on copy of by-reference IDispatch */
5257   VariantInit(&vDst);
5258   u.ref = 1;
5259   V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
5260   V_UNKNOWNREF(&vSrc) = &pu;
5261   hres = VariantCopy(&vDst, &vSrc);
5262   ok(hres == S_OK && u.ref == 1 && V_VT(&vDst) == (VT_UNKNOWN|VT_BYREF),
5263      "copy unknown: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5264      S_OK, 1, VT_DISPATCH, hres, u.ref, V_VT(&vDst));
5265
5266   /* AddRef is called copying by-reference IDispatch with indirection */
5267   VariantInit(&vDst);
5268   u.ref = 1;
5269   V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
5270   V_UNKNOWNREF(&vSrc) = &pu;
5271   hres = VariantCopyInd(&vDst, &vSrc);
5272   ok(hres == S_OK && u.ref == 2 && V_VT(&vDst) == VT_UNKNOWN,
5273      "copy unknown: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5274      S_OK, 2, VT_DISPATCH, hres, u.ref, V_VT(&vDst));
5275
5276   /* Indirection in place also calls AddRef */
5277   u.ref = 1;
5278   V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
5279   V_UNKNOWNREF(&vSrc) = &pu;
5280   hres = VariantCopyInd(&vSrc, &vSrc);
5281   ok(hres == S_OK && u.ref == 2 && V_VT(&vSrc) == VT_UNKNOWN,
5282      "copy unknown: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5283      S_OK, 2, VT_DISPATCH, hres, u.ref, V_VT(&vSrc));
5284 }
5285
5286 static void test_IUnknownChangeTypeEx(void)
5287 {
5288   HRESULT hres;
5289   VARIANTARG vSrc, vDst;
5290   LCID lcid;
5291   VARTYPE vt;
5292   DummyDispatch u = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5293   IUnknown* pu = (IUnknown*)&u;
5294
5295   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5296
5297   V_VT(&vSrc) = VT_UNKNOWN;
5298   V_UNKNOWN(&vSrc) = pu;
5299
5300   /* =>IDispatch in place */
5301   hres = VariantChangeTypeEx(&vSrc, &vSrc, lcid, 0, VT_DISPATCH);
5302   ok(hres == S_OK && u.ref == 1 &&
5303      V_VT(&vSrc) == VT_DISPATCH && V_DISPATCH(&vSrc) == (IDispatch*)pu,
5304      "change unk(src=src): expected 0x%08lx,%d,%d,%p, got 0x%08lx,%ld,%d,%p\n",
5305      S_OK, 1, VT_DISPATCH, pu, hres, u.ref, V_VT(&vSrc), V_DISPATCH(&vSrc));
5306
5307   /* =>IDispatch */
5308   u.ref = 1;
5309   V_VT(&vSrc) = VT_UNKNOWN;
5310   V_UNKNOWN(&vSrc) = (IUnknown*)pu;
5311   VariantInit(&vDst);
5312   hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
5313   /* Note vSrc is not cleared, as final refcount is 2 */
5314   ok(hres == S_OK && u.ref == 2 &&
5315      V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == (IUnknown*)pu,
5316      "change unk(src,dst): expected 0x%08lx,%d,%d,%p, got 0x%08lx,%ld,%d,%p\n",
5317      S_OK, 2, VT_UNKNOWN, pu, hres, u.ref, V_VT(&vDst), V_UNKNOWN(&vDst));
5318
5319   /* Can't change unknown to anything else */
5320   for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5321   {
5322     HRESULT hExpected = DISP_E_BADVARTYPE;
5323
5324     V_VT(&vSrc) = VT_UNKNOWN;
5325     V_UNKNOWN(&vSrc) = (IUnknown*)pu;
5326     VariantInit(&vDst);
5327
5328     if (vt == VT_UNKNOWN || vt == VT_DISPATCH || vt == VT_EMPTY || vt == VT_NULL)
5329       hExpected = S_OK;
5330     else
5331     {
5332       if (vt == VT_I8 || vt == VT_UI8)
5333       {
5334         if (HAVE_OLEAUT32_I8)
5335           hExpected = DISP_E_TYPEMISMATCH;
5336       }
5337       else if (vt == VT_RECORD)
5338       {
5339         if (HAVE_OLEAUT32_RECORD)
5340           hExpected = DISP_E_TYPEMISMATCH;
5341       }
5342       else if (vt  >= VT_I2 && vt <= VT_UINT && vt != (VARTYPE)15)
5343         hExpected = DISP_E_TYPEMISMATCH;
5344     }
5345     if (IS_ANCIENT && IS_MODERN_VTYPE(vt))
5346         hExpected = DISP_E_BADVARTYPE;
5347
5348     hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5349     ok(hres == hExpected,
5350        "change unk(badvar): vt %d expected 0x%08lx, got 0x%08lx\n",
5351        vt, hExpected, hres);
5352   }
5353 }
5354
5355 /* IDispatch */
5356 static void test_IDispatchClear(void)
5357 {
5358   HRESULT hres;
5359   VARIANTARG v;
5360   DummyDispatch d = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5361   IDispatch* pd = (IDispatch*)&d;
5362
5363   /* As per IUnknown */
5364
5365   V_VT(&v) = VT_DISPATCH;
5366   V_DISPATCH(&v) = pd;
5367   hres = VariantClear(&v);
5368   ok(hres == S_OK && d.ref == 0 && V_VT(&v) == VT_EMPTY,
5369      "clear dispatch: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5370      S_OK, 0, VT_EMPTY, hres, d.ref, V_VT(&v));
5371
5372   d.ref = 1;
5373   V_VT(&v) = VT_DISPATCH|VT_BYREF;
5374   V_DISPATCHREF(&v) = &pd;
5375   hres = VariantClear(&v);
5376   ok(hres == S_OK && d.ref == 1 && V_VT(&v) == VT_EMPTY,
5377      "clear dispatch: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5378      S_OK, 1, VT_EMPTY, hres, d.ref, V_VT(&v));
5379 }
5380
5381 static void test_IDispatchCopy(void)
5382 {
5383   HRESULT hres;
5384   VARIANTARG vSrc, vDst;
5385   DummyDispatch d = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5386   IDispatch* pd = (IDispatch*)&d;
5387
5388   /* As per IUnknown */
5389
5390   VariantInit(&vDst);
5391   V_VT(&vSrc) = VT_DISPATCH;
5392   V_DISPATCH(&vSrc) = pd;
5393   hres = VariantCopy(&vDst, &vSrc);
5394   ok(hres == S_OK && d.ref == 2 && V_VT(&vDst) == VT_DISPATCH,
5395      "copy dispatch: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5396      S_OK, 2, VT_EMPTY, hres, d.ref, V_VT(&vDst));
5397
5398   VariantInit(&vDst);
5399   d.ref = 1;
5400   V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
5401   V_DISPATCHREF(&vSrc) = &pd;
5402   hres = VariantCopy(&vDst, &vSrc);
5403   ok(hres == S_OK && d.ref == 1 && V_VT(&vDst) == (VT_DISPATCH|VT_BYREF),
5404      "copy dispatch: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5405      S_OK, 1, VT_DISPATCH, hres, d.ref, V_VT(&vDst));
5406
5407   VariantInit(&vDst);
5408   d.ref = 1;
5409   V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
5410   V_DISPATCHREF(&vSrc) = &pd;
5411   hres = VariantCopyInd(&vDst, &vSrc);
5412   ok(hres == S_OK && d.ref == 2 && V_VT(&vDst) == VT_DISPATCH,
5413      "copy dispatch: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5414      S_OK, 2, VT_DISPATCH, hres, d.ref, V_VT(&vDst));
5415
5416   d.ref = 1;
5417   V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
5418   V_DISPATCHREF(&vSrc) = &pd;
5419   hres = VariantCopyInd(&vSrc, &vSrc);
5420   ok(hres == S_OK && d.ref == 2 && V_VT(&vSrc) == VT_DISPATCH,
5421      "copy dispatch: expected 0x%08lx, %d, %d, got 0x%08lx, %ld, %d\n",
5422      S_OK, 2, VT_DISPATCH, hres, d.ref, V_VT(&vSrc));
5423 }
5424
5425 static void test_IDispatchChangeTypeEx(void)
5426 {
5427   HRESULT hres;
5428   VARIANTARG vSrc, vDst;
5429   LCID lcid;
5430   DummyDispatch d = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5431   IDispatch* pd = (IDispatch*)&d;
5432
5433   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5434
5435   V_VT(&vSrc) = VT_DISPATCH;
5436   V_DISPATCH(&vSrc) = pd;
5437
5438   /* =>IUnknown in place */
5439   hres = VariantChangeTypeEx(&vSrc, &vSrc, lcid, 0, VT_UNKNOWN);
5440   ok(hres == S_OK && d.ref == 1 &&
5441      V_VT(&vSrc) == VT_UNKNOWN && V_UNKNOWN(&vSrc) == (IUnknown*)pd,
5442      "change disp(src=src): expected 0x%08lx,%d,%d,%p, got 0x%08lx,%ld,%d,%p\n",
5443      S_OK, 1, VT_UNKNOWN, pd, hres, d.ref, V_VT(&vSrc), V_UNKNOWN(&vSrc));
5444
5445   /* =>IUnknown */
5446   d.ref = 1;
5447   V_VT(&vSrc) = VT_DISPATCH;
5448   V_DISPATCH(&vSrc) = pd;
5449   VariantInit(&vDst);
5450   hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
5451   /* Note vSrc is not cleared, as final refcount is 2 */
5452   ok(hres == S_OK && d.ref == 2 &&
5453      V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == (IUnknown*)pd,
5454      "change disp(src,dst): expected 0x%08lx,%d,%d,%p, got 0x%08lx,%ld,%d,%p\n",
5455      S_OK, 2, VT_UNKNOWN, pd, hres, d.ref, V_VT(&vDst), V_UNKNOWN(&vDst));
5456
5457   /* FIXME: Verify that VARIANT_NOVALUEPROP prevents conversion to integral
5458    *        types. this requires that the xxxFromDisp tests work first.
5459    */
5460 }
5461
5462 /* VT_ERROR */
5463 static void test_ErrorChangeTypeEx(void)
5464 {
5465   HRESULT hres;
5466   VARIANTARG vSrc, vDst;
5467   VARTYPE vt;
5468   LCID lcid;
5469
5470   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5471
5472   for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5473   {
5474     HRESULT hExpected = DISP_E_BADVARTYPE;
5475
5476     V_VT(&vSrc) = VT_ERROR;
5477     V_ERROR(&vSrc) = 1;
5478     VariantInit(&vDst);
5479     hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5480
5481     if (vt == VT_ERROR)
5482       hExpected = S_OK;
5483     else
5484     {
5485       if (vt == VT_I8 || vt == VT_UI8)
5486       {
5487         if (HAVE_OLEAUT32_I8)
5488           hExpected = DISP_E_TYPEMISMATCH;
5489       }
5490       else if (vt == VT_RECORD)
5491       {
5492         if (HAVE_OLEAUT32_RECORD)
5493           hExpected = DISP_E_TYPEMISMATCH;
5494       }
5495       else if (vt <= VT_UINT && vt != (VARTYPE)15)
5496         hExpected = DISP_E_TYPEMISMATCH;
5497     }
5498     if (IS_ANCIENT && IS_MODERN_VTYPE(vt))
5499         hExpected = DISP_E_BADVARTYPE;
5500
5501     ok(hres == hExpected,
5502      "change err: vt %d expected 0x%08lx, got 0x%08lx\n", vt, hExpected, hres);
5503   }
5504 }
5505
5506 /* VT_EMPTY */
5507 static void test_EmptyChangeTypeEx(void)
5508 {
5509   HRESULT hres;
5510   VARIANTARG vSrc, vDst;
5511   VARTYPE vt;
5512   LCID lcid;
5513
5514   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5515
5516   for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5517   {
5518     HRESULT hExpected = DISP_E_BADVARTYPE;
5519
5520     VariantInit(&vSrc);
5521     memset(&vDst, 0, sizeof(vDst));
5522     V_VT(&vDst) = VT_EMPTY;
5523
5524     if (vt == VT_I8 || vt == VT_UI8)
5525     {
5526       if (HAVE_OLEAUT32_I8)
5527         hExpected = S_OK;
5528     }
5529     else if (vt == VT_RECORD)
5530     {
5531       if (HAVE_OLEAUT32_RECORD)
5532         hExpected = DISP_E_TYPEMISMATCH;
5533     }
5534     else if (vt == VT_VARIANT || vt == VT_DISPATCH ||
5535               vt == VT_UNKNOWN || vt == VT_ERROR)
5536     {
5537       hExpected = DISP_E_TYPEMISMATCH;
5538     }
5539     else if (vt <= VT_UINT && vt != (VARTYPE)15)
5540       hExpected = S_OK;
5541
5542     if (IS_ANCIENT && IS_MODERN_VTYPE(vt))
5543         hExpected = DISP_E_BADVARTYPE;
5544
5545     hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5546
5547     ok(hres == hExpected && (hres != S_OK || V_VT(&vDst) == vt),
5548        "change empty: vt %d expected 0x%08lx, got 0x%08lx, vt %d\n",
5549        vt, hExpected, hres, V_VT(&vDst));
5550   }
5551 }
5552
5553 /* VT_NULL */
5554 static void test_NullChangeTypeEx(void)
5555 {
5556   HRESULT hres;
5557   VARIANTARG vSrc, vDst;
5558   VARTYPE vt;
5559   LCID lcid;
5560
5561   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5562
5563   for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5564   {
5565     HRESULT hExpected = DISP_E_BADVARTYPE;
5566
5567     VariantInit(&vSrc);
5568     V_VT(&vSrc) = VT_NULL;
5569     memset(&vDst, 0, sizeof(vDst));
5570     V_VT(&vDst) = VT_EMPTY;
5571
5572     if (vt == VT_I8 || vt == VT_UI8)
5573     {
5574       if (HAVE_OLEAUT32_I8)
5575         hExpected = DISP_E_TYPEMISMATCH;
5576     }
5577     else if (vt == VT_RECORD)
5578     {
5579       if (HAVE_OLEAUT32_RECORD)
5580         hExpected = DISP_E_TYPEMISMATCH;
5581     }
5582     else if (vt == VT_NULL)
5583     {
5584       hExpected = S_OK;
5585     }
5586     else if (vt == VT_VARIANT || vt == VT_DISPATCH ||
5587               vt == VT_UNKNOWN || vt == VT_ERROR ||
5588               (vt <= VT_UINT && vt != (VARTYPE)15))
5589       hExpected = DISP_E_TYPEMISMATCH;
5590
5591     if (IS_ANCIENT && IS_MODERN_VTYPE(vt))
5592         hExpected = DISP_E_BADVARTYPE;
5593
5594     hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5595
5596     ok(hres == hExpected && (hres != S_OK || V_VT(&vDst) == vt),
5597        "change null: vt %d expected 0x%08lx, got 0x%08lx, vt %d\n",
5598        vt, hExpected, hres, V_VT(&vDst));
5599   }
5600 }
5601
5602
5603 /* VT_UINT */
5604 static void test_UintChangeTypeEx(void)
5605 {
5606   HRESULT hres;
5607   VARIANTARG vSrc, vDst;
5608   LCID lcid;
5609
5610   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5611
5612   /* Converting a VT_UINT to a VT_INT does not check for overflow */
5613   V_VT(&vDst) = VT_EMPTY;
5614   V_VT(&vSrc) = VT_UINT;
5615   V_UI4(&vSrc) = -1;
5616   hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_I4);
5617   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == -1,
5618      "change uint: Expected %d,0x%08lx,%d got %d,0x%08lx,%ld\n",
5619      VT_I4, S_OK, -1, V_VT(&vDst), hres, V_I4(&vDst));
5620 }
5621
5622 #define NUM_CUST_ITEMS 16
5623
5624 static void test_ClearCustData(void)
5625 {
5626   WCHAR buff[sizeof(CUSTDATAITEM) * NUM_CUST_ITEMS / sizeof(WCHAR)];
5627   CUSTDATA ci;
5628   unsigned i;
5629
5630   CHECKPTR(ClearCustData);
5631
5632   memset(buff, 0, sizeof(buff));
5633
5634   ci.cCustData = NUM_CUST_ITEMS;
5635   /* This is a bit tricky. We use SysAllocStringByteLen to allocate the
5636    * array, since native uses an internal IMalloc interface for allocating
5637    * its memory, while Wine uses HeapAlloc(). Doing this ensures we allocate
5638    * using the correct function whether with native or builtin.
5639    */
5640   ci.prgCustData = (LPCUSTDATAITEM)SysAllocStringByteLen((LPCSTR)buff, sizeof(buff));
5641   for (i = 0; i < NUM_CUST_ITEMS; i++)
5642     VariantInit(&ci.prgCustData[i].varValue);
5643   pClearCustData(&ci);
5644   ok(!ci.cCustData && !ci.prgCustData, "ClearCustData didn't clear fields!\n");
5645 }
5646
5647 static void test_NullByRef(void)
5648 {
5649   VARIANT v1, v2;
5650   HRESULT hRes;
5651
5652   VariantClear(&v1);
5653   VariantClear(&v2);
5654   V_VT(&v1) = VT_BYREF|VT_VARIANT;
5655   V_BYREF(&v1) = 0;
5656
5657   hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_I4);
5658   ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
5659
5660   VariantClear(&v1);
5661   V_VT(&v1) = VT_BYREF|VT_VARIANT;
5662   V_BYREF(&v1) = 0;
5663   V_VT(&v2) = VT_I4;
5664   V_I4(&v2) = 123;
5665
5666   hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_VARIANT);
5667   ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
5668   ok(V_VT(&v2) == VT_I4 && V_I4(&v2) == 123, "VariantChangeTypeEx shouldn't change pvargDest\n");
5669
5670   hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_BYREF|VT_I4);
5671   ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
5672
5673   hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, 0x3847);
5674   ok(hRes == DISP_E_BADVARTYPE, "VariantChangeTypeEx should return DISP_E_BADVARTYPE\n");
5675 }
5676
5677 /* Dst Variant should remain unchanged if VariantChangeType cannot convert */
5678 static void test_ChangeType_keep_dst(void)
5679 {
5680      VARIANT v1, v2;
5681      BSTR bstr;
5682      WCHAR testW[] = {'t','e','s','t',0};
5683      HRESULT hres;
5684
5685      bstr = SysAllocString(testW);
5686      VariantClear(&v1);
5687      VariantClear(&v2);
5688      V_VT(&v1) = VT_BSTR;
5689      V_BSTR(&v1) = bstr;
5690      hres = VariantChangeTypeEx(&v1, &v1, 0, 0, VT_INT);
5691      ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08lx\n", hres);
5692      ok(V_VT(&v1) == VT_BSTR && V_BSTR(&v1) == bstr, "VariantChangeTypeEx changed dst variant\n");
5693      V_VT(&v2) = VT_INT;
5694      V_INT(&v2) = 4;
5695      hres = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_INT);
5696      ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08lx\n", hres);
5697      ok(V_VT(&v2) == VT_INT && V_INT(&v2) == 4, "VariantChangeTypeEx changed dst variant\n");
5698      SysFreeString(bstr);
5699 }
5700
5701 START_TEST(vartype)
5702 {
5703   hOleaut32 = LoadLibraryA("oleaut32.dll");
5704   ok(hOleaut32 != 0, "Failed to load oleaut32.dll\n");
5705   if (!hOleaut32)
5706     return;
5707
5708   trace("LCID's: System=0x%08lx, User=0x%08lx\n", GetSystemDefaultLCID(),
5709         GetUserDefaultLCID());
5710
5711   test_VarI1FromI2();
5712   test_VarI1FromI4();
5713   test_VarI1FromI8();
5714   test_VarI1FromUI1();
5715   test_VarI1FromUI2();
5716   test_VarI1FromUI4();
5717   test_VarI1FromUI8();
5718   test_VarI1FromBool();
5719   test_VarI1FromR4();
5720   test_VarI1FromR8();
5721   test_VarI1FromDate();
5722   test_VarI1FromCy();
5723   test_VarI1FromDec();
5724   test_VarI1FromStr();
5725   test_VarUI1FromDisp();
5726   test_VarI1Copy();
5727   test_VarI1ChangeTypeEx();
5728
5729   test_VarUI1FromI1();
5730   test_VarUI1FromI2();
5731   test_VarUI1FromI4();
5732   test_VarUI1FromI8();
5733   test_VarUI1FromUI2();
5734   test_VarUI1FromUI4();
5735   test_VarUI1FromUI8();
5736   test_VarUI1FromBool();
5737   test_VarUI1FromR4();
5738   test_VarUI1FromR8();
5739   test_VarUI1FromDate();
5740   test_VarUI1FromCy();
5741   test_VarUI1FromDec();
5742   test_VarUI1FromStr();
5743   test_VarUI1Copy();
5744   test_VarUI1ChangeTypeEx();
5745
5746   test_VarI2FromI1();
5747   test_VarI2FromI4();
5748   test_VarI2FromI8();
5749   test_VarI2FromUI1();
5750   test_VarI2FromUI2();
5751   test_VarI2FromUI4();
5752   test_VarI2FromUI8();
5753   test_VarI2FromBool();
5754   test_VarI2FromR4();
5755   test_VarI2FromR8();
5756   test_VarI2FromDate();
5757   test_VarI2FromCy();
5758   test_VarI2FromDec();
5759   test_VarI2FromStr();
5760   test_VarI2Copy();
5761   test_VarI2ChangeTypeEx();
5762
5763   test_VarUI2FromI1();
5764   test_VarUI2FromI2();
5765   test_VarUI2FromI4();
5766   test_VarUI2FromI8();
5767   test_VarUI2FromUI1();
5768   test_VarUI2FromUI4();
5769   test_VarUI2FromUI8();
5770   test_VarUI2FromBool();
5771   test_VarUI2FromR4();
5772   test_VarUI2FromR8();
5773   test_VarUI2FromDate();
5774   test_VarUI2FromCy();
5775   test_VarUI2FromDec();
5776   test_VarUI2FromStr();
5777   test_VarUI2Copy();
5778   test_VarUI2ChangeTypeEx();
5779
5780   test_VarI4FromI1();
5781   test_VarI4FromI2();
5782   test_VarI4FromI8();
5783   test_VarI4FromUI1();
5784   test_VarI4FromUI2();
5785   test_VarI4FromUI4();
5786   test_VarI4FromUI8();
5787   test_VarI4FromBool();
5788   test_VarI4FromR4();
5789   test_VarI4FromR8();
5790   test_VarI4FromDate();
5791   test_VarI4FromCy();
5792   test_VarI4FromDec();
5793   test_VarI4FromStr();
5794   test_VarI4Copy();
5795   test_VarI4ChangeTypeEx();
5796
5797   test_VarUI4FromI1();
5798   test_VarUI4FromI2();
5799   test_VarUI4FromUI2();
5800   test_VarUI4FromI8();
5801   test_VarUI4FromUI1();
5802   test_VarUI4FromI4();
5803   test_VarUI4FromUI8();
5804   test_VarUI4FromBool();
5805   test_VarUI4FromR4();
5806   test_VarUI4FromR8();
5807   test_VarUI4FromDate();
5808   test_VarUI4FromCy();
5809   test_VarUI4FromDec();
5810   test_VarUI4FromStr();
5811   test_VarUI4Copy();
5812   test_VarUI4ChangeTypeEx();
5813
5814   test_VarI8FromI1();
5815   test_VarI8FromUI1();
5816   test_VarI8FromI2();
5817   test_VarI8FromUI2();
5818   test_VarI8FromUI4();
5819   test_VarI8FromR4();
5820   test_VarI8FromR8();
5821   test_VarI8FromBool();
5822   test_VarI8FromUI8();
5823   test_VarI8FromCy();
5824   test_VarI8FromDec();
5825   test_VarI8FromDate();
5826   test_VarI8FromStr();
5827   test_VarI8Copy();
5828   test_VarI8ChangeTypeEx();
5829
5830   test_VarUI8FromI1();
5831   test_VarUI8FromUI1();
5832   test_VarUI8FromI2();
5833   test_VarUI8FromUI2();
5834   test_VarUI8FromUI4();
5835   test_VarUI8FromR4();
5836   test_VarUI8FromR8();
5837   test_VarUI8FromBool();
5838   test_VarUI8FromI8();
5839   test_VarUI8FromCy();
5840   test_VarUI8FromDec();
5841   test_VarUI8FromDate();
5842   test_VarUI8FromStr();
5843   test_VarUI8Copy();
5844   test_VarUI8ChangeTypeEx();
5845
5846   test_VarR4FromI1();
5847   test_VarR4FromUI1();
5848   test_VarR4FromI2();
5849   test_VarR4FromUI2();
5850   test_VarR4FromI4();
5851   test_VarR4FromUI4();
5852   test_VarR4FromR8();
5853   test_VarR4FromBool();
5854   test_VarR4FromCy();
5855   test_VarR4FromI8();
5856   test_VarR4FromUI8();
5857   test_VarR4FromDec();
5858   test_VarR4FromDate();
5859   test_VarR4FromStr();
5860   test_VarR4Copy();
5861   test_VarR4ChangeTypeEx();
5862
5863   test_VarR8FromI1();
5864   test_VarR8FromUI1();
5865   test_VarR8FromI2();
5866   test_VarR8FromUI2();
5867   test_VarR8FromI4();
5868   test_VarR8FromUI4();
5869   test_VarR8FromR4();
5870   test_VarR8FromBool();
5871   test_VarR8FromCy();
5872   test_VarR8FromI8();
5873   test_VarR8FromUI8();
5874   test_VarR8FromDec();
5875   test_VarR8FromDate();
5876   test_VarR8FromStr();
5877   test_VarR8Copy();
5878   test_VarR8ChangeTypeEx();
5879   test_VarR8Round();
5880
5881   test_VarDateFromI1();
5882   test_VarDateFromUI1();
5883   test_VarDateFromI2();
5884   test_VarDateFromUI2();
5885   test_VarDateFromI4();
5886   test_VarDateFromUI4();
5887   test_VarDateFromR4();
5888   test_VarDateFromR8();
5889   test_VarDateFromBool();
5890   test_VarDateFromCy();
5891   test_VarDateFromI8();
5892   test_VarDateFromUI8();
5893   test_VarDateFromDec();
5894   test_VarDateFromStr();
5895   test_VarDateCopy();
5896   test_VarDateChangeTypeEx();
5897
5898   test_VarCyFromI1();
5899   test_VarCyFromUI1();
5900   test_VarCyFromI2();
5901   test_VarCyFromUI2();
5902   test_VarCyFromI4();
5903   test_VarCyFromUI4();
5904   test_VarCyFromR4();
5905   test_VarCyFromR8();
5906   test_VarCyFromBool();
5907   test_VarCyFromI8();
5908   test_VarCyFromUI8();
5909   test_VarCyFromDec();
5910   test_VarCyFromDate();
5911
5912   test_VarCyAdd();
5913   test_VarCyMul();
5914   test_VarCySub();
5915   test_VarCyAbs();
5916   test_VarCyNeg();
5917   test_VarCyMulI4();
5918   test_VarCyMulI8();
5919   test_VarCyCmp();
5920   test_VarCyCmpR8();
5921   test_VarCyRound();
5922   test_VarCyFix();
5923   test_VarCyInt();
5924
5925   test_VarDecFromI1();
5926   test_VarDecFromI2();
5927   test_VarDecFromI4();
5928   test_VarDecFromI8();
5929   test_VarDecFromUI1();
5930   test_VarDecFromUI2();
5931   test_VarDecFromUI4();
5932   test_VarDecFromUI8();
5933   test_VarDecFromR4();
5934   test_VarDecFromR8();
5935   test_VarDecFromDate();
5936   test_VarDecFromStr();
5937   test_VarDecFromCy();
5938   test_VarDecFromDate();
5939   test_VarDecFromBool();
5940
5941   test_VarDecAbs();
5942   test_VarDecNeg();
5943   test_VarDecAdd();
5944   test_VarDecSub();
5945   test_VarDecCmp();
5946   test_VarDecMul();
5947   test_VarDecDiv();
5948
5949   test_VarBoolFromI1();
5950   test_VarBoolFromUI1();
5951   test_VarBoolFromI2();
5952   test_VarBoolFromUI2();
5953   test_VarBoolFromI4();
5954   test_VarBoolFromUI4();
5955   test_VarBoolFromR4();
5956   test_VarBoolFromR8();
5957   test_VarBoolFromCy();
5958   test_VarBoolFromI8();
5959   test_VarBoolFromUI8();
5960   test_VarBoolFromDec();
5961   test_VarBoolFromDate();
5962   test_VarBoolFromStr();
5963   test_VarBoolCopy();
5964   test_VarBoolChangeTypeEx();
5965
5966   test_VarCmp();
5967
5968   test_VarBstrFromR4();
5969   test_VarBstrFromDate();
5970   test_VarBstrFromDec();
5971   test_SysStringLen();
5972   test_SysStringByteLen();
5973   test_SysAllocString();
5974   test_SysAllocStringLen();
5975   test_SysAllocStringByteLen();
5976   test_SysReAllocString();
5977   test_SysReAllocStringLen();
5978   test_BstrCopy();
5979
5980   test_IUnknownClear();
5981   test_IUnknownCopy();
5982   test_IUnknownChangeTypeEx();
5983
5984   test_IDispatchClear();
5985   test_IDispatchCopy();
5986   test_IDispatchChangeTypeEx();
5987
5988   test_ErrorChangeTypeEx();
5989   test_EmptyChangeTypeEx();
5990   test_NullChangeTypeEx();
5991   test_UintChangeTypeEx();
5992
5993   test_ClearCustData();
5994
5995   test_NullByRef();
5996   test_ChangeType_keep_dst();
5997 }