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