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