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