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