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

   1 /*
   2  * VARIANT test program
   3  *
   4  * Copyright 1998 Jean-Claude Cote
   5  * Copyright 2006 Google (Benjamin Arai)
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <math.h>
  25 #include <float.h>
  26
  27 #define CONST_VTABLE
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winsock.h"
  32 #include "wine/test.h"
  33 #include "winuser.h"
  34 #include "wingdi.h"
  35 #include "winnls.h"
  36 #include "winerror.h"
  37 #include "winnt.h"
  38
  39 #include "wtypes.h"
  40 #include "oleauto.h"
  41
  42 static HMODULE hOleaut32;
  43
  44 static HRESULT (WINAPI *pVarUdateFromDate)(DATE,ULONG,UDATE*);
  45 static HRESULT (WINAPI *pVarDateFromUdate)(UDATE*,ULONG,DATE*);
  46 static INT (WINAPI *pSystemTimeToVariantTime)(LPSYSTEMTIME,double*);
  47 static INT (WINAPI *pVariantTimeToSystemTime)(double,LPSYSTEMTIME);
  48 static INT (WINAPI *pDosDateTimeToVariantTime)(USHORT,USHORT,double*);
  49 static INT (WINAPI *pVariantTimeToDosDateTime)(double,USHORT*,USHORT *);
  50
  51 static const WCHAR sz12[] = {'1','2','\0'};
  52 /* the strings are localized */
  53 static WCHAR sz12_false[32];
  54 static WCHAR sz12_true[32];
  55
  56 /* Get a conversion function ptr, return if function not available */
  57 #define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
  58   if (!p##func) { win_skip("function " # func " not available, not testing it\n"); return; }
  59
  60 /* Have IRecordInfo data type? */
  61 static int HAVE_OLEAUT32_RECORD = 0;
  62 /* Have I8/UI8 data type? */
  63 static int HAVE_OLEAUT32_I8 = 0;
  64 /* Is this an ancient version with support for only I2/I4/R4/R8/DATE? */
  65 static int IS_ANCIENT = 0;
  66
  67 /* When comparing floating point values we cannot expect an exact match
  68  * because the rounding errors depend on the exact algorithm.
  69  */
  70 #define EQ_DOUBLE(a,b)     (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-14)
  71 #define EQ_FLOAT(a,b)      (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-7)
  72
  73 #define SKIPTESTS(a)  if((a > VT_CLSID+10) && (a < VT_BSTR_BLOB-10)) continue
  74
  75 /* Allow our test macros to work for VT_NULL and VT_EMPTY too */
  76 #define V_EMPTY(v) V_I4(v)
  77 #define V_NULL(v) V_I4(v)
  78
  79 /* Size constraints for overflow tests */
  80 #define I1_MAX   0x7f
  81 #define I1_MIN   ((-I1_MAX)-1)
  82 #define UI1_MAX  0xff
  83 #define UI1_MIN  0
  84 #define I2_MAX   0x7fff
  85 #define I2_MIN   ((-I2_MAX)-1)
  86 #define UI2_MAX  0xffff
  87 #define UI2_MIN  0
  88 #define I4_MAX   0x7fffffff
  89 #define I4_MIN   ((-I4_MAX)-1)
  90 #define UI4_MAX  0xffffffff
  91 #define UI4_MIN  0
  92 #define I8_MAX   (((LONGLONG)I4_MAX << 32) | UI4_MAX)
  93 #define I8_MIN   ((-I8_MAX)-1)
  94 #define UI8_MAX  (((ULONGLONG)UI4_MAX << 32) | UI4_MAX)
  95 #define UI8_MIN  0
  96 #define DATE_MAX 2958465
  97 #define DATE_MIN -657434
  98 #define R4_MAX FLT_MAX
  99 #define R4_MIN FLT_MIN
 100 #define R8_MAX DBL_MAX
 101 #define R8_MIN DBL_MIN
 102
 103 static void init(void)
 104 {
 105     BSTR bstr;
 106     HRESULT res;
 107
 108     res = VarBstrFromBool(VARIANT_TRUE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
 109     ok(res == S_OK && (lstrlenW(bstr) > 0),
 110         "Expected localized string for 'True'\n");
 111     /* lstrcpyW / lstrcatW do not work on win95 */
 112     memcpy(sz12_true, sz12, sizeof(sz12));
 113     if (bstr) memcpy(&sz12_true[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
 114     SysFreeString(bstr);
 115
 116     res = VarBstrFromBool(VARIANT_FALSE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
 117     ok(res == S_OK && (lstrlenW(bstr) > 0),
 118         "Expected localized string for 'False'\n");
 119     memcpy(sz12_false, sz12, sizeof(sz12));
 120     if (bstr) memcpy(&sz12_false[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
 121     SysFreeString(bstr);
 122
 123     hOleaut32 = GetModuleHandle("oleaut32.dll");
 124
 125   /* Is a given function exported from oleaut32? */
 126 #define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
 127
 128   HAVE_OLEAUT32_I8 = HAVE_FUNC(VarI8FromI1);
 129   if (!HAVE_OLEAUT32_I8)
 130       skip("No support for I8 and UI8 data types\n");
 131
 132   HAVE_OLEAUT32_RECORD = HAVE_FUNC(SafeArraySetRecordInfo);
 133   IS_ANCIENT = (!HAVE_FUNC(VarI1FromI2));
 134
 135 #undef HAVE_FUNC
 136 }
 137
 138 /* Functions to set a DECIMAL */
 139 static void setdec(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG64 lo64)
 140 {
 141     S(U(*dec)).scale = scl;
 142     S(U(*dec)).sign = sgn;
 143     dec->Hi32 = hi32;
 144     U1(*dec).Lo64 = lo64;
 145 }
 146
 147 static void setdec64(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG mid32, ULONG lo32)
 148 {
 149     S(U(*dec)).scale = scl;
 150     S(U(*dec)).sign = sgn;
 151     dec->Hi32 = hi32;
 152     S1(U1(*dec)).Mid32 = mid32;
 153     S1(U1(*dec)).Lo32 = lo32;
 154 }
 155
 156 static inline int strcmpW( const WCHAR *str1, const WCHAR *str2 )
 157 {
 158     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 159     return *str1 - *str2;
 160 }
 161
 162 /* return the string text of a given variant type */
 163 static char vtstr_buffer[16][256];
 164 static int vtstr_current=0;
 165 static const char *vtstr(int x)
 166 {
 167     switch(x) {
 168 #define CASE(vt) case VT_##vt: return #vt
 169     CASE(EMPTY);
 170     CASE(NULL);
 171     CASE(I2);
 172     CASE(I4);
 173     CASE(R4);
 174     CASE(R8);
 175     CASE(CY);
 176     CASE(DATE);
 177     CASE(BSTR);
 178     CASE(DISPATCH);
 179     CASE(ERROR);
 180     CASE(BOOL);
 181     CASE(VARIANT);
 182     CASE(UNKNOWN);
 183     CASE(DECIMAL);
 184     CASE(I1);
 185     CASE(UI1);
 186     CASE(UI2);
 187     CASE(UI4);
 188     CASE(I8);
 189     CASE(UI8);
 190     CASE(INT);
 191     CASE(UINT);
 192     CASE(VOID);
 193     CASE(HRESULT);
 194     CASE(PTR);
 195     CASE(SAFEARRAY);
 196     CASE(CARRAY);
 197     CASE(USERDEFINED);
 198     CASE(LPSTR);
 199     CASE(LPWSTR);
 200     CASE(RECORD);
 201     CASE(INT_PTR);
 202     CASE(UINT_PTR);
 203     CASE(FILETIME);
 204     CASE(BLOB);
 205     CASE(STREAM);
 206     CASE(STORAGE);
 207     CASE(STREAMED_OBJECT);
 208     CASE(STORED_OBJECT);
 209     CASE(BLOB_OBJECT);
 210     CASE(CF);
 211     CASE(CLSID);
 212     CASE(VERSIONED_STREAM);
 213     CASE(VECTOR);
 214     CASE(ARRAY);
 215     CASE(BYREF);
 216     CASE(RESERVED);
 217     CASE(ILLEGAL);
 218 #undef CASE
 219
 220     case 0xfff:
 221         return "VT_BSTR_BLOB/VT_ILLEGALMASKED/VT_TYPEMASK";
 222
 223     default:
 224         vtstr_current %= sizeof(vtstr_buffer)/sizeof(*vtstr_buffer);
 225         sprintf(vtstr_buffer[vtstr_current], "unknown variant type %d", x);
 226         return vtstr_buffer[vtstr_current++];
 227     }
 228 }
 229
 230 static const char *variantstr( const VARIANT *var )
 231 {
 232     vtstr_current %= sizeof(vtstr_buffer)/sizeof(*vtstr_buffer);
 233     switch(V_VT(var))
 234     {
 235     case VT_I1:
 236         sprintf( vtstr_buffer[vtstr_current], "VT_I1(%d)", V_I1(var) ); break;
 237     case VT_I2:
 238         sprintf( vtstr_buffer[vtstr_current], "VT_I2(%d)", V_I2(var) ); break;
 239     case VT_I4:
 240         sprintf( vtstr_buffer[vtstr_current], "VT_I4(%d)", V_I4(var) ); break;
 241     case VT_INT:
 242         sprintf( vtstr_buffer[vtstr_current], "VT_INT(%d)", V_INT(var) ); break;
 243     case VT_I8:
 244         sprintf( vtstr_buffer[vtstr_current], "VT_I8(%x%08x)", (UINT)(V_I8(var) >> 32), (UINT)V_I8(var) ); break;
 245     case VT_UI8:
 246         sprintf( vtstr_buffer[vtstr_current], "VT_UI8(%x%08x)", (UINT)(V_UI8(var) >> 32), (UINT)V_UI8(var) ); break;
 247     case VT_R4:
 248         sprintf( vtstr_buffer[vtstr_current], "VT_R4(%g)", V_R4(var) ); break;
 249     case VT_R8:
 250         sprintf( vtstr_buffer[vtstr_current], "VT_R8(%g)", V_R8(var) ); break;
 251     case VT_UI1:
 252         sprintf( vtstr_buffer[vtstr_current], "VT_UI1(%u)", V_UI1(var) ); break;
 253     case VT_UI2:
 254         sprintf( vtstr_buffer[vtstr_current], "VT_UI2(%u)", V_UI2(var) ); break;
 255     case VT_UI4:
 256         sprintf( vtstr_buffer[vtstr_current], "VT_UI4(%u)", V_UI4(var) ); break;
 257     case VT_UINT:
 258         sprintf( vtstr_buffer[vtstr_current], "VT_UINT(%d)", V_UINT(var) ); break;
 259     case VT_CY:
 260         sprintf( vtstr_buffer[vtstr_current], "VT_CY(%x%08x)", S(V_CY(var)).Hi, S(V_CY(var)).Lo ); break;
 261     case VT_DATE:
 262         sprintf( vtstr_buffer[vtstr_current], "VT_DATE(%g)", V_DATE(var) ); break;
 263     default:
 264         return vtstr(V_VT(var));
 265     }
 266     return vtstr_buffer[vtstr_current++];
 267 }
 268
 269 static BOOL is_expected_variant( const VARIANT *result, const VARIANT *expected )
 270 {
 271     if (V_VT(result) != V_VT(expected)) return FALSE;
 272     switch(V_VT(expected))
 273     {
 274     case VT_EMPTY:
 275     case VT_NULL:
 276         return TRUE;
 277
 278 #define CASE(vt) case VT_##vt: return (V_##vt(result) == V_##vt(expected))
 279     CASE(BOOL);
 280     CASE(I1);
 281     CASE(UI1);
 282     CASE(I2);
 283     CASE(UI2);
 284     CASE(I4);
 285     CASE(UI4);
 286     CASE(I8);
 287     CASE(UI8);
 288     CASE(INT);
 289     CASE(UINT);
 290 #undef CASE
 291
 292     case VT_DATE:
 293         return EQ_FLOAT(V_DATE(result), V_DATE(expected));
 294     case VT_R4:
 295         return EQ_FLOAT(V_R4(result), V_R4(expected));
 296     case VT_R8:
 297         return EQ_FLOAT(V_R8(result), V_R8(expected));
 298     case VT_CY:
 299         return (V_CY(result).int64 == V_CY(expected).int64);
 300     case VT_BSTR:
 301         return !lstrcmpW( V_BSTR(result), V_BSTR(expected) );
 302     case VT_DECIMAL:
 303         return !memcmp( &V_DECIMAL(result), &V_DECIMAL(expected), sizeof(DECIMAL) );
 304     default:
 305         ok(0, "unhandled variant type %s\n",vtstr(V_VT(expected)));
 306         return 0;
 307     }
 308 }
 309
 310 static void test_var_call1( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT),
 311                            VARIANT *arg, VARIANT *expected )
 312 {
 313     VARIANT old_arg = *arg;
 314     VARIANT result;
 315     HRESULT hres;
 316
 317     memset( &result, 0, sizeof(result) );
 318     hres = func( arg, &result );
 319     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
 320     if (hres == S_OK)
 321         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
 322                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
 323     ok_(__FILE__,line)( is_expected_variant( arg, &old_arg ), "Modified argument %s / %s\n",
 324                         variantstr(&old_arg), variantstr(arg));
 325     VariantClear( &result );
 326 }
 327
 328 static void test_var_call2( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT,LPVARIANT),
 329                             VARIANT *left, VARIANT *right, VARIANT *expected )
 330 {
 331     VARIANT old_left = *left, old_right = *right;
 332     VARIANT result;
 333     HRESULT hres;
 334
 335     memset( &result, 0, sizeof(result) );
 336     hres = func( left, right, &result );
 337     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
 338     if (hres == S_OK)
 339         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
 340                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
 341     ok_(__FILE__,line)( is_expected_variant( left, &old_left ), "Modified left argument %s / %s\n",
 342                         variantstr(&old_left), variantstr(left));
 343     ok_(__FILE__,line)( is_expected_variant( right, &old_right ), "Modified right argument %s / %s\n",
 344                         variantstr(&old_right), variantstr(right));
 345     VariantClear( &result );
 346 }
 347
 348 static int strcmp_wa(const WCHAR *strw, const char *stra)
 349 {
 350     WCHAR buf[512];
 351     MultiByteToWideChar(CP_ACP, 0, stra, -1, buf, sizeof(buf)/sizeof(buf[0]));
 352     return lstrcmpW(strw, buf);
 353 }
 354
 355 #define test_bstr_var(a,b) _test_bstr_var(__LINE__,a,b)
 356 static void _test_bstr_var(unsigned line, const VARIANT *v, const char *str)
 357 {
 358     ok_(__FILE__,line)(V_VT(v) == VT_BSTR, "unexpected vt=%d\n", V_VT(v));
 359     if(V_VT(v) == VT_BSTR)
 360         ok(!strcmp_wa(V_BSTR(v), str), "v=%s, expected %s\n", wine_dbgstr_w(V_BSTR(v)), str);
 361 }
 362
 363 static void test_VariantInit(void)
 364 {
 365   VARIANTARG v1, v2;
 366
 367   /* Test that VariantInit() only sets the type */
 368   memset(&v1, -1, sizeof(v1));
 369   v2 = v1;
 370   V_VT(&v2) = VT_EMPTY;
 371   VariantInit(&v1);
 372   ok(!memcmp(&v1, &v2, sizeof(v1)), "VariantInit() set extra fields\n");
 373 }
 374
 375 /* All possible combinations of extra V_VT() flags */
 376 static const VARTYPE ExtraFlags[16] =
 377 {
 378   0,
 379   VT_VECTOR,
 380   VT_ARRAY,
 381   VT_BYREF,
 382   VT_RESERVED,
 383   VT_VECTOR|VT_ARRAY,
 384   VT_VECTOR|VT_BYREF,
 385   VT_VECTOR|VT_RESERVED,
 386   VT_VECTOR|VT_ARRAY|VT_BYREF,
 387   VT_VECTOR|VT_ARRAY|VT_RESERVED,
 388   VT_VECTOR|VT_BYREF|VT_RESERVED,
 389   VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED,
 390   VT_ARRAY|VT_BYREF,
 391   VT_ARRAY|VT_RESERVED,
 392   VT_ARRAY|VT_BYREF|VT_RESERVED,
 393   VT_BYREF|VT_RESERVED,
 394 };
 395
 396 /* Determine if a vt is valid for VariantClear() */
 397 static int IsValidVariantClearVT(VARTYPE vt, VARTYPE extraFlags)
 398 {
 399   int ret = 0;
 400
 401   /* Only the following flags/types are valid */
 402   if ((vt <= VT_LPWSTR || vt == VT_RECORD || vt == VT_CLSID) &&
 403       vt != (VARTYPE)15 &&
 404       (vt < (VARTYPE)24 || vt > (VARTYPE)31) &&
 405       (!(extraFlags & (VT_BYREF|VT_ARRAY)) || vt > VT_NULL) &&
 406       (extraFlags == 0 || extraFlags == VT_BYREF || extraFlags == VT_ARRAY ||
 407        extraFlags == (VT_ARRAY|VT_BYREF)))
 408     ret = 1; /* ok */
 409
 410   if ((vt == VT_RECORD && !HAVE_OLEAUT32_RECORD) ||
 411       ((vt == VT_I8 || vt == VT_UI8) && !HAVE_OLEAUT32_I8))
 412     ret = 0; /* Old versions of oleaut32 */
 413   return ret;
 414 }
 415
 416 typedef struct
 417 {
 418     IUnknown IUnknown_iface;
 419     LONG     ref;
 420     LONG     events;
 421 } test_VariantClearImpl;
 422
 423 static inline test_VariantClearImpl *impl_from_IUnknown(IUnknown *iface)
 424 {
 425     return CONTAINING_RECORD(iface, test_VariantClearImpl, IUnknown_iface);
 426 }
 427
 428 static HRESULT WINAPI VC_QueryInterface(LPUNKNOWN iface,REFIID riid,LPVOID *ppobj)
 429 {
 430     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 431     This->events |= 0x1;
 432     return E_NOINTERFACE;
 433 }
 434
 435 static ULONG WINAPI VC_AddRef(LPUNKNOWN iface) {
 436     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 437     This->events |= 0x2;
 438     return InterlockedIncrement(&This->ref);
 439 }
 440
 441 static ULONG WINAPI VC_Release(LPUNKNOWN iface) {
 442     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 443     /* static class, won't be  freed */
 444     This->events |= 0x4;
 445     return InterlockedDecrement(&This->ref);
 446 }
 447
 448 static const IUnknownVtbl test_VariantClear_vtbl = {
 449     VC_QueryInterface,
 450     VC_AddRef,
 451     VC_Release,
 452 };
 453
 454 static test_VariantClearImpl test_myVariantClearImpl = {{&test_VariantClear_vtbl}, 1, 0};
 455
 456 static void test_VariantClear(void)
 457 {
 458   HRESULT hres;
 459   VARIANTARG v;
 460   VARIANT v2;
 461   size_t i;
 462   LONG i4;
 463   IUnknown *punk;
 464
 465   /* Crashes: Native does not test input for NULL, so neither does Wine */
 466   if (0)
 467       VariantClear(NULL);
 468
 469   /* Only the type field is set, to VT_EMPTY */
 470   V_VT(&v) = VT_UI4;
 471   V_UI4(&v) = ~0u;
 472   hres = VariantClear(&v);
 473   ok((hres == S_OK && V_VT(&v) == VT_EMPTY) ||
 474      (IS_ANCIENT && hres == DISP_E_BADVARTYPE && V_VT(&v) == VT_UI4),
 475      "VariantClear: Type set to %d, res %08x\n", V_VT(&v), hres);
 476   ok(V_UI4(&v) == ~0u, "VariantClear: Overwrote value\n");
 477
 478   /* Test all possible V_VT values.
 479    * Also demonstrates that null pointers in 'v' are not dereferenced.
 480    * Individual variant tests should test VariantClear() with non-NULL values.
 481    */
 482   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 483   {
 484     VARTYPE vt;
 485
 486     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 487     {
 488       HRESULT hExpected = DISP_E_BADVARTYPE;
 489
 490       SKIPTESTS(vt);
 491
 492       memset(&v, 0, sizeof(v));
 493       V_VT(&v) = vt | ExtraFlags[i];
 494
 495       hres = VariantClear(&v);
 496
 497       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 498         hExpected = S_OK;
 499
 500       ok(hres == hExpected, "VariantClear: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
 501          hExpected, hres, vt, ExtraFlags[i]);
 502     }
 503   }
 504
 505   /* Some BYREF tests with non-NULL ptrs */
 506
 507   /* VARIANT BYREF */
 508   V_VT(&v2) = VT_I4;
 509   V_I4(&v2) = 0x1234;
 510   V_VT(&v) = VT_VARIANT | VT_BYREF;
 511   V_VARIANTREF(&v) = &v2;
 512
 513   hres = VariantClear(&v);
 514   ok(hres == S_OK, "ret %08x\n", hres);
 515   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 516   ok(V_VARIANTREF(&v) == &v2, "variant ref %p\n", V_VARIANTREF(&v2));
 517   ok(V_VT(&v2) == VT_I4, "vt %04x\n", V_VT(&v2));
 518   ok(V_I4(&v2) == 0x1234, "i4 %04x\n", V_I4(&v2));
 519
 520   /* I4 BYREF */
 521   i4 = 0x4321;
 522   V_VT(&v) = VT_I4 | VT_BYREF;
 523   V_I4REF(&v) = &i4;
 524
 525   hres = VariantClear(&v);
 526   ok(hres == S_OK, "ret %08x\n", hres);
 527   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 528   ok(V_I4REF(&v) == &i4, "i4 ref %p\n", V_I4REF(&v2));
 529   ok(i4 == 0x4321, "i4 changed %08x\n", i4);
 530
 531
 532   /* UNKNOWN */
 533   V_VT(&v) = VT_UNKNOWN;
 534   V_UNKNOWN(&v) = &test_myVariantClearImpl.IUnknown_iface;
 535   test_myVariantClearImpl.events = 0;
 536   hres = VariantClear(&v);
 537   ok(hres == S_OK, "ret %08x\n", hres);
 538   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 539   ok(V_UNKNOWN(&v) == &test_myVariantClearImpl.IUnknown_iface, "unknown %p\n", V_UNKNOWN(&v));
 540   /* Check that Release got called, but nothing else */
 541   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 542
 543   /* UNKNOWN BYREF */
 544   punk = &test_myVariantClearImpl.IUnknown_iface;
 545   V_VT(&v) = VT_UNKNOWN | VT_BYREF;
 546   V_UNKNOWNREF(&v) = &punk;
 547   test_myVariantClearImpl.events = 0;
 548   hres = VariantClear(&v);
 549   ok(hres == S_OK, "ret %08x\n", hres);
 550   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 551   ok(V_UNKNOWNREF(&v) == &punk, "unknown ref %p\n", V_UNKNOWNREF(&v));
 552   /* Check that nothing got called */
 553   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 554
 555   /* DISPATCH */
 556   V_VT(&v) = VT_DISPATCH;
 557   V_DISPATCH(&v) = (IDispatch*)&test_myVariantClearImpl;
 558   test_myVariantClearImpl.events = 0;
 559   hres = VariantClear(&v);
 560   ok(hres == S_OK, "ret %08x\n", hres);
 561   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 562   ok(V_DISPATCH(&v) == (IDispatch*)&test_myVariantClearImpl, "dispatch %p\n", V_DISPATCH(&v));
 563   /* Check that Release got called, but nothing else */
 564   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 565
 566   /* DISPATCH BYREF */
 567   punk = &test_myVariantClearImpl.IUnknown_iface;
 568   V_VT(&v) = VT_DISPATCH | VT_BYREF;
 569   V_DISPATCHREF(&v) = (IDispatch**)&punk;
 570   test_myVariantClearImpl.events = 0;
 571   hres = VariantClear(&v);
 572   ok(hres == S_OK, "ret %08x\n", hres);
 573   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 574   ok(V_DISPATCHREF(&v) == (IDispatch**)&punk, "dispatch ref %p\n", V_DISPATCHREF(&v));
 575   /* Check that nothing got called */
 576   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 577 }
 578
 579 static void test_VariantCopy(void)
 580 {
 581   VARIANTARG vSrc, vDst;
 582   VARTYPE vt;
 583   size_t i;
 584   HRESULT hres, hExpected;
 585
 586   /* Establish that the failure/other cases are dealt with. Individual tests
 587    * for each type should verify that data is copied correctly, references
 588    * are updated, etc.
 589    */
 590
 591   /* vSrc == vDst */
 592   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 593   {
 594     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 595     {
 596       SKIPTESTS(vt);
 597
 598       memset(&vSrc, 0, sizeof(vSrc));
 599       V_VT(&vSrc) = vt | ExtraFlags[i];
 600
 601       hExpected = DISP_E_BADVARTYPE;
 602       /* src is allowed to be a VT_CLSID */
 603       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 604         hExpected = S_OK;
 605
 606       hres = VariantCopy(&vSrc, &vSrc);
 607
 608       ok(hres == hExpected,
 609          "Copy(src==dst): expected 0x%X, got 0x%X for src==dest vt %d|0x%X\n",
 610          hExpected, hres, vt, ExtraFlags[i]);
 611     }
 612   }
 613
 614   /* Test that if VariantClear() fails on dest, the function fails. This also
 615    * shows that dest is in fact cleared and not just overwritten
 616    */
 617   memset(&vSrc, 0, sizeof(vSrc));
 618   V_VT(&vSrc) = VT_UI1;
 619
 620   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 621   {
 622     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 623     {
 624       SKIPTESTS(vt);
 625
 626       hExpected = DISP_E_BADVARTYPE;
 627
 628       memset(&vDst, 0, sizeof(vDst));
 629       V_VT(&vDst) = vt | ExtraFlags[i];
 630
 631       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 632         hExpected = S_OK;
 633
 634       hres = VariantCopy(&vDst, &vSrc);
 635
 636       ok(hres == hExpected,
 637          "Copy(bad dst): expected 0x%X, got 0x%X for dest vt %d|0x%X\n",
 638          hExpected, hres, vt, ExtraFlags[i]);
 639       if (hres == S_OK)
 640         ok(V_VT(&vDst) == VT_UI1,
 641            "Copy(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 642     }
 643   }
 644
 645   /* Test that VariantClear() checks vSrc for validity before copying */
 646   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 647   {
 648     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 649     {
 650       SKIPTESTS(vt);
 651
 652       hExpected = DISP_E_BADVARTYPE;
 653
 654       memset(&vDst, 0, sizeof(vDst));
 655       V_VT(&vDst) = VT_EMPTY;
 656
 657       memset(&vSrc, 0, sizeof(vSrc));
 658       V_VT(&vSrc) = vt | ExtraFlags[i];
 659
 660       /* src is allowed to be a VT_CLSID */
 661       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 662         hExpected = S_OK;
 663
 664       hres = VariantCopy(&vDst, &vSrc);
 665
 666       ok(hres == hExpected,
 667          "Copy(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
 668          hExpected, hres, vt, ExtraFlags[i]);
 669       if (hres == S_OK)
 670       {
 671         ok(V_VT(&vDst) == (vt|ExtraFlags[i]),
 672            "Copy(bad src): expected vt = %d, got %d\n",
 673            vt | ExtraFlags[i], V_VT(&vDst));
 674         VariantClear(&vDst);
 675       }
 676     }
 677   }
 678
 679   /* Test that copying a NULL BSTR results in an empty BSTR */
 680   memset(&vDst, 0, sizeof(vDst));
 681   V_VT(&vDst) = VT_EMPTY;
 682   memset(&vSrc, 0, sizeof(vSrc));
 683   V_VT(&vSrc) = VT_BSTR;
 684   hres = VariantCopy(&vDst, &vSrc);
 685   ok(hres == S_OK, "Copy(NULL BSTR): Failed to copy a NULL BSTR\n");
 686   if (hres == S_OK)
 687   {
 688     ok((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst),
 689        "Copy(NULL BSTR): should have non-NULL result\n");
 690     if ((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst))
 691     {
 692       ok(*V_BSTR(&vDst) == 0, "Copy(NULL BSTR): result not empty\n");
 693     }
 694     VariantClear(&vDst);
 695   }
 696 }
 697
 698 /* Determine if a vt is valid for VariantCopyInd() */
 699 static int IsValidVariantCopyIndVT(VARTYPE vt, VARTYPE extraFlags)
 700 {
 701   int ret = 0;
 702
 703   if ((extraFlags & VT_ARRAY) ||
 704      (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
 705      !(extraFlags & (VT_VECTOR|VT_RESERVED))))
 706   {
 707     ret = 1; /* ok */
 708   }
 709   return ret;
 710 }
 711
 712 static void test_VariantCopyInd(void)
 713 {
 714   VARIANTARG vSrc, vDst, vRef, vRef2;
 715   VARTYPE vt;
 716   size_t i;
 717   BYTE buffer[64];
 718   HRESULT hres, hExpected;
 719
 720   memset(buffer, 0, sizeof(buffer));
 721
 722   /* vSrc == vDst */
 723   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 724   {
 725     if (ExtraFlags[i] & VT_ARRAY)
 726       continue; /* Native crashes on NULL safearray */
 727
 728     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 729     {
 730       SKIPTESTS(vt);
 731
 732       memset(&vSrc, 0, sizeof(vSrc));
 733       V_VT(&vSrc) = vt | ExtraFlags[i];
 734
 735       hExpected = DISP_E_BADVARTYPE;
 736       if (!(ExtraFlags[i] & VT_BYREF))
 737       {
 738         /* if src is not by-reference, acts as VariantCopy() */
 739         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 740           hExpected = S_OK;
 741       }
 742       else
 743       {
 744         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 745             vt == VT_DISPATCH || vt == VT_RECORD)
 746           continue; /* Need valid ptrs for deep copies */
 747
 748         V_BYREF(&vSrc) = &buffer;
 749         hExpected = E_INVALIDARG;
 750
 751         if ((vt == VT_I8 || vt == VT_UI8) &&
 752             ExtraFlags[i] == VT_BYREF)
 753         {
 754           if (HAVE_OLEAUT32_I8)
 755             hExpected = S_OK; /* Only valid if I8 is a known type */
 756         }
 757         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 758           hExpected = S_OK;
 759       }
 760
 761       hres = VariantCopyInd(&vSrc, &vSrc);
 762
 763       ok(hres == hExpected,
 764          "CopyInd(src==dst): expected 0x%X, got 0x%X for src==dst vt %d|0x%X\n",
 765          hExpected, hres, vt, ExtraFlags[i]);
 766     }
 767   }
 768
 769   /* Bad dest */
 770   memset(&vSrc, 0, sizeof(vSrc));
 771   V_VT(&vSrc) = VT_UI1|VT_BYREF;
 772   V_BYREF(&vSrc) = &buffer;
 773
 774   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 775   {
 776     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 777     {
 778       SKIPTESTS(vt);
 779
 780       memset(&vDst, 0, sizeof(vDst));
 781       V_VT(&vDst) = vt | ExtraFlags[i];
 782
 783       hExpected = DISP_E_BADVARTYPE;
 784
 785       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 786         hExpected = S_OK;
 787
 788       hres = VariantCopyInd(&vDst, &vSrc);
 789
 790       ok(hres == hExpected,
 791          "CopyInd(bad dst): expected 0x%X, got 0x%X for dst vt %d|0x%X\n",
 792          hExpected, hres, vt, ExtraFlags[i]);
 793       if (hres == S_OK)
 794         ok(V_VT(&vDst) == VT_UI1,
 795            "CopyInd(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 796     }
 797   }
 798
 799   /* bad src */
 800   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 801   {
 802     if (ExtraFlags[i] & VT_ARRAY)
 803       continue; /* Native crashes on NULL safearray */
 804
 805     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 806     {
 807       SKIPTESTS(vt);
 808
 809       memset(&vDst, 0, sizeof(vDst));
 810       V_VT(&vDst) = VT_EMPTY;
 811
 812       memset(&vSrc, 0, sizeof(vSrc));
 813       V_VT(&vSrc) = vt | ExtraFlags[i];
 814
 815       hExpected = DISP_E_BADVARTYPE;
 816       if (!(ExtraFlags[i] & VT_BYREF))
 817       {
 818         /* if src is not by-reference, acts as VariantCopy() */
 819         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 820           hExpected = S_OK;
 821       }
 822       else
 823       {
 824         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 825             vt == VT_DISPATCH || vt == VT_RECORD)
 826           continue; /* Need valid ptrs for deep copies, see vartype.c */
 827
 828         V_BYREF(&vSrc) = &buffer;
 829
 830         hExpected = E_INVALIDARG;
 831
 832         if ((vt == VT_I8 || vt == VT_UI8) &&
 833             ExtraFlags[i] == VT_BYREF)
 834         {
 835           if (HAVE_OLEAUT32_I8)
 836             hExpected = S_OK; /* Only valid if I8 is a known type */
 837         }
 838         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 839           hExpected = S_OK;
 840       }
 841
 842       hres = VariantCopyInd(&vDst, &vSrc);
 843
 844       ok(hres == hExpected,
 845          "CopyInd(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
 846          hExpected, hres, vt, ExtraFlags[i]);
 847       if (hres == S_OK)
 848       {
 849         if (vt == VT_VARIANT && ExtraFlags[i] == VT_BYREF)
 850         {
 851           /* Type of vDst should be the type of the referenced variant.
 852            * Since we set the buffer to all zeros, its type should be
 853            * VT_EMPTY.
 854            */
 855           ok(V_VT(&vDst) == VT_EMPTY,
 856              "CopyInd(bad src): expected dst vt = VT_EMPTY, got %d|0x%X\n",
 857              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 858         }
 859         else
 860         {
 861           ok(V_VT(&vDst) == (vt|(ExtraFlags[i] & ~VT_BYREF)),
 862              "CopyInd(bad src): expected dst vt = %d|0x%X, got %d|0x%X\n",
 863              vt, ExtraFlags[i] & ~VT_BYREF,
 864              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 865         }
 866         VariantClear(&vDst);
 867       }
 868     }
 869   }
 870
 871   /* By-reference variants are dereferenced */
 872   V_VT(&vRef) = VT_UI1;
 873   V_UI1(&vRef) = 0x77;
 874   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 875   V_VARIANTREF(&vSrc) = &vRef;
 876   VariantInit(&vDst);
 877
 878   hres = VariantCopyInd(&vDst, &vSrc);
 879   ok(hres == S_OK, "VariantCopyInd failed: 0x%08x\n", hres);
 880   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x77,
 881      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 882       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 883
 884   /* By-reference variant to a by-reference type succeeds */
 885   V_VT(&vRef) = VT_UI1|VT_BYREF;
 886   V_UI1REF(&vRef) = buffer; buffer[0] = 0x88;
 887   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 888   V_VARIANTREF(&vSrc) = &vRef;
 889   VariantInit(&vDst);
 890
 891   hres = VariantCopyInd(&vDst, &vSrc);
 892   ok(hres == S_OK, "VariantCopyInd failed: 0x%08x\n", hres);
 893   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x88,
 894      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 895       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 896
 897   /* But a by-reference variant to a by-reference variant fails */
 898   V_VT(&vRef2) = VT_UI1;
 899   V_UI1(&vRef2) = 0x77;
 900   V_VT(&vRef) = VT_VARIANT|VT_BYREF;
 901   V_VARIANTREF(&vRef) = &vRef2;
 902   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 903   V_VARIANTREF(&vSrc) = &vRef;
 904   VariantInit(&vDst);
 905
 906   hres = VariantCopyInd(&vDst, &vSrc);
 907   ok(hres == E_INVALIDARG,
 908      "CopyInd(ref->ref): expected E_INVALIDARG, got 0x%08x\n", hres);
 909 }
 910
 911 static HRESULT (WINAPI *pVarParseNumFromStr)(OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
 912
 913 /* Macros for converting and testing the result of VarParseNumFromStr */
 914 #define FAILDIG 255
 915
 916 static HRESULT convert_str( const char *str, INT dig, ULONG flags,
 917                             NUMPARSE *np, BYTE rgb[128], LCID lcid )
 918 {
 919     OLECHAR buff[128];
 920     MultiByteToWideChar( CP_ACP,0, str, -1, buff, sizeof(buff)/sizeof(WCHAR) );
 921     memset( rgb, FAILDIG, 128 );
 922     memset( np, 255, sizeof(*np) );
 923     np->cDig = dig;
 924     np->dwInFlags = flags;
 925     return pVarParseNumFromStr( buff, lcid, LOCALE_NOUSEROVERRIDE, np, rgb);
 926 }
 927
 928 static void expect_NumFromStr( int line, HRESULT hres, NUMPARSE *np, INT a, ULONG b, ULONG c,
 929                                INT d, INT e, INT f )
 930 {
 931     if (hres == (HRESULT)S_OK)
 932     {
 933         ok_(__FILE__,line)(np->cDig == a, "Expected cDig = %d, got %d\n", a, np->cDig);
 934         ok_(__FILE__,line)(np->dwInFlags == b, "Expected dwInFlags = 0x%x, got 0x%x\n", b, np->dwInFlags);
 935         ok_(__FILE__,line)(np->dwOutFlags == c, "Expected dwOutFlags = 0x%x, got 0x%x\n", c, np->dwOutFlags);
 936         ok_(__FILE__,line)(np->cchUsed == d, "Expected cchUsed = %d, got %d\n", d, np->cchUsed);
 937         ok_(__FILE__,line)(np->nBaseShift == e, "Expected nBaseShift = %d, got %d\n", e, np->nBaseShift);
 938         ok_(__FILE__,line)(np->nPwr10 == f, "Expected nPwr10 = %d, got %d\n", f, np->nPwr10);
 939     }
 940 }
 941
 942 #define CONVERTN(str,dig,flags) hres = convert_str( str, dig, flags, &np, rgb, lcid )
 943 #define CONVERT(str,flags) CONVERTN(str,sizeof(rgb),flags)
 944 #define EXPECT(a,b,c,d,e,f) expect_NumFromStr( __LINE__, hres, &np, a, b, c, d, e, f )
 945 #define EXPECTRGB(a,b) ok(rgb[a] == b, "Digit[%d], expected %d, got %d\n", a, b, rgb[a])
 946 #define EXPECTFAIL ok(hres == (HRESULT)DISP_E_TYPEMISMATCH, "Call succeeded, hres = %08x\n", hres)
 947 #define EXPECT2(a,b) EXPECTRGB(0,a); EXPECTRGB(1,b)
 948
 949 static void test_VarParseNumFromStr(void)
 950 {
 951   HRESULT hres;
 952   /* Ensure all tests are using the same locale characters for '$', ',' etc */
 953   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
 954   NUMPARSE np;
 955   BYTE rgb[128];
 956
 957   /** No flags **/
 958
 959   CHECKPTR(VarParseNumFromStr);
 960
 961   /* Consume a single digit */
 962   CONVERT("7", 0);
 963   EXPECT(1,0,0,1,0,0);
 964   EXPECT2(7,FAILDIG);
 965
 966   /* cDig is not literal digits - zeros are suppressed and nPwr10 is increased */
 967   CONVERT("10", 0);
 968   EXPECT(1,0,0,2,0,1);
 969   /* Note: Win32 writes the trailing zeros if they are within cDig's limits,
 970    * but then excludes them from the returned cDig count.
 971    * In our implementation we don't bother writing them at all.
 972    */
 973   EXPECTRGB(0, 1);
 974
 975   /* if cDig is too small and numbers follow, sets INEXACT */
 976   CONVERTN("11",1, 0);
 977   EXPECT(1,0,NUMPRS_INEXACT,2,0,1);
 978   EXPECT2(1,FAILDIG);
 979
 980   /* Strips leading zeros */
 981   CONVERT("01", 0);
 982   EXPECT(1,0,0,2,0,0);
 983   EXPECT2(1,FAILDIG);
 984
 985   /* Strips leading zeros */
 986   CONVERTN("01",1, 0);
 987   EXPECT(1,0,0,2,0,0);
 988   EXPECT2(1,FAILDIG);
 989
 990
 991   /* Fails on non digits */
 992   CONVERT("a", 0);
 993   EXPECTFAIL;
 994   EXPECTRGB(0,FAILDIG);
 995
 996   /** NUMPRS_LEADING_WHITE/NUMPRS_TRAILING_WHITE **/
 997
 998   /* Without flag, fails on whitespace */
 999   CONVERT(" 0", 0);
1000   EXPECTFAIL;
1001   EXPECTRGB(0,FAILDIG);
1002
1003
1004   /* With flag, consumes whitespace */
1005   CONVERT(" 0", NUMPRS_LEADING_WHITE);
1006   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1007   EXPECT2(0,FAILDIG);
1008
1009   /* Test TAB once, then assume it acts as space for all cases */
1010   CONVERT("\t0", NUMPRS_LEADING_WHITE);
1011   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1012   EXPECT2(0,FAILDIG);
1013
1014
1015   /* Doesn't pick up trailing whitespace without flag */
1016   CONVERT("0 ", 0);
1017   EXPECT(1,0,0,1,0,0);
1018   EXPECT2(0,FAILDIG);
1019
1020   /* With flag, consumes trailing whitespace */
1021   CONVERT("0 ", NUMPRS_TRAILING_WHITE);
1022   EXPECT(1,NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1023   EXPECT2(0,FAILDIG);
1024
1025   /* Leading flag only consumes leading */
1026   CONVERT(" 0 ", NUMPRS_LEADING_WHITE);
1027   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1028   EXPECT2(0,FAILDIG);
1029
1030   /* Both flags consumes both */
1031   CONVERT(" 0 ", NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE);
1032   EXPECT(1,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,3,0,0);
1033   EXPECT2(0,FAILDIG);
1034
1035   /** NUMPRS_LEADING_PLUS/NUMPRS_TRAILING_PLUS **/
1036
1037   /* Without flag, fails on + */
1038   CONVERT("+0", 0);
1039   EXPECTFAIL;
1040   EXPECTRGB(0,FAILDIG);
1041
1042   /* With flag, consumes + */
1043   CONVERT("+0", NUMPRS_LEADING_PLUS);
1044   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1045   EXPECT2(0,FAILDIG);
1046
1047   /* Without flag, doesn't consume trailing + */
1048   CONVERT("0+", 0);
1049   EXPECT(1,0,0,1,0,0);
1050   EXPECT2(0,FAILDIG);
1051
1052   /* With flag, consumes trailing + */
1053   CONVERT("0+", NUMPRS_TRAILING_PLUS);
1054   EXPECT(1,NUMPRS_TRAILING_PLUS,NUMPRS_TRAILING_PLUS,2,0,0);
1055   EXPECT2(0,FAILDIG);
1056
1057   /* With leading flag, doesn't consume trailing + */
1058   CONVERT("+0+", NUMPRS_LEADING_PLUS);
1059   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1060   EXPECT2(0,FAILDIG);
1061
1062   /* Trailing + doesn't get consumed if we specify both (unlike whitespace) */
1063   CONVERT("+0+", NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS);
1064   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1065   EXPECT2(0,FAILDIG);
1066
1067   /** NUMPRS_LEADING_MINUS/NUMPRS_TRAILING_MINUS **/
1068
1069   /* Without flag, fails on - */
1070   CONVERT("-0", 0);
1071   EXPECTFAIL;
1072   EXPECTRGB(0,FAILDIG);
1073
1074   /* With flag, consumes - */
1075   CONVERT("-0", NUMPRS_LEADING_MINUS);
1076   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1077   EXPECT2(0,FAILDIG);
1078
1079   /* Without flag, doesn't consume trailing - */
1080   CONVERT("0-", 0);
1081   EXPECT(1,0,0,1,0,0);
1082   EXPECT2(0,FAILDIG);
1083
1084   /* With flag, consumes trailing - */
1085   CONVERT("0-", NUMPRS_TRAILING_MINUS);
1086   EXPECT(1,NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_TRAILING_MINUS,2,0,0);
1087   EXPECT2(0,FAILDIG);
1088
1089   /* With leading flag, doesn't consume trailing - */
1090   CONVERT("-0-", NUMPRS_LEADING_MINUS);
1091   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1092   EXPECT2(0,FAILDIG);
1093
1094   /* Trailing - doesn't get consumed if we specify both (unlike whitespace) */
1095   CONVERT("-0-", NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS);
1096   EXPECT(1,NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1097   EXPECT2(0,FAILDIG);
1098
1099   /** NUMPRS_HEX_OCT **/
1100
1101   /* Could be hex, octal or decimal - With flag reads as decimal */
1102   CONVERT("0", NUMPRS_HEX_OCT);
1103   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1104   EXPECT2(0,FAILDIG);
1105
1106   /* Doesn't recognise hex in .asm syntax */
1107   CONVERT("0h", NUMPRS_HEX_OCT);
1108   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1109   EXPECT2(0,FAILDIG);
1110
1111   /* Doesn't fail with valid leading string but no digits */
1112   CONVERT("0x", NUMPRS_HEX_OCT);
1113   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1114   EXPECT2(0,FAILDIG);
1115
1116   /* Doesn't recognise hex format numbers at all! */
1117   CONVERT("0x0", NUMPRS_HEX_OCT);
1118   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1119   EXPECT2(0,FAILDIG);
1120
1121   /* Doesn't recognise plain hex digits either */
1122   CONVERT("FE", NUMPRS_HEX_OCT);
1123   EXPECTFAIL;
1124   EXPECTRGB(0,FAILDIG);
1125
1126   /* Octal */
1127   CONVERT("0100", NUMPRS_HEX_OCT);
1128   EXPECT(1,NUMPRS_HEX_OCT,0,4,0,2);
1129   EXPECTRGB(0,1);
1130   EXPECTRGB(1,0);
1131   EXPECTRGB(2,0);
1132   EXPECTRGB(3,FAILDIG);
1133
1134   /* VB hex */
1135   CONVERT("&HF800", NUMPRS_HEX_OCT);
1136   EXPECT(4,NUMPRS_HEX_OCT,0x40,6,4,0);
1137   EXPECTRGB(0,15);
1138   EXPECTRGB(1,8);
1139   EXPECTRGB(2,0);
1140   EXPECTRGB(3,0);
1141   EXPECTRGB(4,FAILDIG);
1142
1143   /* VB hex lower case and leading zero */
1144   CONVERT("&h0abcdef", NUMPRS_HEX_OCT);
1145   EXPECT(6,NUMPRS_HEX_OCT,0x40,9,4,0);
1146   EXPECTRGB(0,10);
1147   EXPECTRGB(1,11);
1148   EXPECTRGB(2,12);
1149   EXPECTRGB(3,13);
1150   EXPECTRGB(4,14);
1151   EXPECTRGB(5,15);
1152   EXPECTRGB(6,FAILDIG);
1153
1154   /* VB oct */
1155   CONVERT("&O300", NUMPRS_HEX_OCT);
1156   EXPECT(3,NUMPRS_HEX_OCT,0x40,5,3,0);
1157   EXPECTRGB(0,3);
1158   EXPECTRGB(1,0);
1159   EXPECTRGB(2,0);
1160   EXPECTRGB(3,FAILDIG);
1161
1162   /* VB oct lower case and leading zero */
1163   CONVERT("&o0777", NUMPRS_HEX_OCT);
1164   EXPECT(3,NUMPRS_HEX_OCT,0x40,6,3,0);
1165   EXPECTRGB(0,7);
1166   EXPECTRGB(1,7);
1167   EXPECTRGB(2,7);
1168   EXPECTRGB(3,FAILDIG);
1169
1170   /* VB oct char bigger than 7 */
1171   CONVERT("&o128", NUMPRS_HEX_OCT);
1172 /*
1173   Native versions 2.x of oleaut32 allow this to succeed: later versions and Wine don't
1174   EXPECTFAIL;
1175   EXPECTRGB(0,FAILDIG);
1176 */
1177   /** NUMPRS_PARENS **/
1178
1179   /* Empty parens = error */
1180   CONVERT("()", NUMPRS_PARENS);
1181   EXPECTFAIL;
1182   EXPECTRGB(0,FAILDIG);
1183
1184   /* With flag, trailing parens not consumed */
1185   CONVERT("0()", NUMPRS_PARENS);
1186   EXPECT(1,NUMPRS_PARENS,0,1,0,0);
1187   EXPECT2(0,FAILDIG);
1188
1189   /* With flag, Number in parens made negative and parens consumed */
1190   CONVERT("(0)", NUMPRS_PARENS);
1191   EXPECT(1,NUMPRS_PARENS,NUMPRS_NEG|NUMPRS_PARENS,3,0,0);
1192   EXPECT2(0,FAILDIG);
1193
1194   /** NUMPRS_THOUSANDS **/
1195
1196   /* With flag, thousands sep. not needed */
1197   CONVERT("0", NUMPRS_THOUSANDS);
1198   EXPECT(1,NUMPRS_THOUSANDS,0,1,0,0);
1199   EXPECT2(0,FAILDIG);
1200
1201   /* With flag, thousands sep. and following digits consumed */
1202   CONVERT("1,000", NUMPRS_THOUSANDS);
1203   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1204   EXPECTRGB(0,1);
1205
1206   /* With flag and decimal point, thousands sep. but not decimals consumed */
1207   CONVERT("1,000.0", NUMPRS_THOUSANDS);
1208   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1209   EXPECTRGB(0,1);
1210
1211   /** NUMPRS_CURRENCY **/
1212
1213   /* Without flag, chokes on currency sign */
1214   CONVERT("$11", 0);
1215   EXPECTFAIL;
1216   EXPECTRGB(0,FAILDIG);
1217
1218   /* With flag, consumes currency sign */
1219   CONVERT("$11", NUMPRS_CURRENCY);
1220   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1221   EXPECT2(1,1);
1222   EXPECTRGB(2,FAILDIG);
1223
1224   /* With flag only, doesn't consume decimal point */
1225   CONVERT("$11.1", NUMPRS_CURRENCY);
1226   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1227   EXPECT2(1,1);
1228   EXPECTRGB(2,FAILDIG);
1229
1230   /* With flag and decimal flag, consumes decimal point and following digits */
1231   CONVERT("$11.1", NUMPRS_CURRENCY|NUMPRS_DECIMAL);
1232   EXPECT(3,NUMPRS_CURRENCY|NUMPRS_DECIMAL,NUMPRS_CURRENCY|NUMPRS_DECIMAL,5,0,-1);
1233   EXPECT2(1,1);
1234   EXPECTRGB(2,1);
1235   EXPECTRGB(3,FAILDIG);
1236
1237   /* Thousands flag can only be used with currency */
1238   CONVERT("$1,234", NUMPRS_CURRENCY|NUMPRS_THOUSANDS);
1239   EXPECT(4,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,6,0,0);
1240   EXPECT2(1,2);
1241   EXPECTRGB(2,3);
1242   EXPECTRGB(3,4);
1243   EXPECTRGB(4,FAILDIG);
1244
1245   /** NUMPRS_DECIMAL **/
1246
1247   /* With flag, consumes decimal point */
1248   CONVERT("1.1", NUMPRS_DECIMAL);
1249   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1250   EXPECT2(1,1);
1251   EXPECTRGB(2,FAILDIG);
1252
1253   /* With flag, consumes decimal point. Skipping the decimal part is not an error */
1254   CONVERT("1.", NUMPRS_DECIMAL);
1255   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,0);
1256   EXPECT2(1,FAILDIG);
1257
1258   /* Consumes only one decimal point */
1259   CONVERT("1.1.", NUMPRS_DECIMAL);
1260   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1261   EXPECT2(1,1);
1262   EXPECTRGB(2,FAILDIG);
1263
1264   /** NUMPRS_EXPONENT **/
1265
1266   /* Without flag, doesn't consume exponent */
1267   CONVERT("1e1", 0);
1268   EXPECT(1,0,0,1,0,0);
1269   EXPECT2(1,FAILDIG);
1270
1271   /* With flag, consumes exponent */
1272   CONVERT("1e1", NUMPRS_EXPONENT);
1273   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1274   EXPECT2(1,FAILDIG);
1275
1276   /* Negative exponents are accepted without flags */
1277   CONVERT("1e-1", NUMPRS_EXPONENT);
1278   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,-1);
1279   EXPECT2(1,FAILDIG);
1280
1281   /* As are positive exponents and leading exponent 0s */
1282   CONVERT("1e+01", NUMPRS_EXPONENT);
1283   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,5,0,1);
1284   EXPECT2(1,FAILDIG);
1285
1286   /* The same for zero exponents */
1287   CONVERT("1e0", NUMPRS_EXPONENT);
1288   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,0);
1289   EXPECT2(1,FAILDIG);
1290
1291   /* Sign on a zero exponent doesn't matter */
1292   CONVERT("1e+0", NUMPRS_EXPONENT);
1293   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1294   EXPECT2(1,FAILDIG);
1295
1296   CONVERT("1e-0", NUMPRS_EXPONENT);
1297   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1298   EXPECT2(1,FAILDIG);
1299
1300   /* Doesn't consume a real number exponent */
1301   CONVERT("1e1.", NUMPRS_EXPONENT);
1302   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1303   EXPECT2(1,FAILDIG);
1304
1305   /* Powers of 10 are calculated from the position of any decimal point */
1306   CONVERT("1.5e20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1307   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,6,0,19);
1308   EXPECT2(1,5);
1309
1310   CONVERT("1.5e-20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1311   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,7,0,-21);
1312   EXPECT2(1,5);
1313
1314   /** NUMPRS_USE_ALL **/
1315
1316   /* Flag expects all digits */
1317   CONVERT("0", NUMPRS_USE_ALL);
1318   EXPECT(1,NUMPRS_USE_ALL,0,1,0,0);
1319   EXPECT2(0,FAILDIG);
1320
1321   /* Rejects anything trailing */
1322   CONVERT("0 ", NUMPRS_USE_ALL);
1323   EXPECTFAIL;
1324   EXPECT2(0,FAILDIG);
1325
1326   /* Unless consumed by trailing flag */
1327   CONVERT("0 ", NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE);
1328   EXPECT(1,NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1329   EXPECT2(0,FAILDIG);
1330
1331   /** Combinations **/
1332
1333   /* Leading whitespace and plus, doesn't consume trailing whitespace */
1334   CONVERT("+ 0 ", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1335   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1336   EXPECT2(0,FAILDIG);
1337
1338   /* Order of whitespace and plus is unimportant */
1339   CONVERT(" +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1340   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1341   EXPECT2(0,FAILDIG);
1342
1343   /* Leading whitespace can be repeated */
1344   CONVERT(" + 0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1345   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,4,0,0);
1346   EXPECT2(0,FAILDIG);
1347
1348   /* But plus/minus etc. cannot */
1349   CONVERT("+ +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1350   EXPECTFAIL;
1351   EXPECTRGB(0,FAILDIG);
1352
1353   /* Inexact is not set if trailing zeros are removed */
1354   CONVERTN("10", 1, 0);
1355   EXPECT(1,0,0,2,0,1);
1356   EXPECT2(1,FAILDIG);
1357
1358   /* Make sure a leading 0 is stripped but decimals after it get read */
1359   CONVERT("-0.51", NUMPRS_STD);
1360   EXPECT(2,NUMPRS_STD,NUMPRS_NEG|NUMPRS_DECIMAL|NUMPRS_LEADING_MINUS,5,0,-2);
1361   EXPECT2(5,1);
1362
1363   /* Keep trailing zeros on whole number part of a decimal */
1364   CONVERT("10.1", NUMPRS_STD);
1365   EXPECT(3,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1366   EXPECT2(1,0);
1367   EXPECTRGB(2,1);
1368
1369   /* Zeros after decimal sign */
1370   CONVERT("0.01", NUMPRS_STD);
1371   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-2);
1372   EXPECT2(1,FAILDIG);
1373
1374   /* Trailing zeros after decimal part */
1375   CONVERT("0.10", NUMPRS_STD);
1376   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1377   EXPECT2(1,0);
1378 }
1379
1380 static HRESULT (WINAPI *pVarNumFromParseNum)(NUMPARSE*,BYTE*,ULONG,VARIANT*);
1381
1382 /* Macros for converting and testing the result of VarNumFromParseNum */
1383 #define SETRGB(indx,val) if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val
1384 #undef CONVERT
1385 #define CONVERT(a,b,c,d,e,f,bits) \
1386     np.cDig = (a); np.dwInFlags = (b); np.dwOutFlags = (c); np.cchUsed = (d); \
1387     np.nBaseShift = (e); np.nPwr10 = (f); hres = pVarNumFromParseNum(&np, rgb, bits, &vOut)
1388 static const char *szFailOverflow = "Expected overflow, hres = %08x\n";
1389 #define EXPECT_OVERFLOW ok(hres == (HRESULT)DISP_E_OVERFLOW, szFailOverflow, hres)
1390 static const char *szFailOk = "Call failed, hres = %08x\n";
1391 #define EXPECT_OK ok(hres == (HRESULT)S_OK, szFailOk, hres); \
1392   if (hres == (HRESULT)S_OK)
1393 #define EXPECT_TYPE(typ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))
1394 #define EXPECT_I1(val) EXPECT_OK { EXPECT_TYPE(VT_I1); \
1395   ok(V_I1(&vOut) == val, "Expected i1 = %d, got %d\n", (signed char)val, V_I1(&vOut)); }
1396 #define EXPECT_UI1(val) EXPECT_OK { EXPECT_TYPE(VT_UI1); \
1397   ok(V_UI1(&vOut) == val, "Expected ui1 = %d, got %d\n", (BYTE)val, V_UI1(&vOut)); }
1398 #define EXPECT_I2(val) EXPECT_OK { EXPECT_TYPE(VT_I2); \
1399   ok(V_I2(&vOut) == val, "Expected i2 = %d, got %d\n", (SHORT)val, V_I2(&vOut)); }
1400 #define EXPECT_UI2(val) EXPECT_OK { EXPECT_TYPE(VT_UI2); \
1401   ok(V_UI2(&vOut) == val, "Expected ui2 = %d, got %d\n", (USHORT)val, V_UI2(&vOut)); }
1402 #define EXPECT_I4(val) EXPECT_OK { EXPECT_TYPE(VT_I4); \
1403   ok(V_I4(&vOut) == val, "Expected i4 = %d, got %d\n", (LONG)val, V_I4(&vOut)); }
1404 #define EXPECT_UI4(val) EXPECT_OK { EXPECT_TYPE(VT_UI4); \
1405   ok(V_UI4(&vOut) == val, "Expected ui4 = %d, got %d\n", (ULONG)val, V_UI4(&vOut)); }
1406 #define EXPECT_I8(high,low) EXPECT_OK { EXPECT_TYPE(VT_I8); \
1407   ok(V_I8(&vOut) == ((((LONG64)(high))<<32)|(low)), "Expected i8 = %x%08x, got %x%08x\n", \
1408      (LONG)(high), (LONG)(low), (LONG)(V_I8(&vOut)>>32), (LONG)V_I8(&vOut) ); }
1409 #define EXPECT_UI8(val) EXPECT_OK { EXPECT_TYPE(VT_UI8); \
1410   ok(V_UI8(&vOut) == val, "Expected ui8 = 0x%x%08x, got 0x%x%08x\n", \
1411       (DWORD)((ULONG64)val >> 32), (DWORD)(ULONG64)val, (DWORD)(V_UI8(&vOut) >> 32), (DWORD)V_UI8(&vOut)); }
1412 #define EXPECT_R4(val) EXPECT_OK { EXPECT_TYPE(VT_R4); \
1413   ok(V_R4(&vOut) == val, "Expected r4 = %f, got %f\n", val, V_R4(&vOut)); }
1414 #define EXPECT_R8(val) EXPECT_OK { EXPECT_TYPE(VT_R8); \
1415   ok(V_R8(&vOut) == val, "Expected r8 = %g, got %g\n", val, V_R8(&vOut)); }
1416 #define CY_MULTIPLIER 10000
1417 #define EXPECT_CY(val) EXPECT_OK { EXPECT_TYPE(VT_CY); \
1418   ok(V_CY(&vOut).int64 == (LONG64)(val * CY_MULTIPLIER), "Expected r8 = 0x%x%08x, got 0x%x%08x\n", \
1419       (DWORD)((LONG64)val >> 23), (DWORD)(LONG64)val, (DWORD)(V_CY(&vOut).int64 >>32), (DWORD)V_CY(&vOut).int64); }
1420 #define EXPECT_DECIMAL(valHi, valMid, valLo) EXPECT_OK { EXPECT_TYPE(VT_DECIMAL); \
1421       ok((V_DECIMAL(&vOut).Hi32 == valHi) && (S1(U1(V_DECIMAL(&vOut))).Mid32 == valMid) && \
1422       (S1(U1(V_DECIMAL(&vOut))).Lo32 == valLo),                      \
1423   "Expected decimal = %x/0x%x%08x, got %x/0x%x%08x\n", valHi, valMid, valLo, \
1424       V_DECIMAL(&vOut).Hi32, S1(U1(V_DECIMAL(&vOut))).Mid32, S1(U1(V_DECIMAL(&vOut))).Lo32); }
1425
1426 static void test_VarNumFromParseNum(void)
1427 {
1428   HRESULT hres;
1429   NUMPARSE np;
1430   BYTE rgb[128];
1431   VARIANT vOut;
1432
1433   CHECKPTR(VarNumFromParseNum);
1434
1435   /* Convert the number 1 to different types */
1436   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1); EXPECT_I1(1);
1437   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_UI1); EXPECT_UI1(1);
1438   /* Prefers a signed type to unsigned of the same size */
1439   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1|VTBIT_UI1); EXPECT_I1(1);
1440   /* But takes the smaller size if possible */
1441   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I2|VTBIT_UI1); EXPECT_UI1(1);
1442
1443   /* Try different integer sizes */
1444 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
1445
1446   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, INTEGER_VTBITS); EXPECT_I1(1);
1447   /* 127 */
1448   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 7);
1449   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I1(127);
1450   /* 128 */
1451   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1452   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(128);
1453   /* 255 */
1454   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 5);
1455   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(255);
1456   /* 256 */
1457   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 6);
1458   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I2(256);
1459   /* 32767 */
1460   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 7);
1461   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_I2(32767);
1462   /* 32768 */
1463   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1464   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_UI2(32768);
1465
1466   /* Assume the above pattern holds for remaining positive integers; test negative */
1467
1468   /* -128 */
1469   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1470   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I1(-128);
1471   /* -129 */
1472   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 9);
1473   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I2(-129);
1474   /* -32768 */
1475   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1476   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I2(-32768);
1477   /* -32768 */
1478   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 9);
1479   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I4(-32769);
1480
1481   /* Assume the above pattern holds for remaining negative integers */
1482
1483   /* Test hexadecimal conversions */
1484   SETRGB(0, 1); CONVERT(1,0,0,1,4,0, INTEGER_VTBITS); EXPECT_I1(0x01);
1485   /* 0x7f */
1486   SETRGB(0, 7); SETRGB(1, 0xf);
1487   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS); EXPECT_I1(0x7f);
1488   SETRGB(0, 7); SETRGB(1, 0xf);
1489   CONVERT(2,0,0,2,4,0, VTBIT_DECIMAL); EXPECT_DECIMAL(0,0,0x7f);
1490   /* 0x7fff */
1491   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1492   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS); EXPECT_I2(0x7fff);
1493   /* 0x7fffffff */
1494   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1495   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1496   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x7fffffffL);
1497   /* 0x7fffffffffffffff (64 bits) */
1498   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1499   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1500   SETRGB(8, 0xf); SETRGB(9, 0xf); SETRGB(10, 0xf); SETRGB(11, 0xf);
1501   SETRGB(12, 0xf); SETRGB(13, 0xf); SETRGB(14, 0xf); SETRGB(15, 0xf);
1502   if (HAVE_OLEAUT32_I8)
1503   {
1504     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1505        truncate the number to the smallest integer size requested:
1506        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS); EXPECT_I1((signed char)0xff); */
1507     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x7fffffff,0xffffffff);
1508   }
1509
1510   /* Assume the above pattern holds for numbers without hi-bit set, test (preservation of) hi-bit */
1511   /* 0x82 */
1512   SETRGB(0, 8); SETRGB(1, 2);
1513   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS);
1514   EXPECT_I1((signed char)0x82);
1515   /* 0x8002 */
1516   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1517   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS);
1518   EXPECT_I2((signed short)0x8002);
1519   /* 0x80000002 */
1520   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1521   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1522   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x80000002);
1523   /* 0x8000000000000002 (64 bits) */
1524   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1525   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1526   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1527   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1528   if (HAVE_OLEAUT32_I8)
1529   {
1530     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1531        truncate the number to the smallest integer size requested:
1532        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS & ~VTBIT_I1);
1533        EXPECT_I2((signed short)0x0002); */
1534     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1535   }
1536
1537   /* Test (preservation of) hi-bit with STRICT type requesting */
1538   /* 0x82 */
1539   SETRGB(0, 8); SETRGB(1, 2);
1540   CONVERT(2,0,0,2,4,0, VTBIT_I1);
1541   EXPECT_I1((signed char)0x82);
1542   /* 0x8002 */
1543   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1544   CONVERT(4,0,0,4,4,0, VTBIT_I2);
1545   EXPECT_I2((signed short)0x8002);
1546   /* 0x80000002 */
1547   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1548   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1549   CONVERT(8,0,0,8,4,0, VTBIT_I4); EXPECT_I4(0x80000002);
1550   /* 0x8000000000000002 (64 bits) */
1551   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1552   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1553   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1554   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1555   if (HAVE_OLEAUT32_I8)
1556   {
1557     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1558   }
1559   /* Assume the above pattern holds for numbers with hi-bit set */
1560
1561   /* Negative numbers overflow if we have only unsigned outputs */
1562   /* -1 */
1563   SETRGB(0, 1); CONVERT(1,0,NUMPRS_NEG,1,0,0, VTBIT_UI1); EXPECT_OVERFLOW;
1564   /* -0.6 */
1565   SETRGB(0, 6); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_OVERFLOW;
1566
1567   /* Except that rounding is done first, so -0.5 to 0 are accepted as 0 */
1568   /* -0.5 */
1569   SETRGB(0, 5); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_UI1(0);
1570
1571   /* Floating point zero is OK */
1572   /* 0.00000000E0 */
1573   SETRGB(0, 0); CONVERT(1,0,NUMPRS_DECIMAL|NUMPRS_EXPONENT,12,0,-8, VTBIT_R8);
1574   EXPECT_R8(0.0);
1575
1576   /* Float is acceptable for an integer input value */
1577   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4); EXPECT_R4(1.0f);
1578   /* As is double */
1579   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8); EXPECT_R8(1.0);
1580   /* As is currency */
1581   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY); EXPECT_CY(1);
1582
1583   /* Float is preferred over double */
1584   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4|VTBIT_R8); EXPECT_R4(1.0f);
1585
1586   /* Double is preferred over currency */
1587   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8|VTBIT_CY); EXPECT_R8(1.0);
1588
1589   /* Currency is preferred over decimal */
1590   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY|VTBIT_DECIMAL); EXPECT_CY(1);
1591 }
1592
1593
1594 static void test_UdateFromDate( int line, DATE dt, ULONG flags, HRESULT r, WORD d, WORD m, WORD y,
1595                                 WORD h, WORD mn, WORD s, WORD ms, WORD dw, WORD dy)
1596 {
1597     UDATE ud;
1598     HRESULT res;
1599
1600     memset(&ud, 0, sizeof(ud));
1601     res = pVarUdateFromDate(dt, flags, &ud);
1602     ok_(__FILE__,line)(r == res && (res != S_OK || (ud.st.wYear == y && ud.st.wMonth == m && ud.st.wDay == d &&
1603                        ud.st.wHour == h && ud.st.wMinute == mn && ud.st.wSecond == s &&
1604                        ud.st.wMilliseconds == ms && ud.st.wDayOfWeek == dw && ud.wDayOfYear == dy)),
1605                        "%.16g expected res(%x) %d,%d,%d,%d,%d,%d,%d  %d %d, got res(%x) %d,%d,%d,%d,%d,%d,%d  %d %d\n",
1606                        dt, r, d, m, y, h, mn, s, ms, dw, dy,
1607                        res, ud.st.wDay, ud.st.wMonth, ud.st.wYear, ud.st.wHour, ud.st.wMinute,
1608                        ud.st.wSecond, ud.st.wMilliseconds, ud.st.wDayOfWeek, ud.wDayOfYear );
1609 }
1610 #define DT2UD(dt,flags,r,d,m,y,h,mn,s,ms,dw,dy) test_UdateFromDate(__LINE__,dt,flags,r,d,m,y,h,mn,s,ms,dw,dy)
1611
1612 static void test_VarUdateFromDate(void)
1613 {
1614   CHECKPTR(VarUdateFromDate);
1615   DT2UD(29221.0,0,S_OK,1,1,1980,0,0,0,0,2,1);        /* 1 Jan 1980 */
1616   DT2UD(29222.0,0,S_OK,2,1,1980,0,0,0,0,3,2);        /* 2 Jan 1980 */
1617   DT2UD(33238.0,0,S_OK,31,12,1990,0,0,0,0,1,365);    /* 31 Dec 1990 */
1618   DT2UD(0.0,0,S_OK,30,12,1899,0,0,0,0,6,364);        /* 30 Dec 1899 - VT_DATE 0.0 */
1619   DT2UD(-657434.0,0,S_OK,1,1,100,0,0,0,0,5,1);       /* 1 Jan 100 - Min */
1620   DT2UD(-657435.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* < 1 Jan 100 => err */
1621   DT2UD(2958465.0,0,S_OK,31,12,9999,0,0,0,0,5,365);  /* 31 Dec 9999 - Max */
1622   DT2UD(2958466.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* > 31 Dec 9999 => err  */
1623
1624   /* VAR_VALIDDATE doesn't prevent upper and lower bounds being checked */
1625   DT2UD(-657435.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1626   DT2UD(2958466.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1627
1628   /* Times */
1629   DT2UD(29221.25,0,S_OK,1,1,1980,6,0,0,0,2,1);           /* 6 AM */
1630   DT2UD(29221.33333333,0,S_OK,1,1,1980,8,0,0,0,2,1);     /* 8 AM */
1631   DT2UD(29221.5,0,S_OK,1,1,1980,12,0,0,0,2,1);           /* 12 AM */
1632   DT2UD(29221.9888884444,0,S_OK,1,1,1980,23,44,0,0,2,1); /* 11:44 PM */
1633   DT2UD(29221.7508765432,0,S_OK,1,1,1980,18,1,16,0,2,1); /* 6:18:02 PM */
1634
1635   /* Test handling of times on dates prior to the epoch */
1636   DT2UD(-5.25,0,S_OK,25,12,1899,6,0,0,0,1,359);
1637   DT2UD(-5.9999884259259,0,S_OK,25,12,1899,23,59,59,0,1,359);
1638   /* This just demonstrates the non-linear nature of values prior to the epoch */
1639   DT2UD(-4.0,0,S_OK,26,12,1899,0,0,0,0,2,360);
1640   /* Numerical oddity: for 0.0 < x < 1.0, x and -x represent the same datetime */
1641   DT2UD(-0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
1642   DT2UD(0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
1643 }
1644
1645
1646 static void test_DateFromUDate( int line, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms,
1647                                 WORD dw, WORD dy, ULONG flags, HRESULT r, DATE dt )
1648 {
1649     UDATE ud;
1650     double out;
1651     HRESULT res;
1652
1653     ud.st.wYear = y;
1654     ud.st.wMonth = m;
1655     ud.st.wDay = d;
1656     ud.st.wHour = h;
1657     ud.st.wMinute = mn;
1658     ud.st.wSecond = s;
1659     ud.st.wMilliseconds = ms;
1660     ud.st.wDayOfWeek = dw;
1661     ud.wDayOfYear = dy;
1662     res = pVarDateFromUdate(&ud, flags, &out);
1663     ok_(__FILE__,line)(r == res && (r != S_OK || EQ_DOUBLE(out, dt)),
1664                        "expected %x, %.16g, got %x, %.16g\n", r, dt, res, out);
1665 }
1666 #define UD2T(d,m,y,h,mn,s,ms,dw,dy,flags,r,dt) test_DateFromUDate(__LINE__,d,m,y,h,mn,s,ms,dw,dy,flags,r,dt)
1667
1668 static void test_VarDateFromUdate(void)
1669 {
1670   CHECKPTR(VarDateFromUdate);
1671   UD2T(1,1,1980,0,0,0,0,2,1,0,S_OK,29221.0);      /* 1 Jan 1980 */
1672   UD2T(2,1,1980,0,0,0,0,3,2,0,S_OK,29222.0);      /* 2 Jan 1980 */
1673   UD2T(2,1,1980,0,0,0,0,4,5,0,S_OK,29222.0);      /* 2 Jan 1980 */
1674   UD2T(31,12,1990,0,0,0,0,0,0,0,S_OK,33238.0);    /* 31 Dec 1990 */
1675   UD2T(31,12,90,0,0,0,0,0,0,0,S_OK,33238.0);      /* year < 100 is 1900+year! */
1676   UD2T(30,12,1899,0,0,0,0,6,364,0,S_OK,0.0);      /* 30 Dec 1899 - VT_DATE 0.0 */
1677   UD2T(1,1,100,0,0,0,0,0,0,0,S_OK,-657434.0);     /* 1 Jan 100 - Min */
1678   UD2T(31,12,9999,0,0,0,0,0,0,0,S_OK,2958465.0);  /* 31 Dec 9999 - Max */
1679   UD2T(1,1,10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0); /* > 31 Dec 9999 => err  */
1680   UD2T(1,1,-10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0);/* < -9999 => err  */
1681
1682   UD2T(30,12,1899,0,0,0,0,0,0,0,S_OK,0.0); /* 30 Dec 1899 0:00:00  */
1683   UD2T(30,12,1899,0,0,0,999,0,0,0,S_OK,0.0); /* Ignore milliseconds  */
1684
1685   UD2T(1,1,1980,18,1,16,0,2,1,0,S_OK,29221.75087962963);             /* 6:18:02 PM */
1686   UD2T(1,300,1980,18,1,16,0,2,1,0,S_OK,38322.75087962963);           /* Test fwdrolled month */
1687   UD2T(300,1,1980,18,1,16,0,2,1,0,S_OK,29520.75087962963);           /* Test fwdrolled days */
1688   UD2T(0,1,1980,42,1,16,0,2,1,0,S_OK,29221.75087962963);             /* Test fwdrolled hours */
1689   UD2T(1,1,1980,17,61,16,0,2,1,0,S_OK,29221.75087962963);            /* Test fwdrolled minutes */
1690   UD2T(1,1,1980,18,0,76,0,2,1,0,S_OK,29221.75087962963);             /* Test fwdrolled seconds */
1691   UD2T(1,-300,1980,18,1,16,0,2,1,0,S_OK,20059.75087962963);          /* Test backrolled month */
1692   UD2T(-300,1,1980,18,1,16,0,2,1,0,S_OK,28920.75087962963);          /* Test backrolled days */
1693   UD2T(3,1,1980,-30,1,16,0,2,1,0,S_OK,29221.75087962963);            /* Test backrolled hours */
1694   UD2T(1,1,1980,20,-119,16,0,2,1,0,S_OK,29221.75087962963);          /* Test backrolled minutes */
1695   UD2T(1,1,1980,18,3,-104,0,2,1,0,S_OK,29221.75087962963);           /* Test backrolled seconds */
1696   UD2T(1,12001,-1020,18,1,16,0,0,0,0,S_OK,29221.75087962963);        /* Test rolled year and month */
1697   UD2T(1,-23,1982,18,1,16,0,0,0,0,S_OK,29221.75087962963);           /* Test backrolled month */
1698   UD2T(-59,3,1980,18,1,16,0,0,0,0,S_OK,29221.75087962963);           /* Test backrolled days */
1699   UD2T(1,1,0,0,0,0,0,0,0,0,S_OK,36526);                              /* Test zero year */
1700   UD2T(0,0,1980,0,0,0,0,0,0,0,S_OK,29189);                           /* Test zero day and month */
1701   UD2T(0,1,1980,0,0,0,0,2,1,0,S_OK,29220.0);                         /* Test zero day = LastDayOfMonth */
1702   UD2T(-1,1,1980,18,1,16,0,0,0,0,S_OK,29219.75087962963);            /* Test day -1 = LastDayOfMonth - 1 */
1703   UD2T(1,1,-1,18,1,16,0,0,0,0,S_OK,36161.75087962963);               /* Test year -1 = 1999 */
1704   UD2T(1,-1,1980,18,1,16,0,0,0,0,S_OK,29160.7508796296);             /* Test month -1 = 11 */
1705   UD2T(1,13,1980,0,0,0,0,2,1,0,S_OK,29587.0);                        /* Rolls fwd to 1/1/1981 */
1706
1707   /* Test handling of times on dates prior to the epoch */
1708   UD2T(25,12,1899,6,0,0,0,1,359,0,S_OK,-5.25);
1709   UD2T(25,12,1899,23,59,59,0,1,359,0,S_OK,-5.9999884259259);
1710   /* This just demonstrates the non-linear nature of values prior to the epoch */
1711   UD2T(26,12,1899,0,0,0,0,2,360,0,S_OK,-4.0);
1712   /* for DATE values 0.0 < x < 1.0, x and -x represent the same datetime */
1713   /* but when converting to DATE, prefer the positive versions */
1714   UD2T(30,12,1899,6,0,0,0,6,364,0,S_OK,0.25);
1715 }
1716
1717 static void test_st2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1718                        WORD s, WORD ms, INT r, double dt)
1719 {
1720     SYSTEMTIME st;
1721     double out;
1722     INT res;
1723
1724     st.wYear = y;
1725     st.wMonth = m;
1726     st.wDay = d;
1727     st.wHour = h;
1728     st.wMinute = mn;
1729     st.wSecond = s;
1730     st.wMilliseconds = ms;
1731     st.wDayOfWeek = 0;
1732     res = pSystemTimeToVariantTime(&st, &out);
1733     ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1734                        "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1735 }
1736 #define ST2DT(d,m,y,h,mn,s,ms,r,dt) test_st2dt(__LINE__,d,m,y,h,mn,s,ms,r,dt)
1737
1738 static void test_SystemTimeToVariantTime(void)
1739 {
1740   CHECKPTR(SystemTimeToVariantTime);
1741   ST2DT(1,1,1980,0,0,0,0,TRUE,29221.0);
1742   ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0);
1743   ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0);   /* Rolls back to 31 Dec 1899 */
1744   ST2DT(1,13,1980,0,0,0,0,FALSE,29587.0); /* Fails on invalid month */
1745   ST2DT(31,12,90,0,0,0,0,TRUE,33238.0);   /* year < 100 is 1900+year! */
1746 }
1747
1748 static void test_dt2st(int line, double dt, INT r, WORD d, WORD m, WORD y,
1749                        WORD h, WORD mn, WORD s, WORD ms)
1750 {
1751   SYSTEMTIME st;
1752   INT res;
1753
1754   memset(&st, 0, sizeof(st));
1755   res = pVariantTimeToSystemTime(dt, &st);
1756   ok_(__FILE__,line)(r == res &&
1757                      (!r || (st.wYear == y && st.wMonth == m && st.wDay == d &&
1758                              st.wHour == h && st.wMinute == mn &&
1759                              st.wSecond == s && st.wMilliseconds == ms)),
1760                      "%.16g expected %d, %d,%d,%d,%d,%d,%d,%d, got %d, %d,%d,%d,%d,%d,%d,%d\n",
1761                      dt, r, d, m, y, h, mn, s, ms, res, st.wDay, st.wMonth,
1762                      st.wYear, st.wHour, st.wMinute, st.wSecond,
1763                      st.wMilliseconds);
1764 }
1765 #define DT2ST(dt,r,d,m,y,h,mn,s,ms) test_dt2st(__LINE__,dt,r,d,m,y,h,mn,s,ms)
1766
1767 static void test_VariantTimeToSystemTime(void)
1768 {
1769   CHECKPTR(VariantTimeToSystemTime);
1770   DT2ST(29221.0,1,1,1,1980,0,0,0,0);
1771   DT2ST(29222.0,1,2,1,1980,0,0,0,0);
1772 }
1773
1774 #define MKDOSDATE(d,m,y) ((d & 0x1f) | ((m & 0xf) << 5) | (((y-1980) & 0x7f) << 9))
1775 #define MKDOSTIME(h,m,s) (((s>>1) & 0x1f) | ((m & 0x3f) << 5) | ((h & 0x1f) << 11))
1776
1777 static void test_dos2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1778                         WORD s, INT r, double dt)
1779 {
1780     unsigned short dosDate, dosTime;
1781     double out;
1782     INT res;
1783
1784     out = 0.0;
1785     dosDate = MKDOSDATE(d, m, y);
1786     dosTime = MKDOSTIME(h, mn, s);
1787     res = pDosDateTimeToVariantTime(dosDate, dosTime, &out);
1788     ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1789                        "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1790 }
1791 #define DOS2DT(d,m,y,h,mn,s,r,dt) test_dos2dt(__LINE__,d,m,y,h,mn,s,r,dt)
1792
1793 static void test_DosDateTimeToVariantTime(void)
1794 {
1795   CHECKPTR(DosDateTimeToVariantTime);
1796
1797   /* Date */
1798   DOS2DT(1,1,1980,0,0,0,1,29221.0); /* 1/1/1980 */
1799   DOS2DT(31,12,2099,0,0,0,1,73050.0); /* 31/12/2099 */
1800   /* Dates are limited to the dos date max of 31/12/2099 */
1801   DOS2DT(31,12,2100,0,0,0,0,0.0); /* 31/12/2100 */
1802   /* Days and months of 0 cause date to roll back 1 day or month */
1803   DOS2DT(0,1,1980,0,0,0,1,29220.0); /* 0 Day => 31/12/1979 */
1804   DOS2DT(1,0,1980,0,0,0,1,29190.0); /* 0 Mth =>  1/12/1979 */
1805   DOS2DT(0,0,1980,0,0,0,1,29189.0); /* 0 D/M => 30/11/1979 */
1806   /* Days > days in the month cause date to roll forward 1 month */
1807   DOS2DT(29,2,1981,0,0,0,1,29646.0); /* 29/2/1981 -> 3/1/1980 */
1808   DOS2DT(30,2,1981,0,0,0,1,29647.0); /* 30/2/1981 -> 4/1/1980 */
1809   /* Takes leap years into account when rolling forward */
1810   DOS2DT(29,2,1980,0,0,0,1,29280.0); /* 2/29/1980 */
1811   /* Months > 12 cause an error */
1812   DOS2DT(2,13,1980,0,0,0,0,0.0);
1813
1814   /* Time */
1815   DOS2DT(1,1,1980,0,0,29,1,29221.00032407407); /* 1/1/1980 12:00:28 AM */
1816   DOS2DT(1,1,1980,0,0,31,1,29221.00034722222); /* 1/1/1980 12:00:30 AM */
1817   DOS2DT(1,1,1980,0,59,0,1,29221.04097222222); /* 1/1/1980 12:59:00 AM */
1818   DOS2DT(1,1,1980,0,60,0,0,0.0);               /* Invalid minutes */
1819   DOS2DT(1,1,1980,0,0,60,0,0.0);               /* Invalid seconds */
1820   DOS2DT(1,1,1980,23,0,0,1,29221.95833333333); /* 1/1/1980 11:00:00 PM */
1821   DOS2DT(1,1,1980,24,0,0,0,0.0);               /* Invalid hours */
1822
1823   DOS2DT(1,1,1980,0,0,1,1,29221.0);
1824   DOS2DT(2,1,1980,0,0,0,1,29222.0);
1825   DOS2DT(2,1,1980,0,0,0,1,29222.0);
1826   DOS2DT(31,12,1990,0,0,0,1,33238.0);
1827   DOS2DT(31,12,90,0,0,0,1,40543.0);
1828   DOS2DT(30,12,1899,0,0,0,1,46751.0);
1829   DOS2DT(1,1,100,0,0,0,1,43831.0);
1830   DOS2DT(31,12,9999,0,0,0,1,59901.0);
1831   DOS2DT(1,1,10000,0,0,0,1,59902.0);
1832   DOS2DT(1,1,-10000,0,0,0,1,48214.0);
1833
1834   DOS2DT(30,12,1899,0,0,0,1,46751.0);
1835   DOS2DT(30,12,1899,0,0,1,1,46751.0);
1836
1837   DOS2DT(1,1,1980,18,1,16,1,29221.75087962963);
1838   DOS2DT(1,300,1980,18,1,16,1,29556.75087962963);
1839   DOS2DT(300,1,1980,18,1,16,1,29232.75087962963);
1840   DOS2DT(0,1,1980,42,1,16,1,29220.4175462963);
1841   DOS2DT(1,1,1980,17,61,16,0,0.0);
1842   DOS2DT(1,1,1980,18,0,76,1,29221.75013888889);
1843   DOS2DT(1,-300,1980,18,1,16,1,29312.75087962963);
1844   DOS2DT(-300,1,1980,18,1,16,1,29240.75087962963);
1845   DOS2DT(3,1,1980,-30,1,16,1,29223.08421296296);
1846   DOS2DT(1,1,1980,20,-119,16,1,29221.83976851852);
1847   DOS2DT(1,1,1980,18,3,-104,1,29221.75236111111);
1848   DOS2DT(1,12001,-1020,18,1,16,1,55519.75087962963);
1849   DOS2DT(1,-23,1982,18,1,16,1,30195.75087962963);
1850   DOS2DT(-59,3,1980,18,1,16,1,29285.75087962963);
1851   DOS2DT(1,1,0,0,0,0,1,54058.0);
1852   DOS2DT(0,0,1980,0,0,0,1,29189.0);
1853   DOS2DT(0,1,1980,0,0,0,1,29220.0);
1854   DOS2DT(-1,1,1980,18,1,16,1,29251.75087962963);
1855   DOS2DT(1,1,-1,18,1,16,1,53693.75087962963);
1856   DOS2DT(1,-1,1980,18,1,16,0,0);
1857 }
1858
1859 static void test_dt2dos(int line, double dt, INT r, WORD d, WORD m, WORD y,
1860                         WORD h, WORD mn, WORD s)
1861 {
1862     unsigned short dosDate, dosTime, expDosDate, expDosTime;
1863     INT res;
1864
1865     dosTime = dosDate = 0;
1866     expDosDate = MKDOSDATE(d,m,y);
1867     expDosTime = MKDOSTIME(h,mn,s);
1868     res = pVariantTimeToDosDateTime(dt, &dosDate, &dosTime);
1869     ok_(__FILE__,line)(r == res && (!r || (dosTime == expDosTime && dosDate == expDosDate)),
1870                        "%g: expected %d,%d(%d/%d/%d),%d(%d:%d:%d) got %d,%d(%d/%d/%d),%d(%d:%d:%d)\n",
1871                        dt, r, expDosDate, expDosDate & 0x1f,
1872                        (expDosDate >> 5) & 0xf, 1980 + (expDosDate >> 9),
1873                        expDosTime, expDosTime >> 11, (expDosTime >> 5) & 0x3f,
1874                        (expDosTime & 0x1f),
1875                        res, dosDate, dosDate & 0x1f, (dosDate >> 5) & 0xf,
1876                        1980 + (dosDate >> 9), dosTime, dosTime >> 11,
1877                        (dosTime >> 5) & 0x3f, (dosTime & 0x1f));
1878 }
1879 #define DT2DOS(dt,r,d,m,y,h,mn,s) test_dt2dos(__LINE__,dt,r,d,m,y,h,mn,s)
1880
1881 static void test_VariantTimeToDosDateTime(void)
1882 {
1883   CHECKPTR(VariantTimeToDosDateTime);
1884
1885   /* Date */
1886   DT2DOS(29221.0,1,1,1,1980,0,0,0);   /* 1/1/1980 */
1887   DT2DOS(73050.0,1,31,12,2099,0,0,0); /* 31/12/2099 */
1888   DT2DOS(29220.0,0,0,0,0,0,0,0);      /* 31/12/1979 - out of range */
1889   DT2DOS(73415.0,0,0,0,0,0,0,0);      /* 31/12/2100 - out of range */
1890
1891   /* Time */
1892   DT2DOS(29221.00032407407,1,1,1,1980,0,0,29); /* 1/1/1980 12:00:28 AM */
1893   DT2DOS(29221.00034722222,1,1,1,1980,0,0,31); /* 1/1/1980 12:00:30 AM */
1894   DT2DOS(29221.04097222222,1,1,1,1980,0,59,0); /* 1/1/1980 12:59:00 AM */
1895   DT2DOS(29221.95833333333,1,1,1,1980,23,0,0); /* 1/1/1980 11:00:00 PM */
1896 }
1897
1898 static HRESULT (WINAPI *pVarAbs)(LPVARIANT,LPVARIANT);
1899
1900 #define VARABS(vt,val,rvt,rval)                  \
1901     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
1902     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
1903     test_var_call1( __LINE__, pVarAbs, &v, &exp )
1904
1905 static void test_VarAbs(void)
1906 {
1907     static WCHAR szNum[] = {'-','1','.','1','\0' };
1908     char buff[8];
1909     HRESULT hres;
1910     VARIANT v, vDst, exp;
1911     size_t i;
1912
1913     CHECKPTR(VarAbs);
1914
1915     /* Test all possible V_VT values.
1916      */
1917     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1918     {
1919         VARTYPE vt;
1920
1921         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1922         {
1923             HRESULT hExpected = DISP_E_BADVARTYPE;
1924
1925             SKIPTESTS(vt);
1926
1927             memset(&v, 0, sizeof(v));
1928             V_VT(&v) = vt | ExtraFlags[i];
1929             V_VT(&vDst) = VT_EMPTY;
1930
1931             hres = pVarAbs(&v,&vDst);
1932             if (ExtraFlags[i] & (VT_ARRAY|VT_ARRAY) ||
1933                 (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
1934                  vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
1935             {
1936                 hExpected = DISP_E_TYPEMISMATCH;
1937             }
1938             else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
1939             {
1940                 hExpected = DISP_E_BADVARTYPE;
1941             }
1942             else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
1943                 hExpected = S_OK;
1944
1945             /* Native always fails on some vartypes that should be valid. don't
1946              * check that Wine does the same; these are bugs in native.
1947              */
1948             if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
1949                 vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
1950                 continue;
1951             ok(hres == hExpected, "VarAbs: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
1952                hExpected, hres, vt, ExtraFlags[i]);
1953         }
1954     }
1955
1956     /* BOOL->I2, BSTR->R8, all others remain the same */
1957     VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
1958     VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
1959     VARABS(EMPTY,0,I2,0);
1960     VARABS(EMPTY,1,I2,0);
1961     VARABS(NULL,0,NULL,0);
1962     VARABS(NULL,1,NULL,0);
1963     VARABS(I2,1,I2,1);
1964     VARABS(I2,-1,I2,1);
1965     VARABS(I4,1,I4,1);
1966     VARABS(I4,-1,I4,1);
1967     VARABS(UI1,1,UI1,1);
1968     VARABS(R4,1,R4,1);
1969     VARABS(R4,-1,R4,1);
1970     VARABS(R8,1,R8,1);
1971     VARABS(R8,-1,R8,1);
1972     VARABS(DATE,1,DATE,1);
1973     VARABS(DATE,-1,DATE,1);
1974     V_VT(&v) = VT_CY;
1975     V_CY(&v).int64 = -10000;
1976     memset(&vDst,0,sizeof(vDst));
1977     hres = pVarAbs(&v,&vDst);
1978     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
1979        "VarAbs(CY): expected 0x0 got 0x%X\n", hres);
1980     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1981     if (buff[1])
1982     {
1983         trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
1984         return;
1985     } else {
1986         szNum[2] = buff[0];
1987     }
1988     V_VT(&v) = VT_BSTR;
1989     V_BSTR(&v) = (BSTR)szNum;
1990     memset(&vDst,0,sizeof(vDst));
1991     hres = pVarAbs(&v,&vDst);
1992     ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
1993        "VarAbs: expected 0x0,%d,%g, got 0x%X,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
1994 }
1995
1996 static HRESULT (WINAPI *pVarNot)(LPVARIANT,LPVARIANT);
1997
1998 #define VARNOT(vt,val,rvt,rval)                  \
1999     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2000     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2001     test_var_call1( __LINE__, pVarNot, &v, &exp )
2002
2003 static void test_VarNot(void)
2004 {
2005     static const WCHAR szNum0[] = {'0','\0' };
2006     static const WCHAR szNum1[] = {'1','\0' };
2007     HRESULT hres;
2008     VARIANT v, exp, vDst;
2009     DECIMAL *pdec = &V_DECIMAL(&v);
2010     CY *pcy = &V_CY(&v);
2011     size_t i;
2012
2013     CHECKPTR(VarNot);
2014
2015     /* Test all possible V_VT values */
2016     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2017     {
2018         VARTYPE vt;
2019
2020         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2021         {
2022             HRESULT hExpected = DISP_E_BADVARTYPE;
2023
2024             SKIPTESTS(vt);
2025
2026             memset(&v, 0, sizeof(v));
2027             V_VT(&v) = vt | ExtraFlags[i];
2028             V_VT(&vDst) = VT_EMPTY;
2029
2030             switch (V_VT(&v))
2031             {
2032             case VT_I1:  case VT_UI1: case VT_I2:  case VT_UI2:
2033             case VT_INT: case VT_UINT: case VT_I4:  case VT_UI4:
2034             case VT_R4:  case VT_R8:
2035             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2036             case VT_DATE: case VT_CY:
2037                 hExpected = S_OK;
2038                 break;
2039             case VT_I8: case VT_UI8:
2040                 if (HAVE_OLEAUT32_I8)
2041                     hExpected = S_OK;
2042                 break;
2043             case VT_RECORD:
2044                 if (HAVE_OLEAUT32_RECORD)
2045                     hExpected = DISP_E_TYPEMISMATCH;
2046                 break;
2047             case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
2048                 hExpected = DISP_E_TYPEMISMATCH;
2049                 break;
2050             default:
2051                 if (IsValidVariantClearVT(vt, ExtraFlags[i]) && vt != VT_CLSID)
2052                    hExpected = DISP_E_TYPEMISMATCH;
2053                 break;
2054             }
2055
2056             hres = pVarNot(&v,&vDst);
2057             ok(hres == hExpected, "VarNot: expected 0x%X, got 0x%X vt %d|0x%X\n",
2058                hExpected, hres, vt, ExtraFlags[i]);
2059         }
2060     }
2061     /* Test the values returned by all cases that can succeed */
2062     VARNOT(EMPTY,0,I2,-1);
2063     VARNOT(EMPTY,1,I2,-1);
2064     VARNOT(NULL,0,NULL,0);
2065     VARNOT(NULL,1,NULL,0);
2066     VARNOT(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
2067     VARNOT(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
2068     VARNOT(I1,-1,I4,0);
2069     VARNOT(I1,0,I4,-1);
2070     VARNOT(I2,-1,I2,0);
2071     VARNOT(I2,0,I2,-1);
2072     VARNOT(I2,1,I2,-2);
2073     VARNOT(I4,1,I4,-2);
2074     VARNOT(I4,0,I4,-1);
2075     VARNOT(UI1,1,UI1,254);
2076     VARNOT(UI1,0,UI1,255);
2077     VARNOT(UI2,0,I4,-1);
2078     VARNOT(UI2,1,I4,-2);
2079     VARNOT(UI4,0,I4,-1);
2080     VARNOT(UI4,1,I4,-2);
2081     VARNOT(INT,0,I4,-1);
2082     VARNOT(INT,1,I4,-2);
2083     VARNOT(UINT,0,I4,-1);
2084     VARNOT(UINT,1,I4,-2);
2085     if (HAVE_OLEAUT32_I8)
2086     {
2087         VARNOT(I8,1,I8,-2);
2088         VARNOT(I8,0,I8,-1);
2089         VARNOT(UI8,0,I4,-1);
2090         VARNOT(UI8,1,I4,-2);
2091     }
2092     VARNOT(R4,1,I4,-2);
2093     VARNOT(R4,0,I4,-1);
2094     VARNOT(R8,1,I4,-2);
2095     VARNOT(R8,0,I4,-1);
2096     VARNOT(DATE,1,I4,-2);
2097     VARNOT(DATE,0,I4,-1);
2098     VARNOT(BSTR,(BSTR)szNum0,I4,-1);
2099     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum0, "VarNot(0): changed input\n");
2100     VARNOT(BSTR,(BSTR)szNum1,I4,-2);
2101     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum1, "VarNot(1): changed input\n");
2102
2103     V_VT(&v) = VT_DECIMAL;
2104     S(U(*pdec)).sign = DECIMAL_NEG;
2105     S(U(*pdec)).scale = 0;
2106     pdec->Hi32 = 0;
2107     S1(U1(*pdec)).Mid32 = 0;
2108     S1(U1(*pdec)).Lo32 = 1;
2109     VARNOT(DECIMAL,*pdec,I4,0);
2110
2111     pcy->int64 = 10000;
2112     VARNOT(CY,*pcy,I4,-2);
2113
2114     pcy->int64 = 0;
2115     VARNOT(CY,*pcy,I4,-1);
2116
2117     pcy->int64 = -1;
2118     VARNOT(CY,*pcy,I4,-1);
2119 }
2120
2121 static HRESULT (WINAPI *pVarSub)(LPVARIANT,LPVARIANT,LPVARIANT);
2122
2123 #define VARSUB(vt1,val1,vt2,val2,rvt,rval)               \
2124         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
2125         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2126         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
2127         test_var_call2( __LINE__, pVarSub, &left, &right, &exp )
2128
2129 static void test_VarSub(void)
2130 {
2131     VARIANT left, right, exp, result, cy, dec;
2132     VARTYPE i;
2133     BSTR lbstr, rbstr;
2134     HRESULT hres, expectedhres;
2135     double r;
2136
2137     CHECKPTR(VarSub);
2138
2139     lbstr = SysAllocString(sz12);
2140     rbstr = SysAllocString(sz12);
2141
2142     VariantInit(&left);
2143     VariantInit(&right);
2144     VariantInit(&result);
2145
2146     /* Test all possible flag/vt combinations & the resulting vt type */
2147     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2148     {
2149
2150         VARTYPE leftvt, rightvt, resvt;
2151
2152         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
2153         {
2154
2155             SKIPTESTS(leftvt);
2156
2157             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
2158             {
2159
2160                 SKIPTESTS(rightvt);
2161                 expectedhres = S_OK;
2162
2163                 memset(&left, 0, sizeof(left));
2164                 memset(&right, 0, sizeof(right));
2165                 V_VT(&left) = leftvt | ExtraFlags[i];
2166                 if (leftvt == VT_BSTR)
2167                     V_BSTR(&left) = lbstr;
2168                 V_VT(&right) = rightvt | ExtraFlags[i];
2169                 if (rightvt == VT_BSTR)
2170                     V_BSTR(&right) = rbstr;
2171                 V_VT(&result) = VT_EMPTY;
2172
2173                 /* All extra flags produce errors */
2174                 if (ExtraFlags[i] == (VT_VECTOR|VT_BYREF|VT_RESERVED) ||
2175                     ExtraFlags[i] == (VT_VECTOR|VT_RESERVED) ||
2176                     ExtraFlags[i] == (VT_VECTOR|VT_BYREF) ||
2177                     ExtraFlags[i] == (VT_BYREF|VT_RESERVED) ||
2178                     ExtraFlags[i] == VT_VECTOR ||
2179                     ExtraFlags[i] == VT_BYREF ||
2180                     ExtraFlags[i] == VT_RESERVED)
2181                 {
2182                     expectedhres = DISP_E_BADVARTYPE;
2183                     resvt = VT_EMPTY;
2184                 }
2185                 else if (ExtraFlags[i] >= VT_ARRAY)
2186                 {
2187                     expectedhres = DISP_E_TYPEMISMATCH;
2188                     resvt = VT_EMPTY;
2189                 }
2190                 /* Native VarSub cannot handle: VT_I1, VT_UI2, VT_UI4,
2191                    VT_INT, VT_UINT and VT_UI8. Tested with WinXP */
2192                 else if (!IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
2193                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
2194                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
2195                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
2196                     leftvt == VT_I1 || rightvt == VT_I1 ||
2197                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
2198                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
2199                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
2200                     leftvt == VT_INT || rightvt == VT_INT ||
2201                     leftvt == VT_UINT || rightvt == VT_UINT ||
2202                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
2203                     leftvt == VT_RECORD || rightvt == VT_RECORD)
2204                 {
2205                     if (leftvt == VT_RECORD && rightvt == VT_I8)
2206                     {
2207                         if (HAVE_OLEAUT32_I8)
2208                             expectedhres = DISP_E_TYPEMISMATCH;
2209                         else
2210                             expectedhres = DISP_E_BADVARTYPE;
2211                     }
2212                     else if (leftvt < VT_UI1 && rightvt == VT_RECORD)
2213                         expectedhres = DISP_E_TYPEMISMATCH;
2214                     else if (leftvt >= VT_UI1 && rightvt == VT_RECORD)
2215                         expectedhres = DISP_E_TYPEMISMATCH;
2216                     else if (leftvt == VT_RECORD && rightvt <= VT_UI1)
2217                         expectedhres = DISP_E_TYPEMISMATCH;
2218                     else if (leftvt == VT_RECORD && rightvt > VT_UI1)
2219                         expectedhres = DISP_E_BADVARTYPE;
2220                     else
2221                         expectedhres = DISP_E_BADVARTYPE;
2222                     resvt = VT_EMPTY;
2223                 }
2224                 else if ((leftvt == VT_NULL && rightvt == VT_DISPATCH) ||
2225                     (leftvt == VT_DISPATCH && rightvt == VT_NULL))
2226                     resvt = VT_NULL;
2227                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
2228                     leftvt == VT_ERROR || rightvt == VT_ERROR)
2229                 {
2230                     resvt = VT_EMPTY;
2231                     expectedhres = DISP_E_TYPEMISMATCH;
2232                 }
2233                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
2234                     resvt = VT_NULL;
2235                 else if ((leftvt == VT_EMPTY && rightvt == VT_BSTR) ||
2236                     (leftvt == VT_DATE && rightvt == VT_DATE) ||
2237                     (leftvt == VT_BSTR && rightvt == VT_EMPTY) ||
2238                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
2239                     resvt = VT_R8;
2240                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
2241                     resvt = VT_DECIMAL;
2242                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
2243                     resvt = VT_DATE;
2244                 else if (leftvt == VT_CY || rightvt == VT_CY)
2245                     resvt = VT_CY;
2246                 else if (leftvt == VT_R8 || rightvt == VT_R8)
2247                     resvt = VT_R8;
2248                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
2249                     resvt = VT_R8;
2250                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
2251                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
2252                         leftvt == VT_I8 || rightvt == VT_I8)
2253                         resvt = VT_R8;
2254                     else
2255                         resvt = VT_R4;
2256                 }
2257                 else if (leftvt == VT_I8 || rightvt == VT_I8)
2258                     resvt = VT_I8;
2259                 else if (leftvt == VT_I4 || rightvt == VT_I4)
2260                     resvt = VT_I4;
2261                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
2262                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
2263                     (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
2264                     resvt = VT_I2;
2265                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
2266                     resvt = VT_UI1;
2267                 else
2268                 {
2269                     resvt = VT_EMPTY;
2270                     expectedhres = DISP_E_TYPEMISMATCH;
2271                 }
2272
2273                 hres = pVarSub(&left, &right, &result);
2274
2275                 ok(hres == expectedhres && V_VT(&result) == resvt,
2276                     "VarSub: %d|0x%X, %d|0x%X: Expected failure 0x%X, "
2277                     "got 0x%X, expected vt %d got vt %d\n",
2278                     leftvt, ExtraFlags[i], rightvt, ExtraFlags[i],
2279                     expectedhres, hres, resvt, V_VT(&result));
2280             }
2281         }
2282     }
2283
2284     /* Test returned values */
2285     VARSUB(I4,4,I4,2,I4,2);
2286     VARSUB(I2,4,I2,2,I2,2);
2287     VARSUB(I2,-13,I4,5,I4,-18);
2288     VARSUB(I4,-13,I4,5,I4,-18);
2289     VARSUB(I2,7,R4,0.5f,R4,6.5f);
2290     VARSUB(R4,0.5f,I4,5,R8,-4.5);
2291     VARSUB(R8,7.1,BOOL,0,R8,7.1);
2292     VARSUB(BSTR,lbstr,I2,4,R8,8);
2293     VARSUB(BSTR,lbstr,BOOL,1,R8,11);
2294     VARSUB(BSTR,lbstr,R4,0.1f,R8,11.9);
2295     VARSUB(R4,0.2f,BSTR,rbstr,R8,-11.8);
2296     VARSUB(DATE,2.25,I4,7,DATE,-4.75);
2297     VARSUB(DATE,1.25,R4,-1.7f,DATE,2.95);
2298
2299     VARSUB(UI1, UI1_MAX, UI1, UI1_MAX, UI1, 0);
2300     VARSUB(I2, I2_MAX, I2, I2_MAX, I2, 0);
2301     VARSUB(I2, I2_MIN, I2, I2_MIN, I2, 0);
2302     VARSUB(I4, I4_MAX, I4, I4_MAX, I4, 0);
2303     VARSUB(I4, I4_MIN, I4, I4_MIN, I4, 0);
2304     VARSUB(R4, R4_MAX, R4, R4_MAX, R4, 0.0f);
2305     VARSUB(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX - R4_MIN);
2306     VARSUB(R4, R4_MIN, R4, R4_MIN, R4, 0.0f);
2307     VARSUB(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX - R8_MIN);
2308     VARSUB(R8, R8_MIN, R8, R8_MIN, R8, 0.0);
2309
2310     /* Manually test BSTR + BSTR */
2311     V_VT(&left) = VT_BSTR;
2312     V_BSTR(&left) = lbstr;
2313     V_VT(&right) = VT_BSTR;
2314     V_BSTR(&right) = rbstr;
2315     hres = pVarSub(&left, &right, &result);
2316     ok(hres == S_OK && V_VT(&result) == VT_R8,
2317         "VarSub: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
2318     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0),
2319         "VarSub: BSTR + BSTR, expected %f got %f\n", 0.0, V_R8(&result));
2320
2321     /* Manually test some VT_CY and VT_DECIMAL variants */
2322     V_VT(&cy) = VT_CY;
2323     hres = VarCyFromI4(4711, &V_CY(&cy));
2324     ok(hres == S_OK, "VarCyFromI4 failed!\n");
2325     V_VT(&dec) = VT_DECIMAL;
2326     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
2327     ok(hres == S_OK, "VarDecFromR4 failed!\n");
2328     memset(&left, 0, sizeof(left));
2329     memset(&right, 0, sizeof(right));
2330     V_VT(&left) = VT_I4;
2331     V_I4(&left) = -11;
2332     V_VT(&right) = VT_UI1;
2333     V_UI1(&right) = 9;
2334
2335     hres = pVarSub(&cy, &right, &result);
2336     ok(hres == S_OK && V_VT(&result) == VT_CY,
2337         "VarSub: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
2338     hres = VarR8FromCy(V_CY(&result), &r);
2339     ok(hres == S_OK && EQ_DOUBLE(r, 4702),
2340         "VarSub: CY value %f, expected %f\n", r, (double)4720);
2341
2342     hres = pVarSub(&left, &dec, &result);
2343     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
2344         "VarSub: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
2345     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
2346     ok(hres == S_OK && EQ_DOUBLE(r, -6.8),
2347         "VarSub: DECIMAL value %f, expected %f\n", r, (double)-15.2);
2348
2349     SysFreeString(lbstr);
2350     SysFreeString(rbstr);
2351 }
2352
2353 static HRESULT (WINAPI *pVarMod)(LPVARIANT,LPVARIANT,LPVARIANT);
2354
2355 static void test_Mod( int line, VARIANT *left, VARIANT *right, VARIANT *expected, HRESULT expres )
2356 {
2357     VARIANT result;
2358     HRESULT hres;
2359
2360     memset( &result, 0, sizeof(result) );
2361     hres = pVarMod( left, right, &result );
2362     ok_(__FILE__,line)( hres == expres, "wrong result %x/%x\n", hres, expres );
2363     if (hres == S_OK)
2364         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
2365                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
2366 }
2367
2368 #define VARMOD(vt1,vt2,val1,val2,rvt,rval)               \
2369         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
2370         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2371         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
2372         test_var_call2( __LINE__, pVarMod, &left, &right, &exp )
2373
2374 #define VARMOD2(vt1,vt2,val1,val2,rvt,rval,hexpected)         \
2375         V_VT(&left) = VT_##vt1; V_I4(&left) = val1;           \
2376         V_VT(&right) = VT_##vt2; V_I4(&right) = val2;         \
2377         V_VT(&exp) = VT_##rvt; V_I4(&exp) = rval;             \
2378         test_Mod( __LINE__, &left, &right, &exp, hexpected )
2379
2380 static void test_VarMod(void)
2381 {
2382   VARIANT v1, v2, vDst, left, right, exp;
2383   HRESULT hres;
2384   HRESULT hexpected = 0;
2385   static const WCHAR szNum0[] = {'1','2','5','\0'};
2386   static const WCHAR szNum1[] = {'1','0','\0'};
2387   int l, r;
2388   BOOL lFound, rFound;
2389   BOOL lValid;
2390   BSTR strNum0, strNum1;
2391
2392   CHECKPTR(VarMod);
2393
2394   VARMOD(I1,BOOL,100,10,I4,0);
2395   VARMOD(I1,I1,100,10,I4,0);
2396   VARMOD(I1,UI1,100,10,I4,0);
2397   VARMOD(I1,I2,100,10,I4,0);
2398   VARMOD(I1,UI2,100,10,I4,0);
2399   VARMOD(I1,I4,100,10,I4,0);
2400   VARMOD(I1,UI4,100,10,I4,0);
2401   VARMOD(I1,R4,100,10,I4,0);
2402   VARMOD(I1,R8,100,10,I4,0);
2403
2404   VARMOD(UI1,BOOL,100,10,I2,0);
2405   VARMOD(UI1,I1,100,10,I4,0);
2406   VARMOD(UI1,UI1,100,10,UI1,0);
2407   VARMOD(UI1,I2,100,10,I2,0);
2408   VARMOD(UI1,UI2,100,10,I4,0);
2409   VARMOD(UI1,I4,100,10,I4,0);
2410   VARMOD(UI1,UI4,100,10,I4,0);
2411   VARMOD(UI1,R4,100,10,I4,0);
2412   VARMOD(UI1,R8,100,10,I4,0);
2413
2414   VARMOD(I2,BOOL,100,10,I2,0);
2415   VARMOD(I2,I1,100,10,I4,0);
2416   VARMOD(I2,UI1,100,10,I2,0);
2417   VARMOD(I2,I2,100,10,I2,0);
2418   VARMOD(I2,UI2,100,10,I4,0);
2419   VARMOD(I2,I4,100,10,I4,0);
2420   VARMOD(I2,UI4,100,10,I4,0);
2421   VARMOD(I2,R4,100,10,I4,0);
2422   VARMOD(I2,R8,100,10,I4,0);
2423
2424   VARMOD(I4,BOOL,100,10,I4,0);
2425   VARMOD(I4,I1,100,10,I4,0);
2426   VARMOD(I4,UI1,100,10,I4,0);
2427   VARMOD(I4,I2,100,10,I4,0);
2428   VARMOD(I4,UI2,100,10,I4,0);
2429   VARMOD(I4,I4,100,10,I4,0);
2430   VARMOD(I4,UI4,100,10,I4,0);
2431   VARMOD(I4,R4,100,10,I4,0);
2432   VARMOD(I4,R8,100,10,I4,0);
2433   VARMOD(UI4,BOOL,100,10,I4,0);
2434   VARMOD(UI4,I1,100,10,I4,0);
2435   VARMOD(UI4,UI1,100,10,I4,0);
2436   VARMOD(UI4,I2,100,10,I4,0);
2437   VARMOD(UI4,UI2,100,10,I4,0);
2438   VARMOD(UI4,I4,100,10,I4,0);
2439   VARMOD(UI4,UI4,100,10,I4,0);
2440   VARMOD(UI4,R4,100,10,I4,0);
2441   VARMOD(UI4,R8,100,10,I4,0);
2442   VARMOD(R4,BOOL,100,10,I4,0);
2443   VARMOD(R4,I1,100,10,I4,0);
2444   VARMOD(R4,UI1,100,10,I4,0);
2445   VARMOD(R4,I2,100,10,I4,0);
2446   VARMOD(R4,UI2,100,10,I4,0);
2447   VARMOD(R4,I4,100,10,I4,0);
2448   VARMOD(R4,UI4,100,10,I4,0);
2449   VARMOD(R4,R4,100,10,I4,0);
2450   VARMOD(R4,R8,100,10,I4,0);
2451   VARMOD(R8,BOOL,100,10,I4,0);
2452   VARMOD(R8,I1,100,10,I4,0);
2453   VARMOD(R8,UI1,100,10,I4,0);
2454   VARMOD(R8,I2,100,10,I4,0);
2455   VARMOD(R8,UI2,100,10,I4,0);
2456   VARMOD(R8,I4,100,10,I4,0);
2457   VARMOD(R8,UI4,100,10,I4,0);
2458   VARMOD(R8,R4,100,10,I4,0);
2459   VARMOD(R8,R8,100,10,I4,0);
2460
2461   VARMOD(INT,INT,100,10,I4,0);
2462   VARMOD(INT,UINT,100,10,I4,0);
2463
2464   VARMOD(BOOL,BOOL,100,10,I2,0);
2465   VARMOD(BOOL,I1,100,10,I4,0);
2466   VARMOD(BOOL,UI1,100,10,I2,0);
2467   VARMOD(BOOL,I2,100,10,I2,0);
2468   VARMOD(BOOL,UI2,100,10,I4,0);
2469   VARMOD(BOOL,I4,100,10,I4,0);
2470   VARMOD(BOOL,UI4,100,10,I4,0);
2471   VARMOD(BOOL,R4,100,10,I4,0);
2472   VARMOD(BOOL,R8,100,10,I4,0);
2473   VARMOD(BOOL,DATE,100,10,I4,0);
2474
2475   VARMOD(DATE,BOOL,100,10,I4,0);
2476   VARMOD(DATE,I1,100,10,I4,0);
2477   VARMOD(DATE,UI1,100,10,I4,0);
2478   VARMOD(DATE,I2,100,10,I4,0);
2479   VARMOD(DATE,UI2,100,10,I4,0);
2480   VARMOD(DATE,I4,100,10,I4,0);
2481   VARMOD(DATE,UI4,100,10,I4,0);
2482   VARMOD(DATE,R4,100,10,I4,0);
2483   VARMOD(DATE,R8,100,10,I4,0);
2484   VARMOD(DATE,DATE,100,10,I4,0);
2485
2486   strNum0 = SysAllocString(szNum0);
2487   strNum1 = SysAllocString(szNum1);
2488   VARMOD(BSTR,BSTR,strNum0,strNum1,I4,5);
2489   VARMOD(BSTR,I1,strNum0,10,I4,5);
2490   VARMOD(BSTR,I2,strNum0,10,I4,5);
2491   VARMOD(BSTR,I4,strNum0,10,I4,5);
2492   VARMOD(BSTR,R4,strNum0,10,I4,5);
2493   VARMOD(BSTR,R8,strNum0,10,I4,5);
2494   VARMOD(I4,BSTR,125,strNum1,I4,5);
2495
2496   if (HAVE_OLEAUT32_I8)
2497   {
2498     VARMOD(BOOL,I8,100,10,I8,0);
2499     VARMOD(I1,I8,100,10,I8,0);
2500     VARMOD(UI1,I8,100,10,I8,0);
2501     VARMOD(I2,I8,100,10,I8,0);
2502     VARMOD(I4,I8,100,10,I8,0);
2503     VARMOD(UI4,I8,100,10,I8,0);
2504     VARMOD(R4,I8,100,10,I8,0);
2505     VARMOD(R8,I8,100,10,I8,0);
2506     VARMOD(DATE,I8,100,10,I8,0);
2507
2508     VARMOD(I8,BOOL,100,10,I8,0);
2509     VARMOD(I8,I1,100,10,I8,0);
2510     VARMOD(I8,UI1,100,10,I8,0);
2511     VARMOD(I8,I2,100,10,I8,0);
2512     VARMOD(I8,UI2,100,10,I8,0);
2513     VARMOD(I8,I4,100,10,I8,0);
2514     VARMOD(I8,UI4,100,10,I8,0);
2515     VARMOD(I8,R4,100,10,I8,0);
2516     VARMOD(I8,R8,100,10,I8,0);
2517     VARMOD(I8,I8,100,10,I8,0);
2518
2519     VARMOD(BSTR,I8,strNum0,10,I8,5);
2520   }
2521
2522   /* test all combinations of types */
2523   for(l = 0; l < VT_BSTR_BLOB; l++)
2524   {
2525     SKIPTESTS(l);
2526
2527     for(r = 0; r < VT_BSTR_BLOB; r++)
2528     {
2529       SKIPTESTS(r);
2530
2531       if(l == VT_BSTR) continue;
2532       if(l == VT_DISPATCH) continue;
2533       if(r == VT_BSTR) continue;
2534       if(r == VT_DISPATCH) continue;
2535
2536       lFound = TRUE;
2537       lValid = TRUE;
2538       switch(l)
2539         {
2540         case VT_EMPTY:
2541         case VT_NULL:
2542         case VT_I1:
2543         case VT_UI1:
2544         case VT_I2:
2545         case VT_UI2:
2546         case VT_I4:
2547         case VT_I8:
2548         case VT_UI4:
2549         case VT_UI8:
2550         case VT_INT:
2551         case VT_UINT:
2552         case VT_R4:
2553         case VT_R8:
2554         case VT_BOOL:
2555         case VT_DATE:
2556         case VT_CY:
2557         case VT_DECIMAL:
2558           hexpected = S_OK;
2559           break;
2560         case VT_ERROR:
2561         case VT_VARIANT:
2562         case VT_UNKNOWN:
2563         case VT_RECORD:
2564           lValid = FALSE;
2565           break;
2566         default:
2567           lFound = FALSE;
2568           hexpected = DISP_E_BADVARTYPE;
2569           break;
2570         }
2571
2572       rFound = TRUE;
2573       switch(r)
2574         {
2575         case VT_EMPTY:
2576         case VT_NULL:
2577         case VT_I1:
2578         case VT_UI1:
2579         case VT_I2:
2580         case VT_UI2:
2581         case VT_I4:
2582         case VT_I8:
2583         case VT_UI4:
2584         case VT_UI8:
2585         case VT_INT:
2586         case VT_UINT:
2587         case VT_R4:
2588         case VT_R8:
2589         case VT_BOOL:
2590         case VT_DATE:
2591         case VT_DECIMAL:
2592         case VT_CY:
2593           hexpected = S_OK;
2594           break;
2595         case VT_ERROR:
2596         case VT_VARIANT:
2597         case VT_UNKNOWN:
2598         case VT_RECORD:
2599           break;
2600         default:
2601           rFound = FALSE;
2602           break;
2603         }
2604
2605       if(((l == VT_I8) && (r == VT_INT)) || ((l == VT_INT) && (r == VT_I8)))
2606       {
2607         hexpected = DISP_E_TYPEMISMATCH;
2608       } else if((l == VT_EMPTY) && (r == VT_NULL))
2609       {
2610         hexpected = S_OK;
2611       } else if((l == VT_NULL) && (r == VT_EMPTY))
2612       {
2613         hexpected = S_OK;
2614       } else if((l == VT_EMPTY) && (r == VT_CY))
2615       {
2616         hexpected = S_OK;
2617       } else if((l == VT_EMPTY) && (r == VT_RECORD))
2618       {
2619         hexpected = DISP_E_TYPEMISMATCH;
2620       } else if((r == VT_EMPTY) && lFound && lValid)
2621       {
2622         hexpected = DISP_E_DIVBYZERO;
2623       } else if((l == VT_ERROR) || ((r == VT_ERROR) && lFound && lValid))
2624       {
2625         hexpected = DISP_E_TYPEMISMATCH;
2626       } else if((l == VT_NULL) && (r == VT_NULL))
2627       {
2628         hexpected = S_OK;
2629       } else if((l == VT_VARIANT) || ((r == VT_VARIANT) && lFound && lValid))
2630       {
2631         hexpected = DISP_E_TYPEMISMATCH;
2632       } else if((l == VT_NULL) && (r == VT_RECORD))
2633       {
2634         hexpected = DISP_E_TYPEMISMATCH;
2635       } else if((l == VT_I8) && (r == VT_DECIMAL))
2636       {
2637         hexpected = S_OK;
2638       } else if((l == VT_DECIMAL) && (r == VT_I8))
2639       {
2640         hexpected = S_OK;
2641       } else if((l == VT_UNKNOWN) || ((r == VT_UNKNOWN) && lFound && lValid))
2642       {
2643         hexpected = DISP_E_TYPEMISMATCH;
2644       } else if((l == VT_NULL) && rFound)
2645       {
2646         hexpected = S_OK;
2647       } else if(l == VT_RECORD)
2648       {
2649         hexpected = DISP_E_TYPEMISMATCH;
2650       } else if((r == VT_RECORD) && lValid && lFound)
2651       {
2652         hexpected = DISP_E_TYPEMISMATCH;
2653       } else if((l == VT_EMPTY) && (r == VT_EMPTY))
2654       {
2655         hexpected = DISP_E_DIVBYZERO;
2656       } else if((l == VT_CY) && !rFound)
2657       {
2658         hexpected = DISP_E_BADVARTYPE;
2659       } else if(lFound && !rFound)
2660       {
2661         hexpected = DISP_E_BADVARTYPE;
2662       } else if(!lFound && rFound)
2663       {
2664         hexpected = DISP_E_BADVARTYPE;
2665       } else if((r == VT_NULL) && lFound && lValid)
2666       {
2667         hexpected = S_OK;
2668       } else if((l == VT_NULL) || (r == VT_NULL))
2669       {
2670         hexpected = DISP_E_BADVARTYPE;
2671       } else if((l == VT_VARIANT) || (r == VT_VARIANT))
2672       {
2673         hexpected = DISP_E_BADVARTYPE;
2674       } else if(lFound && !rFound)
2675       {
2676         hexpected = DISP_E_BADVARTYPE;
2677       } else if(!lFound && !rFound)
2678       {
2679         hexpected = DISP_E_BADVARTYPE;
2680       }
2681
2682       V_VT(&v1) = l;
2683       V_VT(&v2) = r;
2684
2685       if(l == VT_CY)
2686         V_CY(&v1).int64 = 1000000;
2687       else if(l == VT_R4)
2688         V_R4(&v1) = 100;
2689       else if(l == VT_R8)
2690         V_R8(&v1) = 100;
2691       else if(l == VT_UI8)
2692         V_UI8(&v1) = 100;
2693       else if(l == VT_I8)
2694         V_I8(&v1) = 100;
2695       else if(l == VT_DATE)
2696         V_DATE(&v1) = 1000;
2697       else if (l == VT_DECIMAL)
2698       {
2699         V_DECIMAL(&v1).Hi32 = 0;
2700         U1(V_DECIMAL(&v1)).Lo64 = 100;
2701         U(V_DECIMAL(&v1)).signscale = 0;
2702       }
2703       else
2704         V_I4(&v1) = 10000;
2705
2706       if(r == VT_CY)
2707         V_CY(&v2).int64 = 10000;
2708       else if(r == VT_R4)
2709         V_R4(&v2) = 100;
2710       else if(r == VT_R8)
2711         V_R8(&v2) = 100;
2712       else if(r == VT_UI8)
2713         V_UI8(&v2) = 100;
2714       else if(r == VT_I8)
2715         V_I8(&v2) = 100;
2716       else if(r == VT_DATE)
2717         V_DATE(&v2) = 1000;
2718       else if (r == VT_DECIMAL)
2719       {
2720         V_DECIMAL(&v2).Hi32 = 0;
2721         U1(V_DECIMAL(&v2)).Lo64 = 100;
2722         U(V_DECIMAL(&v2)).signscale = 0;
2723       }
2724       else
2725         V_I4(&v2) = 10000;
2726
2727       if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || HAVE_OLEAUT32_I8)
2728       {
2729         hres = pVarMod(&v1,&v2,&vDst);
2730         ok(hres == hexpected,
2731            "VarMod: expected 0x%x, got 0x%X for l type of %d, r type of %d,\n", hexpected, hres, l, r);
2732       }
2733     }
2734   }
2735
2736
2737   /****************************/
2738   /* test some bad parameters */
2739   VARMOD(I4,I4,-1,-1,I4,0);
2740
2741   /* test modulus with zero */
2742   VARMOD2(I4,I4,100,0,EMPTY,0,DISP_E_DIVBYZERO);
2743
2744   VARMOD(I4,I4,0,10,I4,0); /* test 0 mod 10 */
2745
2746   /* right parameter is type empty */
2747   VARMOD2(I4,EMPTY,100,10,EMPTY,0,DISP_E_DIVBYZERO);
2748
2749   /* left parameter is type empty */
2750   VARMOD2(EMPTY,I4,100,10,I4,0,S_OK);
2751
2752   /* mod with a null left value */
2753   VARMOD2(NULL,I4,125,10,NULL,0,S_OK);
2754
2755   /* mod with a null right value */
2756   VARMOD2(I4,NULL,100,10,NULL,0,S_OK);
2757
2758   /* void left value */
2759   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2760
2761   /* void right value */
2762   VARMOD2(I4,VOID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2763
2764   /* null left value, void right value */
2765   VARMOD2(NULL,VOID,100,10,EMPTY, 0, DISP_E_BADVARTYPE);
2766
2767   /* void left value, null right value */
2768   VARMOD2(VOID,NULL,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2769
2770   /* some currencies */
2771   V_VT(&v1) = VT_CY;
2772   V_VT(&v2) = VT_CY;
2773   V_CY(&v1).int64 = 100000;
2774   V_CY(&v2).int64 = 100000;
2775   hres = pVarMod(&v1,&v2,&vDst);
2776   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2777      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2778
2779   V_VT(&v1) = VT_I4;
2780   V_VT(&v2) = VT_CY;
2781   V_I4(&v1) = 100;
2782   V_CY(&v2).int64 = 100000;
2783   hres = pVarMod(&v1,&v2,&vDst);
2784   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2785      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2786
2787   /* some decimals */
2788   V_VT(&v1) = VT_DECIMAL;
2789   V_VT(&v2) = VT_DECIMAL;
2790   VarDecFromI4(100, &V_DECIMAL(&v1));
2791   VarDecFromI4(10, &V_DECIMAL(&v2));
2792   hres = pVarMod(&v1,&v2,&vDst);
2793   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2794      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2795
2796   V_VT(&v1) = VT_I4;
2797   V_VT(&v2) = VT_DECIMAL;
2798   V_I4(&v1) = 100;
2799   VarDecFromI4(10, &V_DECIMAL(&v2));
2800   hres = pVarMod(&v1,&v2,&vDst);
2801   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2802      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2803
2804   VARMOD2(UINT,I4,100,10,I4,0,S_OK);
2805
2806   /* test that an error results in the type of the result changing but not its value */
2807   V_VT(&v1) = VT_UNKNOWN;
2808   V_VT(&v2) = VT_EMPTY;
2809   V_I4(&v1) = 100;
2810   V_CY(&v2).int64 = 100000;
2811   V_VT(&vDst) = VT_I4;
2812   V_I4(&vDst) = 1231;
2813   hres = pVarMod(&v1,&v2,&vDst);
2814   ok(hres == DISP_E_TYPEMISMATCH && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 1231,
2815      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", DISP_E_TYPEMISMATCH, VT_EMPTY, 1231, hres, V_VT(&vDst), V_I4(&vDst));
2816
2817
2818   /* test some invalid types */
2819   /*TODO: not testing VT_DISPATCH */
2820   if (HAVE_OLEAUT32_I8)
2821   {
2822     VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2823   }
2824   VARMOD2(ERROR,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2825   VARMOD2(VARIANT,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2826   VARMOD2(UNKNOWN,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2827   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2828   VARMOD2(HRESULT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2829   VARMOD2(PTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2830   VARMOD2(SAFEARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2831   VARMOD2(CARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2832   VARMOD2(USERDEFINED,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2833   VARMOD2(LPSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2834   VARMOD2(LPWSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2835   VARMOD2(RECORD,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2836   VARMOD2(FILETIME,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2837   VARMOD2(BLOB,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2838   VARMOD2(STREAM,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2839   VARMOD2(STORAGE,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2840   VARMOD2(STREAMED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2841   VARMOD2(STORED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2842   VARMOD2(BLOB_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2843   VARMOD2(CF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2844   VARMOD2(CLSID,CLSID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2845   VARMOD2(VECTOR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2846   VARMOD2(ARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2847   VARMOD2(BYREF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2848
2849   /* test some more invalid types */
2850   V_VT(&v1) = 456;
2851   V_VT(&v2) = 234;
2852   V_I4(&v1) = 100;
2853   V_I4(&v2)=  10;
2854   hres = pVarMod(&v1,&v2,&vDst);
2855   ok(hres == DISP_E_BADVARTYPE && V_VT(&vDst) == VT_EMPTY,
2856      "VarMod: expected 0x%x,%d, got 0x%X,%d\n", DISP_E_BADVARTYPE, VT_EMPTY, hres, V_VT(&vDst));
2857
2858   SysFreeString(strNum0);
2859   SysFreeString(strNum1);
2860 }
2861
2862 static HRESULT (WINAPI *pVarFix)(LPVARIANT,LPVARIANT);
2863
2864 #define VARFIX(vt,val,rvt,rval)                  \
2865     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2866     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2867     test_var_call1( __LINE__, pVarFix, &v, &exp )
2868
2869 static void test_VarFix(void)
2870 {
2871     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2872     HRESULT hres;
2873     VARIANT v, exp, vDst;
2874     DECIMAL *pdec = &V_DECIMAL(&v);
2875     CY *pcy = &V_CY(&v);
2876     size_t i;
2877
2878     CHECKPTR(VarFix);
2879
2880     /* Test all possible V_VT values */
2881     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2882     {
2883         VARTYPE vt;
2884
2885         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2886         {
2887             HRESULT bFail = TRUE;
2888
2889             SKIPTESTS(vt);
2890
2891             memset(&v, 0, sizeof(v));
2892             V_VT(&v) = vt | ExtraFlags[i];
2893             V_VT(&vDst) = VT_EMPTY;
2894
2895             switch (V_VT(&v))
2896             {
2897               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2898               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2899               case VT_DATE: case VT_CY:
2900                 bFail = FALSE;
2901                 break;
2902               case VT_I8:
2903                 if (HAVE_OLEAUT32_I8)
2904                   bFail = FALSE;
2905                 break;
2906             }
2907
2908             hres = pVarFix(&v,&vDst);
2909             if (bFail)
2910               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2911                  "VarFix: expected failure, got 0x%X vt %d|0x%X\n",
2912                  hres, vt, ExtraFlags[i]);
2913             else
2914                  ok(hres == S_OK, "VarFix: expected S_OK, got 0x%X vt %d|0x%X\n",
2915                     hres, vt, ExtraFlags[i]);
2916         }
2917     }
2918
2919     VARFIX(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2920     VARFIX(BOOL,VARIANT_FALSE,I2,0);
2921     VARFIX(BOOL,1,I2,1);
2922     VARFIX(UI1,1,UI1,1);
2923     VARFIX(I2,-1,I2,-1);
2924     VARFIX(I4,-1,I4,-1);
2925     if (HAVE_OLEAUT32_I8)
2926     {
2927         VARFIX(I8,-1,I8,-1);
2928     }
2929     VARFIX(R4,1.4f,R4,1);
2930     VARFIX(R4,1.5f,R4,1);
2931     VARFIX(R4,1.6f,R4,1);
2932     VARFIX(R4,-1.4f,R4,-1);
2933     VARFIX(R4,-1.5f,R4,-1);
2934     VARFIX(R4,-1.6f,R4,-1);
2935     /* DATE & R8 round as for R4 */
2936     VARFIX(DATE,-1,DATE,-1);
2937     VARFIX(R8,-1,R8,-1);
2938     VARFIX(BSTR,(BSTR)szNumMinus1,R8,-1);
2939
2940     V_VT(&v) = VT_EMPTY;
2941     hres = pVarFix(&v,&vDst);
2942     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2943        "VarFix: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
2944        hres, V_VT(&vDst), V_I2(&vDst));
2945
2946     V_VT(&v) = VT_NULL;
2947     hres = pVarFix(&v,&vDst);
2948     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2949        "VarFix: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
2950
2951     V_VT(&v) = VT_DECIMAL;
2952     S(U(*pdec)).sign = DECIMAL_NEG;
2953     S(U(*pdec)).scale = 0;
2954     pdec->Hi32 = 0;
2955     S1(U1(*pdec)).Mid32 = 0;
2956     S1(U1(*pdec)).Lo32 = 1;
2957     hres = pVarFix(&v,&vDst);
2958     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
2959        "VarFix: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
2960        hres, V_VT(&vDst));
2961
2962     /* FIXME: Test some fractional decimals when VarDecFix is implemented */
2963
2964     V_VT(&v) = VT_CY;
2965     pcy->int64 = -10000;
2966     hres = pVarFix(&v,&vDst);
2967     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2968        "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2969
2970     V_VT(&v) = VT_CY;
2971     pcy->int64 = -16000;
2972     hres = pVarFix(&v,&vDst);
2973     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2974        "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2975 }
2976
2977 static HRESULT (WINAPI *pVarInt)(LPVARIANT,LPVARIANT);
2978
2979 #define VARINT(vt,val,rvt,rval)                  \
2980     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2981     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2982     test_var_call1( __LINE__, pVarInt, &v, &exp )
2983
2984 static void test_VarInt(void)
2985 {
2986     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2987     HRESULT hres;
2988     VARIANT v, exp, vDst;
2989     DECIMAL *pdec = &V_DECIMAL(&v);
2990     CY *pcy = &V_CY(&v);
2991     size_t i;
2992
2993     CHECKPTR(VarInt);
2994
2995     /* Test all possible V_VT values */
2996     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2997     {
2998         VARTYPE vt;
2999
3000         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3001         {
3002             HRESULT bFail = TRUE;
3003
3004             SKIPTESTS(vt);
3005
3006             memset(&v, 0, sizeof(v));
3007             V_VT(&v) = vt | ExtraFlags[i];
3008             V_VT(&vDst) = VT_EMPTY;
3009
3010             switch (V_VT(&v))
3011             {
3012               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
3013               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3014               case VT_DATE: case VT_CY:
3015                 bFail = FALSE;
3016                 break;
3017               case VT_I8:
3018                 if (HAVE_OLEAUT32_I8)
3019                   bFail = FALSE;
3020                 break;
3021             }
3022
3023             hres = pVarInt(&v,&vDst);
3024             if (bFail)
3025               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3026                  "VarInt: expected failure, got 0x%X vt %d|0x%X\n",
3027                  hres, vt, ExtraFlags[i]);
3028             else
3029                  ok(hres == S_OK, "VarInt: expected S_OK, got 0x%X vt %d|0x%X\n",
3030                     hres, vt, ExtraFlags[i]);
3031         }
3032     }
3033
3034     VARINT(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
3035     VARINT(BOOL,VARIANT_FALSE,I2,0);
3036     VARINT(BOOL,1,I2,1);
3037     VARINT(UI1,1,UI1,1);
3038     VARINT(I2,-1,I2,-1);
3039     VARINT(I4,-1,I4,-1);
3040     if (HAVE_OLEAUT32_I8)
3041     {
3042         VARINT(I8,-1,I8,-1);
3043     }
3044     VARINT(R4,1.4f,R4,1);
3045     VARINT(R4,1.5f,R4,1);
3046     VARINT(R4,1.6f,R4,1);
3047     VARINT(R4,-1.4f,R4,-2); /* Note these 3 are different from VarFix */
3048     VARINT(R4,-1.5f,R4,-2);
3049     VARINT(R4,-1.6f,R4,-2);
3050     /* DATE & R8 round as for R4 */
3051     VARINT(DATE,-1,DATE,-1);
3052     VARINT(R8,-1,R8,-1);
3053     VARINT(BSTR,(BSTR)szNumMinus1,R8,-1);
3054
3055     V_VT(&v) = VT_EMPTY;
3056     hres = pVarInt(&v,&vDst);
3057     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3058        "VarInt: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3059        hres, V_VT(&vDst), V_I2(&vDst));
3060
3061     V_VT(&v) = VT_NULL;
3062     hres = pVarInt(&v,&vDst);
3063     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3064        "VarInt: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3065
3066     V_VT(&v) = VT_DECIMAL;
3067     S(U(*pdec)).sign = DECIMAL_NEG;
3068     S(U(*pdec)).scale = 0;
3069     pdec->Hi32 = 0;
3070     S1(U1(*pdec)).Mid32 = 0;
3071     S1(U1(*pdec)).Lo32 = 1;
3072     hres = pVarInt(&v,&vDst);
3073     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
3074        "VarInt: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
3075        hres, V_VT(&vDst));
3076
3077     /* FIXME: Test some fractional decimals when VarDecInt is implemented */
3078
3079     V_VT(&v) = VT_CY;
3080     pcy->int64 = -10000;
3081     hres = pVarInt(&v,&vDst);
3082     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
3083        "VarInt: VT_CY wrong, hres=0x%X\n", hres);
3084
3085     V_VT(&v) = VT_CY;
3086     pcy->int64 = -11000;
3087     hres = pVarInt(&v,&vDst);
3088     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -20000,
3089        "VarInt: VT_CY wrong, hres=0x%X 0x%x%08x\n",
3090        hres, (DWORD)(V_CY(&vDst).int64 >> 32), (DWORD)V_CY(&vDst).int64);
3091 }
3092
3093 static HRESULT (WINAPI *pVarNeg)(LPVARIANT,LPVARIANT);
3094
3095 #define VARNEG(vt,val,rvt,rval)                  \
3096     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
3097     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3098     test_var_call1( __LINE__, pVarNeg, &v, &exp )
3099
3100 static void test_VarNeg(void)
3101 {
3102     static const WCHAR szNumMinus1[] = {'-','1','\0' };
3103     static const WCHAR szNum1[] = {'1','\0' };
3104     HRESULT hres;
3105     VARIANT v, exp, vDst;
3106     DECIMAL *pdec = &V_DECIMAL(&v);
3107     CY *pcy = &V_CY(&v);
3108     size_t i;
3109
3110     CHECKPTR(VarNeg);
3111
3112     /* Test all possible V_VT values. But don't test the exact return values
3113      * except for success/failure, since M$ made a hash of them in the
3114      * native version. This at least ensures (as with all tests here) that
3115      * we will notice if/when new vtypes/flags are added in native.
3116      */
3117     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3118     {
3119         VARTYPE vt;
3120
3121         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3122         {
3123             HRESULT bFail = TRUE;
3124
3125             SKIPTESTS(vt);
3126
3127             memset(&v, 0, sizeof(v));
3128             V_VT(&v) = vt | ExtraFlags[i];
3129             V_VT(&vDst) = VT_EMPTY;
3130
3131             switch (V_VT(&v))
3132             {
3133             case VT_UI1: case VT_I2: case VT_I4:
3134             case VT_R4:  case VT_R8:
3135             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3136             case VT_DATE: case VT_CY:
3137                 bFail = FALSE;
3138                 break;
3139             case VT_I8:
3140                 if (HAVE_OLEAUT32_I8)
3141                     bFail = FALSE;
3142             }
3143
3144             hres = pVarNeg(&v,&vDst);
3145             if (bFail)
3146                 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3147                    "VarNeg: expected failure, got 0x%X vt %d|0x%X\n",
3148                    hres, vt, ExtraFlags[i]);
3149             else
3150                 ok(hres == S_OK, "VarNeg: expected S_OK, got 0x%X vt %d|0x%X\n",
3151                     hres, vt, ExtraFlags[i]);
3152         }
3153     }
3154
3155     VARNEG(BOOL,VARIANT_TRUE,I2,1);
3156     VARNEG(BOOL,VARIANT_FALSE,I2,0);
3157     VARNEG(BOOL,1,I2,-1);
3158     VARNEG(UI1,1,I2,-1);
3159     VARNEG(UI1,254,I2,-254);
3160     VARNEG(I2,-32768,I4,32768);
3161     VARNEG(I2,-1,I2,1);
3162     VARNEG(I2,1,I2,-1);
3163     VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
3164     VARNEG(I4,-1,I4,1);
3165     VARNEG(I4,1,I4,-1);
3166     if (HAVE_OLEAUT32_I8)
3167     {
3168         VARNEG(I8,1,I8,-1);
3169         VARNEG(I8,-1,I8,1);
3170     }
3171     VARNEG(R4,1,R4,-1);
3172     VARNEG(R4,-1,R4,1);
3173     VARNEG(DATE,1,DATE,-1);
3174     VARNEG(DATE,-1,DATE,1);
3175     VARNEG(R8,1,R8,-1);
3176     VARNEG(R8,-1,R8,1);
3177     VARNEG(BSTR,(BSTR)szNumMinus1,R8,1);
3178     VARNEG(BSTR,(BSTR)szNum1,R8,-1);
3179
3180     V_VT(&v) = VT_EMPTY;
3181     hres = pVarNeg(&v,&vDst);
3182     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3183        "VarNeg: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3184        hres, V_VT(&vDst), V_I2(&vDst));
3185
3186     V_VT(&v) = VT_NULL;
3187     hres = pVarNeg(&v,&vDst);
3188     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3189        "VarNeg: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3190
3191     V_VT(&v) = VT_DECIMAL;
3192     S(U(*pdec)).sign = DECIMAL_NEG;
3193     S(U(*pdec)).scale = 0;
3194     pdec->Hi32 = 0;
3195     S1(U1(*pdec)).Mid32 = 0;
3196     S1(U1(*pdec)).Lo32 = 1;
3197     hres = pVarNeg(&v,&vDst);
3198     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3199        S(U(V_DECIMAL(&vDst))).sign == 0,
3200        "VarNeg: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3201        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3202
3203     S(U(*pdec)).sign = 0;
3204     hres = pVarNeg(&v,&vDst);
3205     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3206        S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3207        "VarNeg: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3208        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3209
3210     V_VT(&v) = VT_CY;
3211     pcy->int64 = -10000;
3212     hres = pVarNeg(&v,&vDst);
3213     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3214        "VarNeg: VT_CY wrong, hres=0x%X\n", hres);
3215 }
3216
3217 static HRESULT (WINAPI *pVarRound)(LPVARIANT,int,LPVARIANT);
3218
3219 static void test_Round( int line, VARIANT *arg, int deci, VARIANT *expected )
3220 {
3221     VARIANT result;
3222     HRESULT hres;
3223
3224     memset( &result, 0, sizeof(result) );
3225     hres = pVarRound( arg, deci, &result );
3226     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
3227     if (hres == S_OK)
3228         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
3229                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
3230 }
3231 #define VARROUND(vt,val,deci,rvt,rval)           \
3232     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
3233     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3234     test_Round( __LINE__, &v, deci, &exp )
3235
3236 static void test_VarRound(void)
3237 {
3238     static WCHAR szNumMin[] = {'-','1','.','4','4','9','\0' };
3239     static WCHAR szNum[] = {'1','.','4','5','1','\0' };
3240     HRESULT hres;
3241     VARIANT v, exp, vDst;
3242     CY *pcy = &V_CY(&v);
3243     char buff[8];
3244
3245     CHECKPTR(VarRound);
3246
3247     /* first check valid integer types */
3248     VARROUND(BOOL,VARIANT_TRUE,0,I2,-1);
3249     VARROUND(BOOL,VARIANT_FALSE,0,I2,0);
3250     VARROUND(BOOL,1,0,I2,1);
3251     VARROUND(UI1,1,0,UI1,1);
3252     VARROUND(UI1,254,0,UI1,254);
3253     VARROUND(I2,-32768,0,I2,-32768);
3254     VARROUND(I2,-1,0,I2,-1);
3255     VARROUND(I2,1,0,I2,1);
3256     VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1);
3257     VARROUND(I4,-1,0,I4,-1);
3258     VARROUND(I4,1,0,I4,1);
3259
3260
3261     /* MSDN states that rounding of R4/R8 is dependent on the underlying
3262      * bit pattern of the number and so is architecture dependent. In this
3263      * case Wine returns .2 (which is more correct) and Native returns .3
3264      */
3265
3266     VARROUND(R4,1.0f,0,R4,1.0f);
3267     VARROUND(R4,-1.0f,0,R4,-1.0f);
3268     VARROUND(R8,1.0,0,R8,1.0);
3269     VARROUND(R8,-1.0,0,R8,-1.0);
3270
3271     /* floating point numbers aren't exactly equal and we can't just
3272      * compare the first few digits. */
3273     VARROUND(DATE,1.451,1,DATE,1.5);
3274     VARROUND(DATE,-1.449,1,DATE,-1.4);
3275
3276     /* replace the decimal separator */
3277     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
3278     if (!buff[1]) {
3279         szNumMin[2] = buff[0];
3280         szNum[1] = buff[0];
3281         VARROUND(BSTR,(BSTR)szNumMin,1,R8,-1.40);
3282         VARROUND(BSTR,(BSTR)szNum,1,R8,1.50);
3283     } else {
3284         skip("Skipping VarRound(BSTR) as decimal separator is '%s'\n", buff);
3285     }
3286
3287     VARROUND(R4,1.23456f,0,R4,1.0f);
3288     VARROUND(R4,1.23456f,1,R4,1.2f);
3289     VARROUND(R4,1.23456f,2,R4,1.23f);
3290     VARROUND(R4,1.23456f,3,R4,1.235f);
3291     VARROUND(R4,1.23456f,4,R4,1.2346f);
3292     VARROUND(R4,-1.23456f,0,R4,-1.0f);
3293     VARROUND(R4,-1.23456f,1,R4,-1.2f);
3294     VARROUND(R4,-1.23456f,2,R4,-1.23f);
3295     VARROUND(R4,-1.23456f,3,R4,-1.235f);
3296     VARROUND(R4,-1.23456f,4,R4,-1.2346f);
3297
3298     VARROUND(R8,1.23456,0,R8,1.0);
3299     VARROUND(R8,1.23456,1,R8,1.2);
3300     VARROUND(R8,1.23456,2,R8,1.23);
3301     VARROUND(R8,1.23456,3,R8,1.235);
3302     VARROUND(R8,1.23456,4,R8,1.2346);
3303     VARROUND(R8,-1.23456,0,R8,-1.0);
3304     VARROUND(R8,-1.23456,1,R8,-1.2);
3305     VARROUND(R8,-1.23456,2,R8,-1.23);
3306     VARROUND(R8,-1.23456,3,R8,-1.235);
3307     VARROUND(R8,-1.23456,4,R8,-1.2346);
3308
3309     V_VT(&v) = VT_EMPTY;
3310     hres = pVarRound(&v,0,&vDst);
3311     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3312         "VarRound: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3313         hres, V_VT(&vDst), V_I2(&vDst));
3314
3315     V_VT(&v) = VT_NULL;
3316     hres = pVarRound(&v,0,&vDst);
3317     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3318         "VarRound: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3319
3320     /* not yet implemented so no use testing yet
3321     todo_wine {
3322         DECIMAL *pdec = &V_DECIMAL(&v);
3323         V_VT(&v) = VT_DECIMAL;
3324         S(U(*pdec)).sign = DECIMAL_NEG;
3325         S(U(*pdec)).scale = 0;
3326         pdec->Hi32 = 0;
3327         S1(U1(*pdec)).Mid32 = 0;
3328         S1(U1(*pdec)).Lo32 = 1;
3329         hres = pVarRound(&v,0,&vDst);
3330         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3331             S(U(V_DECIMAL(&vDst))).sign == 0,
3332             "VarRound: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3333             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3334
3335         S(U(*pdec)).sign = 0;
3336         hres = pVarRound(&v,0,&vDst);
3337         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3338             S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3339             "VarRound: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3340             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3341     }
3342     */
3343
3344     V_VT(&v) = VT_CY;
3345     pcy->int64 = 10000;
3346     hres = pVarRound(&v,0,&vDst);
3347     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3348         "VarRound: VT_CY wrong, hres=0x%X\n", hres);
3349
3350 }
3351
3352 static HRESULT (WINAPI *pVarXor)(LPVARIANT,LPVARIANT,LPVARIANT);
3353
3354 #define VARXOR(vt1,val1,vt2,val2,rvt,rval)               \
3355         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3356         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3357         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3358         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3359
3360 #define VARXORCY(vt1,val1,val2,rvt,rval)                 \
3361         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3362         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3363         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3364         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3365
3366 static void test_VarXor(void)
3367 {
3368     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3369     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3370     VARIANT left, right, exp, result;
3371     BSTR lbstr, rbstr;
3372     VARTYPE i;
3373     HRESULT hres;
3374
3375     CHECKPTR(VarXor);
3376
3377     /* Test all possible flag/vt combinations & the resulting vt type */
3378     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3379     {
3380         VARTYPE leftvt, rightvt, resvt;
3381
3382         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3383         {
3384
3385             SKIPTESTS(leftvt);
3386
3387             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3388             {
3389                 BOOL bFail = FALSE;
3390
3391                 SKIPTESTS(rightvt);
3392
3393                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3394                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3395                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3396                     continue;
3397
3398                 memset(&left, 0, sizeof(left));
3399                 memset(&right, 0, sizeof(right));
3400                 V_VT(&left) = leftvt | ExtraFlags[i];
3401                 V_VT(&right) = rightvt | ExtraFlags[i];
3402                 V_VT(&result) = VT_EMPTY;
3403                 resvt = VT_I4;
3404
3405                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3406                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3407                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3408                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3409                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
3410                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3411                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3412                 {
3413                     bFail = TRUE;
3414                 }
3415                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3416                 {
3417                     if (leftvt == rightvt ||
3418                         leftvt == VT_I2 || rightvt == VT_I2 ||
3419                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
3420                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3421                         resvt = VT_I2;
3422                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
3423                         resvt = VT_NULL;
3424                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3425                         resvt = VT_I8;
3426                 }
3427                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3428                 {
3429                     resvt = VT_NULL;
3430                 }
3431                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3432                 {
3433                     if (leftvt == rightvt)
3434                         resvt = VT_UI1;
3435                     else if (leftvt == rightvt ||
3436                         leftvt == VT_I2 || rightvt == VT_I2 ||
3437                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3438                     {
3439                         resvt = VT_I2;
3440                     }
3441                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3442                         resvt = VT_I8;
3443                 }
3444                 else if (leftvt == VT_I2 || rightvt == VT_I2)
3445                 {
3446                     if (leftvt == rightvt ||
3447                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3448                         resvt = VT_I2;
3449                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3450                         resvt = VT_I8;
3451                 }
3452                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3453                 {
3454                     resvt = VT_BOOL;
3455                 }
3456                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3457                 {
3458                     if (leftvt == VT_INT || rightvt == VT_INT)
3459                         bFail = TRUE;
3460                     else
3461                         resvt = VT_I8;
3462                 }
3463                 hres = pVarXor(&left, &right, &result);
3464                 if (bFail)
3465                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3466                        "VarXor: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
3467                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3468                        V_VT(&result));
3469                 else
3470                     ok(hres == S_OK && V_VT(&result) == resvt,
3471                        "VarXor: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
3472                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3473                        V_VT(&result));
3474             }
3475         }
3476     }
3477
3478     /* Test returned values
3479      * FIXME: Test VT_DECIMAL/VT_DISPATCH
3480      */
3481     VARXOR(EMPTY,0,EMPTY,0,I2,0);
3482     VARXOR(EMPTY,1,EMPTY,0,I2,0);
3483     VARXOR(EMPTY,0,NULL,0,NULL,0);
3484     VARXOR(EMPTY,0,I1,0,I4,0);
3485     VARXOR(EMPTY,0,I1,1,I4,1);
3486     VARXOR(EMPTY,0,UI1,0,I2,0);
3487     VARXOR(EMPTY,0,UI1,1,I2,1);
3488     VARXOR(EMPTY,0,I2,0,I2,0);
3489     VARXOR(EMPTY,0,I2,1,I2,1);
3490     VARXOR(EMPTY,0,UI2,0,I4,0);
3491     VARXOR(EMPTY,0,UI2,1,I4,1);
3492     VARXOR(EMPTY,0,I4,0,I4,0);
3493     VARXOR(EMPTY,0,I4,1,I4,1);
3494     VARXOR(EMPTY,0,UI4,0,I4,0);
3495     VARXOR(EMPTY,0,UI4,1,I4,1);
3496     if (HAVE_OLEAUT32_I8)
3497     {
3498         VARXOR(EMPTY,0,I8,0,I8,0);
3499         VARXOR(EMPTY,0,I8,1,I8,1);
3500         VARXOR(EMPTY,0,UI8,0,I4,0);
3501         VARXOR(EMPTY,0,UI8,1,I4,1);
3502     }
3503     VARXOR(EMPTY,0,INT,0,I4,0);
3504     VARXOR(EMPTY,0,INT,1,I4,1);
3505     VARXOR(EMPTY,0,UINT,0,I4,0);
3506     VARXOR(EMPTY,0,UINT,1,I4,1);
3507     VARXOR(EMPTY,0,BOOL,0,I2,0);
3508     VARXOR(EMPTY,0,BOOL,1,I2,1);
3509     VARXOR(EMPTY,0,R4,0,I4,0);
3510     VARXOR(EMPTY,0,R4,1,I4,1);
3511     VARXOR(EMPTY,0,R8,0,I4,0);
3512     VARXOR(EMPTY,0,R8,1,I4,1);
3513     rbstr = SysAllocString(szFalse);
3514     VARXOR(EMPTY,0,BSTR,rbstr,I2,0);
3515     SysFreeString(rbstr);
3516     rbstr = SysAllocString(szTrue);
3517     VARXOR(EMPTY,0,BSTR,rbstr,I2,-1);
3518     VARXORCY(EMPTY,0,10000,I4,1);
3519     SysFreeString(rbstr);
3520
3521     /* NULL OR 0 = NULL. NULL OR n = n */
3522     VARXOR(NULL,0,NULL,0,NULL,0);
3523     VARXOR(NULL,1,NULL,0,NULL,0);
3524     VARXOR(NULL,0,I1,0,NULL,0);
3525     VARXOR(NULL,0,I1,1,NULL,0);
3526     VARXOR(NULL,0,UI1,0,NULL,0);
3527     VARXOR(NULL,0,UI1,1,NULL,0);
3528     VARXOR(NULL,0,I2,0,NULL,0);
3529     VARXOR(NULL,0,I2,1,NULL,0);
3530     VARXOR(NULL,0,UI2,0,NULL,0);
3531     VARXOR(NULL,0,UI2,1,NULL,0);
3532     VARXOR(NULL,0,I4,0,NULL,0);
3533     VARXOR(NULL,0,I4,1,NULL,0);
3534     VARXOR(NULL,0,UI4,0,NULL,0);
3535     VARXOR(NULL,0,UI4,1,NULL,0);
3536     if (HAVE_OLEAUT32_I8)
3537     {
3538         VARXOR(NULL,0,I8,0,NULL,0);
3539         VARXOR(NULL,0,I8,1,NULL,0);
3540         VARXOR(NULL,0,UI8,0,NULL,0);
3541         VARXOR(NULL,0,UI8,1,NULL,0);
3542     }
3543     VARXOR(NULL,0,INT,0,NULL,0);
3544     VARXOR(NULL,0,INT,1,NULL,0);
3545     VARXOR(NULL,0,UINT,0,NULL,0);
3546     VARXOR(NULL,0,UINT,1,NULL,0);
3547     VARXOR(NULL,0,BOOL,0,NULL,0);
3548     VARXOR(NULL,0,BOOL,1,NULL,0);
3549     VARXOR(NULL,0,R4,0,NULL,0);
3550     VARXOR(NULL,0,R4,1,NULL,0);
3551     VARXOR(NULL,0,R8,0,NULL,0);
3552     VARXOR(NULL,0,R8,1,NULL,0);
3553     rbstr = SysAllocString(szFalse);
3554     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3555     SysFreeString(rbstr);
3556     rbstr = SysAllocString(szTrue);
3557     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3558     SysFreeString(rbstr);
3559     VARXORCY(NULL,0,10000,NULL,0);
3560     VARXORCY(NULL,0,0,NULL,0);
3561
3562     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
3563     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3564     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3565     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3566     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3567     VARXOR(BOOL,VARIANT_TRUE,I1,-1,I4,0);
3568     VARXOR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3569     VARXOR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3570     VARXOR(BOOL,VARIANT_TRUE,UI1,255,I2,-256);
3571     VARXOR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3572     VARXOR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3573     VARXOR(BOOL,VARIANT_TRUE,I2,-1,I2,0);
3574     VARXOR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3575     VARXOR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3576     VARXOR(BOOL,VARIANT_TRUE,UI2,65535,I4,-65536);
3577     VARXOR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3578     VARXOR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3579     VARXOR(BOOL,VARIANT_TRUE,I4,-1,I4,0);
3580     VARXOR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3581     VARXOR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3582     VARXOR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,0);
3583     VARXOR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3584     VARXOR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3585     VARXOR(BOOL,VARIANT_TRUE,R4,-1,I4,0);
3586     VARXOR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3587     VARXOR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3588     VARXOR(BOOL,VARIANT_TRUE,R8,-1,I4,0);
3589     VARXOR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3590     VARXOR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3591     VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
3592     VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3593     VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3594     if (HAVE_OLEAUT32_I8)
3595     {
3596         VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
3597         VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3598         VARXOR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3599         /* This returns DISP_E_OVERFLOW which indicates that a conversion
3600          * to I4 is performed.
3601          */
3602         /* VARXOR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3603         VARXOR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3604         VARXOR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3605     }
3606     VARXOR(BOOL,VARIANT_TRUE,INT,-1,I4,0);
3607     VARXOR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3608     VARXOR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3609     VARXOR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,0);
3610     VARXOR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3611     VARXOR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3612     rbstr = SysAllocString(szFalse);
3613     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3614     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3615     SysFreeString(rbstr);
3616     rbstr = SysAllocString(szTrue);
3617     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3618     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3619     SysFreeString(rbstr);
3620     VARXORCY(BOOL,VARIANT_TRUE,10000,I4,-2);
3621     VARXORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3622     VARXORCY(BOOL,VARIANT_FALSE,0,I4,0);
3623
3624     VARXOR(I1,-1,I1,-1,I4,0);
3625     VARXOR(I1,-1,I1,0,I4,-1);
3626     VARXOR(I1,0,I1,0,I4,0);
3627     VARXOR(I1,-1,UI1,255,I4,-256);
3628     VARXOR(I1,-1,UI1,0,I4,-1);
3629     VARXOR(I1,0,UI1,0,I4,0);
3630     VARXOR(I1,-1,I2,-1,I4,0);
3631     VARXOR(I1,-1,I2,0,I4,-1);
3632     VARXOR(I1,0,I2,0,I4,0);
3633     VARXOR(I1,-1,UI2,65535,I4,-65536);
3634     VARXOR(I1,-1,UI2,0,I4,-1);
3635     VARXOR(I1,0,UI2,0,I4,0);
3636     VARXOR(I1,-1,I4,-1,I4,0);
3637     VARXOR(I1,-1,I4,0,I4,-1);
3638     VARXOR(I1,0,I4,0,I4,0);
3639     VARXOR(I1,-1,UI4,0xffffffff,I4,0);
3640     VARXOR(I1,-1,UI4,0,I4,-1);
3641     VARXOR(I1,0,UI4,0,I4,0);
3642     VARXOR(I1,-1,R4,-1,I4,0);
3643     VARXOR(I1,-1,R4,0,I4,-1);
3644     VARXOR(I1,0,R4,0,I4,0);
3645     VARXOR(I1,-1,R8,-1,I4,0);
3646     VARXOR(I1,-1,R8,0,I4,-1);
3647     VARXOR(I1,0,R8,0,I4,0);
3648     VARXOR(I1,-1,DATE,-1,I4,0);
3649     VARXOR(I1,-1,DATE,0,I4,-1);
3650     VARXOR(I1,0,DATE,0,I4,0);
3651     if (HAVE_OLEAUT32_I8)
3652     {
3653         VARXOR(I1,-1,I8,-1,I8,0);
3654         VARXOR(I1,-1,I8,0,I8,-1);
3655         VARXOR(I1,0,I8,0,I8,0);
3656         VARXOR(I1,-1,UI8,0,I4,-1);
3657         VARXOR(I1,0,UI8,0,I4,0);
3658     }
3659     VARXOR(I1,-1,INT,-1,I4,0);
3660     VARXOR(I1,-1,INT,0,I4,-1);
3661     VARXOR(I1,0,INT,0,I4,0);
3662     VARXOR(I1,-1,UINT,0xffffffff,I4,0);
3663     VARXOR(I1,-1,UINT,0,I4,-1);
3664     VARXOR(I1,0,UINT,0,I4,0);
3665     rbstr = SysAllocString(szFalse);
3666     VARXOR(I1,0,BSTR,rbstr,I4,0);
3667     VARXOR(I1,-1,BSTR,rbstr,I4,-1);
3668     SysFreeString(rbstr);
3669     rbstr = SysAllocString(szTrue);
3670     VARXOR(I1,0,BSTR,rbstr,I4,-1);
3671     VARXOR(I1,-1,BSTR,rbstr,I4,0);
3672     SysFreeString(rbstr);
3673     VARXORCY(I1,-1,10000,I4,-2);
3674     VARXORCY(I1,-1,0,I4,-1);
3675     VARXORCY(I1,0,0,I4,0);
3676
3677     VARXOR(UI1,255,UI1,255,UI1,0);
3678     VARXOR(UI1,255,UI1,0,UI1,255);
3679     VARXOR(UI1,0,UI1,0,UI1,0);
3680     VARXOR(UI1,255,I2,-1,I2,-256);
3681     VARXOR(UI1,255,I2,0,I2,255);
3682     VARXOR(UI1,0,I2,0,I2,0);
3683     VARXOR(UI1,255,UI2,65535,I4,65280);
3684     VARXOR(UI1,255,UI2,0,I4,255);
3685     VARXOR(UI1,0,UI2,0,I4,0);
3686     VARXOR(UI1,255,I4,-1,I4,-256);
3687     VARXOR(UI1,255,I4,0,I4,255);
3688     VARXOR(UI1,0,I4,0,I4,0);
3689     VARXOR(UI1,255,UI4,0xffffffff,I4,-256);
3690     VARXOR(UI1,255,UI4,0,I4,255);
3691     VARXOR(UI1,0,UI4,0,I4,0);
3692     VARXOR(UI1,255,R4,-1,I4,-256);
3693     VARXOR(UI1,255,R4,0,I4,255);
3694     VARXOR(UI1,0,R4,0,I4,0);
3695     VARXOR(UI1,255,R8,-1,I4,-256);
3696     VARXOR(UI1,255,R8,0,I4,255);
3697     VARXOR(UI1,0,R8,0,I4,0);
3698     VARXOR(UI1,255,DATE,-1,I4,-256);
3699     VARXOR(UI1,255,DATE,0,I4,255);
3700     VARXOR(UI1,0,DATE,0,I4,0);
3701     if (HAVE_OLEAUT32_I8)
3702     {
3703         VARXOR(UI1,255,I8,-1,I8,-256);
3704         VARXOR(UI1,255,I8,0,I8,255);
3705         VARXOR(UI1,0,I8,0,I8,0);
3706         VARXOR(UI1,255,UI8,0,I4,255);
3707         VARXOR(UI1,0,UI8,0,I4,0);
3708     }
3709     VARXOR(UI1,255,INT,-1,I4,-256);
3710     VARXOR(UI1,255,INT,0,I4,255);
3711     VARXOR(UI1,0,INT,0,I4,0);
3712     VARXOR(UI1,255,UINT,0xffffffff,I4,-256);
3713     VARXOR(UI1,255,UINT,0,I4,255);
3714     VARXOR(UI1,0,UINT,0,I4,0);
3715     rbstr = SysAllocString(szFalse);
3716     VARXOR(UI1,0,BSTR,rbstr,I2,0);
3717     VARXOR(UI1,255,BSTR,rbstr,I2,255);
3718     SysFreeString(rbstr);
3719     rbstr = SysAllocString(szTrue);
3720     VARXOR(UI1,0,BSTR,rbstr,I2,-1);
3721     VARXOR(UI1,255,BSTR,rbstr,I2,-256);
3722     SysFreeString(rbstr);
3723     VARXORCY(UI1,255,10000,I4,254);
3724     VARXORCY(UI1,255,0,I4,255);
3725     VARXORCY(UI1,0,0,I4,0);
3726
3727     VARXOR(I2,-1,I2,-1,I2,0);
3728     VARXOR(I2,-1,I2,0,I2,-1);
3729     VARXOR(I2,0,I2,0,I2,0);
3730     VARXOR(I2,-1,UI2,65535,I4,-65536);
3731     VARXOR(I2,-1,UI2,0,I4,-1);
3732     VARXOR(I2,0,UI2,0,I4,0);
3733     VARXOR(I2,-1,I4,-1,I4,0);
3734     VARXOR(I2,-1,I4,0,I4,-1);
3735     VARXOR(I2,0,I4,0,I4,0);
3736     VARXOR(I2,-1,UI4,0xffffffff,I4,0);
3737     VARXOR(I2,-1,UI4,0,I4,-1);
3738     VARXOR(I2,0,UI4,0,I4,0);
3739     VARXOR(I2,-1,R4,-1,I4,0);
3740     VARXOR(I2,-1,R4,0,I4,-1);
3741     VARXOR(I2,0,R4,0,I4,0);
3742     VARXOR(I2,-1,R8,-1,I4,0);
3743     VARXOR(I2,-1,R8,0,I4,-1);
3744     VARXOR(I2,0,R8,0,I4,0);
3745     VARXOR(I2,-1,DATE,-1,I4,0);
3746     VARXOR(I2,-1,DATE,0,I4,-1);
3747     VARXOR(I2,0,DATE,0,I4,0);
3748     if (HAVE_OLEAUT32_I8)
3749     {
3750         VARXOR(I2,-1,I8,-1,I8,0);
3751         VARXOR(I2,-1,I8,0,I8,-1);
3752         VARXOR(I2,0,I8,0,I8,0);
3753         VARXOR(I2,-1,UI8,0,I4,-1);
3754         VARXOR(I2,0,UI8,0,I4,0);
3755     }
3756     VARXOR(I2,-1,INT,-1,I4,0);
3757     VARXOR(I2,-1,INT,0,I4,-1);
3758     VARXOR(I2,0,INT,0,I4,0);
3759     VARXOR(I2,-1,UINT,0xffffffff,I4,0);
3760     VARXOR(I2,-1,UINT,0,I4,-1);
3761     VARXOR(I2,0,UINT,0,I4,0);
3762     rbstr = SysAllocString(szFalse);
3763     VARXOR(I2,0,BSTR,rbstr,I2,0);
3764     VARXOR(I2,-1,BSTR,rbstr,I2,-1);
3765     SysFreeString(rbstr);
3766     rbstr = SysAllocString(szTrue);
3767     VARXOR(I2,0,BSTR,rbstr,I2,-1);
3768     VARXOR(I2,-1,BSTR,rbstr,I2,0);
3769     SysFreeString(rbstr);
3770     VARXORCY(I2,-1,10000,I4,-2);
3771     VARXORCY(I2,-1,0,I4,-1);
3772     VARXORCY(I2,0,0,I4,0);
3773
3774     VARXOR(UI2,65535,UI2,65535,I4,0);
3775     VARXOR(UI2,65535,UI2,0,I4,65535);
3776     VARXOR(UI2,0,UI2,0,I4,0);
3777     VARXOR(UI2,65535,I4,-1,I4,-65536);
3778     VARXOR(UI2,65535,I4,0,I4,65535);
3779     VARXOR(UI2,0,I4,0,I4,0);
3780     VARXOR(UI2,65535,UI4,0xffffffff,I4,-65536);
3781     VARXOR(UI2,65535,UI4,0,I4,65535);
3782     VARXOR(UI2,0,UI4,0,I4,0);
3783     VARXOR(UI2,65535,R4,-1,I4,-65536);
3784     VARXOR(UI2,65535,R4,0,I4,65535);
3785     VARXOR(UI2,0,R4,0,I4,0);
3786     VARXOR(UI2,65535,R8,-1,I4,-65536);
3787     VARXOR(UI2,65535,R8,0,I4,65535);
3788     VARXOR(UI2,0,R8,0,I4,0);
3789     VARXOR(UI2,65535,DATE,-1,I4,-65536);
3790     VARXOR(UI2,65535,DATE,0,I4,65535);
3791     VARXOR(UI2,0,DATE,0,I4,0);
3792     if (HAVE_OLEAUT32_I8)
3793     {
3794         VARXOR(UI2,65535,I8,-1,I8,-65536);
3795         VARXOR(UI2,65535,I8,0,I8,65535);
3796         VARXOR(UI2,0,I8,0,I8,0);
3797         VARXOR(UI2,65535,UI8,0,I4,65535);
3798         VARXOR(UI2,0,UI8,0,I4,0);
3799     }
3800     VARXOR(UI2,65535,INT,-1,I4,-65536);
3801     VARXOR(UI2,65535,INT,0,I4,65535);
3802     VARXOR(UI2,0,INT,0,I4,0);
3803     VARXOR(UI2,65535,UINT,0xffffffff,I4,-65536);
3804     VARXOR(UI2,65535,UINT,0,I4,65535);
3805     VARXOR(UI2,0,UINT,0,I4,0);
3806     rbstr = SysAllocString(szFalse);
3807     VARXOR(UI2,0,BSTR,rbstr,I4,0);
3808     VARXOR(UI2,65535,BSTR,rbstr,I4,65535);
3809     SysFreeString(rbstr);
3810     rbstr = SysAllocString(szTrue);
3811     VARXOR(UI2,0,BSTR,rbstr,I4,-1);
3812     VARXOR(UI2,65535,BSTR,rbstr,I4,-65536);
3813     SysFreeString(rbstr);
3814     VARXORCY(UI2,65535,10000,I4,65534);
3815     VARXORCY(UI2,65535,0,I4,65535);
3816     VARXORCY(UI2,0,0,I4,0);
3817
3818     VARXOR(I4,-1,I4,-1,I4,0);
3819     VARXOR(I4,-1,I4,0,I4,-1);
3820     VARXOR(I4,0,I4,0,I4,0);
3821     VARXOR(I4,-1,UI4,0xffffffff,I4,0);
3822     VARXOR(I4,-1,UI4,0,I4,-1);
3823     VARXOR(I4,0,UI4,0,I4,0);
3824     VARXOR(I4,-1,R4,-1,I4,0);
3825     VARXOR(I4,-1,R4,0,I4,-1);
3826     VARXOR(I4,0,R4,0,I4,0);
3827     VARXOR(I4,-1,R8,-1,I4,0);
3828     VARXOR(I4,-1,R8,0,I4,-1);
3829     VARXOR(I4,0,R8,0,I4,0);
3830     VARXOR(I4,-1,DATE,-1,I4,0);
3831     VARXOR(I4,-1,DATE,0,I4,-1);
3832     VARXOR(I4,0,DATE,0,I4,0);
3833     if (HAVE_OLEAUT32_I8)
3834     {
3835         VARXOR(I4,-1,I8,-1,I8,0);
3836         VARXOR(I4,-1,I8,0,I8,-1);
3837         VARXOR(I4,0,I8,0,I8,0);
3838         VARXOR(I4,-1,UI8,0,I4,-1);
3839         VARXOR(I4,0,UI8,0,I4,0);
3840     }
3841     VARXOR(I4,-1,INT,-1,I4,0);
3842     VARXOR(I4,-1,INT,0,I4,-1);
3843     VARXOR(I4,0,INT,0,I4,0);
3844     VARXOR(I4,-1,UINT,0xffffffff,I4,0);
3845     VARXOR(I4,-1,UINT,0,I4,-1);
3846     VARXOR(I4,0,UINT,0,I4,0);
3847     rbstr = SysAllocString(szFalse);
3848     VARXOR(I4,0,BSTR,rbstr,I4,0);
3849     VARXOR(I4,-1,BSTR,rbstr,I4,-1);
3850     SysFreeString(rbstr);
3851     rbstr = SysAllocString(szTrue);
3852     VARXOR(I4,0,BSTR,rbstr,I4,-1);
3853     VARXOR(I4,-1,BSTR,rbstr,I4,0);
3854     SysFreeString(rbstr);
3855     VARXORCY(I4,-1,10000,I4,-2);
3856     VARXORCY(I4,-1,0,I4,-1);
3857     VARXORCY(I4,0,0,I4,0);
3858
3859     VARXOR(UI4,0xffffffff,UI4,0xffffffff,I4,0);
3860     VARXOR(UI4,0xffffffff,UI4,0,I4,-1);
3861     VARXOR(UI4,0,UI4,0,I4,0);
3862     VARXOR(UI4,0xffffffff,R4,-1,I4,0);
3863     VARXOR(UI4,0xffffffff,R4,0,I4,-1);
3864     VARXOR(UI4,0,R4,0,I4,0);
3865     VARXOR(UI4,0xffffffff,R8,-1,I4,0);
3866     VARXOR(UI4,0xffffffff,R8,0,I4,-1);
3867     VARXOR(UI4,0,R8,0,I4,0);
3868     VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
3869     VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
3870     VARXOR(UI4,0,DATE,0,I4,0);
3871     if (HAVE_OLEAUT32_I8)
3872     {
3873         VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
3874         VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
3875         VARXOR(UI4,0,I8,0,I8,0);
3876         VARXOR(UI4,0xffffffff,UI8,0,I4,-1);
3877         VARXOR(UI4,0,UI8,0,I4,0);
3878     }
3879     VARXOR(UI4,0xffffffff,INT,-1,I4,0);
3880     VARXOR(UI4,0xffffffff,INT,0,I4,-1);
3881     VARXOR(UI4,0,INT,0,I4,0);
3882     VARXOR(UI4,0xffffffff,UINT,0xffffffff,I4,0);
3883     VARXOR(UI4,0xffffffff,UINT,0,I4,-1);
3884     VARXOR(UI4,0,UINT,0,I4,0);
3885     rbstr = SysAllocString(szFalse);
3886     VARXOR(UI4,0,BSTR,rbstr,I4,0);
3887     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
3888     SysFreeString(rbstr);
3889     rbstr = SysAllocString(szTrue);
3890     VARXOR(UI4,0,BSTR,rbstr,I4,-1);
3891     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,0);
3892     SysFreeString(rbstr);
3893     VARXORCY(UI4,0xffffffff,10000,I4,-2);
3894     VARXORCY(UI4,0xffffffff,0,I4,-1);
3895     VARXORCY(UI4,0,0,I4,0);
3896
3897     VARXOR(R4,-1,R4,-1,I4,0);
3898     VARXOR(R4,-1,R4,0,I4,-1);
3899     VARXOR(R4,0,R4,0,I4,0);
3900     VARXOR(R4,-1,R8,-1,I4,0);
3901     VARXOR(R4,-1,R8,0,I4,-1);
3902     VARXOR(R4,0,R8,0,I4,0);
3903     VARXOR(R4,-1,DATE,-1,I4,0);
3904     VARXOR(R4,-1,DATE,0,I4,-1);
3905     VARXOR(R4,0,DATE,0,I4,0);
3906     if (HAVE_OLEAUT32_I8)
3907     {
3908         VARXOR(R4,-1,I8,-1,I8,0);
3909         VARXOR(R4,-1,I8,0,I8,-1);
3910         VARXOR(R4,0,I8,0,I8,0);
3911         VARXOR(R4,-1,UI8,0,I4,-1);
3912         VARXOR(R4,0,UI8,0,I4,0);
3913     }
3914     VARXOR(R4,-1,INT,-1,I4,0);
3915     VARXOR(R4,-1,INT,0,I4,-1);
3916     VARXOR(R4,0,INT,0,I4,0);
3917     VARXOR(R4,-1,UINT,0xffffffff,I4,0);
3918     VARXOR(R4,-1,UINT,0,I4,-1);
3919     VARXOR(R4,0,UINT,0,I4,0);
3920     rbstr = SysAllocString(szFalse);
3921     VARXOR(R4,0,BSTR,rbstr,I4,0);
3922     VARXOR(R4,-1,BSTR,rbstr,I4,-1);
3923     SysFreeString(rbstr);
3924     rbstr = SysAllocString(szTrue);
3925     VARXOR(R4,0,BSTR,rbstr,I4,-1);
3926     VARXOR(R4,-1,BSTR,rbstr,I4,0);
3927     SysFreeString(rbstr);
3928     VARXORCY(R4,-1,10000,I4,-2);
3929     VARXORCY(R4,-1,0,I4,-1);
3930     VARXORCY(R4,0,0,I4,0);
3931
3932     VARXOR(R8,-1,R8,-1,I4,0);
3933     VARXOR(R8,-1,R8,0,I4,-1);
3934     VARXOR(R8,0,R8,0,I4,0);
3935     VARXOR(R8,-1,DATE,-1,I4,0);
3936     VARXOR(R8,-1,DATE,0,I4,-1);
3937     VARXOR(R8,0,DATE,0,I4,0);
3938     if (HAVE_OLEAUT32_I8)
3939     {
3940         VARXOR(R8,-1,I8,-1,I8,0);
3941         VARXOR(R8,-1,I8,0,I8,-1);
3942         VARXOR(R8,0,I8,0,I8,0);
3943         VARXOR(R8,-1,UI8,0,I4,-1);
3944         VARXOR(R8,0,UI8,0,I4,0);
3945     }
3946     VARXOR(R8,-1,INT,-1,I4,0);
3947     VARXOR(R8,-1,INT,0,I4,-1);
3948     VARXOR(R8,0,INT,0,I4,0);
3949     VARXOR(R8,-1,UINT,0xffffffff,I4,0);
3950     VARXOR(R8,-1,UINT,0,I4,-1);
3951     VARXOR(R8,0,UINT,0,I4,0);
3952     rbstr = SysAllocString(szFalse);
3953     VARXOR(R8,0,BSTR,rbstr,I4,0);
3954     VARXOR(R8,-1,BSTR,rbstr,I4,-1);
3955     SysFreeString(rbstr);
3956     rbstr = SysAllocString(szTrue);
3957     VARXOR(R8,0,BSTR,rbstr,I4,-1);
3958     VARXOR(R8,-1,BSTR,rbstr,I4,0);
3959     SysFreeString(rbstr);
3960     VARXORCY(R8,-1,10000,I4,-2);
3961     VARXORCY(R8,-1,0,I4,-1);
3962     VARXORCY(R8,0,0,I4,0);
3963
3964     VARXOR(DATE,-1,DATE,-1,I4,0);
3965     VARXOR(DATE,-1,DATE,0,I4,-1);
3966     VARXOR(DATE,0,DATE,0,I4,0);
3967     if (HAVE_OLEAUT32_I8)
3968     {
3969         VARXOR(DATE,-1,I8,-1,I8,0);
3970         VARXOR(DATE,-1,I8,0,I8,-1);
3971         VARXOR(DATE,0,I8,0,I8,0);
3972         VARXOR(DATE,-1,UI8,0,I4,-1);
3973         VARXOR(DATE,0,UI8,0,I4,0);
3974     }
3975     VARXOR(DATE,-1,INT,-1,I4,0);
3976     VARXOR(DATE,-1,INT,0,I4,-1);
3977     VARXOR(DATE,0,INT,0,I4,0);
3978     VARXOR(DATE,-1,UINT,0xffffffff,I4,0);
3979     VARXOR(DATE,-1,UINT,0,I4,-1);
3980     VARXOR(DATE,0,UINT,0,I4,0);
3981     rbstr = SysAllocString(szFalse);
3982     VARXOR(DATE,0,BSTR,rbstr,I4,0);
3983     VARXOR(DATE,-1,BSTR,rbstr,I4,-1);
3984     SysFreeString(rbstr);
3985     rbstr = SysAllocString(szTrue);
3986     VARXOR(DATE,0,BSTR,rbstr,I4,-1);
3987     VARXOR(DATE,-1,BSTR,rbstr,I4,0);
3988     SysFreeString(rbstr);
3989     VARXORCY(DATE,-1,10000,I4,-2);
3990     VARXORCY(DATE,-1,0,I4,-1);
3991     VARXORCY(DATE,0,0,I4,0);
3992
3993     if (HAVE_OLEAUT32_I8)
3994     {
3995         VARXOR(I8,-1,I8,-1,I8,0);
3996         VARXOR(I8,-1,I8,0,I8,-1);
3997         VARXOR(I8,0,I8,0,I8,0);
3998         VARXOR(I8,-1,UI8,0,I8,-1);
3999         VARXOR(I8,0,UI8,0,I8,0);
4000         VARXOR(I8,-1,UINT,0,I8,-1);
4001         VARXOR(I8,0,UINT,0,I8,0);
4002         rbstr = SysAllocString(szFalse);
4003         VARXOR(I8,0,BSTR,rbstr,I8,0);
4004         VARXOR(I8,-1,BSTR,rbstr,I8,-1);
4005         SysFreeString(rbstr);
4006         rbstr = SysAllocString(szTrue);
4007         VARXOR(I8,0,BSTR,rbstr,I8,-1);
4008         VARXOR(I8,-1,BSTR,rbstr,I8,0);
4009         SysFreeString(rbstr);
4010         VARXORCY(I8,-1,10000,I8,-2);
4011         VARXORCY(I8,-1,0,I8,-1);
4012         VARXORCY(I8,0,0,I8,0);
4013
4014         VARXOR(UI8,0xffff,UI8,0xffff,I4,0);
4015         VARXOR(UI8,0xffff,UI8,0,I4,0xffff);
4016         VARXOR(UI8,0,UI8,0,I4,0);
4017         VARXOR(UI8,0xffff,INT,-1,I4,-65536);
4018         VARXOR(UI8,0xffff,INT,0,I4,0xffff);
4019         VARXOR(UI8,0,INT,0,I4,0);
4020         VARXOR(UI8,0xffff,UINT,0xffff,I4,0);
4021         VARXOR(UI8,0xffff,UINT,0,I4,0xffff);
4022         VARXOR(UI8,0,UINT,0,I4,0);
4023         rbstr = SysAllocString(szFalse);
4024         VARXOR(UI8,0,BSTR,rbstr,I4,0);
4025         VARXOR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4026         SysFreeString(rbstr);
4027         rbstr = SysAllocString(szTrue);
4028         VARXOR(UI8,0,BSTR,rbstr,I4,-1);
4029         VARXOR(UI8,0xffff,BSTR,rbstr,I4,-65536);
4030         SysFreeString(rbstr);
4031         VARXORCY(UI8,0xffff,10000,I4,65534);
4032         VARXORCY(UI8,0xffff,0,I4,0xffff);
4033         VARXORCY(UI8,0,0,I4,0);
4034     }
4035
4036     VARXOR(INT,-1,INT,-1,I4,0);
4037     VARXOR(INT,-1,INT,0,I4,-1);
4038     VARXOR(INT,0,INT,0,I4,0);
4039     VARXOR(INT,-1,UINT,0xffff,I4,-65536);
4040     VARXOR(INT,-1,UINT,0,I4,-1);
4041     VARXOR(INT,0,UINT,0,I4,0);
4042     rbstr = SysAllocString(szFalse);
4043     VARXOR(INT,0,BSTR,rbstr,I4,0);
4044     VARXOR(INT,-1,BSTR,rbstr,I4,-1);
4045     SysFreeString(rbstr);
4046     rbstr = SysAllocString(szTrue);
4047     VARXOR(INT,0,BSTR,rbstr,I4,-1);
4048     VARXOR(INT,-1,BSTR,rbstr,I4,0);
4049     SysFreeString(rbstr);
4050     VARXORCY(INT,-1,10000,I4,-2);
4051     VARXORCY(INT,-1,0,I4,-1);
4052     VARXORCY(INT,0,0,I4,0);
4053
4054     VARXOR(UINT,0xffff,UINT,0xffff,I4,0);
4055     VARXOR(UINT,0xffff,UINT,0,I4,0xffff);
4056     VARXOR(UINT,0,UINT,0,I4,0);
4057     rbstr = SysAllocString(szFalse);
4058     VARXOR(UINT,0,BSTR,rbstr,I4,0);
4059     VARXOR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4060     SysFreeString(rbstr);
4061     rbstr = SysAllocString(szTrue);
4062     VARXOR(UINT,0,BSTR,rbstr,I4,-1);
4063     VARXOR(UINT,0xffff,BSTR,rbstr,I4,-65536);
4064     SysFreeString(rbstr);
4065     VARXORCY(UINT,0xffff,10000,I4,65534);
4066     VARXORCY(UINT,0xffff,0,I4,0xffff);
4067     VARXORCY(UINT,0,0,I4,0);
4068
4069     lbstr = SysAllocString(szFalse);
4070     rbstr = SysAllocString(szFalse);
4071     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4072     SysFreeString(rbstr);
4073     rbstr = SysAllocString(szTrue);
4074     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4075     SysFreeString(lbstr);
4076     lbstr = SysAllocString(szTrue);
4077     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_FALSE);
4078     VARXORCY(BSTR,lbstr,10000,I4,-2);
4079     SysFreeString(lbstr);
4080     lbstr = SysAllocString(szFalse);
4081     VARXORCY(BSTR,lbstr,10000,I4,1);
4082     SysFreeString(lbstr);
4083     SysFreeString(rbstr);
4084 }
4085
4086 static HRESULT (WINAPI *pVarOr)(LPVARIANT,LPVARIANT,LPVARIANT);
4087
4088 #define VAROR(vt1,val1,vt2,val2,rvt,rval)                \
4089         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4090         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4091         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4092         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
4093
4094 #define VARORCY(vt1,val1,val2,rvt,rval)                  \
4095         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4096         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
4097         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4098         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
4099
4100 static void test_VarOr(void)
4101 {
4102     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
4103     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
4104     VARIANT left, right, exp, result;
4105     BSTR lbstr, rbstr;
4106     VARTYPE i;
4107     HRESULT hres;
4108
4109     CHECKPTR(VarOr);
4110
4111     /* Test all possible flag/vt combinations & the resulting vt type */
4112     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4113     {
4114         VARTYPE leftvt, rightvt, resvt;
4115
4116         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4117         {
4118
4119             SKIPTESTS(leftvt);
4120
4121             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4122             {
4123                 BOOL bFail = FALSE;
4124
4125                 SKIPTESTS(rightvt);
4126
4127                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4128                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4129                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4130                     continue;
4131
4132                 memset(&left, 0, sizeof(left));
4133                 memset(&right, 0, sizeof(right));
4134                 V_VT(&left) = leftvt | ExtraFlags[i];
4135                 V_VT(&right) = rightvt | ExtraFlags[i];
4136                 V_VT(&result) = VT_EMPTY;
4137                 resvt = VT_I4;
4138
4139                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4140                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4141                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4142                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4143                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4144                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4145                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4146                 {
4147                     bFail = TRUE;
4148                 }
4149                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4150                 {
4151                     if (leftvt == rightvt ||
4152                         leftvt == VT_I2 || rightvt == VT_I2 ||
4153                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4154                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4155                         resvt = VT_I2;
4156                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4157                         resvt = VT_NULL;
4158                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4159                         resvt = VT_I8;
4160                 }
4161                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4162                 {
4163                     resvt = VT_NULL;
4164                 }
4165                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4166                 {
4167                     if (leftvt == rightvt)
4168                         resvt = VT_UI1;
4169                     else if (leftvt == rightvt ||
4170                         leftvt == VT_I2 || rightvt == VT_I2 ||
4171                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4172                     {
4173                         resvt = VT_I2;
4174                     }
4175                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4176                         resvt = VT_I8;
4177                 }
4178                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4179                 {
4180                     if (leftvt == rightvt ||
4181                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4182                         resvt = VT_I2;
4183                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4184                         resvt = VT_I8;
4185                 }
4186                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4187                 {
4188                     resvt = VT_BOOL;
4189                 }
4190                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4191                 {
4192                     if (leftvt == VT_INT || rightvt == VT_INT)
4193                         bFail = TRUE;
4194                     else
4195                         resvt = VT_I8;
4196                 }
4197                 hres = pVarOr(&left, &right, &result);
4198                 if (bFail)
4199                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4200                        "VarOr: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4201                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4202                        V_VT(&result));
4203                 else
4204                     ok(hres == S_OK && V_VT(&result) == resvt,
4205                        "VarOr: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4206                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4207                        V_VT(&result));
4208             }
4209         }
4210     }
4211
4212     /* Test returned values. Since we know the returned type is correct
4213      * and that we handle all combinations of invalid types, just check
4214      * that good type combinations produce the desired value.
4215      * FIXME: Test VT_DECIMAL/VT_DISPATCH
4216      */
4217     VAROR(EMPTY,0,EMPTY,0,I2,0);
4218     VAROR(EMPTY,1,EMPTY,0,I2,0);
4219     VAROR(EMPTY,0,NULL,0,NULL,0);
4220     VAROR(EMPTY,0,I1,0,I4,0);
4221     VAROR(EMPTY,0,I1,1,I4,1);
4222     VAROR(EMPTY,0,UI1,0,I2,0);
4223     VAROR(EMPTY,0,UI1,1,I2,1);
4224     VAROR(EMPTY,0,I2,0,I2,0);
4225     VAROR(EMPTY,0,I2,1,I2,1);
4226     VAROR(EMPTY,0,UI2,0,I4,0);
4227     VAROR(EMPTY,0,UI2,1,I4,1);
4228     VAROR(EMPTY,0,I4,0,I4,0);
4229     VAROR(EMPTY,0,I4,1,I4,1);
4230     VAROR(EMPTY,0,UI4,0,I4,0);
4231     VAROR(EMPTY,0,UI4,1,I4,1);
4232     if (HAVE_OLEAUT32_I8)
4233     {
4234         VAROR(EMPTY,0,I8,0,I8,0);
4235         VAROR(EMPTY,0,I8,1,I8,1);
4236         VAROR(EMPTY,0,UI8,0,I4,0);
4237         VAROR(EMPTY,0,UI8,1,I4,1);
4238     }
4239     VAROR(EMPTY,0,INT,0,I4,0);
4240     VAROR(EMPTY,0,INT,1,I4,1);
4241     VAROR(EMPTY,0,UINT,0,I4,0);
4242     VAROR(EMPTY,0,UINT,1,I4,1);
4243     VAROR(EMPTY,0,BOOL,0,I2,0);
4244     VAROR(EMPTY,0,BOOL,1,I2,1);
4245     VAROR(EMPTY,0,R4,0,I4,0);
4246     VAROR(EMPTY,0,R4,1,I4,1);
4247     VAROR(EMPTY,0,R8,0,I4,0);
4248     VAROR(EMPTY,0,R8,1,I4,1);
4249     rbstr = SysAllocString(szFalse);
4250     VAROR(EMPTY,0,BSTR,rbstr,I2,0);
4251     SysFreeString(rbstr);
4252     rbstr = SysAllocString(szTrue);
4253     VAROR(EMPTY,0,BSTR,rbstr,I2,-1);
4254     SysFreeString(rbstr);
4255     VARORCY(EMPTY,0,10000,I4,1);
4256
4257     /* NULL OR 0 = NULL. NULL OR n = n */
4258     VAROR(NULL,0,NULL,0,NULL,0);
4259     VAROR(NULL,1,NULL,0,NULL,0);
4260     VAROR(NULL,0,I1,0,NULL,0);
4261     VAROR(NULL,0,I1,1,I4,1);
4262     VAROR(NULL,0,UI1,0,NULL,0);
4263     VAROR(NULL,0,UI1,1,UI1,1);
4264     VAROR(NULL,0,I2,0,NULL,0);
4265     VAROR(NULL,0,I2,1,I2,1);
4266     VAROR(NULL,0,UI2,0,NULL,0);
4267     VAROR(NULL,0,UI2,1,I4,1);
4268     VAROR(NULL,0,I4,0,NULL,0);
4269     VAROR(NULL,0,I4,1,I4,1);
4270     VAROR(NULL,0,UI4,0,NULL,0);
4271     VAROR(NULL,0,UI4,1,I4,1);
4272     if (HAVE_OLEAUT32_I8)
4273     {
4274         VAROR(NULL,0,I8,0,NULL,0);
4275         VAROR(NULL,0,I8,1,I8,1);
4276         VAROR(NULL,0,UI8,0,NULL,0);
4277         VAROR(NULL,0,UI8,1,I4,1);
4278     }
4279     VAROR(NULL,0,INT,0,NULL,0);
4280     VAROR(NULL,0,INT,1,I4,1);
4281     VAROR(NULL,0,UINT,0,NULL,0);
4282     VAROR(NULL,0,UINT,1,I4,1);
4283     VAROR(NULL,0,BOOL,0,NULL,0);
4284     VAROR(NULL,0,BOOL,1,BOOL,1);
4285     VAROR(NULL,0,R4,0,NULL,0);
4286     VAROR(NULL,0,R4,1,I4,1);
4287     VAROR(NULL,0,R8,0,NULL,0);
4288     VAROR(NULL,0,R8,1,I4,1);
4289     rbstr = SysAllocString(szFalse);
4290     VAROR(NULL,0,BSTR,rbstr,NULL,0);
4291     SysFreeString(rbstr);
4292     rbstr = SysAllocString(szTrue);
4293     VAROR(NULL,0,BSTR,rbstr,BOOL,VARIANT_TRUE);
4294     SysFreeString(rbstr);
4295     VARORCY(NULL,0,10000,I4,1);
4296     VARORCY(NULL,0,0,NULL,0);
4297
4298     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4299     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
4300     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4301     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
4302     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
4303     VAROR(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
4304     VAROR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
4305     VAROR(BOOL,VARIANT_FALSE,I1,0,I4,0);
4306     VAROR(BOOL,VARIANT_TRUE,UI1,255,I2,-1);
4307     VAROR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
4308     VAROR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
4309     VAROR(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
4310     VAROR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
4311     VAROR(BOOL,VARIANT_FALSE,I2,0,I2,0);
4312     VAROR(BOOL,VARIANT_TRUE,UI2,65535,I4,-1);
4313     VAROR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
4314     VAROR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
4315     VAROR(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
4316     VAROR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
4317     VAROR(BOOL,VARIANT_FALSE,I4,0,I4,0);
4318     VAROR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
4319     VAROR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
4320     VAROR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
4321     VAROR(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
4322     VAROR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
4323     VAROR(BOOL,VARIANT_FALSE,R4,0,I4,0);
4324     VAROR(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
4325     VAROR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
4326     VAROR(BOOL,VARIANT_FALSE,R8,0,I4,0);
4327     VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
4328     VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
4329     VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
4330     if (HAVE_OLEAUT32_I8)
4331     {
4332         VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
4333         VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
4334         VAROR(BOOL,VARIANT_FALSE,I8,0,I8,0);
4335         /* This returns DISP_E_OVERFLOW which indicates that a conversion
4336          * to I4 is performed.
4337          */
4338         /* VAROR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
4339         VAROR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
4340         VAROR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
4341     }
4342     VAROR(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
4343     VAROR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
4344     VAROR(BOOL,VARIANT_FALSE,INT,0,I4,0);
4345     VAROR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
4346     VAROR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
4347     VAROR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
4348     rbstr = SysAllocString(szFalse);
4349     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
4350     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4351     SysFreeString(rbstr);
4352     rbstr = SysAllocString(szTrue);
4353     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4354     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4355     SysFreeString(rbstr);
4356     VARORCY(BOOL,VARIANT_TRUE,10000,I4,-1);
4357     VARORCY(BOOL,VARIANT_TRUE,0,I4,-1);
4358     VARORCY(BOOL,VARIANT_FALSE,0,I4,0);
4359
4360     VAROR(I1,-1,I1,-1,I4,-1);
4361     VAROR(I1,-1,I1,0,I4,-1);
4362     VAROR(I1,0,I1,0,I4,0);
4363     VAROR(I1,-1,UI1,255,I4,-1);
4364     VAROR(I1,-1,UI1,0,I4,-1);
4365     VAROR(I1,0,UI1,0,I4,0);
4366     VAROR(I1,-1,I2,-1,I4,-1);
4367     VAROR(I1,-1,I2,0,I4,-1);
4368     VAROR(I1,0,I2,0,I4,0);
4369     VAROR(I1,-1,UI2,65535,I4,-1);
4370     VAROR(I1,-1,UI2,0,I4,-1);
4371     VAROR(I1,0,UI2,0,I4,0);
4372     VAROR(I1,-1,I4,-1,I4,-1);
4373     VAROR(I1,-1,I4,0,I4,-1);
4374     VAROR(I1,0,I4,0,I4,0);
4375     VAROR(I1,-1,UI4,0xffffffff,I4,-1);
4376     VAROR(I1,-1,UI4,0,I4,-1);
4377     VAROR(I1,0,UI4,0,I4,0);
4378     VAROR(I1,-1,R4,-1,I4,-1);
4379     VAROR(I1,-1,R4,0,I4,-1);
4380     VAROR(I1,0,R4,0,I4,0);
4381     VAROR(I1,-1,R8,-1,I4,-1);
4382     VAROR(I1,-1,R8,0,I4,-1);
4383     VAROR(I1,0,R8,0,I4,0);
4384     VAROR(I1,-1,DATE,-1,I4,-1);
4385     VAROR(I1,-1,DATE,0,I4,-1);
4386     VAROR(I1,0,DATE,0,I4,0);
4387     if (HAVE_OLEAUT32_I8)
4388     {
4389         VAROR(I1,-1,I8,-1,I8,-1);
4390         VAROR(I1,-1,I8,0,I8,-1);
4391         VAROR(I1,0,I8,0,I8,0);
4392         VAROR(I1,-1,UI8,0,I4,-1);
4393         VAROR(I1,0,UI8,0,I4,0);
4394     }
4395     VAROR(I1,-1,INT,-1,I4,-1);
4396     VAROR(I1,-1,INT,0,I4,-1);
4397     VAROR(I1,0,INT,0,I4,0);
4398     VAROR(I1,-1,UINT,0xffffffff,I4,-1);
4399     VAROR(I1,-1,UINT,0,I4,-1);
4400     VAROR(I1,0,UINT,0,I4,0);
4401     rbstr = SysAllocString(szFalse);
4402     VAROR(I1,0,BSTR,rbstr,I4,0);
4403     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4404     SysFreeString(rbstr);
4405     rbstr = SysAllocString(szTrue);
4406     VAROR(I1,0,BSTR,rbstr,I4,-1);
4407     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4408     SysFreeString(rbstr);
4409     VARORCY(I1,-1,10000,I4,-1);
4410     VARORCY(I1,-1,0,I4,-1);
4411     VARORCY(I1,0,0,I4,0);
4412
4413     VAROR(UI1,255,UI1,255,UI1,255);
4414     VAROR(UI1,255,UI1,0,UI1,255);
4415     VAROR(UI1,0,UI1,0,UI1,0);
4416     VAROR(UI1,255,I2,-1,I2,-1);
4417     VAROR(UI1,255,I2,0,I2,255);
4418     VAROR(UI1,0,I2,0,I2,0);
4419     VAROR(UI1,255,UI2,65535,I4,65535);
4420     VAROR(UI1,255,UI2,0,I4,255);
4421     VAROR(UI1,0,UI2,0,I4,0);
4422     VAROR(UI1,255,I4,-1,I4,-1);
4423     VAROR(UI1,255,I4,0,I4,255);
4424     VAROR(UI1,0,I4,0,I4,0);
4425     VAROR(UI1,255,UI4,0xffffffff,I4,-1);
4426     VAROR(UI1,255,UI4,0,I4,255);
4427     VAROR(UI1,0,UI4,0,I4,0);
4428     VAROR(UI1,255,R4,-1,I4,-1);
4429     VAROR(UI1,255,R4,0,I4,255);
4430     VAROR(UI1,0,R4,0,I4,0);
4431     VAROR(UI1,255,R8,-1,I4,-1);
4432     VAROR(UI1,255,R8,0,I4,255);
4433     VAROR(UI1,0,R8,0,I4,0);
4434     VAROR(UI1,255,DATE,-1,I4,-1);
4435     VAROR(UI1,255,DATE,0,I4,255);
4436     VAROR(UI1,0,DATE,0,I4,0);
4437     if (HAVE_OLEAUT32_I8)
4438     {
4439         VAROR(UI1,255,I8,-1,I8,-1);
4440         VAROR(UI1,255,I8,0,I8,255);
4441         VAROR(UI1,0,I8,0,I8,0);
4442         VAROR(UI1,255,UI8,0,I4,255);
4443         VAROR(UI1,0,UI8,0,I4,0);
4444     }
4445     VAROR(UI1,255,INT,-1,I4,-1);
4446     VAROR(UI1,255,INT,0,I4,255);
4447     VAROR(UI1,0,INT,0,I4,0);
4448     VAROR(UI1,255,UINT,0xffffffff,I4,-1);
4449     VAROR(UI1,255,UINT,0,I4,255);
4450     VAROR(UI1,0,UINT,0,I4,0);
4451     rbstr = SysAllocString(szFalse);
4452     VAROR(UI1,0,BSTR,rbstr,I2,0);
4453     VAROR(UI1,255,BSTR,rbstr,I2,255);
4454     SysFreeString(rbstr);
4455     rbstr = SysAllocString(szTrue);
4456     VAROR(UI1,0,BSTR,rbstr,I2,-1);
4457     VAROR(UI1,255,BSTR,rbstr,I2,-1);
4458     SysFreeString(rbstr);
4459     VARORCY(UI1,255,10000,I4,255);
4460     VARORCY(UI1,255,0,I4,255);
4461     VARORCY(UI1,0,0,I4,0);
4462
4463     VAROR(I2,-1,I2,-1,I2,-1);
4464     VAROR(I2,-1,I2,0,I2,-1);
4465     VAROR(I2,0,I2,0,I2,0);
4466     VAROR(I2,-1,UI2,65535,I4,-1);
4467     VAROR(I2,-1,UI2,0,I4,-1);
4468     VAROR(I2,0,UI2,0,I4,0);
4469     VAROR(I2,-1,I4,-1,I4,-1);
4470     VAROR(I2,-1,I4,0,I4,-1);
4471     VAROR(I2,0,I4,0,I4,0);
4472     VAROR(I2,-1,UI4,0xffffffff,I4,-1);
4473     VAROR(I2,-1,UI4,0,I4,-1);
4474     VAROR(I2,0,UI4,0,I4,0);
4475     VAROR(I2,-1,R4,-1,I4,-1);
4476     VAROR(I2,-1,R4,0,I4,-1);
4477     VAROR(I2,0,R4,0,I4,0);
4478     VAROR(I2,-1,R8,-1,I4,-1);
4479     VAROR(I2,-1,R8,0,I4,-1);
4480     VAROR(I2,0,R8,0,I4,0);
4481     VAROR(I2,-1,DATE,-1,I4,-1);
4482     VAROR(I2,-1,DATE,0,I4,-1);
4483     VAROR(I2,0,DATE,0,I4,0);
4484     if (HAVE_OLEAUT32_I8)
4485     {
4486         VAROR(I2,-1,I8,-1,I8,-1);
4487         VAROR(I2,-1,I8,0,I8,-1);
4488         VAROR(I2,0,I8,0,I8,0);
4489         VAROR(I2,-1,UI8,0,I4,-1);
4490         VAROR(I2,0,UI8,0,I4,0);
4491     }
4492     VAROR(I2,-1,INT,-1,I4,-1);
4493     VAROR(I2,-1,INT,0,I4,-1);
4494     VAROR(I2,0,INT,0,I4,0);
4495     VAROR(I2,-1,UINT,0xffffffff,I4,-1);
4496     VAROR(I2,-1,UINT,0,I4,-1);
4497     VAROR(I2,0,UINT,0,I4,0);
4498     rbstr = SysAllocString(szFalse);
4499     VAROR(I2,0,BSTR,rbstr,I2,0);
4500     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4501     SysFreeString(rbstr);
4502     rbstr = SysAllocString(szTrue);
4503     VAROR(I2,0,BSTR,rbstr,I2,-1);
4504     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4505     SysFreeString(rbstr);
4506     VARORCY(I2,-1,10000,I4,-1);
4507     VARORCY(I2,-1,0,I4,-1);
4508     VARORCY(I2,0,0,I4,0);
4509
4510     VAROR(UI2,65535,UI2,65535,I4,65535);
4511     VAROR(UI2,65535,UI2,0,I4,65535);
4512     VAROR(UI2,0,UI2,0,I4,0);
4513     VAROR(UI2,65535,I4,-1,I4,-1);
4514     VAROR(UI2,65535,I4,0,I4,65535);
4515     VAROR(UI2,0,I4,0,I4,0);
4516     VAROR(UI2,65535,UI4,0xffffffff,I4,-1);
4517     VAROR(UI2,65535,UI4,0,I4,65535);
4518     VAROR(UI2,0,UI4,0,I4,0);
4519     VAROR(UI2,65535,R4,-1,I4,-1);
4520     VAROR(UI2,65535,R4,0,I4,65535);
4521     VAROR(UI2,0,R4,0,I4,0);
4522     VAROR(UI2,65535,R8,-1,I4,-1);
4523     VAROR(UI2,65535,R8,0,I4,65535);
4524     VAROR(UI2,0,R8,0,I4,0);
4525     VAROR(UI2,65535,DATE,-1,I4,-1);
4526     VAROR(UI2,65535,DATE,0,I4,65535);
4527     VAROR(UI2,0,DATE,0,I4,0);
4528     if (HAVE_OLEAUT32_I8)
4529     {
4530         VAROR(UI2,65535,I8,-1,I8,-1);
4531         VAROR(UI2,65535,I8,0,I8,65535);
4532         VAROR(UI2,0,I8,0,I8,0);
4533         VAROR(UI2,65535,UI8,0,I4,65535);
4534         VAROR(UI2,0,UI8,0,I4,0);
4535     }
4536     VAROR(UI2,65535,INT,-1,I4,-1);
4537     VAROR(UI2,65535,INT,0,I4,65535);
4538     VAROR(UI2,0,INT,0,I4,0);
4539     VAROR(UI2,65535,UINT,0xffffffff,I4,-1);
4540     VAROR(UI2,65535,UINT,0,I4,65535);
4541     VAROR(UI2,0,UINT,0,I4,0);
4542     rbstr = SysAllocString(szFalse);
4543     VAROR(UI2,0,BSTR,rbstr,I4,0);
4544     VAROR(UI2,65535,BSTR,rbstr,I4,65535);
4545     SysFreeString(rbstr);
4546     rbstr = SysAllocString(szTrue);
4547     VAROR(UI2,0,BSTR,rbstr,I4,-1);
4548     VAROR(UI2,65535,BSTR,rbstr,I4,-1);
4549     SysFreeString(rbstr);
4550     VARORCY(UI2,65535,10000,I4,65535);
4551     VARORCY(UI2,65535,0,I4,65535);
4552     VARORCY(UI2,0,0,I4,0);
4553
4554     VAROR(I4,-1,I4,-1,I4,-1);
4555     VAROR(I4,-1,I4,0,I4,-1);
4556     VAROR(I4,0,I4,0,I4,0);
4557     VAROR(I4,-1,UI4,0xffffffff,I4,-1);
4558     VAROR(I4,-1,UI4,0,I4,-1);
4559     VAROR(I4,0,UI4,0,I4,0);
4560     VAROR(I4,-1,R4,-1,I4,-1);
4561     VAROR(I4,-1,R4,0,I4,-1);
4562     VAROR(I4,0,R4,0,I4,0);
4563     VAROR(I4,-1,R8,-1,I4,-1);
4564     VAROR(I4,-1,R8,0,I4,-1);
4565     VAROR(I4,0,R8,0,I4,0);
4566     VAROR(I4,-1,DATE,-1,I4,-1);
4567     VAROR(I4,-1,DATE,0,I4,-1);
4568     VAROR(I4,0,DATE,0,I4,0);
4569     if (HAVE_OLEAUT32_I8)
4570     {
4571         VAROR(I4,-1,I8,-1,I8,-1);
4572         VAROR(I4,-1,I8,0,I8,-1);
4573         VAROR(I4,0,I8,0,I8,0);
4574         VAROR(I4,-1,UI8,0,I4,-1);
4575         VAROR(I4,0,UI8,0,I4,0);
4576     }
4577     VAROR(I4,-1,INT,-1,I4,-1);
4578     VAROR(I4,-1,INT,0,I4,-1);
4579     VAROR(I4,0,INT,0,I4,0);
4580     VAROR(I4,-1,UINT,0xffffffff,I4,-1);
4581     VAROR(I4,-1,UINT,0,I4,-1);
4582     VAROR(I4,0,UINT,0,I4,0);
4583     rbstr = SysAllocString(szFalse);
4584     VAROR(I4,0,BSTR,rbstr,I4,0);
4585     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4586     SysFreeString(rbstr);
4587     rbstr = SysAllocString(szTrue);
4588     VAROR(I4,0,BSTR,rbstr,I4,-1);
4589     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4590     SysFreeString(rbstr);
4591     VARORCY(I4,-1,10000,I4,-1);
4592     VARORCY(I4,-1,0,I4,-1);
4593     VARORCY(I4,0,0,I4,0);
4594
4595     VAROR(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
4596     VAROR(UI4,0xffffffff,UI4,0,I4,-1);
4597     VAROR(UI4,0,UI4,0,I4,0);
4598     VAROR(UI4,0xffffffff,R4,-1,I4,-1);
4599     VAROR(UI4,0xffffffff,R4,0,I4,-1);
4600     VAROR(UI4,0,R4,0,I4,0);
4601     VAROR(UI4,0xffffffff,R8,-1,I4,-1);
4602     VAROR(UI4,0xffffffff,R8,0,I4,-1);
4603     VAROR(UI4,0,R8,0,I4,0);
4604     VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
4605     VAROR(UI4,0xffffffff,DATE,0,I4,-1);
4606     VAROR(UI4,0,DATE,0,I4,0);
4607     if (HAVE_OLEAUT32_I8)
4608     {
4609         VAROR(UI4,0xffffffff,I8,-1,I8,-1);
4610         VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
4611         VAROR(UI4,0,I8,0,I8,0);
4612         VAROR(UI4,0xffffffff,UI8,0,I4,-1);
4613         VAROR(UI4,0,UI8,0,I4,0);
4614     }
4615     VAROR(UI4,0xffffffff,INT,-1,I4,-1);
4616     VAROR(UI4,0xffffffff,INT,0,I4,-1);
4617     VAROR(UI4,0,INT,0,I4,0);
4618     VAROR(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
4619     VAROR(UI4,0xffffffff,UINT,0,I4,-1);
4620     VAROR(UI4,0,UINT,0,I4,0);
4621     rbstr = SysAllocString(szFalse);
4622     VAROR(UI4,0,BSTR,rbstr,I4,0);
4623     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4624     SysFreeString(rbstr);
4625     rbstr = SysAllocString(szTrue);
4626     VAROR(UI4,0,BSTR,rbstr,I4,-1);
4627     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4628     SysFreeString(rbstr);
4629     VARORCY(UI4,0xffffffff,10000,I4,-1);
4630     VARORCY(UI4,0xffffffff,0,I4,-1);
4631     VARORCY(UI4,0,0,I4,0);
4632
4633     VAROR(R4,-1,R4,-1,I4,-1);
4634     VAROR(R4,-1,R4,0,I4,-1);
4635     VAROR(R4,0,R4,0,I4,0);
4636     VAROR(R4,-1,R8,-1,I4,-1);
4637     VAROR(R4,-1,R8,0,I4,-1);
4638     VAROR(R4,0,R8,0,I4,0);
4639     VAROR(R4,-1,DATE,-1,I4,-1);
4640     VAROR(R4,-1,DATE,0,I4,-1);
4641     VAROR(R4,0,DATE,0,I4,0);
4642     if (HAVE_OLEAUT32_I8)
4643     {
4644         VAROR(R4,-1,I8,-1,I8,-1);
4645         VAROR(R4,-1,I8,0,I8,-1);
4646         VAROR(R4,0,I8,0,I8,0);
4647         VAROR(R4,-1,UI8,0,I4,-1);
4648         VAROR(R4,0,UI8,0,I4,0);
4649     }
4650     VAROR(R4,-1,INT,-1,I4,-1);
4651     VAROR(R4,-1,INT,0,I4,-1);
4652     VAROR(R4,0,INT,0,I4,0);
4653     VAROR(R4,-1,UINT,0xffffffff,I4,-1);
4654     VAROR(R4,-1,UINT,0,I4,-1);
4655     VAROR(R4,0,UINT,0,I4,0);
4656     rbstr = SysAllocString(szFalse);
4657     VAROR(R4,0,BSTR,rbstr,I4,0);
4658     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4659     SysFreeString(rbstr);
4660     rbstr = SysAllocString(szTrue);
4661     VAROR(R4,0,BSTR,rbstr,I4,-1);
4662     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4663     SysFreeString(rbstr);
4664     VARORCY(R4,-1,10000,I4,-1);
4665     VARORCY(R4,-1,0,I4,-1);
4666     VARORCY(R4,0,0,I4,0);
4667
4668     VAROR(R8,-1,R8,-1,I4,-1);
4669     VAROR(R8,-1,R8,0,I4,-1);
4670     VAROR(R8,0,R8,0,I4,0);
4671     VAROR(R8,-1,DATE,-1,I4,-1);
4672     VAROR(R8,-1,DATE,0,I4,-1);
4673     VAROR(R8,0,DATE,0,I4,0);
4674     if (HAVE_OLEAUT32_I8)
4675     {
4676         VAROR(R8,-1,I8,-1,I8,-1);
4677         VAROR(R8,-1,I8,0,I8,-1);
4678         VAROR(R8,0,I8,0,I8,0);
4679         VAROR(R8,-1,UI8,0,I4,-1);
4680         VAROR(R8,0,UI8,0,I4,0);
4681     }
4682     VAROR(R8,-1,INT,-1,I4,-1);
4683     VAROR(R8,-1,INT,0,I4,-1);
4684     VAROR(R8,0,INT,0,I4,0);
4685     VAROR(R8,-1,UINT,0xffffffff,I4,-1);
4686     VAROR(R8,-1,UINT,0,I4,-1);
4687     VAROR(R8,0,UINT,0,I4,0);
4688     rbstr = SysAllocString(szFalse);
4689     VAROR(R8,0,BSTR,rbstr,I4,0);
4690     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4691     SysFreeString(rbstr);
4692     rbstr = SysAllocString(szTrue);
4693     VAROR(R8,0,BSTR,rbstr,I4,-1);
4694     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4695     SysFreeString(rbstr);
4696     VARORCY(R8,-1,10000,I4,-1);
4697     VARORCY(R8,-1,0,I4,-1);
4698     VARORCY(R8,0,0,I4,0);
4699
4700     VAROR(DATE,-1,DATE,-1,I4,-1);
4701     VAROR(DATE,-1,DATE,0,I4,-1);
4702     VAROR(DATE,0,DATE,0,I4,0);
4703     if (HAVE_OLEAUT32_I8)
4704     {
4705         VAROR(DATE,-1,I8,-1,I8,-1);
4706         VAROR(DATE,-1,I8,0,I8,-1);
4707         VAROR(DATE,0,I8,0,I8,0);
4708         VAROR(DATE,-1,UI8,0,I4,-1);
4709         VAROR(DATE,0,UI8,0,I4,0);
4710     }
4711     VAROR(DATE,-1,INT,-1,I4,-1);
4712     VAROR(DATE,-1,INT,0,I4,-1);
4713     VAROR(DATE,0,INT,0,I4,0);
4714     VAROR(DATE,-1,UINT,0xffffffff,I4,-1);
4715     VAROR(DATE,-1,UINT,0,I4,-1);
4716     VAROR(DATE,0,UINT,0,I4,0);
4717     rbstr = SysAllocString(szFalse);
4718     VAROR(DATE,0,BSTR,rbstr,I4,0);
4719     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4720     SysFreeString(rbstr);
4721     rbstr = SysAllocString(szTrue);
4722     VAROR(DATE,0,BSTR,rbstr,I4,-1);
4723     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4724     SysFreeString(rbstr);
4725     VARORCY(DATE,-1,10000,I4,-1);
4726     VARORCY(DATE,-1,0,I4,-1);
4727     VARORCY(DATE,0,0,I4,0);
4728
4729     if (HAVE_OLEAUT32_I8)
4730     {
4731         VAROR(I8,-1,I8,-1,I8,-1);
4732         VAROR(I8,-1,I8,0,I8,-1);
4733         VAROR(I8,0,I8,0,I8,0);
4734         VAROR(I8,-1,UI8,0,I8,-1);
4735         VAROR(I8,0,UI8,0,I8,0);
4736         /* These overflow under native and Wine
4737         VAROR(I8,-1,INT,-1,I4,-1);
4738         VAROR(I8,-1,INT,0,I4,-1);
4739         VAROR(I8,0,INT,0,I4,0); */
4740         VAROR(I8,-1,UINT,0xffffffff,I8,-1);
4741         VAROR(I8,-1,UINT,0,I8,-1);
4742         VAROR(I8,0,UINT,0,I8,0);
4743         rbstr = SysAllocString(szFalse);
4744         VAROR(I8,0,BSTR,rbstr,I8,0);
4745         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4746         SysFreeString(rbstr);
4747         rbstr = SysAllocString(szTrue);
4748         VAROR(I8,0,BSTR,rbstr,I8,-1);
4749         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4750         SysFreeString(rbstr);
4751         VARORCY(I8,-1,10000,I8,-1);
4752         VARORCY(I8,-1,0,I8,-1);
4753         VARORCY(I8,0,0,I8,0);
4754
4755         VAROR(UI8,0xffff,UI8,0xffff,I4,0xffff);
4756         VAROR(UI8,0xffff,UI8,0,I4,0xffff);
4757         VAROR(UI8,0,UI8,0,I4,0);
4758         VAROR(UI8,0xffff,INT,-1,I4,-1);
4759         VAROR(UI8,0xffff,INT,0,I4,0xffff);
4760         VAROR(UI8,0,INT,0,I4,0);
4761         VAROR(UI8,0xffff,UINT,0xffff,I4,0xffff);
4762         VAROR(UI8,0xffff,UINT,0,I4,0xffff);
4763         VAROR(UI8,0,UINT,0,I4,0);
4764         rbstr = SysAllocString(szFalse);
4765         VAROR(UI8,0,BSTR,rbstr,I4,0);
4766         VAROR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4767         SysFreeString(rbstr);
4768         rbstr = SysAllocString(szTrue);
4769         VAROR(UI8,0,BSTR,rbstr,I4,-1);
4770         VAROR(UI8,0xffff,BSTR,rbstr,I4,-1);
4771         SysFreeString(rbstr);
4772         VARORCY(UI8,0xffff,10000,I4,0xffff);
4773         VARORCY(UI8,0xffff,0,I4,0xffff);
4774         VARORCY(UI8,0,0,I4,0);
4775     }
4776
4777     VAROR(INT,-1,INT,-1,I4,-1);
4778     VAROR(INT,-1,INT,0,I4,-1);
4779     VAROR(INT,0,INT,0,I4,0);
4780     VAROR(INT,-1,UINT,0xffff,I4,-1);
4781     VAROR(INT,-1,UINT,0,I4,-1);
4782     VAROR(INT,0,UINT,0,I4,0);
4783     rbstr = SysAllocString(szFalse);
4784     VAROR(INT,0,BSTR,rbstr,I4,0);
4785     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4786     SysFreeString(rbstr);
4787     rbstr = SysAllocString(szTrue);
4788     VAROR(INT,0,BSTR,rbstr,I4,-1);
4789     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4790     SysFreeString(rbstr);
4791     VARORCY(INT,-1,10000,I4,-1);
4792     VARORCY(INT,-1,0,I4,-1);
4793     VARORCY(INT,0,0,I4,0);
4794
4795     VAROR(UINT,0xffff,UINT,0xffff,I4,0xffff);
4796     VAROR(UINT,0xffff,UINT,0,I4,0xffff);
4797     VAROR(UINT,0,UINT,0,I4,0);
4798     rbstr = SysAllocString(szFalse);
4799     VAROR(UINT,0,BSTR,rbstr,I4,0);
4800     VAROR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4801     SysFreeString(rbstr);
4802     rbstr = SysAllocString(szTrue);
4803     VAROR(UINT,0,BSTR,rbstr,I4,-1);
4804     VAROR(UINT,0xffff,BSTR,rbstr,I4,-1);
4805     SysFreeString(rbstr);
4806     VARORCY(UINT,0xffff,10000,I4,0xffff);
4807     VARORCY(UINT,0xffff,0,I4,0xffff);
4808     VARORCY(UINT,0,0,I4,0);
4809
4810     lbstr = SysAllocString(szFalse);
4811     rbstr = SysAllocString(szFalse);
4812     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4813     SysFreeString(rbstr);
4814     rbstr = SysAllocString(szTrue);
4815     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4816     SysFreeString(lbstr);
4817     lbstr = SysAllocString(szTrue);
4818     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4819     VARORCY(BSTR,lbstr,10000,I4,-1);
4820     SysFreeString(lbstr);
4821     lbstr = SysAllocString(szFalse);
4822     VARORCY(BSTR,lbstr,10000,I4,1);
4823     SysFreeString(lbstr);
4824     SysFreeString(rbstr);
4825 }
4826
4827 static HRESULT (WINAPI *pVarEqv)(LPVARIANT,LPVARIANT,LPVARIANT);
4828
4829 #define VAREQV(vt1,val1,vt2,val2,rvt,rval)           \
4830     V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4831     V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4832     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4833     test_var_call2( __LINE__, pVarEqv, &left, &right, &exp )
4834
4835 static void test_VarEqv(void)
4836 {
4837     VARIANT left, right, exp, result;
4838     VARTYPE i;
4839     HRESULT hres;
4840
4841     CHECKPTR(VarEqv);
4842
4843     /* Test all possible flag/vt combinations & the resulting vt type */
4844     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4845     {
4846         VARTYPE leftvt, rightvt, resvt;
4847
4848         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4849         {
4850             SKIPTESTS(leftvt);
4851
4852             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4853             {
4854                 BOOL bFail = FALSE;
4855
4856                 SKIPTESTS(rightvt);
4857
4858                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4859                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4860                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4861                     continue;
4862
4863                 memset(&left, 0, sizeof(left));
4864                 memset(&right, 0, sizeof(right));
4865                 V_VT(&left) = leftvt | ExtraFlags[i];
4866                 V_VT(&right) = rightvt | ExtraFlags[i];
4867                 V_VT(&result) = VT_EMPTY;
4868                 resvt = VT_I4;
4869
4870                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4871                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4872                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4873                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4874                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4875                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4876                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4877                 {
4878                     bFail = TRUE;
4879                 }
4880                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4881                 {
4882                     if (leftvt == rightvt ||
4883                         leftvt == VT_I2 || rightvt == VT_I2 ||
4884                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4885                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4886                         resvt = VT_I2;
4887                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4888                         resvt = VT_NULL;
4889                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4890                         resvt = VT_I8;
4891                 }
4892                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4893                 {
4894                     resvt = VT_NULL;
4895                 }
4896                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4897                 {
4898                     if (leftvt == rightvt)
4899                         resvt = VT_UI1;
4900                     else if (leftvt == rightvt ||
4901                         leftvt == VT_I2 || rightvt == VT_I2 ||
4902                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4903                     {
4904                         resvt = VT_I2;
4905                     }
4906                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4907                         resvt = VT_I8;
4908                 }
4909                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4910                 {
4911                     if (leftvt == rightvt ||
4912                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4913                         resvt = VT_I2;
4914                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4915                         resvt = VT_I8;
4916                 }
4917                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4918                 {
4919                     resvt = VT_BOOL;
4920                 }
4921                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4922                 {
4923                     if (leftvt == VT_INT || rightvt == VT_INT)
4924                         bFail = TRUE;
4925                     else
4926                         resvt = VT_I8;
4927                 }
4928                 hres = pVarEqv(&left, &right, &result);
4929                 if (bFail)
4930                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4931                        "VarEqv: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4932                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4933                        V_VT(&result));
4934                 else
4935                     ok(hres == S_OK && V_VT(&result) == resvt,
4936                        "VarEqv: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4937                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4938                        V_VT(&result));
4939             }
4940         }
4941     }
4942
4943     /* Test returned values */
4944     VAREQV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4945     VAREQV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
4946     VAREQV(BOOL,TRUE,BOOL,TRUE,BOOL,VARIANT_TRUE);
4947     VAREQV(BOOL,FALSE,BOOL,FALSE,BOOL,VARIANT_TRUE);
4948     VAREQV(BOOL,TRUE,BOOL,FALSE,BOOL,-2);
4949     VAREQV(BOOL,FALSE,BOOL,TRUE,BOOL,-2);
4950     VAREQV(BOOL,6,BOOL,7,BOOL,-2);
4951     VAREQV(BOOL,6,BOOL,6,BOOL,VARIANT_TRUE);
4952     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE,I2,VARIANT_TRUE);
4953     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_FALSE,I2,VARIANT_FALSE);
4954     VAREQV(BOOL,6,I2,7,I2,-2);
4955     VAREQV(UI1,1,UI1,1,UI1,255);
4956     VAREQV(UI1,1,UI1,0,UI1,254);
4957     VAREQV(UI1,0,UI1,1,UI1,254);
4958     if (HAVE_OLEAUT32_I8)
4959     {
4960         VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
4961         VAREQV(UI4,5,I8,19,I8,-23);
4962         VAREQV(UI4,VARIANT_FALSE,UI8,VARIANT_FALSE,I4,-1);
4963     }
4964 }
4965
4966 static HRESULT (WINAPI *pVarMul)(LPVARIANT,LPVARIANT,LPVARIANT);
4967
4968 #define VARMUL(vt1,val1,vt2,val2,rvt,rval)               \
4969         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4970         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4971         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4972         test_var_call2( __LINE__, pVarMul, &left, &right, &exp )
4973
4974 static void test_VarMul(void)
4975 {
4976     VARIANT left, right, exp, result, cy, dec;
4977     VARTYPE i;
4978     BSTR lbstr, rbstr;
4979     HRESULT hres;
4980     double r;
4981
4982     CHECKPTR(VarMul);
4983
4984     lbstr = SysAllocString(sz12);
4985     rbstr = SysAllocString(sz12);
4986
4987     /* Test all possible flag/vt combinations & the resulting vt type */
4988     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4989     {
4990         VARTYPE leftvt, rightvt, resvt;
4991
4992         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4993         {
4994
4995             SKIPTESTS(leftvt);
4996
4997             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4998             {
4999                 BOOL bFail = FALSE;
5000
5001                 SKIPTESTS(rightvt);
5002
5003                 if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5004                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
5005                     continue;
5006
5007                 memset(&left, 0, sizeof(left));
5008                 memset(&right, 0, sizeof(right));
5009                 V_VT(&left) = leftvt | ExtraFlags[i];
5010                 if (leftvt == VT_BSTR)
5011                     V_BSTR(&left) = lbstr;
5012                 V_VT(&right) = rightvt | ExtraFlags[i];
5013                 if (rightvt == VT_BSTR)
5014                     V_BSTR(&right) = rbstr;
5015                 V_VT(&result) = VT_EMPTY;
5016                 resvt = VT_UNKNOWN;
5017
5018                 /* Don't ask me why but native VarMul cannot handle:
5019                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
5020                    Tested with DCOM98, Win2k, WinXP */
5021                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5022                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5023                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5024                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5025                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5026                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5027                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
5028                     leftvt == VT_I1 || rightvt == VT_I1 ||
5029                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5030                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5031                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5032                     leftvt == VT_INT || rightvt == VT_INT ||
5033                     leftvt == VT_UINT || rightvt == VT_UINT) {
5034                     bFail = TRUE;
5035                 }
5036
5037                 if (leftvt == VT_NULL || rightvt == VT_NULL)
5038                     resvt = VT_NULL;
5039                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5040                     resvt = VT_DECIMAL;
5041                 else if (leftvt == VT_R8 || rightvt == VT_R8 ||
5042                          leftvt == VT_BSTR || rightvt == VT_BSTR ||
5043                          leftvt == VT_DATE || rightvt == VT_DATE)
5044                     resvt = VT_R8;
5045                 else if (leftvt == VT_R4 || rightvt == VT_R4) {
5046                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
5047                         leftvt == VT_I8 || rightvt == VT_I8 ||
5048                         leftvt == VT_CY || rightvt == VT_CY)
5049                         resvt = VT_R8;
5050                     else
5051                         resvt = VT_R4;
5052                 } else if (leftvt == VT_CY || rightvt == VT_CY)
5053                     resvt = VT_CY;
5054                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5055                     resvt = VT_I8;
5056                 else if (leftvt == VT_I4 || rightvt == VT_I4)
5057                     resvt = VT_I4;
5058                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5059                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
5060                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5061                     resvt = VT_I2;
5062                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5063                     resvt = VT_UI1;
5064
5065                 hres = pVarMul(&left, &right, &result);
5066                 if (bFail) {
5067                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5068                        "VarMul: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
5069                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5070                        V_VT(&result));
5071                 } else {
5072                     ok(hres == S_OK && V_VT(&result) == resvt,
5073                        "VarMul: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
5074                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5075                        V_VT(&result));
5076                 }
5077             }
5078         }
5079     }
5080
5081     /* Test returned values */
5082     VARMUL(I4,4,I4,2,I4,8);
5083     VARMUL(I2,4,I2,2,I2,8);
5084     VARMUL(I2,-13,I4,5,I4,-65);
5085     VARMUL(I4,-13,I4,5,I4,-65);
5086     VARMUL(I2,7,R4,0.5f,R4,3.5f);
5087     VARMUL(R4,0.5f,I4,5,R8,2.5);
5088     VARMUL(R8,7.1,BOOL,0,R8,0);
5089     VARMUL(BSTR,lbstr,I2,4,R8,48);
5090     VARMUL(BSTR,lbstr,BOOL,1,R8,12);
5091     VARMUL(BSTR,lbstr,R4,0.1f,R8,1.2);
5092     VARMUL(BSTR,lbstr,BSTR,rbstr,R8,144);
5093     VARMUL(R4,0.2f,BSTR,rbstr,R8,2.4);
5094     VARMUL(DATE,2.25,I4,7,R8,15.75);
5095
5096     VARMUL(UI1, UI1_MAX, UI1, UI1_MAX, I4, UI1_MAX * UI1_MAX);
5097     VARMUL(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX * I2_MAX);
5098     VARMUL(I2, I2_MAX, I2, I2_MIN, I4, I2_MAX * I2_MIN);
5099     VARMUL(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN * I2_MIN);
5100     VARMUL(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX * I4_MAX);
5101     VARMUL(I4, I4_MAX, I4, I4_MIN, R8, (double)I4_MAX * I4_MIN);
5102     VARMUL(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN * I4_MIN);
5103     VARMUL(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX * R4_MAX);
5104     VARMUL(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX * R4_MIN);
5105     VARMUL(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN * R4_MIN);
5106     VARMUL(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX * R8_MIN);
5107     VARMUL(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN * R8_MIN);
5108
5109     /* Manuly test some VT_CY and VT_DECIMAL variants */
5110     V_VT(&cy) = VT_CY;
5111     hres = VarCyFromI4(4711, &V_CY(&cy));
5112     ok(hres == S_OK, "VarCyFromI4 failed!\n");
5113     V_VT(&dec) = VT_DECIMAL;
5114     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5115     ok(hres == S_OK, "VarDecFromR4 failed!\n");
5116     memset(&left, 0, sizeof(left));
5117     memset(&right, 0, sizeof(right));
5118     V_VT(&left) = VT_I4;
5119     V_I4(&left) = -11;
5120     V_VT(&right) = VT_UI1;
5121     V_UI1(&right) = 9;
5122
5123     hres = pVarMul(&cy, &right, &result);
5124     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarMul: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5125     hres = VarR8FromCy(V_CY(&result), &r);
5126     ok(hres == S_OK && EQ_DOUBLE(r, 42399), "VarMul: CY value %f, expected %f\n", r, (double)42399);
5127
5128     hres = pVarMul(&left, &dec, &result);
5129     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarMul: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5130     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5131     ok(hres == S_OK && EQ_DOUBLE(r, 46.2), "VarMul: DECIMAL value %f, expected %f\n", r, (double)46.2);
5132
5133     SysFreeString(lbstr);
5134     SysFreeString(rbstr);
5135 }
5136
5137 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
5138
5139 #define VARADD(vt1,val1,vt2,val2,rvt,rval)               \
5140         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5141         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5142         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5143         test_var_call2( __LINE__, pVarAdd, &left, &right, &exp )
5144
5145 static void test_VarAdd(void)
5146 {
5147     VARIANT left, right, exp, result, cy, dec;
5148     VARTYPE i;
5149     BSTR lbstr, rbstr;
5150     HRESULT hres;
5151     double r;
5152
5153     CHECKPTR(VarAdd);
5154
5155     lbstr = SysAllocString(sz12);
5156     rbstr = SysAllocString(sz12);
5157
5158     /* Test all possible flag/vt combinations & the resulting vt type */
5159     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5160     {
5161         VARTYPE leftvt, rightvt, resvt;
5162
5163         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5164         {
5165
5166             SKIPTESTS(leftvt);
5167
5168             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5169             {
5170                 BOOL bFail = FALSE;
5171
5172                 SKIPTESTS(rightvt);
5173
5174                 if (leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
5175                     continue;
5176
5177                 memset(&left, 0, sizeof(left));
5178                 memset(&right, 0, sizeof(right));
5179                 V_VT(&left) = leftvt | ExtraFlags[i];
5180                 if (leftvt == VT_BSTR)
5181                     V_BSTR(&left) = lbstr;
5182                 V_VT(&right) = rightvt | ExtraFlags[i];
5183                 if (rightvt == VT_BSTR)
5184                     V_BSTR(&right) = rbstr;
5185                 V_VT(&result) = VT_EMPTY;
5186                 resvt = VT_ERROR;
5187
5188                 /* Don't ask me why but native VarAdd cannot handle:
5189                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
5190                    Tested with DCOM98, Win2k, WinXP */
5191                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5192                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5193                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5194                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5195                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5196                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5197                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
5198                     leftvt == VT_I1 || rightvt == VT_I1 ||
5199                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5200                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5201                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5202                     leftvt == VT_INT || rightvt == VT_INT ||
5203                     leftvt == VT_UINT || rightvt == VT_UINT) {
5204                     bFail = TRUE;
5205                 }
5206
5207                 if (leftvt == VT_NULL || rightvt == VT_NULL)
5208                     resvt = VT_NULL;
5209                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH)
5210                     bFail = TRUE;
5211                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5212                     resvt = VT_DECIMAL;
5213                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
5214                     resvt = VT_DATE;
5215                 else if (leftvt == VT_CY || rightvt == VT_CY)
5216                     resvt = VT_CY;
5217                 else if (leftvt == VT_R8 || rightvt == VT_R8)
5218                     resvt = VT_R8;
5219                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
5220                     if ((leftvt == VT_BSTR && rightvt == VT_BSTR) ||
5221                          leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5222                         resvt = VT_BSTR;
5223                     else
5224                         resvt = VT_R8;
5225                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
5226                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
5227                         leftvt == VT_I8 || rightvt == VT_I8)
5228                         resvt = VT_R8;
5229                     else
5230                         resvt = VT_R4;
5231                 }
5232                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5233                     resvt = VT_I8;
5234                 else if (leftvt == VT_I4 || rightvt == VT_I4)
5235                     resvt = VT_I4;
5236                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5237                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
5238                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5239                     resvt = VT_I2;
5240                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5241                     resvt = VT_UI1;
5242
5243                 hres = pVarAdd(&left, &right, &result);
5244                 if (bFail) {
5245                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5246                        "VarAdd: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
5247                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5248                        V_VT(&result));
5249                 } else {
5250                     ok(hres == S_OK && V_VT(&result) == resvt,
5251                        "VarAdd: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
5252                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5253                        V_VT(&result));
5254                 }
5255                 /* Note, we don't clear left/right deliberately here */
5256                 VariantClear(&result);
5257             }
5258         }
5259     }
5260
5261     /* Test returned values */
5262     VARADD(I4,4,I4,2,I4,6);
5263     VARADD(I2,4,I2,2,I2,6);
5264     VARADD(I2,-13,I4,5,I4,-8);
5265     VARADD(I4,-13,I4,5,I4,-8);
5266     VARADD(I2,7,R4,0.5f,R4,7.5f);
5267     VARADD(R4,0.5f,I4,5,R8,5.5);
5268     VARADD(R8,7.1,BOOL,0,R8,7.1);
5269     VARADD(BSTR,lbstr,I2,4,R8,16);
5270     VARADD(BSTR,lbstr,BOOL,1,R8,13);
5271     VARADD(BSTR,lbstr,R4,0.1f,R8,12.1);
5272     VARADD(R4,0.2f,BSTR,rbstr,R8,12.2);
5273     VARADD(DATE,2.25,I4,7,DATE,9.25);
5274     VARADD(DATE,1.25,R4,-1.7f,DATE,-0.45);
5275
5276     VARADD(UI1, UI1_MAX, UI1, UI1_MAX, I2, UI1_MAX + UI1_MAX);
5277     VARADD(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX + I2_MAX);
5278     VARADD(I2, I2_MAX, I2, I2_MIN, I2, I2_MAX + I2_MIN);
5279     VARADD(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN + I2_MIN);
5280     VARADD(I4, I4_MAX, I4, I4_MIN, I4, I4_MAX + I4_MIN);
5281     VARADD(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX + I4_MAX);
5282     VARADD(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN + I4_MIN);
5283     VARADD(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX + R4_MAX);
5284     VARADD(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX + R4_MIN);
5285     VARADD(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN + R4_MIN);
5286     VARADD(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX + R8_MIN);
5287     VARADD(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN + R8_MIN);
5288
5289     /* Manually test BSTR + BSTR */
5290     V_VT(&left) = VT_BSTR;
5291     V_BSTR(&left) = lbstr;
5292     V_VT(&right) = VT_BSTR;
5293     V_BSTR(&right) = rbstr;
5294     hres = pVarAdd(&left, &right, &result);
5295     ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n", vtstr(V_VT(&result)));
5296     hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
5297     ok(hres == S_OK && EQ_DOUBLE(r, 1212), "VarAdd: BSTR value %f, expected %f\n", r, (double)1212);
5298     VariantClear(&result);
5299
5300     /* Manuly test some VT_CY and VT_DECIMAL variants */
5301     V_VT(&cy) = VT_CY;
5302     hres = VarCyFromI4(4711, &V_CY(&cy));
5303     ok(hres == S_OK, "VarCyFromI4 failed!\n");
5304     V_VT(&dec) = VT_DECIMAL;
5305     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5306     ok(hres == S_OK, "VarDecFromR4 failed!\n");
5307     memset(&left, 0, sizeof(left));
5308     memset(&right, 0, sizeof(right));
5309     V_VT(&left) = VT_I4;
5310     V_I4(&left) = -11;
5311     V_VT(&right) = VT_UI1;
5312     V_UI1(&right) = 9;
5313
5314     hres = pVarAdd(&cy, &right, &result);
5315     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5316     hres = VarR8FromCy(V_CY(&result), &r);
5317     ok(hres == S_OK && EQ_DOUBLE(r, 4720), "VarAdd: CY value %f, expected %f\n", r, (double)4720);
5318
5319     hres = pVarAdd(&left, &dec, &result);
5320     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5321     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5322     ok(hres == S_OK && EQ_DOUBLE(r, -15.2), "VarAdd: DECIMAL value %f, expected %f\n", r, (double)-15.2);
5323     VariantClear(&result);
5324
5325     SysFreeString(lbstr);
5326     SysFreeString(rbstr);
5327 }
5328
5329 static HRESULT (WINAPI *pVarCmp)(LPVARIANT,LPVARIANT,LCID,ULONG);
5330 static HRESULT (WINAPI *pVarCat)(LPVARIANT,LPVARIANT,LPVARIANT);
5331
5332 static void test_VarCat(void)
5333 {
5334     LCID lcid;
5335     VARIANT left, right, result, expected, expected_broken;
5336     static const WCHAR sz34[] = {'3','4','\0'};
5337     static const WCHAR sz1234[] = {'1','2','3','4','\0'};
5338     static const WCHAR date_sz12[] = {'9','/','3','0','/','1','9','8','0','1','2','\0'};
5339     static const WCHAR date_sz12_broken[] = {'9','/','3','0','/','8','0','1','2','\0'};
5340     static const WCHAR sz12_date[] = {'1','2','9','/','3','0','/','1','9','8','0','\0'};
5341     static const WCHAR sz12_date_broken[] = {'1','2','9','/','3','0','/','8','0','\0'};
5342     static const WCHAR sz_empty[] = {'\0'};
5343     TCHAR orig_date_format[128];
5344     VARTYPE leftvt, rightvt, resultvt;
5345     HRESULT hres;
5346     HRESULT expected_error_num;
5347
5348     CHECKPTR(VarCat);
5349
5350     /* Set date format for testing */
5351     lcid = LOCALE_USER_DEFAULT;
5352     GetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format,128);
5353     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,"M/d/yyyy");
5354
5355     VariantInit(&left);
5356     VariantInit(&right);
5357     VariantInit(&result);
5358     VariantInit(&expected);
5359
5360     /* Check expected types for all combinations */
5361     for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5362     {
5363
5364         SKIPTESTS(leftvt);
5365
5366         /* Check if we need/have support for I8 and/or UI8 */
5367         if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5368             continue;
5369
5370         for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5371         {
5372
5373             SKIPTESTS(rightvt);
5374             expected_error_num = S_OK;
5375             resultvt = VT_EMPTY;
5376
5377             if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5378                 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN  ||
5379                 leftvt == VT_RECORD || rightvt == VT_RECORD  ||
5380                 leftvt == 15 || rightvt == 15 /* Undefined type */)
5381                 continue;
5382
5383             /* Check if we need/have support for I8 and/or UI8 */
5384             if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5385                 continue;
5386
5387             if (leftvt == VT_NULL && rightvt == VT_NULL)
5388                 resultvt = VT_NULL;
5389             else if (leftvt == VT_VARIANT && (rightvt == VT_ERROR ||
5390                 rightvt == VT_DATE || rightvt == VT_DECIMAL))
5391                 expected_error_num = DISP_E_TYPEMISMATCH;
5392             else if ((leftvt == VT_I2 || leftvt == VT_I4 ||
5393                 leftvt == VT_R4 || leftvt == VT_R8 ||
5394                 leftvt == VT_CY || leftvt == VT_BOOL ||
5395                 leftvt == VT_BSTR || leftvt == VT_I1 ||
5396                 leftvt == VT_UI1 || leftvt == VT_UI2 ||
5397                 leftvt == VT_UI4 || leftvt == VT_I8 ||
5398                 leftvt == VT_UI8 || leftvt == VT_INT ||
5399                 leftvt == VT_UINT || leftvt == VT_EMPTY ||
5400                 leftvt == VT_NULL || leftvt == VT_DECIMAL ||
5401                 leftvt == VT_DATE)
5402                 &&
5403                 (rightvt == VT_I2 || rightvt == VT_I4 ||
5404                 rightvt == VT_R4 || rightvt == VT_R8 ||
5405                 rightvt == VT_CY || rightvt == VT_BOOL ||
5406                 rightvt == VT_BSTR || rightvt == VT_I1 ||
5407                 rightvt == VT_UI1 || rightvt == VT_UI2 ||
5408                 rightvt == VT_UI4 || rightvt == VT_I8 ||
5409                 rightvt == VT_UI8 || rightvt == VT_INT ||
5410                 rightvt == VT_UINT || rightvt == VT_EMPTY ||
5411                 rightvt == VT_NULL || rightvt == VT_DECIMAL ||
5412                 rightvt == VT_DATE))
5413                 resultvt = VT_BSTR;
5414             else if (rightvt == VT_ERROR && leftvt < VT_VOID)
5415                 expected_error_num = DISP_E_TYPEMISMATCH;
5416             else if (leftvt == VT_ERROR && (rightvt == VT_DATE ||
5417                 rightvt == VT_ERROR || rightvt == VT_DECIMAL))
5418                 expected_error_num = DISP_E_TYPEMISMATCH;
5419             else if (rightvt == VT_DATE || rightvt == VT_ERROR ||
5420                 rightvt == VT_DECIMAL)
5421                 expected_error_num = DISP_E_BADVARTYPE;
5422             else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
5423                 expected_error_num = DISP_E_TYPEMISMATCH;
5424             else if (leftvt == VT_VARIANT)
5425                 expected_error_num = DISP_E_TYPEMISMATCH;
5426             else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY ||
5427                 leftvt == VT_NULL || leftvt ==  VT_I2 ||
5428                 leftvt == VT_I4 || leftvt == VT_R4 ||
5429                 leftvt == VT_R8 || leftvt == VT_CY ||
5430                 leftvt == VT_DATE || leftvt == VT_BSTR ||
5431                 leftvt == VT_BOOL ||  leftvt == VT_DECIMAL ||
5432                 leftvt == VT_I1 || leftvt == VT_UI1 ||
5433                 leftvt == VT_UI2 || leftvt == VT_UI4 ||
5434                 leftvt == VT_I8 || leftvt == VT_UI8 ||
5435                 leftvt == VT_INT || leftvt == VT_UINT
5436                 ))
5437                 expected_error_num = DISP_E_TYPEMISMATCH;
5438             else
5439                 expected_error_num = DISP_E_BADVARTYPE;
5440
5441             V_VT(&left) = leftvt;
5442             V_VT(&right) = rightvt;
5443
5444             switch (leftvt) {
5445             case VT_BSTR:
5446                 V_BSTR(&left) = SysAllocString(sz_empty); break;
5447             case VT_DATE:
5448                 V_DATE(&left) = 0.0; break;
5449             case VT_DECIMAL:
5450                 VarDecFromR8(0.0, &V_DECIMAL(&left)); break;
5451             default:
5452                 V_I8(&left) = 0;
5453             }
5454
5455             switch (rightvt) {
5456             case VT_BSTR:
5457                 V_BSTR(&right) = SysAllocString(sz_empty); break;
5458             case VT_DATE:
5459                 V_DATE(&right) = 0.0; break;
5460             case VT_DECIMAL:
5461                 VarDecFromR8(0.0, &V_DECIMAL(&right)); break;
5462             default:
5463                 V_I8(&right) = 0;
5464             }
5465
5466             hres = pVarCat(&left, &right, &result);
5467
5468             /* Determine the error code for the vt combination */
5469             ok(hres == expected_error_num,
5470                 "VarCat: %d, %d returned error, 0x%X expected 0x%X.\n",
5471                 leftvt, rightvt, expected_error_num, hres);
5472
5473             /* Check types are correct */
5474             ok(V_VT(&result) == resultvt,
5475                 "VarCat: %d, %d: expected vt %d, got vt %d\n",
5476                 leftvt, rightvt, resultvt, V_VT(&result));
5477
5478             VariantClear(&left);
5479             VariantClear(&right);
5480             VariantClear(&result);
5481         }
5482     }
5483
5484     /* Running single comparison tests to compare outputs */
5485
5486     /* Test concat strings */
5487     V_VT(&left) = VT_BSTR;
5488     V_VT(&right) = VT_BSTR;
5489     V_VT(&expected) = VT_BSTR;
5490     V_BSTR(&left) = SysAllocString(sz12);
5491     V_BSTR(&right) = SysAllocString(sz34);
5492     V_BSTR(&expected) = SysAllocString(sz1234);
5493     hres = pVarCat(&left,&right,&result);
5494     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5495     if (pVarCmp)
5496         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5497            "VarCat: VT_BSTR concat with VT_BSTR failed to return correct result\n");
5498
5499     VariantClear(&left);
5500     VariantClear(&right);
5501     VariantClear(&result);
5502
5503     /* Test if expression is VT_ERROR */
5504     V_VT(&left) = VT_ERROR;
5505     V_VT(&right) = VT_BSTR;
5506     V_BSTR(&right) = SysAllocString(sz1234);
5507     hres = pVarCat(&left,&right,&result);
5508     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5509     ok(V_VT(&result) == VT_EMPTY,
5510         "VarCat: VT_ERROR concat with VT_BSTR should have returned VT_EMPTY\n");
5511
5512     VariantClear(&left);
5513     VariantClear(&right);
5514     VariantClear(&result);
5515
5516     V_VT(&left) = VT_BSTR;
5517     V_VT(&right) = VT_ERROR;
5518     V_BSTR(&left) = SysAllocString(sz1234);
5519     hres = pVarCat(&left,&right,&result);
5520     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5521     ok(V_VT(&result) == VT_EMPTY,
5522         "VarCat: VT_BSTR concat with VT_ERROR should have returned VT_EMPTY\n");
5523
5524     VariantClear(&left);
5525     VariantClear(&right);
5526     VariantClear(&result);
5527     VariantClear(&expected);
5528
5529     /* Test combining boolean with number */
5530     V_VT(&left) = VT_INT;
5531     V_VT(&right) = VT_BOOL;
5532     V_VT(&expected) = VT_BSTR;
5533     V_INT(&left) = 12;
5534     V_BOOL(&right) = TRUE;
5535     V_BSTR(&expected) = SysAllocString(sz12_true);
5536     hres = pVarCat(&left,&right,&result);
5537     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5538     if (pVarCmp)
5539     {
5540         hres = pVarCmp(&result,&expected,lcid,0);
5541         ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5542            hres, variantstr(&result), variantstr(&expected));
5543     }
5544
5545     VariantClear(&left);
5546     VariantClear(&right);
5547     VariantClear(&result);
5548     VariantClear(&expected);
5549
5550     V_VT(&left) = VT_INT;
5551     V_VT(&right) = VT_BOOL;
5552     V_VT(&expected) = VT_BSTR;
5553     V_INT(&left) = 12;
5554     V_BOOL(&right) = FALSE;
5555     V_BSTR(&expected) = SysAllocString(sz12_false);
5556     hres = pVarCat(&left,&right,&result);
5557     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5558     if (pVarCmp)
5559     {
5560         hres = pVarCmp(&result,&expected,lcid,0);
5561         ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5562            hres, variantstr(&result), variantstr(&expected));
5563     }
5564
5565     VariantClear(&left);
5566     VariantClear(&right);
5567     VariantClear(&result);
5568     VariantClear(&expected);
5569
5570     /* Test when both expressions are numeric */
5571     V_VT(&left) = VT_INT;
5572     V_VT(&right) = VT_INT;
5573     V_VT(&expected) = VT_BSTR;
5574     V_INT(&left)  = 12;
5575     V_INT(&right) = 34;
5576     V_BSTR(&expected) = SysAllocString(sz1234);
5577     hres = pVarCat(&left,&right,&result);
5578     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5579     if (pVarCmp)
5580         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5581            "VarCat: NUMBER concat with NUMBER returned incorrect result\n");
5582
5583     VariantClear(&left);
5584     VariantClear(&right);
5585     VariantClear(&result);
5586
5587     /* Test if one expression is numeric and the other is a string */
5588     V_VT(&left) = VT_INT;
5589     V_VT(&right) = VT_BSTR;
5590     V_INT(&left) = 12;
5591     V_BSTR(&right) = SysAllocString(sz34);
5592     hres = pVarCat(&left,&right,&result);
5593     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5594     if (pVarCmp)
5595         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5596            "VarCat: NUMBER concat with VT_BSTR, incorrect result\n");
5597
5598     VariantClear(&left);
5599     VariantClear(&right);
5600     VariantClear(&result);
5601
5602     V_VT(&left) = VT_BSTR;
5603     V_VT(&right) = VT_INT;
5604     V_BSTR(&left) = SysAllocString(sz12);
5605     V_INT(&right) = 34;
5606     hres = pVarCat(&left,&right,&result);
5607     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5608     if (pVarCmp)
5609         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5610            "VarCat: VT_BSTR concat with NUMBER, incorrect result\n");
5611
5612     VariantClear(&left);
5613     VariantClear(&right);
5614     VariantClear(&result);
5615     VariantClear(&expected);
5616
5617     /* Test concat dates with strings */
5618     V_VT(&left) = VT_BSTR;
5619     V_VT(&right) = VT_DATE;
5620     V_VT(&expected) = VT_BSTR;
5621     V_VT(&expected_broken) = VT_BSTR;
5622     V_BSTR(&left) = SysAllocString(sz12);
5623     V_DATE(&right) = 29494.0;
5624     V_BSTR(&expected)= SysAllocString(sz12_date);
5625     V_BSTR(&expected_broken)= SysAllocString(sz12_date_broken);
5626     hres = pVarCat(&left,&right,&result);
5627     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5628     if (pVarCmp)
5629         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5630            broken(pVarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5631            "VarCat: VT_BSTR concat with VT_DATE returned incorrect result\n");
5632
5633     VariantClear(&left);
5634     VariantClear(&right);
5635     VariantClear(&result);
5636     VariantClear(&expected);
5637     VariantClear(&expected_broken);
5638
5639     V_VT(&left) = VT_DATE;
5640     V_VT(&right) = VT_BSTR;
5641     V_VT(&expected) = VT_BSTR;
5642     V_VT(&expected_broken) = VT_BSTR;
5643     V_DATE(&left) = 29494.0;
5644     V_BSTR(&right) = SysAllocString(sz12);
5645     V_BSTR(&expected)= SysAllocString(date_sz12);
5646     V_BSTR(&expected_broken)= SysAllocString(date_sz12_broken);
5647     hres = pVarCat(&left,&right,&result);
5648     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5649     if (pVarCmp)
5650         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5651            broken(pVarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5652            "VarCat: VT_DATE concat with VT_BSTR returned incorrect result\n");
5653
5654     VariantClear(&left);
5655     VariantClear(&right);
5656     VariantClear(&result);
5657     VariantClear(&expected);
5658     VariantClear(&expected_broken);
5659
5660     /* Test of both expressions are empty */
5661     V_VT(&left) = VT_BSTR;
5662     V_VT(&right) = VT_BSTR;
5663     V_VT(&expected) = VT_BSTR;
5664     V_BSTR(&left) = SysAllocString(sz_empty);
5665     V_BSTR(&right) = SysAllocString(sz_empty);
5666     V_BSTR(&expected)= SysAllocString(sz_empty);
5667     hres = pVarCat(&left,&right,&result);
5668     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5669     if (pVarCmp)
5670         ok(pVarCmp(&result,&left,lcid,0) == VARCMP_EQ,
5671            "VarCat: EMPTY concat with EMPTY did not return empty VT_BSTR\n");
5672
5673     /* Restore original date format settings */
5674     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format);
5675
5676     VariantClear(&left);
5677     VariantClear(&right);
5678     VariantClear(&result);
5679     VariantClear(&expected);
5680
5681     /* Test boolean conversion */
5682     V_VT(&left) = VT_BOOL;
5683     V_BOOL(&left) = VARIANT_TRUE;
5684     V_VT(&right) = VT_BSTR;
5685     V_BSTR(&right) = SysAllocStringLen(NULL,0);
5686     hres = pVarCat(&left, &right, &result);
5687     ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5688     if(!strcmp_wa(V_BSTR(&result), "True")) {
5689         V_VT(&right) = VT_BOOL;
5690         V_BOOL(&right) = 100;
5691         hres = pVarCat(&left, &right, &result);
5692         ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5693         test_bstr_var(&result, "TrueTrue");
5694         VariantClear(&result);
5695
5696         V_BOOL(&right) = VARIANT_FALSE;
5697         hres = pVarCat(&left, &right, &result);
5698         ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5699         test_bstr_var(&result, "TrueFalse");
5700         VariantClear(&result);
5701     }else {
5702         skip("Got %s as True, assuming non-English locale\n", wine_dbgstr_w(V_BSTR(&result)));
5703     }
5704 }
5705
5706 static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);
5707
5708 #define VARAND(vt1,val1,vt2,val2,rvt,rval)               \
5709         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5710         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5711         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5712         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5713
5714 #define VARANDCY(vt1,val1,val2,rvt,rval)                 \
5715         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5716         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
5717         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5718         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5719
5720 /* Skip any type that is not defined or produces an error for every case */
5721 #define SKIPTESTAND(a)                                \
5722         if (a == VT_ERROR || a == VT_VARIANT ||       \
5723             a == VT_DISPATCH || a == VT_UNKNOWN ||    \
5724             a > VT_UINT || a == 15 /*not defined*/)   \
5725             continue
5726
5727 static void test_VarAnd(void)
5728 {
5729     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
5730     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
5731     VARIANT left, right, exp, result;
5732     BSTR false_str, true_str;
5733     VARTYPE i;
5734     HRESULT hres;
5735
5736     true_str = SysAllocString(szTrue);
5737     false_str = SysAllocString(szFalse);
5738
5739     CHECKPTR(VarAnd);
5740
5741     /* Test all possible flag/vt combinations & the resulting vt type */
5742     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5743     {
5744         VARTYPE leftvt, rightvt, resvt;
5745
5746         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5747         {
5748             SKIPTESTAND(leftvt);
5749
5750             /* Check if we need/have support for I8 and/or UI8 */
5751             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5752                 continue;
5753
5754             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5755             {
5756                 BOOL bFail = FALSE;
5757                 SKIPTESTAND(rightvt);
5758
5759                 /* Check if we need/have support for I8 and/or UI8 */
5760                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5761                     continue;
5762
5763                 memset(&left, 0, sizeof(left));
5764                 memset(&right, 0, sizeof(right));
5765                 V_VT(&left) = leftvt | ExtraFlags[i];
5766                 V_VT(&right) = rightvt | ExtraFlags[i];
5767                 V_VT(&result) = VT_EMPTY;
5768                 resvt = VT_EMPTY;
5769                 if ((leftvt | ExtraFlags[i]) == VT_BSTR)
5770                     V_BSTR(&left) = true_str;
5771                 if ((rightvt | ExtraFlags[i]) == VT_BSTR)
5772                     V_BSTR(&right) = true_str;
5773
5774                 /* Native VarAnd always returns an error when using extra
5775                  * flags or if the variant combination is I8 and INT.
5776                  */
5777                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
5778                     (leftvt == VT_INT && rightvt == VT_I8) ||
5779                     ExtraFlags[i] != 0)
5780                     bFail = TRUE;
5781
5782                 /* Determine return type */
5783                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5784                     resvt = VT_I8;
5785                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
5786                     leftvt == VT_UINT || rightvt == VT_UINT ||
5787                     leftvt == VT_INT || rightvt == VT_INT ||
5788                     leftvt == VT_UINT || rightvt == VT_UINT ||
5789                     leftvt == VT_R4 || rightvt == VT_R4 ||
5790                     leftvt == VT_R8 || rightvt == VT_R8 ||
5791                     leftvt == VT_CY || rightvt == VT_CY ||
5792                     leftvt == VT_DATE || rightvt == VT_DATE ||
5793                     leftvt == VT_I1 || rightvt == VT_I1 ||
5794                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5795                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5796                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5797                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5798                     resvt = VT_I4;
5799                 else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
5800                     leftvt == VT_I2 || rightvt == VT_I2 ||
5801                     leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5802                     if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
5803                         (leftvt == VT_UI1 && rightvt == VT_NULL) ||
5804                         (leftvt == VT_UI1 && rightvt == VT_UI1))
5805                         resvt = VT_UI1;
5806                     else
5807                         resvt = VT_I2;
5808                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
5809                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
5810                     resvt = VT_BOOL;
5811                 else if (leftvt == VT_NULL || rightvt == VT_NULL ||
5812                     leftvt == VT_BSTR || rightvt == VT_BSTR)
5813                     resvt = VT_NULL;
5814                 else
5815                     bFail = TRUE;
5816
5817                 hres = pVarAnd(&left, &right, &result);
5818
5819                 /* Check expected HRESULT and if result variant type is correct */
5820                 if (bFail)
5821                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
5822                         "VarAnd: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
5823                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
5824                         vtstr(V_VT(&result)), hres);
5825                 else
5826                     ok (hres == S_OK && resvt == V_VT(&result),
5827                         "VarAnd: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
5828                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
5829                         S_OK, vtstr(V_VT(&result)), hres);
5830             }
5831         }
5832     }
5833
5834     /*
5835      * Test returned values. Since we know the returned type is correct
5836      * and that we handle all combinations of invalid types, just check
5837      * that good type combinations produce the desired value.
5838      * FIXME: Test VT_DECIMAL
5839      */
5840     VARAND(EMPTY,0,EMPTY,0,I2,0);
5841     VARAND(EMPTY,1,EMPTY,0,I2,0);
5842     VARAND(EMPTY,1,EMPTY,1,I2,0);
5843     VARAND(EMPTY,0,NULL,0,I2,0);
5844     VARAND(EMPTY,1,NULL,0,I2,0);
5845     VARAND(EMPTY,1,NULL,1,I2,0);
5846     VARAND(EMPTY,0,I1,0,I4,0);
5847     VARAND(EMPTY,0,I1,1,I4,0);
5848     VARAND(EMPTY,1,I1,1,I4,0);
5849     VARAND(EMPTY,0,UI1,0,I2,0);
5850     VARAND(EMPTY,0,UI1,1,I2,0);
5851     VARAND(EMPTY,1,UI1,1,I2,0);
5852     VARAND(EMPTY,0,I2,0,I2,0);
5853     VARAND(EMPTY,0,I2,1,I2,0);
5854     VARAND(EMPTY,1,I2,1,I2,0);
5855     VARAND(EMPTY,0,UI2,0,I4,0);
5856     VARAND(EMPTY,0,UI2,1,I4,0);
5857     VARAND(EMPTY,1,UI2,1,I4,0);
5858     VARAND(EMPTY,0,I4,0,I4,0);
5859     VARAND(EMPTY,0,I4,1,I4,0);
5860     VARAND(EMPTY,1,I4,1,I4,0);
5861     VARAND(EMPTY,0,UI4,0,I4,0);
5862     VARAND(EMPTY,0,UI4,1,I4,0);
5863     VARAND(EMPTY,1,UI4,1,I4,0);
5864     if (HAVE_OLEAUT32_I8)
5865     {
5866         VARAND(EMPTY,0,I8,0,I8,0);
5867         VARAND(EMPTY,0,I8,1,I8,0);
5868         VARAND(EMPTY,1,I8,1,I8,0);
5869         VARAND(EMPTY,0,UI8,0,I4,0);
5870         VARAND(EMPTY,0,UI8,1,I4,0);
5871         VARAND(EMPTY,1,UI8,1,I4,0);
5872     }
5873     VARAND(EMPTY,0,INT,0,I4,0);
5874     VARAND(EMPTY,0,INT,1,I4,0);
5875     VARAND(EMPTY,1,INT,1,I4,0);
5876     VARAND(EMPTY,0,UINT,0,I4,0);
5877     VARAND(EMPTY,0,UINT,1,I4,0);
5878     VARAND(EMPTY,1,UINT,1,I4,0);
5879     VARAND(EMPTY,0,BOOL,0,I2,0);
5880     VARAND(EMPTY,0,BOOL,1,I2,0);
5881     VARAND(EMPTY,1,BOOL,1,I2,0);
5882     VARAND(EMPTY,0,R4,0,I4,0);
5883     VARAND(EMPTY,0,R4,1,I4,0);
5884     VARAND(EMPTY,1,R4,1,I4,0);
5885     VARAND(EMPTY,0,R8,0,I4,0);
5886     VARAND(EMPTY,0,R8,1,I4,0);
5887     VARAND(EMPTY,1,R8,1,I4,0);
5888     VARAND(EMPTY,0,BSTR,false_str,I2,0);
5889     VARAND(EMPTY,0,BSTR,true_str,I2,0);
5890     VARANDCY(EMPTY,0,10000,I4,0);
5891
5892     /* NULL OR 0 = NULL. NULL OR n = n */
5893     VARAND(NULL,0,NULL,0,NULL,0);
5894     VARAND(NULL,1,NULL,0,NULL,0);
5895     VARAND(NULL,0,I1,0,I4,0);
5896     VARAND(NULL,0,I1,1,NULL,0);
5897     VARAND(NULL,0,UI1,0,UI1,0);
5898     VARAND(NULL,0,UI1,1,NULL,0);
5899     VARAND(NULL,0,I2,0,I2,0);
5900     VARAND(NULL,0,I2,1,NULL,0);
5901     VARAND(NULL,0,UI2,0,I4,0);
5902     VARAND(NULL,0,UI2,1,NULL,0);
5903     VARAND(NULL,0,I4,0,I4,0);
5904     VARAND(NULL,0,I4,1,NULL,0);
5905     VARAND(NULL,0,UI4,0,I4,0);
5906     VARAND(NULL,0,UI4,1,NULL,0);
5907     if (HAVE_OLEAUT32_I8)
5908     {
5909         VARAND(NULL,0,I8,0,I8,0);
5910         VARAND(NULL,0,I8,1,NULL,0);
5911         VARAND(NULL,0,UI8,0,I4,0);
5912         VARAND(NULL,0,UI8,1,NULL,0);
5913     }
5914     VARAND(NULL,0,INT,0,I4,0);
5915     VARAND(NULL,0,INT,1,NULL,0);
5916     VARAND(NULL,0,UINT,0,I4,0);
5917     VARAND(NULL,0,UINT,1,NULL,0);
5918     VARAND(NULL,0,BOOL,0,BOOL,0);
5919     VARAND(NULL,0,BOOL,1,NULL,0);
5920     VARAND(NULL,0,R4,0,I4,0);
5921     VARAND(NULL,0,R4,1,NULL,0);
5922     VARAND(NULL,0,R8,0,I4,0);
5923     VARAND(NULL,0,R8,1,NULL,0);
5924     VARAND(NULL,0,BSTR,false_str,BOOL,0);
5925     VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE);
5926     VARANDCY(NULL,0,10000,NULL,0);
5927     VARANDCY(NULL,0,0,I4,0);
5928     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
5929     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5930     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
5931     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5932
5933     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
5934     VARAND(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
5935     VARAND(BOOL,VARIANT_TRUE,I1,0,I4,0);
5936     VARAND(BOOL,VARIANT_FALSE,I1,0,I4,0);
5937     VARAND(BOOL,VARIANT_TRUE,UI1,255,I2,255);
5938     VARAND(BOOL,VARIANT_TRUE,UI1,0,I2,0);
5939     VARAND(BOOL,VARIANT_FALSE,UI1,0,I2,0);
5940     VARAND(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
5941     VARAND(BOOL,VARIANT_TRUE,I2,0,I2,0);
5942     VARAND(BOOL,VARIANT_FALSE,I2,0,I2,0);
5943     VARAND(BOOL,VARIANT_TRUE,UI2,65535,I4,65535);
5944     VARAND(BOOL,VARIANT_TRUE,UI2,0,I4,0);
5945     VARAND(BOOL,VARIANT_FALSE,UI2,0,I4,0);
5946     VARAND(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
5947     VARAND(BOOL,VARIANT_TRUE,I4,0,I4,0);
5948     VARAND(BOOL,VARIANT_FALSE,I4,0,I4,0);
5949     VARAND(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
5950     VARAND(BOOL,VARIANT_TRUE,UI4,0,I4,0);
5951     VARAND(BOOL,VARIANT_FALSE,UI4,0,I4,0);
5952     VARAND(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
5953     VARAND(BOOL,VARIANT_TRUE,R4,0,I4,0);
5954     VARAND(BOOL,VARIANT_FALSE,R4,0,I4,0);
5955     VARAND(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
5956     VARAND(BOOL,VARIANT_TRUE,R8,0,I4,0);
5957     VARAND(BOOL,VARIANT_FALSE,R8,0,I4,0);
5958     VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
5959     VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
5960     VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
5961     if (HAVE_OLEAUT32_I8)
5962     {
5963         VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
5964         VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
5965         VARAND(BOOL,VARIANT_FALSE,I8,0,I8,0);
5966         VARAND(BOOL,VARIANT_TRUE,UI8,0,I4,0);
5967         VARAND(BOOL,VARIANT_FALSE,UI8,0,I4,0);
5968     }
5969     VARAND(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
5970     VARAND(BOOL,VARIANT_TRUE,INT,0,I4,0);
5971     VARAND(BOOL,VARIANT_FALSE,INT,0,I4,0);
5972     VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
5973     VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0);
5974     VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0);
5975     VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE);
5976     VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE);
5977     VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE);
5978     VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE);
5979     VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1);
5980     VARANDCY(BOOL,VARIANT_TRUE,0,I4,0);
5981     VARANDCY(BOOL,VARIANT_FALSE,0,I4,0);
5982     VARAND(I1,-1,I1,-1,I4,-1);
5983     VARAND(I1,-1,I1,0,I4,0);
5984     VARAND(I1,0,I1,0,I4,0);
5985     VARAND(I1,-1,UI1,255,I4,255);
5986     VARAND(I1,-1,UI1,0,I4,0);
5987     VARAND(I1,0,UI1,0,I4,0);
5988     VARAND(I1,-1,I2,-1,I4,-1);
5989     VARAND(I1,-1,I2,0,I4,0);
5990     VARAND(I1,0,I2,0,I4,0);
5991     VARAND(I1,-1,UI2,65535,I4,65535);
5992     VARAND(I1,-1,UI2,0,I4,0);
5993     VARAND(I1,0,UI2,0,I4,0);
5994     VARAND(I1,-1,I4,-1,I4,-1);
5995     VARAND(I1,-1,I4,0,I4,0);
5996     VARAND(I1,0,I4,0,I4,0);
5997     VARAND(I1,-1,UI4,0xffffffff,I4,-1);
5998     VARAND(I1,-1,UI4,0,I4,0);
5999     VARAND(I1,0,UI4,0,I4,0);
6000     VARAND(I1,-1,R4,-1,I4,-1);
6001     VARAND(I1,-1,R4,0,I4,0);
6002     VARAND(I1,0,R4,0,I4,0);
6003     VARAND(I1,-1,R8,-1,I4,-1);
6004     VARAND(I1,-1,R8,0,I4,0);
6005     VARAND(I1,0,R8,0,I4,0);
6006     VARAND(I1,-1,DATE,-1,I4,-1);
6007     VARAND(I1,-1,DATE,0,I4,0);
6008     VARAND(I1,0,DATE,0,I4,0);
6009     if (HAVE_OLEAUT32_I8)
6010     {
6011         VARAND(I1,-1,I8,-1,I8,-1);
6012         VARAND(I1,-1,I8,0,I8,0);
6013         VARAND(I1,0,I8,0,I8,0);
6014         VARAND(I1,-1,UI8,0,I4,0);
6015         VARAND(I1,0,UI8,0,I4,0);
6016     }
6017     VARAND(I1,-1,INT,-1,I4,-1);
6018     VARAND(I1,-1,INT,0,I4,0);
6019     VARAND(I1,0,INT,0,I4,0);
6020     VARAND(I1,-1,UINT,0xffffffff,I4,-1);
6021     VARAND(I1,-1,UINT,0,I4,0);
6022     VARAND(I1,0,UINT,0,I4,0);
6023     VARAND(I1,0,BSTR,false_str,I4,0);
6024     VARAND(I1,-1,BSTR,false_str,I4,0);
6025     VARAND(I1,0,BSTR,true_str,I4,0);
6026     VARAND(I1,-1,BSTR,true_str,I4,-1);
6027     VARANDCY(I1,-1,10000,I4,1);
6028     VARANDCY(I1,-1,0,I4,0);
6029     VARANDCY(I1,0,0,I4,0);
6030
6031     VARAND(UI1,255,UI1,255,UI1,255);
6032     VARAND(UI1,255,UI1,0,UI1,0);
6033     VARAND(UI1,0,UI1,0,UI1,0);
6034     VARAND(UI1,255,I2,-1,I2,255);
6035     VARAND(UI1,255,I2,0,I2,0);
6036     VARAND(UI1,0,I2,0,I2,0);
6037     VARAND(UI1,255,UI2,65535,I4,255);
6038     VARAND(UI1,255,UI2,0,I4,0);
6039     VARAND(UI1,0,UI2,0,I4,0);
6040     VARAND(UI1,255,I4,-1,I4,255);
6041     VARAND(UI1,255,I4,0,I4,0);
6042     VARAND(UI1,0,I4,0,I4,0);
6043     VARAND(UI1,255,UI4,0xffffffff,I4,255);
6044     VARAND(UI1,255,UI4,0,I4,0);
6045     VARAND(UI1,0,UI4,0,I4,0);
6046     VARAND(UI1,255,R4,-1,I4,255);
6047     VARAND(UI1,255,R4,0,I4,0);
6048     VARAND(UI1,0,R4,0,I4,0);
6049     VARAND(UI1,255,R8,-1,I4,255);
6050     VARAND(UI1,255,R8,0,I4,0);
6051     VARAND(UI1,0,R8,0,I4,0);
6052     VARAND(UI1,255,DATE,-1,I4,255);
6053     VARAND(UI1,255,DATE,0,I4,0);
6054     VARAND(UI1,0,DATE,0,I4,0);
6055     if (HAVE_OLEAUT32_I8)
6056     {
6057         VARAND(UI1,255,I8,-1,I8,255);
6058         VARAND(UI1,255,I8,0,I8,0);
6059         VARAND(UI1,0,I8,0,I8,0);
6060         VARAND(UI1,255,UI8,0,I4,0);
6061         VARAND(UI1,0,UI8,0,I4,0);
6062     }
6063     VARAND(UI1,255,INT,-1,I4,255);
6064     VARAND(UI1,255,INT,0,I4,0);
6065     VARAND(UI1,0,INT,0,I4,0);
6066     VARAND(UI1,255,UINT,0xffffffff,I4,255);
6067     VARAND(UI1,255,UINT,0,I4,0);
6068     VARAND(UI1,0,UINT,0,I4,0);
6069     VARAND(UI1,0,BSTR,false_str,I2,0);
6070     VARAND(UI1,255,BSTR,false_str,I2,0);
6071     VARAND(UI1,0,BSTR,true_str,I2,0);
6072     VARAND(UI1,255,BSTR,true_str,I2,255);
6073     VARANDCY(UI1,255,10000,I4,1);
6074     VARANDCY(UI1,255,0,I4,0);
6075     VARANDCY(UI1,0,0,I4,0);
6076
6077     VARAND(I2,-1,I2,-1,I2,-1);
6078     VARAND(I2,-1,I2,0,I2,0);
6079     VARAND(I2,0,I2,0,I2,0);
6080     VARAND(I2,-1,UI2,65535,I4,65535);
6081     VARAND(I2,-1,UI2,0,I4,0);
6082     VARAND(I2,0,UI2,0,I4,0);
6083     VARAND(I2,-1,I4,-1,I4,-1);
6084     VARAND(I2,-1,I4,0,I4,0);
6085     VARAND(I2,0,I4,0,I4,0);
6086     VARAND(I2,-1,UI4,0xffffffff,I4,-1);
6087     VARAND(I2,-1,UI4,0,I4,0);
6088     VARAND(I2,0,UI4,0,I4,0);
6089     VARAND(I2,-1,R4,-1,I4,-1);
6090     VARAND(I2,-1,R4,0,I4,0);
6091     VARAND(I2,0,R4,0,I4,0);
6092     VARAND(I2,-1,R8,-1,I4,-1);
6093     VARAND(I2,-1,R8,0,I4,0);
6094     VARAND(I2,0,R8,0,I4,0);
6095     VARAND(I2,-1,DATE,-1,I4,-1);
6096     VARAND(I2,-1,DATE,0,I4,0);
6097     VARAND(I2,0,DATE,0,I4,0);
6098     if (HAVE_OLEAUT32_I8)
6099     {
6100         VARAND(I2,-1,I8,-1,I8,-1);
6101         VARAND(I2,-1,I8,0,I8,0);
6102         VARAND(I2,0,I8,0,I8,0);
6103         VARAND(I2,-1,UI8,0,I4,0);
6104         VARAND(I2,0,UI8,0,I4,0);
6105     }
6106     VARAND(I2,-1,INT,-1,I4,-1);
6107     VARAND(I2,-1,INT,0,I4,0);
6108     VARAND(I2,0,INT,0,I4,0);
6109     VARAND(I2,-1,UINT,0xffffffff,I4,-1);
6110     VARAND(I2,-1,UINT,0,I4,0);
6111     VARAND(I2,0,UINT,0,I4,0);
6112     VARAND(I2,0,BSTR,false_str,I2,0);
6113     VARAND(I2,-1,BSTR,false_str,I2,0);
6114     VARAND(I2,0,BSTR,true_str,I2,0);
6115     VARAND(I2,-1,BSTR,true_str,I2,-1);
6116     VARANDCY(I2,-1,10000,I4,1);
6117     VARANDCY(I2,-1,0,I4,0);
6118     VARANDCY(I2,0,0,I4,0);
6119
6120     VARAND(UI2,65535,UI2,65535,I4,65535);
6121     VARAND(UI2,65535,UI2,0,I4,0);
6122     VARAND(UI2,0,UI2,0,I4,0);
6123     VARAND(UI2,65535,I4,-1,I4,65535);
6124     VARAND(UI2,65535,I4,0,I4,0);
6125     VARAND(UI2,0,I4,0,I4,0);
6126     VARAND(UI2,65535,UI4,0xffffffff,I4,65535);
6127     VARAND(UI2,65535,UI4,0,I4,0);
6128     VARAND(UI2,0,UI4,0,I4,0);
6129     VARAND(UI2,65535,R4,-1,I4,65535);
6130     VARAND(UI2,65535,R4,0,I4,0);
6131     VARAND(UI2,0,R4,0,I4,0);
6132     VARAND(UI2,65535,R8,-1,I4,65535);
6133     VARAND(UI2,65535,R8,0,I4,0);
6134     VARAND(UI2,0,R8,0,I4,0);
6135     VARAND(UI2,65535,DATE,-1,I4,65535);
6136     VARAND(UI2,65535,DATE,0,I4,0);
6137     VARAND(UI2,0,DATE,0,I4,0);
6138     if (HAVE_OLEAUT32_I8)
6139     {
6140         VARAND(UI2,65535,I8,-1,I8,65535);
6141         VARAND(UI2,65535,I8,0,I8,0);
6142         VARAND(UI2,0,I8,0,I8,0);
6143         VARAND(UI2,65535,UI8,0,I4,0);
6144         VARAND(UI2,0,UI8,0,I4,0);
6145     }
6146     VARAND(UI2,65535,INT,-1,I4,65535);
6147     VARAND(UI2,65535,INT,0,I4,0);
6148     VARAND(UI2,0,INT,0,I4,0);
6149     VARAND(UI2,65535,UINT,0xffffffff,I4,65535);
6150     VARAND(UI2,65535,UINT,0,I4,0);
6151     VARAND(UI2,0,UINT,0,I4,0);
6152     VARAND(UI2,0,BSTR,false_str,I4,0);
6153     VARAND(UI2,65535,BSTR,false_str,I4,0);
6154     VARAND(UI2,0,BSTR,true_str,I4,0);
6155     VARAND(UI2,65535,BSTR,true_str,I4,65535);
6156     VARANDCY(UI2,65535,10000,I4,1);
6157     VARANDCY(UI2,65535,0,I4,0);
6158     VARANDCY(UI2,0,0,I4,0);
6159
6160     VARAND(I4,-1,I4,-1,I4,-1);
6161     VARAND(I4,-1,I4,0,I4,0);
6162     VARAND(I4,0,I4,0,I4,0);
6163     VARAND(I4,-1,UI4,0xffffffff,I4,-1);
6164     VARAND(I4,-1,UI4,0,I4,0);
6165     VARAND(I4,0,UI4,0,I4,0);
6166     VARAND(I4,-1,R4,-1,I4,-1);
6167     VARAND(I4,-1,R4,0,I4,0);
6168     VARAND(I4,0,R4,0,I4,0);
6169     VARAND(I4,-1,R8,-1,I4,-1);
6170     VARAND(I4,-1,R8,0,I4,0);
6171     VARAND(I4,0,R8,0,I4,0);
6172     VARAND(I4,-1,DATE,-1,I4,-1);
6173     VARAND(I4,-1,DATE,0,I4,0);
6174     VARAND(I4,0,DATE,0,I4,0);
6175     if (HAVE_OLEAUT32_I8)
6176     {
6177         VARAND(I4,-1,I8,-1,I8,-1);
6178         VARAND(I4,-1,I8,0,I8,0);
6179         VARAND(I4,0,I8,0,I8,0);
6180         VARAND(I4,-1,UI8,0,I4,0);
6181         VARAND(I4,0,UI8,0,I4,0);
6182     }
6183     VARAND(I4,-1,INT,-1,I4,-1);
6184     VARAND(I4,-1,INT,0,I4,0);
6185     VARAND(I4,0,INT,0,I4,0);
6186     VARAND(I4,-1,UINT,0xffffffff,I4,-1);
6187     VARAND(I4,-1,UINT,0,I4,0);
6188     VARAND(I4,0,UINT,0,I4,0);
6189     VARAND(I4,0,BSTR,false_str,I4,0);
6190     VARAND(I4,-1,BSTR,false_str,I4,0);
6191     VARAND(I4,0,BSTR,true_str,I4,0);
6192     VARAND(I4,-1,BSTR,true_str,I4,-1);
6193     VARANDCY(I4,-1,10000,I4,1);
6194     VARANDCY(I4,-1,0,I4,0);
6195     VARANDCY(I4,0,0,I4,0);
6196
6197     VARAND(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
6198     VARAND(UI4,0xffffffff,UI4,0,I4,0);
6199     VARAND(UI4,0,UI4,0,I4,0);
6200     VARAND(UI4,0xffffffff,R4,-1,I4,-1);
6201     VARAND(UI4,0xffffffff,R4,0,I4,0);
6202     VARAND(UI4,0,R4,0,I4,0);
6203     VARAND(UI4,0xffffffff,R8,-1,I4,-1);
6204     VARAND(UI4,0xffffffff,R8,0,I4,0);
6205     VARAND(UI4,0,R8,0,I4,0);
6206     VARAND(UI4,0xffffffff,DATE,-1,I4,-1);
6207     VARAND(UI4,0xffffffff,DATE,0,I4,0);
6208     VARAND(UI4,0,DATE,0,I4,0);
6209     if (HAVE_OLEAUT32_I8)
6210     {
6211         VARAND(UI4,0xffffffff,I8,0,I8,0);
6212         VARAND(UI4,0,I8,0,I8,0);
6213         VARAND(UI4,0xffffffff,UI8,0,I4,0);
6214         VARAND(UI4,0,UI8,0,I4,0);
6215     }
6216     VARAND(UI4,0xffffffff,INT,-1,I4,-1);
6217     VARAND(UI4,0xffffffff,INT,0,I4,0);
6218     VARAND(UI4,0,INT,0,I4,0);
6219     VARAND(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
6220     VARAND(UI4,0xffffffff,UINT,0,I4,0);
6221     VARAND(UI4,0,UINT,0,I4,0);
6222     VARAND(UI4,0,BSTR,false_str,I4,0);
6223     VARAND(UI4,0xffffffff,BSTR,false_str,I4,0);
6224     VARAND(UI4,0,BSTR,true_str,I4,0);
6225     VARAND(UI4,0xffffffff,BSTR,true_str,I4,-1);
6226     VARANDCY(UI4,0xffffffff,10000,I4,1);
6227     VARANDCY(UI4,0xffffffff,0,I4,0);
6228     VARANDCY(UI4,0,0,I4,0);
6229
6230     VARAND(R4,-1,R4,-1,I4,-1);
6231     VARAND(R4,-1,R4,0,I4,0);
6232     VARAND(R4,0,R4,0,I4,0);
6233     VARAND(R4,-1,R8,-1,I4,-1);
6234     VARAND(R4,-1,R8,0,I4,0);
6235     VARAND(R4,0,R8,0,I4,0);
6236     VARAND(R4,-1,DATE,-1,I4,-1);
6237     VARAND(R4,-1,DATE,0,I4,0);
6238     VARAND(R4,0,DATE,0,I4,0);
6239     if (HAVE_OLEAUT32_I8)
6240     {
6241         VARAND(R4,-1,I8,-1,I8,-1);
6242         VARAND(R4,-1,I8,0,I8,0);
6243         VARAND(R4,0,I8,0,I8,0);
6244         VARAND(R4,-1,UI8,0,I4,0);
6245         VARAND(R4,0,UI8,0,I4,0);
6246     }
6247     VARAND(R4,-1,INT,-1,I4,-1);
6248     VARAND(R4,-1,INT,0,I4,0);
6249     VARAND(R4,0,INT,0,I4,0);
6250     VARAND(R4,-1,UINT,0xffffffff,I4,-1);
6251     VARAND(R4,-1,UINT,0,I4,0);
6252     VARAND(R4,0,UINT,0,I4,0);
6253     VARAND(R4,0,BSTR,false_str,I4,0);
6254     VARAND(R4,-1,BSTR,false_str,I4,0);
6255     VARAND(R4,0,BSTR,true_str,I4,0);
6256     VARAND(R4,-1,BSTR,true_str,I4,-1);
6257     VARANDCY(R4,-1,10000,I4,1);
6258     VARANDCY(R4,-1,0,I4,0);
6259     VARANDCY(R4,0,0,I4,0);
6260
6261     VARAND(R8,-1,R8,-1,I4,-1);
6262     VARAND(R8,-1,R8,0,I4,0);
6263     VARAND(R8,0,R8,0,I4,0);
6264     VARAND(R8,-1,DATE,-1,I4,-1);
6265     VARAND(R8,-1,DATE,0,I4,0);
6266     VARAND(R8,0,DATE,0,I4,0);
6267     if (HAVE_OLEAUT32_I8)
6268     {
6269         VARAND(R8,-1,I8,-1,I8,-1);
6270         VARAND(R8,-1,I8,0,I8,0);
6271         VARAND(R8,0,I8,0,I8,0);
6272         VARAND(R8,-1,UI8,0,I4,0);
6273         VARAND(R8,0,UI8,0,I4,0);
6274     }
6275     VARAND(R8,-1,INT,-1,I4,-1);
6276     VARAND(R8,-1,INT,0,I4,0);
6277     VARAND(R8,0,INT,0,I4,0);
6278     VARAND(R8,-1,UINT,0xffffffff,I4,-1);
6279     VARAND(R8,-1,UINT,0,I4,0);
6280     VARAND(R8,0,UINT,0,I4,0);
6281     VARAND(R8,0,BSTR,false_str,I4,0);
6282     VARAND(R8,-1,BSTR,false_str,I4,0);
6283     VARAND(R8,0,BSTR,true_str,I4,0);
6284     VARAND(R8,-1,BSTR,true_str,I4,-1);
6285     VARANDCY(R8,-1,10000,I4,1);
6286     VARANDCY(R8,-1,0,I4,0);
6287     VARANDCY(R8,0,0,I4,0);
6288
6289     VARAND(DATE,-1,DATE,-1,I4,-1);
6290     VARAND(DATE,-1,DATE,0,I4,0);
6291     VARAND(DATE,0,DATE,0,I4,0);
6292     if (HAVE_OLEAUT32_I8)
6293     {
6294         VARAND(DATE,-1,I8,-1,I8,-1);
6295         VARAND(DATE,-1,I8,0,I8,0);
6296         VARAND(DATE,0,I8,0,I8,0);
6297         VARAND(DATE,-1,UI8,0,I4,0);
6298         VARAND(DATE,0,UI8,0,I4,0);
6299     }
6300     VARAND(DATE,-1,INT,-1,I4,-1);
6301     VARAND(DATE,-1,INT,0,I4,0);
6302     VARAND(DATE,0,INT,0,I4,0);
6303     VARAND(DATE,-1,UINT,0xffffffff,I4,-1);
6304     VARAND(DATE,-1,UINT,0,I4,0);
6305     VARAND(DATE,0,UINT,0,I4,0);
6306     VARAND(DATE,0,BSTR,false_str,I4,0);
6307     VARAND(DATE,-1,BSTR,false_str,I4,0);
6308     VARAND(DATE,0,BSTR,true_str,I4,0);
6309     VARAND(DATE,-1,BSTR,true_str,I4,-1);
6310     VARANDCY(DATE,-1,10000,I4,1);
6311     VARANDCY(DATE,-1,0,I4,0);
6312     VARANDCY(DATE,0,0,I4,0);
6313
6314     if (HAVE_OLEAUT32_I8)
6315     {
6316         VARAND(I8,-1,I8,-1,I8,-1);
6317         VARAND(I8,-1,I8,0,I8,0);
6318         VARAND(I8,0,I8,0,I8,0);
6319         VARAND(I8,-1,UI8,0,I8,0);
6320         VARAND(I8,0,UI8,0,I8,0);
6321         VARAND(I8,-1,UINT,0,I8,0);
6322         VARAND(I8,0,UINT,0,I8,0);
6323         VARAND(I8,0,BSTR,false_str,I8,0);
6324         VARAND(I8,-1,BSTR,false_str,I8,0);
6325         VARAND(I8,0,BSTR,true_str,I8,0);
6326         VARAND(I8,-1,BSTR,true_str,I8,-1);
6327         VARANDCY(I8,-1,10000,I8,1);
6328         VARANDCY(I8,-1,0,I8,0);
6329         VARANDCY(I8,0,0,I8,0);
6330
6331         VARAND(UI8,0xffff,UI8,0xffff,I4,0xffff);
6332         VARAND(UI8,0xffff,UI8,0,I4,0);
6333         VARAND(UI8,0,UI8,0,I4,0);
6334         VARAND(UI8,0xffff,INT,-1,I4,65535);
6335         VARAND(UI8,0xffff,INT,0,I4,0);
6336         VARAND(UI8,0,INT,0,I4,0);
6337         VARAND(UI8,0xffff,UINT,0xffff,I4,0xffff);
6338         VARAND(UI8,0xffff,UINT,0,I4,0);
6339         VARAND(UI8,0,UINT,0,I4,0);
6340         VARAND(UI8,0,BSTR,false_str,I4,0);
6341         VARAND(UI8,0xffff,BSTR,false_str,I4,0);
6342         VARAND(UI8,0,BSTR,true_str,I4,0);
6343         VARAND(UI8,0xffff,BSTR,true_str,I4,65535);
6344         VARANDCY(UI8,0xffff,10000,I4,1);
6345         VARANDCY(UI8,0xffff,0,I4,0);
6346         VARANDCY(UI8,0,0,I4,0);
6347     }
6348
6349     VARAND(INT,-1,INT,-1,I4,-1);
6350     VARAND(INT,-1,INT,0,I4,0);
6351     VARAND(INT,0,INT,0,I4,0);
6352     VARAND(INT,-1,UINT,0xffff,I4,65535);
6353     VARAND(INT,-1,UINT,0,I4,0);
6354     VARAND(INT,0,UINT,0,I4,0);
6355     VARAND(INT,0,BSTR,false_str,I4,0);
6356     VARAND(INT,-1,BSTR,false_str,I4,0);
6357     VARAND(INT,0,BSTR,true_str,I4,0);
6358     VARAND(INT,-1,BSTR,true_str,I4,-1);
6359     VARANDCY(INT,-1,10000,I4,1);
6360     VARANDCY(INT,-1,0,I4,0);
6361     VARANDCY(INT,0,0,I4,0);
6362
6363     VARAND(UINT,0xffff,UINT,0xffff,I4,0xffff);
6364     VARAND(UINT,0xffff,UINT,0,I4,0);
6365     VARAND(UINT,0,UINT,0,I4,0);
6366     VARAND(UINT,0,BSTR,false_str,I4,0);
6367     VARAND(UINT,0xffff,BSTR, false_str,I4,0);
6368     VARAND(UINT,0,BSTR,true_str,I4,0);
6369     VARAND(UINT,0xffff,BSTR,true_str,I4,65535);
6370     VARANDCY(UINT,0xffff,10000,I4,1);
6371     VARANDCY(UINT,0xffff,0,I4,0);
6372     VARANDCY(UINT,0,0,I4,0);
6373
6374     VARAND(BSTR,false_str,BSTR,false_str,BOOL,0);
6375     VARAND(BSTR,true_str,BSTR,false_str,BOOL,VARIANT_FALSE);
6376     VARAND(BSTR,true_str,BSTR,true_str,BOOL,VARIANT_TRUE);
6377     VARANDCY(BSTR,true_str,10000,I4,1);
6378     VARANDCY(BSTR,false_str,10000,I4,0);
6379
6380     SysFreeString(true_str);
6381     SysFreeString(false_str);
6382 }
6383
6384 static void test_cmp( int line, LCID lcid, UINT flags, VARIANT *left, VARIANT *right, HRESULT result )
6385 {
6386     HRESULT hres;
6387
6388     CHECKPTR(VarCmp);
6389
6390     hres = pVarCmp(left,right,lcid,flags);
6391     ok_(__FILE__,line)(hres == result, "VarCmp(%s,%s): expected 0x%x, got hres=0x%x\n",
6392                        variantstr(left), variantstr(right), result, hres );
6393 }
6394 static void test_cmpex( int line, LCID lcid, VARIANT *left, VARIANT *right,
6395                         HRESULT res1, HRESULT res2, HRESULT res3, HRESULT res4 )
6396 {
6397     test_cmp( line, lcid, 0, left, right, res1 );
6398     V_VT(left) |= VT_RESERVED;
6399     test_cmp( line, lcid, 0, left, right, res2 );
6400     V_VT(left) &= ~VT_RESERVED;
6401     V_VT(right) |= VT_RESERVED;
6402     test_cmp( line, lcid, 0, left, right, res3 );
6403     V_VT(left) |= VT_RESERVED;
6404     test_cmp( line, lcid, 0, left, right, res4 );
6405     ok_(__FILE__,line)(V_VT(left) & V_VT(right) & VT_RESERVED, "VT_RESERVED filtered out\n");
6406 }
6407
6408 /* ERROR from wingdi.h is interfering here */
6409 #undef ERROR
6410 #define _VARCMP(vt1,val1,vtfl1,vt2,val2,vtfl2,lcid,flags,result) \
6411         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1 | vtfl1; \
6412         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2 | vtfl2; \
6413         test_cmp( __LINE__, lcid, flags, &left, &right, result )
6414 #define VARCMPEX(vt1,val1,vt2,val2,res1,res2,res3,res4) \
6415         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1; \
6416         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2; \
6417         test_cmpex( __LINE__, lcid, &left, &right, res1, res2, res3, res4 )
6418 #define VARCMP(vt1,val1,vt2,val2,result) \
6419         VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)
6420 /* The above macros do not work for VT_NULL as NULL gets expanded first */
6421 #define V_NULL_  V_NULL
6422 #define VT_NULL_ VT_NULL
6423
6424 static void test_VarCmp(void)
6425 {
6426     VARIANT left, right;
6427     VARTYPE i;
6428     LCID lcid;
6429     HRESULT hres;
6430     DECIMAL dec;
6431     static const WCHAR szhuh[] = {'h','u','h','?','\0'};
6432     static const WCHAR sz2cents[] = {'2','c','e','n','t','s','\0'};
6433     static const WCHAR szempty[] = {'\0'};
6434     static const WCHAR sz0[] = {'0','\0'};
6435     static const WCHAR sz1[] = {'1','\0'};
6436     static const WCHAR sz7[] = {'7','\0'};
6437     static const WCHAR sz42[] = {'4','2','\0'};
6438     static const WCHAR sz1neg[] = {'-','1','\0'};
6439     static const WCHAR sz666neg[] = {'-','6','6','6','\0'};
6440     static const WCHAR sz1few[] = {'1','.','0','0','0','0','0','0','0','1','\0'};
6441     BSTR bstrhuh, bstrempty, bstr0, bstr1, bstr7, bstr42, bstr1neg, bstr666neg;
6442     BSTR bstr2cents, bstr1few;
6443
6444     CHECKPTR(VarCmp);
6445
6446     lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
6447     bstrempty = SysAllocString(szempty);
6448     bstrhuh = SysAllocString(szhuh);
6449     bstr2cents = SysAllocString(sz2cents);
6450     bstr0 = SysAllocString(sz0);
6451     bstr1 = SysAllocString(sz1);
6452     bstr7 = SysAllocString(sz7);
6453     bstr42 = SysAllocString(sz42);
6454     bstr1neg = SysAllocString(sz1neg);
6455     bstr666neg = SysAllocString(sz666neg);
6456     bstr1few = SysAllocString(sz1few);
6457
6458     /* Test all possible flag/vt combinations & the resulting vt type */
6459     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6460     {
6461         VARTYPE leftvt, rightvt;
6462
6463         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6464         {
6465
6466             SKIPTESTS(leftvt);
6467
6468             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6469             {
6470                 BOOL bFail = FALSE;
6471                 HRESULT expect = VARCMP_EQ;
6472
6473                 SKIPTESTS(rightvt);
6474
6475                 memset(&left, 0, sizeof(left));
6476                 memset(&right, 0, sizeof(right));
6477                 V_VT(&left) = leftvt | ExtraFlags[i];
6478                 if (leftvt == VT_BSTR) {
6479                     V_BSTR(&left) = bstr1neg;
6480                     if (ExtraFlags[i] & VT_RESERVED)
6481                         expect = VARCMP_LT;
6482                     else
6483                         expect = VARCMP_GT;
6484                 }
6485                 V_VT(&right) = rightvt | ExtraFlags[i];
6486                 if (rightvt == VT_BSTR) {
6487                     V_BSTR(&right) = bstr1neg;
6488                     if (ExtraFlags[i] & VT_RESERVED)
6489                         expect = VARCMP_GT;
6490                     else
6491                         expect = VARCMP_LT;
6492                 }
6493
6494                 /* Don't ask me why but native VarCmp cannot handle:
6495                    VT_I1, VT_UI2, VT_UI4, VT_UINT and VT_UI8.
6496                    VT_INT is only supported as left variant. Go figure.
6497                    Tested with DCOM98, Win2k, WinXP */
6498                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
6499                     !IsValidVariantClearVT(leftvt, ExtraFlags[i] & ~VT_RESERVED) ||
6500                     !IsValidVariantClearVT(rightvt, ExtraFlags[i] & ~VT_RESERVED) ||
6501                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
6502                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
6503                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
6504                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
6505                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
6506                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
6507                     leftvt == VT_I1 || rightvt == VT_I1 ||
6508                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
6509                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
6510                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
6511                     rightvt == VT_INT ||
6512                     leftvt == VT_UINT || rightvt == VT_UINT) {
6513                     bFail = TRUE;
6514                 }
6515
6516                 if (leftvt == VT_ERROR && rightvt == VT_ERROR &&
6517                     !(ExtraFlags[i] & ~VT_RESERVED)) {
6518                     expect = VARCMP_EQ;
6519                     bFail = FALSE;
6520                 } else if (leftvt == VT_NULL || rightvt == VT_NULL)
6521                     expect = VARCMP_NULL;
6522                 else if (leftvt == VT_BSTR && rightvt == VT_BSTR)
6523                     expect = VARCMP_EQ;
6524                 else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
6525                     expect = VARCMP_GT;
6526                 else if (leftvt == VT_EMPTY && rightvt == VT_BSTR)
6527                     expect = VARCMP_LT;
6528
6529                 hres = pVarCmp(&left, &right, LOCALE_USER_DEFAULT, 0);
6530                 if (bFail) {
6531                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
6532                        "VarCmp: %d|0x%X, %d|0x%X: Expected failure, got 0x%X\n",
6533                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres);
6534                 } else {
6535                     ok(hres == expect,
6536                        "VarCmp: %d|0x%X, %d|0x%X: Expected 0x%X, got 0x%X\n",
6537                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], expect,
6538                        hres);
6539                 }
6540             }
6541         }
6542     }
6543
6544     /* VARCMP{,EX} run each 4 tests with a permutation of all possible
6545        input variants with (1) and without (0) VT_RESERVED set. The order
6546        of the permutations is (0,0); (1,0); (0,1); (1,1) */
6547     VARCMP(INT,4711,I2,4711,VARCMP_EQ);
6548     VARCMP(INT,4711,I2,-4711,VARCMP_GT);
6549     VARCMP(ERROR,0,ERROR,0,VARCMP_EQ);
6550     VARCMP(ERROR,0,UI1,0,DISP_E_TYPEMISMATCH);
6551     VARCMP(EMPTY,0,EMPTY,0,VARCMP_EQ);
6552     VARCMP(I4,1,R8,1.0,VARCMP_EQ);
6553     VARCMP(EMPTY,19,I2,0,VARCMP_EQ);
6554     ok(V_EMPTY(&left) == 19, "VT_EMPTY modified!\n");
6555     VARCMP(I4,1,UI1,1,VARCMP_EQ);
6556     VARCMP(I2,2,I2,2,VARCMP_EQ);
6557     VARCMP(I2,1,I2,2,VARCMP_LT);
6558     VARCMP(I2,2,I2,1,VARCMP_GT);
6559     VARCMP(I2,2,EMPTY,1,VARCMP_GT);
6560     VARCMP(I2,2,NULL_,1,VARCMP_NULL);
6561
6562     /* BSTR handling, especially in conjunction with VT_RESERVED */
6563     VARCMP(BSTR,bstr0,NULL_,0,VARCMP_NULL);
6564     VARCMP(BSTR,bstr0,BSTR,bstr0,VARCMP_EQ);
6565     VARCMP(BSTR,bstrempty,BSTR,bstr0,VARCMP_LT);
6566     VARCMP(BSTR,bstr7,BSTR,bstr0,VARCMP_GT);
6567     VARCMP(BSTR,bstr7,BSTR,bstr1neg,VARCMP_GT);
6568     VARCMP(BSTR,bstr0,BSTR,NULL,VARCMP_GT);
6569     VARCMP(BSTR,NULL,BSTR,NULL,VARCMP_EQ);
6570     VARCMP(BSTR,bstrempty,BSTR,NULL,VARCMP_EQ);
6571     VARCMP(BSTR,NULL,EMPTY,0,VARCMP_EQ);
6572     VARCMP(EMPTY,0,BSTR,NULL,VARCMP_EQ);
6573     VARCMP(EMPTY,0,BSTR,bstrempty,VARCMP_EQ);
6574     VARCMP(EMPTY,1,BSTR,bstrempty,VARCMP_EQ);
6575     VARCMP(BSTR,bstr0,EMPTY,0,VARCMP_GT);
6576     VARCMP(BSTR,bstr42,EMPTY,0,VARCMP_GT);
6577     VARCMPEX(BSTR,bstrempty,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6578     VARCMPEX(BSTR,bstrempty,I2,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6579     VARCMPEX(I4,0,BSTR,bstrempty,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6580     VARCMPEX(BSTR,NULL,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6581     VARCMPEX(I4,7,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6582     _VARCMP(BSTR,(BSTR)100,0,I2,100,0,lcid,0,VARCMP_GT);
6583     VARCMPEX(BSTR,bstr0,UI1,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6584     VARCMPEX(I2,0,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6585     VARCMP(BSTR,bstrhuh,I4,I4_MAX,VARCMP_GT);
6586     VARCMP(BSTR,bstr2cents,I4,2,VARCMP_GT);
6587     VARCMPEX(BSTR,bstr2cents,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6588     VARCMP(BSTR,bstr2cents,I4,-1,VARCMP_GT);
6589     VARCMPEX(BSTR,bstr2cents,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6590     VARCMPEX(BSTR,bstr0,I2,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6591     VARCMPEX(BSTR,bstr0,I4,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6592     VARCMPEX(BSTR,bstr0,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6593     VARCMP(BSTR,bstr1,I4,0,VARCMP_GT);
6594     VARCMPEX(BSTR,bstr1,I4,1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6595     VARCMPEX(BSTR,bstr1,I4,I4_MAX,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_GT);
6596     VARCMPEX(BSTR,bstr1,I4,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6597     VARCMP(BSTR,bstr7,I4,1,VARCMP_GT);
6598     VARCMPEX(BSTR,bstr7,I4,7,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6599     VARCMPEX(BSTR,bstr7,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6600     VARCMPEX(BSTR,bstr42,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6601     VARCMPEX(BSTR,bstr42,I4,42,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6602     VARCMPEX(BSTR,bstr42,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6603     VARCMPEX(BSTR,bstr1neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6604     VARCMPEX(BSTR,bstr1neg,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6605     VARCMPEX(BSTR,bstr1neg,I4,-1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6606     VARCMPEX(BSTR,bstr1neg,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6607     VARCMPEX(BSTR,bstr666neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6608     VARCMPEX(BSTR,bstr666neg,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6609     VARCMPEX(BSTR,bstr666neg,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6610     VARCMPEX(BSTR,bstr666neg,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6611     VARCMPEX(BSTR,bstr666neg,I4,-1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6612     VARCMPEX(BSTR,bstr666neg,I4,-666,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6613     VARCMPEX(BSTR,bstr7,R8,7.0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6614     VARCMPEX(R8,3.141592,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6615     VARCMP(BSTR,bstr7,BSTR,bstr7,VARCMP_EQ);
6616     VARCMP(BSTR,bstr7,BSTR,bstr42,VARCMP_GT);
6617     VARCMP(BSTR,bstr42,BSTR,bstr7,VARCMP_LT);
6618
6619     /* DECIMAL handling */
6620     setdec(&dec,0,0,0,0);
6621     VARCMPEX(DECIMAL,dec,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6622     setdec64(&dec,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); /* max DECIMAL */
6623     VARCMP(DECIMAL,dec,R8,R8_MAX,VARCMP_LT);    /* R8 has bigger range */
6624     VARCMP(DECIMAL,dec,DATE,R8_MAX,VARCMP_LT);  /* DATE has bigger range */
6625     setdec64(&dec,0,0x80,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
6626     VARCMP(DECIMAL,dec,R8,-R8_MAX,VARCMP_GT);
6627     setdec64(&dec,20,0,0x5,0x6BC75E2D,0x63100001);    /* 1+1e-20 */
6628     VARCMP(DECIMAL,dec,R8,1,VARCMP_GT); /* DECIMAL has higher precision */
6629
6630     /* Show that DATE is handled just as a R8 */
6631     VARCMP(DATE,DATE_MAX,DATE,DATE_MAX+1,VARCMP_LT);
6632     VARCMP(DATE,DATE_MIN,DATE,DATE_MIN-1,VARCMP_GT);
6633     VARCMP(DATE,R8_MIN,R8,R8_MIN,VARCMP_EQ);
6634     VARCMP(DATE,1,DATE,1+1e-15,VARCMP_LT);      /* 1e-15 == 8.64e-11 seconds */
6635     VARCMP(DATE,25570.0,DATE,25570.0,VARCMP_EQ);
6636     VARCMP(DATE,25570.0,DATE,25571.0,VARCMP_LT);
6637     VARCMP(DATE,25571.0,DATE,25570.0,VARCMP_GT);
6638     VARCMP(DATE,25570.0,EMPTY,0,VARCMP_GT);
6639     VARCMP(DATE,25570.0,NULL_,0,VARCMP_NULL);
6640
6641     /* R4 precision handling */
6642     VARCMP(R4,1,R8,1+1e-8,VARCMP_EQ);
6643     VARCMP(R8,1+1e-8,R4,1,VARCMP_EQ);
6644     VARCMP(R8,1+1e-8,R8,1,VARCMP_GT);
6645     VARCMP(R8,R4_MAX*1.1,R4,R4_MAX,VARCMP_GT);
6646     VARCMP(R4,R4_MAX,R8,R8_MAX,VARCMP_LT);
6647     VARCMP(R4,1,DATE,1+1e-8,VARCMP_EQ);
6648     VARCMP(R4,1,BSTR,bstr1few,VARCMP_LT); /* bstr1few == 1+1e-8 */
6649     setdec(&dec,8,0,0,0x5F5E101);         /* 1+1e-8 */
6650     VARCMP(R4,1,DECIMAL,dec,VARCMP_LT);
6651
6652     SysFreeString(bstrhuh);
6653     SysFreeString(bstrempty);
6654     SysFreeString(bstr0);
6655     SysFreeString(bstr1);
6656     SysFreeString(bstr7);
6657     SysFreeString(bstr42);
6658     SysFreeString(bstr1neg);
6659     SysFreeString(bstr666neg);
6660     SysFreeString(bstr2cents);
6661     SysFreeString(bstr1few);
6662 }
6663
6664 static HRESULT (WINAPI *pVarPow)(LPVARIANT,LPVARIANT,LPVARIANT);
6665
6666 #define VARPOW(vt1,val1,vt2,val2,rvt,rval)               \
6667         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
6668         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
6669         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
6670         test_var_call2( __LINE__, pVarPow, &left, &right, &exp )
6671
6672 /* Skip any type that is not defined or produces an error for every case */
6673 #define SKIPTESTPOW(a)                            \
6674     if (a == VT_ERROR || a == VT_VARIANT ||       \
6675         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
6676         a == VT_RECORD || a > VT_UINT ||          \
6677         a == 15 /*not defined*/)                  \
6678         continue
6679
6680 static void test_VarPow(void)
6681 {
6682     static const WCHAR str2[] = { '2','\0' };
6683     static const WCHAR str3[] = { '3','\0' };
6684     VARIANT left, right, exp, result, cy, dec;
6685     BSTR num2_str, num3_str;
6686     VARTYPE i;
6687     HRESULT hres;
6688
6689     CHECKPTR(VarPow);
6690
6691     num2_str = SysAllocString(str2);
6692     num3_str = SysAllocString(str3);
6693
6694     /* Test all possible flag/vt combinations & the resulting vt type */
6695     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6696     {
6697         VARTYPE leftvt, rightvt, resvt;
6698
6699         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6700         {
6701             SKIPTESTPOW(leftvt);
6702
6703             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6704             {
6705                 BOOL bFail = FALSE;
6706                 SKIPTESTPOW(rightvt);
6707
6708                 /* Native crashes with VT_BYREF */
6709                 if (ExtraFlags[i] == VT_BYREF)
6710                     continue;
6711
6712                 memset(&left, 0, sizeof(left));
6713                 memset(&right, 0, sizeof(right));
6714                 V_VT(&left) = leftvt | ExtraFlags[i];
6715                 V_VT(&right) = rightvt | ExtraFlags[i];
6716                 V_VT(&result) = VT_EMPTY;
6717                 resvt = VT_EMPTY;
6718
6719                 if (leftvt == VT_BSTR)
6720                     V_BSTR(&left) = num2_str;
6721                 if (rightvt == VT_BSTR)
6722                     V_BSTR(&right) = num2_str;
6723
6724                 /* Native VarPow always returns an error when using extra flags */
6725                 if (ExtraFlags[i] != 0)
6726                     bFail = TRUE;
6727
6728                 /* Determine return type */
6729                 else if ((leftvt == VT_NULL || rightvt == VT_NULL) &&
6730                          ((leftvt != VT_I8 && leftvt != VT_UI8 &&
6731                            rightvt != VT_I8 && rightvt != VT_UI8) || HAVE_OLEAUT32_I8))
6732                     resvt = VT_NULL;
6733                 else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
6734                     leftvt == VT_I4 || leftvt == VT_R4 ||
6735                     leftvt == VT_R8 || leftvt == VT_CY ||
6736                     leftvt == VT_DATE || leftvt == VT_BSTR ||
6737                     leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
6738                     (leftvt >= VT_I1 && leftvt <= VT_UI4) ||
6739                     (HAVE_OLEAUT32_I8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
6740                     leftvt == VT_INT || leftvt == VT_UINT) &&
6741                     (rightvt == VT_EMPTY || rightvt == VT_I2 ||
6742                     rightvt == VT_I4 || rightvt == VT_R4 ||
6743                     rightvt == VT_R8 || rightvt == VT_CY ||
6744                     rightvt == VT_DATE || rightvt == VT_BSTR ||
6745                     rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
6746                     (rightvt >= VT_I1 && rightvt <= VT_UI4) ||
6747                     (HAVE_OLEAUT32_I8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
6748                     rightvt == VT_INT || rightvt == VT_UINT))
6749                     resvt = VT_R8;
6750                 else
6751                     bFail = TRUE;
6752
6753                 hres = pVarPow(&left, &right, &result);
6754
6755                 /* Check expected HRESULT and if result variant type is correct */
6756                 if (bFail)
6757                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
6758                         "VarPow: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
6759                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
6760                         vtstr(V_VT(&result)), hres);
6761                 else
6762                     ok (hres == S_OK && resvt == V_VT(&result),
6763                         "VarPow: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
6764                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
6765                         S_OK, vtstr(V_VT(&result)), hres);
6766             }
6767         }
6768     }
6769
6770     /* Check return values for valid variant type combinations */
6771     VARPOW(EMPTY,0,EMPTY,0,R8,1.0);
6772     VARPOW(EMPTY,0,NULL,0,NULL,0);
6773     VARPOW(EMPTY,0,I2,3,R8,0.0);
6774     VARPOW(EMPTY,0,I4,3,R8,0.0);
6775     VARPOW(EMPTY,0,R4,3.0f,R8,0.0);
6776     VARPOW(EMPTY,0,R8,3.0,R8,0.0);
6777     VARPOW(EMPTY,0,DATE,3,R8,0.0);
6778     VARPOW(EMPTY,0,BSTR,num3_str,R8,0.0);
6779     VARPOW(EMPTY,0,BOOL,VARIANT_FALSE,R8,1.0);
6780     VARPOW(EMPTY,0,I1,3,R8,0.0);
6781     VARPOW(EMPTY,0,UI1,3,R8,0.0);
6782     VARPOW(EMPTY,0,UI2,3,R8,0.0);
6783     VARPOW(EMPTY,0,UI4,3,R8,0.0);
6784     if (HAVE_OLEAUT32_I8)
6785     {
6786         VARPOW(EMPTY,0,I8,3,R8,0.0);
6787         VARPOW(EMPTY,0,UI8,3,R8,0.0);
6788     }
6789     VARPOW(EMPTY,0,INT,3,R8,0.0);
6790     VARPOW(EMPTY,0,UINT,3,R8,0.0);
6791     VARPOW(NULL,0,EMPTY,0,NULL,0);
6792     VARPOW(NULL,0,NULL,0,NULL,0);
6793     VARPOW(NULL,0,I2,3,NULL,0);
6794     VARPOW(NULL,0,I4,3,NULL,0);
6795     VARPOW(NULL,0,R4,3.0f,NULL,0);
6796     VARPOW(NULL,0,R8,3.0,NULL,0);
6797     VARPOW(NULL,0,DATE,3,NULL,0);
6798     VARPOW(NULL,0,BSTR,num3_str,NULL,0);
6799     VARPOW(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
6800     VARPOW(NULL,0,I1,3,NULL,0);
6801     VARPOW(NULL,0,UI1,3,NULL,0);
6802     VARPOW(NULL,0,UI2,3,NULL,0);
6803     VARPOW(NULL,0,UI4,3,NULL,0);
6804     if (HAVE_OLEAUT32_I8)
6805     {
6806         VARPOW(NULL,0,I8,3,NULL,0);
6807         VARPOW(NULL,0,UI8,3,NULL,0);
6808     }
6809     VARPOW(NULL,0,INT,3,NULL,0);
6810     VARPOW(NULL,0,UINT,3,NULL,0);
6811     VARPOW(I2,2,EMPTY,0,R8,1.0);
6812     VARPOW(I2,2,NULL,0,NULL,0);
6813     VARPOW(I2,2,I2,3,R8,8.0);
6814     VARPOW(I2,2,I4,3,R8,8.0);
6815     VARPOW(I2,2,R4,3.0f,R8,8.0);
6816     VARPOW(I2,2,R8,3.0,R8,8.0);
6817     VARPOW(I2,2,DATE,3,R8,8.0);
6818     VARPOW(I2,2,BSTR,num3_str,R8,8.0);
6819     VARPOW(I2,2,BOOL,VARIANT_FALSE,R8,1.0);
6820     VARPOW(I2,2,I1,3,R8,8.0);
6821     VARPOW(I2,2,UI1,3,R8,8.0);
6822     VARPOW(I2,2,UI2,3,R8,8.0);
6823     VARPOW(I2,2,UI4,3,R8,8.0);
6824     if (HAVE_OLEAUT32_I8)
6825     {
6826         VARPOW(I2,2,I8,3,R8,8.0);
6827         VARPOW(I2,2,UI8,3,R8,8.0);
6828     }
6829     VARPOW(I2,2,INT,3,R8,8.0);
6830     VARPOW(I2,2,UINT,3,R8,8.0);
6831     VARPOW(I4,2,EMPTY,0,R8,1.0);
6832     VARPOW(I4,2,NULL,0,NULL,0);
6833     VARPOW(I4,2,I2,3,R8,8.0);
6834     VARPOW(I4,2,I4,3,R8,8.0);
6835     VARPOW(I4,2,R4,3.0f,R8,8.0);
6836     VARPOW(I4,2,R8,3.0,R8,8.0);
6837     VARPOW(I4,2,DATE,3,R8,8.0);
6838     VARPOW(I4,2,BSTR,num3_str,R8,8.0);
6839     VARPOW(I4,2,BOOL,VARIANT_FALSE,R8,1.0);
6840     VARPOW(I4,2,I1,3,R8,8.0);
6841     VARPOW(I4,2,UI1,3,R8,8.0);
6842     VARPOW(I4,2,UI2,3,R8,8.0);
6843     VARPOW(I4,2,UI4,3,R8,8.0);
6844     if (HAVE_OLEAUT32_I8)
6845     {
6846         VARPOW(I4,2,I8,3,R8,8.0);
6847         VARPOW(I4,2,UI8,3,R8,8.0);
6848     }
6849     VARPOW(I4,2,INT,3,R8,8.0);
6850     VARPOW(I4,2,UINT,3,R8,8.0);
6851     VARPOW(R4,2,EMPTY,0,R8,1.0);
6852     VARPOW(R4,2,NULL,0,NULL,0);
6853     VARPOW(R4,2,I2,3,R8,8.0);
6854     VARPOW(R4,2,I4,3,R8,8.0);
6855     VARPOW(R4,2,R4,3.0f,R8,8.0);
6856     VARPOW(R4,2,R8,3.0,R8,8.0);
6857     VARPOW(R4,2,DATE,3,R8,8.0);
6858     VARPOW(R4,2,BSTR,num3_str,R8,8.0);
6859     VARPOW(R4,2,BOOL,VARIANT_FALSE,R8,1.0);
6860     VARPOW(R4,2,I1,3,R8,8.0);
6861     VARPOW(R4,2,UI1,3,R8,8.0);
6862     VARPOW(R4,2,UI2,3,R8,8.0);
6863     VARPOW(R4,2,UI4,3,R8,8.0);
6864     if (HAVE_OLEAUT32_I8)
6865     {
6866         VARPOW(R4,2,I8,3,R8,8.0);
6867         VARPOW(R4,2,UI8,3,R8,8.0);
6868     }
6869     VARPOW(R4,2,INT,3,R8,8.0);
6870     VARPOW(R4,2,UINT,3,R8,8.0);
6871     VARPOW(R8,2,EMPTY,0,R8,1.0);
6872     VARPOW(R8,2,NULL,0,NULL,0);
6873     VARPOW(R8,2,I2,3,R8,8.0);
6874     VARPOW(R8,2,I4,3,R8,8.0);
6875     VARPOW(R8,2,R4,3.0f,R8,8.0);
6876     VARPOW(R8,2,R8,3.0,R8,8.0);
6877     VARPOW(R8,2,DATE,3,R8,8.0);
6878     VARPOW(R8,2,BSTR,num3_str,R8,8.0);
6879     VARPOW(R8,2,BOOL,VARIANT_FALSE,R8,1.0);
6880     VARPOW(R8,2,I1,3,R8,8.0);
6881     VARPOW(R8,2,UI1,3,R8,8.0);
6882     VARPOW(R8,2,UI2,3,R8,8.0);
6883     VARPOW(R8,2,UI4,3,R8,8.0);
6884     if (HAVE_OLEAUT32_I8)
6885     {
6886         VARPOW(R8,2,I8,3,R8,8.0);
6887         VARPOW(R8,2,UI8,3,R8,8.0);
6888     }
6889     VARPOW(R8,2,INT,3,R8,8.0);
6890     VARPOW(R8,2,UINT,3,R8,8.0);
6891     VARPOW(DATE,2,EMPTY,0,R8,1.0);
6892     VARPOW(DATE,2,NULL,0,NULL,0);
6893     VARPOW(DATE,2,I2,3,R8,8.0);
6894     VARPOW(DATE,2,I4,3,R8,8.0);
6895     VARPOW(DATE,2,R4,3.0f,R8,8.0);
6896     VARPOW(DATE,2,R8,3.0,R8,8.0);
6897     VARPOW(DATE,2,DATE,3,R8,8.0);
6898     VARPOW(DATE,2,BSTR,num3_str,R8,8.0);
6899     VARPOW(DATE,2,BOOL,VARIANT_FALSE,R8,1.0);
6900     VARPOW(DATE,2,I1,3,R8,8.0);
6901     VARPOW(DATE,2,UI1,3,R8,8.0);
6902     VARPOW(DATE,2,UI2,3,R8,8.0);
6903     VARPOW(DATE,2,UI4,3,R8,8.0);
6904     if (HAVE_OLEAUT32_I8)
6905     {
6906         VARPOW(DATE,2,I8,3,R8,8.0);
6907         VARPOW(DATE,2,UI8,3,R8,8.0);
6908     }
6909     VARPOW(DATE,2,INT,3,R8,8.0);
6910     VARPOW(DATE,2,UINT,3,R8,8.0);
6911     VARPOW(BSTR,num2_str,EMPTY,0,R8,1.0);
6912     VARPOW(BSTR,num2_str,NULL,0,NULL,0);
6913     VARPOW(BSTR,num2_str,I2,3,R8,8.0);
6914     VARPOW(BSTR,num2_str,I4,3,R8,8.0);
6915     VARPOW(BSTR,num2_str,R4,3.0f,R8,8.0);
6916     VARPOW(BSTR,num2_str,R8,3.0,R8,8.0);
6917     VARPOW(BSTR,num2_str,DATE,3,R8,8.0);
6918     VARPOW(BSTR,num2_str,BSTR,num3_str,R8,8.0);
6919     VARPOW(BSTR,num2_str,BOOL,VARIANT_FALSE,R8,1.0);
6920     VARPOW(BSTR,num2_str,I1,3,R8,8.0);
6921     VARPOW(BSTR,num2_str,UI1,3,R8,8.0);
6922     VARPOW(BSTR,num2_str,UI2,3,R8,8.0);
6923     VARPOW(BSTR,num2_str,UI4,3,R8,8.0);
6924     if (HAVE_OLEAUT32_I8)
6925     {
6926         VARPOW(BSTR,num2_str,I8,3,R8,8.0);
6927         VARPOW(BSTR,num2_str,UI8,3,R8,8.0);
6928     }
6929     VARPOW(BSTR,num2_str,INT,3,R8,8.0);
6930     VARPOW(BSTR,num2_str,UINT,3,R8,8.0);
6931     VARPOW(BOOL,VARIANT_TRUE,EMPTY,0,R8,1.0);
6932     VARPOW(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
6933     VARPOW(BOOL,VARIANT_TRUE,I2,3,R8,-1.0);
6934     VARPOW(BOOL,VARIANT_TRUE,I4,3,R8,-1.0);
6935     VARPOW(BOOL,VARIANT_TRUE,R4,3.0f,R8,-1.0);
6936     VARPOW(BOOL,VARIANT_TRUE,R8,3.0,R8,-1.0);
6937     VARPOW(BOOL,VARIANT_TRUE,DATE,3,R8,-1.0);
6938     VARPOW(BOOL,VARIANT_TRUE,BSTR,num3_str,R8,-1.0);
6939     VARPOW(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,-1.0);
6940     VARPOW(BOOL,VARIANT_TRUE,I1,3,R8,-1.0);
6941     VARPOW(BOOL,VARIANT_TRUE,UI1,3,R8,-1.0);
6942     VARPOW(BOOL,VARIANT_TRUE,UI2,3,R8,-1.0);
6943     VARPOW(BOOL,VARIANT_TRUE,UI4,3,R8,-1.0);
6944     if (HAVE_OLEAUT32_I8)
6945     {
6946         VARPOW(BOOL,VARIANT_TRUE,I8,3,R8,-1.0);
6947         VARPOW(BOOL,VARIANT_TRUE,UI8,3,R8,-1.0);
6948     }
6949     VARPOW(BOOL,VARIANT_TRUE,INT,3,R8,-1.0);
6950     VARPOW(BOOL,VARIANT_TRUE,UINT,3,R8,-1.0);
6951     VARPOW(I1,2,EMPTY,0,R8,1.0);
6952     VARPOW(I1,2,NULL,0,NULL,0);
6953     VARPOW(I1,2,I2,3,R8,8.0);
6954     VARPOW(I1,2,I4,3,R8,8.0);
6955     VARPOW(I1,2,R4,3.0f,R8,8.0);
6956     VARPOW(I1,2,R8,3.0,R8,8.0);
6957     VARPOW(I1,2,DATE,3,R8,8.0);
6958     VARPOW(I1,2,BSTR,num3_str,R8,8.0);
6959     VARPOW(I1,2,BOOL,VARIANT_FALSE,R8,1.0);
6960     VARPOW(I1,2,I1,3,R8,8.0);
6961     VARPOW(I1,2,UI1,3,R8,8.0);
6962     VARPOW(I1,2,UI2,3,R8,8.0);
6963     VARPOW(I1,2,UI4,3,R8,8.0);
6964     if (HAVE_OLEAUT32_I8)
6965     {
6966         VARPOW(I1,2,I8,3,R8,8.0);
6967         VARPOW(I1,2,UI8,3,R8,8.0);
6968     }
6969     VARPOW(I1,2,INT,3,R8,8.0);
6970     VARPOW(I1,2,UINT,3,R8,8.0);
6971     VARPOW(UI1,2,EMPTY,0,R8,1.0);
6972     VARPOW(UI1,2,NULL,0,NULL,0);
6973     VARPOW(UI1,2,I2,3,R8,8.0);
6974     VARPOW(UI1,2,I4,3,R8,8.0);
6975     VARPOW(UI1,2,R4,3.0f,R8,8.0);
6976     VARPOW(UI1,2,R8,3.0,R8,8.0);
6977     VARPOW(UI1,2,DATE,3,R8,8.0);
6978     VARPOW(UI1,2,BSTR,num3_str,R8,8.0);
6979     VARPOW(UI1,2,BOOL,VARIANT_FALSE,R8,1.0);
6980     VARPOW(UI1,2,I1,3,R8,8.0);
6981     VARPOW(UI1,2,UI1,3,R8,8.0);
6982     VARPOW(UI1,2,UI2,3,R8,8.0);
6983     VARPOW(UI1,2,UI4,3,R8,8.0);
6984     if (HAVE_OLEAUT32_I8)
6985     {
6986         VARPOW(UI1,2,I8,3,R8,8.0);
6987         VARPOW(UI1,2,UI8,3,R8,8.0);
6988     }
6989     VARPOW(UI1,2,INT,3,R8,8.0);
6990     VARPOW(UI1,2,UINT,3,R8,8.0);
6991     VARPOW(UI2,2,EMPTY,0,R8,1.0);
6992     VARPOW(UI2,2,NULL,0,NULL,0);
6993     VARPOW(UI2,2,I2,3,R8,8.0);
6994     VARPOW(UI2,2,I4,3,R8,8.0);
6995     VARPOW(UI2,2,R4,3.0f,R8,8.0);
6996     VARPOW(UI2,2,R8,3.0,R8,8.0);
6997     VARPOW(UI2,2,DATE,3,R8,8.0);
6998     VARPOW(UI2,2,BSTR,num3_str,R8,8.0);
6999     VARPOW(UI2,2,BOOL,VARIANT_FALSE,R8,1.0);
7000     VARPOW(UI2,2,I1,3,R8,8.0);
7001     VARPOW(UI2,2,UI1,3,R8,8.0);
7002     VARPOW(UI2,2,UI2,3,R8,8.0);
7003     VARPOW(UI2,2,UI4,3,R8,8.0);
7004     if (HAVE_OLEAUT32_I8)
7005     {
7006         VARPOW(UI2,2,I8,3,R8,8.0);
7007         VARPOW(UI2,2,UI8,3,R8,8.0);
7008     }
7009     VARPOW(UI2,2,INT,3,R8,8.0);
7010     VARPOW(UI2,2,UINT,3,R8,8.0);
7011     VARPOW(UI4,2,EMPTY,0,R8,1.0);
7012     VARPOW(UI4,2,NULL,0,NULL,0);
7013     VARPOW(UI4,2,I2,3,R8,8.0);
7014     VARPOW(UI4,2,I4,3,R8,8.0);
7015     VARPOW(UI4,2,R4,3.0f,R8,8.0);
7016     VARPOW(UI4,2,R8,3.0,R8,8.0);
7017     VARPOW(UI4,2,DATE,3,R8,8.0);
7018     VARPOW(UI4,2,BSTR,num3_str,R8,8.0);
7019     VARPOW(UI4,2,BOOL,VARIANT_FALSE,R8,1.0);
7020     VARPOW(UI4,2,I1,3,R8,8.0);
7021     VARPOW(UI4,2,UI1,3,R8,8.0);
7022     VARPOW(UI4,2,UI2,3,R8,8.0);
7023     VARPOW(UI4,2,UI4,3,R8,8.0);
7024     if (HAVE_OLEAUT32_I8)
7025     {
7026         VARPOW(UI4,2,I8,3,R8,8.0);
7027         VARPOW(UI4,2,UI8,3,R8,8.0);
7028     }
7029     VARPOW(UI4,2,INT,3,R8,8.0);
7030     VARPOW(UI4,2,UINT,3,R8,8.0);
7031     if (HAVE_OLEAUT32_I8)
7032     {
7033         VARPOW(I8,2,EMPTY,0,R8,1.0);
7034         VARPOW(I8,2,NULL,0,NULL,0);
7035         VARPOW(I8,2,I2,3,R8,8.0);
7036         VARPOW(I8,2,I4,3,R8,8.0);
7037         VARPOW(I8,2,R4,3.0f,R8,8.0);
7038         VARPOW(I8,2,R8,3.0,R8,8.0);
7039         VARPOW(I8,2,DATE,3,R8,8.0);
7040         VARPOW(I8,2,BSTR,num3_str,R8,8.0);
7041         VARPOW(I8,2,BOOL,VARIANT_FALSE,R8,1.0);
7042         VARPOW(I8,2,I1,3,R8,8.0);
7043         VARPOW(I8,2,UI1,3,R8,8.0);
7044         VARPOW(I8,2,UI2,3,R8,8.0);
7045         VARPOW(I8,2,UI4,3,R8,8.0);
7046         VARPOW(I8,2,I8,3,R8,8.0);
7047         VARPOW(I8,2,UI8,3,R8,8.0);
7048         VARPOW(I8,2,INT,3,R8,8.0);
7049         VARPOW(I8,2,UINT,3,R8,8.0);
7050         VARPOW(UI8,2,EMPTY,0,R8,1.0);
7051         VARPOW(UI8,2,NULL,0,NULL,0);
7052         VARPOW(UI8,2,I2,3,R8,8.0);
7053         VARPOW(UI8,2,I4,3,R8,8.0);
7054         VARPOW(UI8,2,R4,3.0f,R8,8.0);
7055         VARPOW(UI8,2,R8,3.0,R8,8.0);
7056         VARPOW(UI8,2,DATE,3,R8,8.0);
7057         VARPOW(UI8,2,BSTR,num3_str,R8,8.0);
7058         VARPOW(UI8,2,I1,3,R8,8.0);
7059         VARPOW(UI8,2,UI1,3,R8,8.0);
7060         VARPOW(UI8,2,UI2,3,R8,8.0);
7061         VARPOW(UI8,2,UI4,3,R8,8.0);
7062         VARPOW(UI8,2,I8,3,R8,8.0);
7063         VARPOW(UI8,2,UI8,3,R8,8.0);
7064         VARPOW(UI8,2,INT,3,R8,8.0);
7065         VARPOW(UI8,2,UINT,3,R8,8.0);
7066     }
7067     VARPOW(INT,2,EMPTY,0,R8,1.0);
7068     VARPOW(INT,2,NULL,0,NULL,0);
7069     VARPOW(INT,2,I2,3,R8,8.0);
7070     VARPOW(INT,2,I4,3,R8,8.0);
7071     VARPOW(INT,2,R4,3.0f,R8,8.0);
7072     VARPOW(INT,2,R8,3.0,R8,8.0);
7073     VARPOW(INT,2,DATE,3,R8,8.0);
7074     VARPOW(INT,2,BSTR,num3_str,R8,8.0);
7075     VARPOW(INT,2,BOOL,VARIANT_FALSE,R8,1.0);
7076     VARPOW(INT,2,I1,3,R8,8.0);
7077     VARPOW(INT,2,UI1,3,R8,8.0);
7078     VARPOW(INT,2,UI2,3,R8,8.0);
7079     VARPOW(INT,2,UI4,3,R8,8.0);
7080     if (HAVE_OLEAUT32_I8)
7081     {
7082         VARPOW(INT,2,I8,3,R8,8.0);
7083         VARPOW(INT,2,UI8,3,R8,8.0);
7084     }
7085     VARPOW(INT,2,INT,3,R8,8.0);
7086     VARPOW(INT,2,UINT,3,R8,8.0);
7087     VARPOW(UINT,2,EMPTY,0,R8,1.0);
7088     VARPOW(UINT,2,NULL,0,NULL,0);
7089     VARPOW(UINT,2,I2,3,R8,8.0);
7090     VARPOW(UINT,2,I4,3,R8,8.0);
7091     VARPOW(UINT,2,R4,3.0f,R8,8.0);
7092     VARPOW(UINT,2,R8,3.0,R8,8.0);
7093     VARPOW(UINT,2,DATE,3,R8,8.0);
7094     VARPOW(UINT,2,BSTR,num3_str,R8,8.0);
7095     VARPOW(UINT,2,BOOL,VARIANT_FALSE,R8,1.0);
7096     VARPOW(UINT,2,I1,3,R8,8.0);
7097     VARPOW(UINT,2,UI1,3,R8,8.0);
7098     VARPOW(UINT,2,UI2,3,R8,8.0);
7099     VARPOW(UINT,2,UI4,3,R8,8.0);
7100     if (HAVE_OLEAUT32_I8)
7101     {
7102         VARPOW(UINT,2,I8,3,R8,8.0);
7103         VARPOW(UINT,2,UI8,3,R8,8.0);
7104     }
7105     VARPOW(UINT,2,INT,3,R8,8.0);
7106     VARPOW(UINT,2,UINT,3,R8,8.0);
7107
7108     /* Manually test some VT_CY, VT_DECIMAL variants */
7109     V_VT(&cy) = VT_CY;
7110     hres = VarCyFromI4(2, &V_CY(&cy));
7111     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7112     V_VT(&dec) = VT_DECIMAL;
7113     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7114     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7115     memset(&left, 0, sizeof(left));
7116     memset(&right, 0, sizeof(right));
7117     V_VT(&left) = VT_I4;
7118     V_I4(&left) = 100;
7119     V_VT(&right) = VT_I8;
7120     V_UI1(&right) = 2;
7121
7122     hres = pVarPow(&cy, &cy, &result);
7123     ok(hres == S_OK && V_VT(&result) == VT_R8,
7124         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7125         S_OK, hres, vtstr(V_VT(&result)));
7126     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7127         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7128
7129     hres = pVarPow(&cy, &right, &result);
7130     if (hres == S_OK)
7131     {
7132         ok(hres == S_OK && V_VT(&result) == VT_R8,
7133            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7134            S_OK, hres, vtstr(V_VT(&result)));
7135         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7136            "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7137     }
7138     else
7139     {
7140         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7141            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7142            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7143     }
7144
7145     hres = pVarPow(&left, &cy, &result);
7146     ok(hres == S_OK && V_VT(&result) == VT_R8,
7147         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7148         S_OK, hres, vtstr(V_VT(&result)));
7149     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 10000.0),
7150         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 10000.0);
7151
7152     hres = pVarPow(&left, &dec, &result);
7153     ok(hres == S_OK && V_VT(&result) == VT_R8,
7154         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7155         S_OK, hres, vtstr(V_VT(&result)));
7156     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result),10000.0),
7157         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 10000.0);
7158
7159     hres = pVarPow(&dec, &dec, &result);
7160     ok(hres == S_OK && V_VT(&result) == VT_R8,
7161         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7162         S_OK, hres, vtstr(V_VT(&result)));
7163     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7164         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7165
7166     hres = pVarPow(&dec, &right, &result);
7167     if (hres == S_OK)
7168     {
7169         ok(hres == S_OK && V_VT(&result) == VT_R8,
7170            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7171            S_OK, hres, vtstr(V_VT(&result)));
7172         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7173            "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7174     }
7175     else
7176     {
7177         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7178            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7179            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7180     }
7181
7182     SysFreeString(num2_str);
7183     SysFreeString(num3_str);
7184 }
7185
7186 static HRESULT (WINAPI *pVarDiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7187
7188 #define VARDIV(vt1,val1,vt2,val2,rvt,rval)               \
7189         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7190         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7191         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7192         test_var_call2( __LINE__, pVarDiv, &left, &right, &exp )
7193
7194 /* Skip any type that is not defined or produces an error for every case */
7195 #define SKIPTESTDIV(a)                            \
7196     if (a == VT_ERROR || a == VT_VARIANT ||       \
7197         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7198         a == VT_RECORD || a > VT_UINT ||          \
7199         a == VT_I1 || a == VT_UI8 ||              \
7200         a == VT_INT || a == VT_UINT ||            \
7201         a == VT_UI2 || a == VT_UI4 ||             \
7202         a == 15 /*not defined*/)                  \
7203         continue
7204
7205 static void test_VarDiv(void)
7206 {
7207     static const WCHAR str1[] = { '1','\0' };
7208     static const WCHAR str2[] = { '2','\0' };
7209     VARIANT left, right, exp, result, cy, dec;
7210     BSTR num1_str, num2_str;
7211     VARTYPE i;
7212     HRESULT hres;
7213     double r;
7214
7215     num1_str = SysAllocString(str1);
7216     num2_str = SysAllocString(str2);
7217
7218     CHECKPTR(VarDiv);
7219
7220     /* Test all possible flag/vt combinations & the resulting vt type */
7221     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7222     {
7223         VARTYPE leftvt, rightvt, resvt;
7224
7225         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7226         {
7227             SKIPTESTDIV(leftvt);
7228
7229             /* Check if we need/have support for I8 */
7230             if (leftvt == VT_I8 && !HAVE_OLEAUT32_I8)
7231                 continue;
7232
7233             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7234             {
7235                 BOOL bFail = FALSE;
7236                 SKIPTESTDIV(rightvt);
7237
7238                 /* Check if we need/have support for I8 */
7239                 if (rightvt == VT_I8 && !HAVE_OLEAUT32_I8)
7240                     continue;
7241
7242                 /* Native crashes with VT_BYREF */
7243                 if (ExtraFlags[i] == VT_BYREF)
7244                     continue;
7245
7246                 memset(&left, 0, sizeof(left));
7247                 memset(&right, 0, sizeof(right));
7248                 V_VT(&left) = leftvt | ExtraFlags[i];
7249                 V_VT(&right) = rightvt | ExtraFlags[i];
7250                 V_VT(&result) = VT_EMPTY;
7251                 resvt = VT_EMPTY;
7252
7253                 if (leftvt == VT_BSTR)
7254                     V_BSTR(&left) = num2_str;
7255                 else if (leftvt == VT_DECIMAL)
7256                 {
7257                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7258                     V_VT(&left) = leftvt | ExtraFlags[i];
7259                 }
7260
7261                 /* Division by 0 is undefined */
7262                 switch(rightvt)
7263                 {
7264                 case VT_BSTR:
7265                     V_BSTR(&right) = num2_str;
7266                     break;
7267                 case VT_DECIMAL:
7268                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7269                     V_VT(&right) = rightvt | ExtraFlags[i];
7270                     break;
7271                 case VT_BOOL:
7272                     V_BOOL(&right) = VARIANT_TRUE;
7273                     break;
7274                 case VT_I2: V_I2(&right) = 2; break;
7275                 case VT_I4: V_I4(&right) = 2; break;
7276                 case VT_R4: V_R4(&right) = 2.0f; break;
7277                 case VT_R8: V_R8(&right) = 2.0; break;
7278                 case VT_CY: V_CY(&right).int64 = 2; break;
7279                 case VT_DATE: V_DATE(&right) = 2; break;
7280                 case VT_UI1: V_UI1(&right) = 2; break;
7281                 case VT_I8: V_I8(&right) = 2; break;
7282                 default: break;
7283                 }
7284
7285                 /* Determine return type */
7286                 if (!(rightvt == VT_EMPTY))
7287                 {
7288                     if (leftvt == VT_NULL || rightvt == VT_NULL)
7289                         resvt = VT_NULL;
7290                     else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
7291                         resvt = VT_DECIMAL;
7292                     else if (leftvt == VT_I8 || rightvt == VT_I8 ||
7293                         leftvt == VT_CY || rightvt == VT_CY ||
7294                         leftvt == VT_DATE || rightvt == VT_DATE ||
7295                         leftvt == VT_I4 || rightvt == VT_I4 ||
7296                         leftvt == VT_BSTR || rightvt == VT_BSTR ||
7297                         leftvt == VT_I2 || rightvt == VT_I2 ||
7298                         leftvt == VT_BOOL || rightvt == VT_BOOL ||
7299                         leftvt == VT_R8 || rightvt == VT_R8 ||
7300                         leftvt == VT_UI1 || rightvt == VT_UI1)
7301                     {
7302                         if ((leftvt == VT_UI1 && rightvt == VT_R4) ||
7303                             (leftvt == VT_R4 && rightvt == VT_UI1))
7304                             resvt = VT_R4;
7305                         else if ((leftvt == VT_R4 && (rightvt == VT_BOOL ||
7306                             rightvt == VT_I2)) || (rightvt == VT_R4 &&
7307                             (leftvt == VT_BOOL || leftvt == VT_I2)))
7308                             resvt = VT_R4;
7309                         else
7310                             resvt = VT_R8;
7311                     }
7312                     else if (leftvt == VT_R4 || rightvt == VT_R4)
7313                         resvt = VT_R4;
7314                 }
7315                 else if (leftvt == VT_NULL && rightvt == VT_EMPTY)
7316                     resvt = VT_NULL;
7317                 else
7318                     bFail = TRUE;
7319
7320                 /* Native VarDiv always returns an error when using extra flags */
7321                 if (ExtraFlags[i] != 0)
7322                     bFail = TRUE;
7323
7324                 hres = pVarDiv(&left, &right, &result);
7325
7326                 /* Check expected HRESULT and if result variant type is correct */
7327                 if (bFail)
7328                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7329                         hres == DISP_E_OVERFLOW || hres == DISP_E_DIVBYZERO,
7330                         "VarDiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7331                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7332                         vtstr(V_VT(&result)), hres);
7333                 else
7334                     ok (hres == S_OK && resvt == V_VT(&result),
7335                         "VarDiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7336                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7337                         S_OK, vtstr(V_VT(&result)), hres);
7338             }
7339         }
7340     }
7341
7342     /* Test return values for all the good cases */
7343     VARDIV(EMPTY,0,NULL,0,NULL,0);
7344     VARDIV(EMPTY,0,I2,2,R8,0.0);
7345     VARDIV(EMPTY,0,I4,2,R8,0.0);
7346     VARDIV(EMPTY,0,R4,2.0f,R4,0.0f);
7347     VARDIV(EMPTY,0,R8,2.0,R8,0.0);
7348     VARDIV(EMPTY,0,DATE,2.0,R8,0.0);
7349     VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
7350     VARDIV(EMPTY,0,BOOL,VARIANT_TRUE,R8,0.0);
7351     VARDIV(EMPTY,0,UI1,2,R8,0.0);
7352     if (HAVE_OLEAUT32_I8)
7353     {
7354         VARDIV(EMPTY,0,I8,2,R8,0.0);
7355     }
7356     VARDIV(NULL,0,EMPTY,0,NULL,0);
7357     VARDIV(NULL,0,NULL,0,NULL,0);
7358     VARDIV(NULL,0,I2,2,NULL,0);
7359     VARDIV(NULL,0,I4,2,NULL,0);
7360     VARDIV(NULL,0,R4,2.0f,NULL,0);
7361     VARDIV(NULL,0,R8,2.0,NULL,0);
7362     VARDIV(NULL,0,DATE,2,NULL,0);
7363     VARDIV(NULL,0,BSTR,num2_str,NULL,0);
7364     VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7365     VARDIV(NULL,0,UI1,2,NULL,0);
7366     if (HAVE_OLEAUT32_I8)
7367     {
7368         VARDIV(NULL,0,I8,2,NULL,0);
7369     }
7370     VARDIV(I2,2,NULL,0,NULL,0);
7371     VARDIV(I2,1,I2,2,R8,0.5);
7372     VARDIV(I2,1,I4,2,R8,0.5);
7373     VARDIV(I2,1,R4,2,R4,0.5f);
7374     VARDIV(I2,1,R8,2.0,R8,0.5);
7375     VARDIV(I2,1,DATE,2,R8,0.5);
7376     VARDIV(I2,1,BOOL,VARIANT_TRUE,R8,-1.0);
7377     VARDIV(I2,1,UI1,2,R8,0.5);
7378     if (HAVE_OLEAUT32_I8)
7379     {
7380         VARDIV(I2,1,I8,2,R8,0.5);
7381     }
7382     VARDIV(I4,1,NULL,0,NULL,0);
7383     VARDIV(I4,1,I2,2,R8,0.5);
7384     VARDIV(I4,1,I4,2,R8,0.5);
7385     VARDIV(I4,1,R4,2.0f,R8,0.5);
7386     VARDIV(I4,1,R8,2.0,R8,0.5);
7387     VARDIV(I4,1,DATE,2,R8,0.5);
7388     VARDIV(I4,1,BSTR,num2_str,R8,0.5);
7389     VARDIV(I4,1,BOOL,VARIANT_TRUE,R8,-1.0);
7390     VARDIV(I4,1,UI1,2,R8,0.5);
7391     if (HAVE_OLEAUT32_I8)
7392     {
7393         VARDIV(I4,1,I8,2,R8,0.5);
7394     }
7395     VARDIV(R4,1.0f,NULL,0,NULL,0);
7396     VARDIV(R4,1.0f,I2,2,R4,0.5f);
7397     VARDIV(R4,1.0f,I4,2,R8,0.5);
7398     VARDIV(R4,1.0f,R4,2.0f,R4,0.5f);
7399     VARDIV(R4,1.0f,R8,2.0,R8,0.5);
7400     VARDIV(R4,1.0f,DATE,2,R8,0.5);
7401     VARDIV(R4,1.0f,BSTR,num2_str,R8,0.5);
7402     VARDIV(R4,1.0f,BOOL,VARIANT_TRUE,R4,-1);
7403     VARDIV(R4,1.0f,UI1,2,R4,0.5f);
7404     if (HAVE_OLEAUT32_I8)
7405     {
7406         VARDIV(R4,1.0f,I8,2,R8,0.5);
7407     }
7408     VARDIV(R8,1.0,NULL,0,NULL,0);
7409     VARDIV(R8,1.0,I2,2,R8,0.5);
7410     VARDIV(R8,1.0,I4,2,R8,0.5);
7411     VARDIV(R8,1.0,R4,2.0f,R8,0.5);
7412     VARDIV(R8,1.0,R8,2.0,R8,0.5);
7413     VARDIV(R8,1.0,DATE,2,R8,0.5);
7414     VARDIV(R8,1.0,BSTR,num2_str,R8,0.5);
7415     VARDIV(R8,1.0,BOOL,VARIANT_TRUE,R8,-1.0);
7416     VARDIV(R8,1.0,UI1,2,R8,0.5);
7417     if (HAVE_OLEAUT32_I8)
7418     {
7419         VARDIV(R8,1.0,I8,2,R8,0.5);
7420     }
7421     VARDIV(DATE,1,NULL,0,NULL,0);
7422     VARDIV(DATE,1,I2,2,R8,0.5);
7423     VARDIV(DATE,1,I4,2,R8,0.5);
7424     VARDIV(DATE,1,R4,2.0f,R8,0.5);
7425     VARDIV(DATE,1,R8,2.0,R8,0.5);
7426     VARDIV(DATE,1,DATE,2,R8,0.5);
7427     VARDIV(DATE,1,BSTR,num2_str,R8,0.5);
7428     VARDIV(DATE,1,BOOL,VARIANT_TRUE,R8,-1.0);
7429     VARDIV(DATE,1,UI1,2,R8,0.5);
7430     if (HAVE_OLEAUT32_I8)
7431     {
7432         VARDIV(DATE,1,I8,2,R8,0.5);
7433     }
7434     VARDIV(BSTR,num1_str,NULL,0,NULL,0);
7435     VARDIV(BSTR,num1_str,I2,2,R8,0.5);
7436     VARDIV(BSTR,num1_str,I4,2,R8,0.5);
7437     VARDIV(BSTR,num1_str,R4,2.0f,R8,0.5);
7438     VARDIV(BSTR,num1_str,R8,2.0,R8,0.5);
7439     VARDIV(BSTR,num1_str,DATE,2,R8,0.5);
7440     VARDIV(BSTR,num1_str,BSTR,num2_str,R8,0.5);
7441     VARDIV(BSTR,num1_str,BOOL,VARIANT_TRUE,R8,-1);
7442     VARDIV(BSTR,num1_str,UI1,2,R8,0.5);
7443     if (HAVE_OLEAUT32_I8)
7444     {
7445         VARDIV(BSTR,num1_str,I8,2,R8,0.5);
7446     }
7447     VARDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7448     VARDIV(BOOL,VARIANT_TRUE,I2,1,R8,-1.0);
7449     VARDIV(BOOL,VARIANT_FALSE,I2,1,R8,0.0);
7450     VARDIV(BOOL,VARIANT_TRUE,I4,1,R8,-1.0);
7451     VARDIV(BOOL,VARIANT_FALSE,I4,1,R8,0.0);
7452     VARDIV(BOOL,VARIANT_TRUE,R4,1,R4,-1.0f);
7453     VARDIV(BOOL,VARIANT_FALSE,R4,1,R4,0.0f);
7454     VARDIV(BOOL,VARIANT_TRUE,R8,1.0,R8,-1.0);
7455     VARDIV(BOOL,VARIANT_FALSE,R8,1.0,R8,0.0);
7456     VARDIV(BOOL,VARIANT_FALSE,DATE,2,R8,0.0);
7457     VARDIV(BOOL,VARIANT_FALSE,BSTR,num2_str,R8,0.0);
7458     VARDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,1.0);
7459     VARDIV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,R8,0.0);
7460     VARDIV(BOOL,VARIANT_TRUE,UI1,1,R8,-1.0);
7461     if (HAVE_OLEAUT32_I8)
7462     {
7463         VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
7464     }
7465     VARDIV(UI1,1,NULL,0,NULL,0);
7466     VARDIV(UI1,1,I2,2,R8,0.5);
7467     VARDIV(UI1,1,I4,2,R8,0.5);
7468     VARDIV(UI1,1,R4,2.0f,R4,0.5f);
7469     VARDIV(UI1,1,R8,2.0,R8,0.5);
7470     VARDIV(UI1,1,DATE,2,R8,0.5);
7471     VARDIV(UI1,1,BSTR,num2_str,R8,0.5);
7472     VARDIV(UI1,1,BOOL,VARIANT_TRUE,R8,-1);
7473     VARDIV(UI1,1,UI1,2,R8,0.5);
7474     if (HAVE_OLEAUT32_I8)
7475     {
7476         VARDIV(UI1,1,I8,2,R8,0.5);
7477         VARDIV(I8,1,NULL,0,NULL,0);
7478         VARDIV(I8,1,I2,2,R8,0.5);
7479         VARDIV(I8,1,I4,2,R8,0.5);
7480         VARDIV(I8,1,R4,2.0f,R8,0.5);
7481         VARDIV(I8,1,R8,2.0,R8,0.5);
7482         VARDIV(I8,1,DATE,2,R8,0.5);
7483         VARDIV(I8,1,BSTR,num2_str,R8,0.5);
7484         VARDIV(I8,1,BOOL,VARIANT_TRUE,R8,-1);
7485         VARDIV(I8,1,UI1,2,R8,0.5);
7486         VARDIV(I8,1,I8,2,R8,0.5);
7487     }
7488
7489     /* Manually test some VT_CY, VT_DECIMAL variants */
7490     V_VT(&cy) = VT_CY;
7491     hres = VarCyFromI4(10000, &V_CY(&cy));
7492     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7493     V_VT(&dec) = VT_DECIMAL;
7494     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7495     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7496     memset(&left, 0, sizeof(left));
7497     memset(&right, 0, sizeof(right));
7498     V_VT(&left) = VT_I4;
7499     V_I4(&left) = 100;
7500     V_VT(&right) = VT_UI1;
7501     V_UI1(&right) = 2;
7502
7503     hres = pVarDiv(&cy, &cy, &result);
7504     ok(hres == S_OK && V_VT(&result) == VT_R8,
7505         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7506     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 1.0),
7507         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)1.0);
7508
7509     hres = pVarDiv(&cy, &right, &result);
7510     ok(hres == S_OK && V_VT(&result) == VT_R8,
7511         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7512     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 5000.0),
7513         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)5000.0);
7514
7515     hres = pVarDiv(&left, &cy, &result);
7516     ok(hres == S_OK && V_VT(&result) == VT_R8,
7517         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7518     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.01),
7519         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)0.01);
7520
7521     hres = pVarDiv(&left, &dec, &result);
7522     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7523         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7524     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7525     ok(hres == S_OK && EQ_DOUBLE(r, 50.0),
7526         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)50.0);
7527
7528     hres = pVarDiv(&dec, &dec, &result);
7529     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7530         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7531     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7532     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7533         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7534
7535     hres = pVarDiv(&dec, &right, &result);
7536     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7537         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7538     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7539     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7540         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7541
7542     /* Check for division by zero and overflow */
7543     V_VT(&left) = VT_R8;
7544     V_I4(&left) = 1;
7545     V_VT(&right) = VT_R8;
7546     V_I4(&right) = 0;
7547     hres = pVarDiv(&left, &right, &result);
7548     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
7549         "VARDIV: Division by (1.0/0.0) should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
7550
7551     V_VT(&left) = VT_R8;
7552     V_I4(&left) = 0;
7553     V_VT(&right) = VT_R8;
7554     V_I4(&right) = 0;
7555     hres = pVarDiv(&left, &right, &result);
7556     ok(hres == DISP_E_OVERFLOW && V_VT(&result) == VT_EMPTY,
7557         "VARDIV: Division by (0.0/0.0) should result in DISP_E_OVERFLOW but got 0x%X\n", hres);
7558
7559     SysFreeString(num1_str);
7560     SysFreeString(num2_str);
7561 }
7562
7563 static HRESULT (WINAPI *pVarIdiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7564
7565 #define VARIDIV(vt1,val1,vt2,val2,rvt,rval)              \
7566         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7567         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7568         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7569         test_var_call2( __LINE__, pVarIdiv, &left, &right, &exp )
7570
7571 /* Skip any type that is not defined or produces an error for every case */
7572 #define SKIPTESTIDIV(a)                           \
7573     if (a == VT_ERROR || a == VT_VARIANT ||       \
7574         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7575         a == VT_RECORD || a > VT_UINT ||          \
7576         a == 15 /*not defined*/)                  \
7577         continue
7578
7579 static void test_VarIdiv(void)
7580 {
7581     static const WCHAR str1[] = { '1','\0' };
7582     static const WCHAR str2[] = { '2','\0' };
7583     VARIANT left, right, exp, result, cy, dec;
7584     BSTR num1_str, num2_str;
7585     VARTYPE i;
7586     HRESULT hres;
7587
7588     CHECKPTR(VarIdiv);
7589
7590     num1_str = SysAllocString(str1);
7591     num2_str = SysAllocString(str2);
7592
7593     /* Test all possible flag/vt combinations & the resulting vt type */
7594     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7595     {
7596         VARTYPE leftvt, rightvt, resvt;
7597
7598         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7599         {
7600             SKIPTESTIDIV(leftvt);
7601
7602             /* Check if we need/have support for I8 and/or UI8 */
7603             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7604                 continue;
7605
7606             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7607             {
7608                 BOOL bFail = FALSE;
7609                 SKIPTESTIDIV(rightvt);
7610
7611                 /* Native crashes with extra flag VT_BYREF */
7612                 if (ExtraFlags[i] == VT_BYREF)
7613                     continue;
7614
7615                 /* Check if we need/have support for I8 and/or UI8 */
7616                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7617                     continue;
7618
7619                 memset(&left, 0, sizeof(left));
7620                 memset(&right, 0, sizeof(right));
7621                 V_VT(&left) = leftvt | ExtraFlags[i];
7622                 V_VT(&right) = rightvt | ExtraFlags[i];
7623                 V_VT(&result) = VT_EMPTY;
7624                 resvt = VT_EMPTY;
7625
7626                 if (leftvt == VT_BSTR)
7627                     V_BSTR(&left) = num2_str;
7628                 else if (leftvt == VT_DECIMAL)
7629                 {
7630                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7631                     V_VT(&left) = leftvt | ExtraFlags[i];
7632                 }
7633
7634                 /* Division by 0 is undefined */
7635                 switch(rightvt)
7636                 {
7637                 case VT_BSTR:
7638                     V_BSTR(&right) = num2_str;
7639                     break;
7640                 case VT_DECIMAL:
7641                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7642                     V_VT(&right) = rightvt | ExtraFlags[i];
7643                     break;
7644                 case VT_BOOL:
7645                     V_BOOL(&right) = VARIANT_TRUE;
7646                     break;
7647                 case VT_CY:
7648                     VarCyFromI4(10000, &V_CY(&right));
7649                     V_VT(&right) = rightvt | ExtraFlags[i];
7650                     break;
7651                 case VT_I2: V_I2(&right) = 2; break;
7652                 case VT_I4: V_I4(&right) = 2; break;
7653                 case VT_R4: V_R4(&right) = 2.0f; break;
7654                 case VT_R8: V_R8(&right) = 2.0; break;
7655                 case VT_DATE: V_DATE(&right) = 2; break;
7656                 case VT_I1: V_I1(&right) = 2; break;
7657                 case VT_UI1: V_UI1(&right) = 2; break;
7658                 case VT_UI2: V_UI2(&right) = 2; break;
7659                 case VT_UI4: V_UI4(&right) = 2; break;
7660                 case VT_I8: V_I8(&right) = 2; break;
7661                 case VT_UI8: V_UI8(&right) = 2; break;
7662                 case VT_INT: V_INT(&right) = 2; break;
7663                 case VT_UINT: V_UINT(&right) = 2; break;
7664                 default: break;
7665                 }
7666
7667                 /* Native VarIdiv always returns an error when using extra
7668                  * flags or if the variant combination is I8 and INT.
7669                  */
7670                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
7671                     (leftvt == VT_INT && rightvt == VT_I8) ||
7672                     (rightvt == VT_EMPTY && leftvt != VT_NULL) ||
7673                     ExtraFlags[i] != 0)
7674                     bFail = TRUE;
7675
7676                 /* Determine variant type */
7677                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
7678                     resvt = VT_NULL;
7679                 else if (leftvt == VT_I8 || rightvt == VT_I8)
7680                     resvt = VT_I8;
7681                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
7682                     leftvt == VT_INT || rightvt == VT_INT ||
7683                     leftvt == VT_UINT || rightvt == VT_UINT ||
7684                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
7685                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
7686                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
7687                     leftvt == VT_I1 || rightvt == VT_I1 ||
7688                     leftvt == VT_BSTR || rightvt == VT_BSTR ||
7689                     leftvt == VT_DATE || rightvt == VT_DATE ||
7690                     leftvt == VT_CY || rightvt == VT_CY ||
7691                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
7692                     leftvt == VT_R8 || rightvt == VT_R8 ||
7693                     leftvt == VT_R4 || rightvt == VT_R4)
7694                     resvt = VT_I4;
7695                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
7696                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
7697                     leftvt == VT_EMPTY)
7698                     resvt = VT_I2;
7699                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
7700                     resvt = VT_UI1;
7701                 else
7702                     bFail = TRUE;
7703
7704                 hres = pVarIdiv(&left, &right, &result);
7705
7706                 /* Check expected HRESULT and if result variant type is correct */
7707                 if (bFail)
7708                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7709                         hres == DISP_E_DIVBYZERO,
7710                         "VarIdiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7711                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7712                         vtstr(V_VT(&result)), hres);
7713                 else
7714                     ok (hres == S_OK && resvt == V_VT(&result),
7715                         "VarIdiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7716                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7717                         S_OK, vtstr(V_VT(&result)), hres);
7718             }
7719         }
7720     }
7721
7722     /* Test return values for all the good cases */
7723     VARIDIV(EMPTY,0,NULL,0,NULL,0);
7724     VARIDIV(EMPTY,0,I2,1,I2,0);
7725     VARIDIV(EMPTY,0,I4,1,I4,0);
7726     VARIDIV(EMPTY,0,R4,1.0f,I4,0);
7727     VARIDIV(EMPTY,0,R8,1.0,I4,0);
7728     VARIDIV(EMPTY,0,DATE,1.0,I4,0);
7729     VARIDIV(EMPTY,0,BSTR,num1_str,I4,0);
7730     VARIDIV(EMPTY,0,BOOL,VARIANT_TRUE,I2,0);
7731     VARIDIV(EMPTY,0,I1,1,I4,0);
7732     VARIDIV(EMPTY,0,UI1,1,I2,0);
7733     VARIDIV(EMPTY,0,UI2,1,I4,0);
7734     VARIDIV(EMPTY,0,UI4,1,I4,0);
7735     if (HAVE_OLEAUT32_I8)
7736     {
7737         VARIDIV(EMPTY,0,I8,1,I8,0);
7738         VARIDIV(EMPTY,0,UI8,1,I4,0);
7739     }
7740     VARIDIV(EMPTY,0,INT,1,I4,0);
7741     VARIDIV(EMPTY,0,UINT,1,I4,0);
7742     VARIDIV(NULL,0,EMPTY,0,NULL,0);
7743     VARIDIV(NULL,0,NULL,0,NULL,0);
7744     VARIDIV(NULL,0,I2,1,NULL,0);
7745     VARIDIV(NULL,0,I4,1,NULL,0);
7746     VARIDIV(NULL,0,R4,1,NULL,0);
7747     VARIDIV(NULL,0,R8,1,NULL,0);
7748     VARIDIV(NULL,0,DATE,1,NULL,0);
7749     VARIDIV(NULL,0,BSTR,num1_str,NULL,0);
7750     VARIDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7751     VARIDIV(NULL,0,I1,1,NULL,0);
7752     VARIDIV(NULL,0,UI1,1,NULL,0);
7753     VARIDIV(NULL,0,UI2,1,NULL,0);
7754     VARIDIV(NULL,0,UI4,1,NULL,0);
7755     if (HAVE_OLEAUT32_I8)
7756     {
7757         VARIDIV(NULL,0,I8,1,NULL,0);
7758         VARIDIV(NULL,0,UI8,1,NULL,0);
7759     }
7760     VARIDIV(NULL,0,INT,1,NULL,0);
7761     VARIDIV(NULL,0,UINT,1,NULL,0);
7762     VARIDIV(I2,2,NULL,0,NULL,0);
7763     VARIDIV(I2,2,I2,1,I2,2);
7764     VARIDIV(I2,2,I4,1,I4,2);
7765     VARIDIV(I2,2,R4,1,I4,2);
7766     VARIDIV(I2,2,R8,1,I4,2);
7767     VARIDIV(I2,2,DATE,1,I4,2);
7768     VARIDIV(I2,2,BSTR,num1_str,I4,2);
7769     VARIDIV(I2,2,BOOL,VARIANT_TRUE,I2,-2);
7770     VARIDIV(I2,2,I1,1,I4,2);
7771     VARIDIV(I2,2,UI1,1,I2,2);
7772     VARIDIV(I2,2,UI2,1,I4,2);
7773     VARIDIV(I2,2,UI4,1,I4,2);
7774     if (HAVE_OLEAUT32_I8)
7775     {
7776         VARIDIV(I2,2,I8,1,I8,2);
7777         VARIDIV(I2,2,UI8,1,I4,2);
7778     }
7779     VARIDIV(I2,2,INT,1,I4,2);
7780     VARIDIV(I2,2,UINT,1,I4,2);
7781     VARIDIV(I4,2,NULL,0,NULL,0);
7782     VARIDIV(I4,2,I2,1,I4,2);
7783     VARIDIV(I4,2,I4,1,I4,2);
7784     VARIDIV(I4,2,R4,1,I4,2);
7785     VARIDIV(I4,2,R8,1,I4,2);
7786     VARIDIV(I4,2,DATE,1,I4,2);
7787     VARIDIV(I4,2,BSTR,num1_str,I4,2);
7788     VARIDIV(I4,2,BOOL,VARIANT_TRUE,I4,-2);
7789     VARIDIV(I4,2,I1,1,I4,2);
7790     VARIDIV(I4,2,UI1,1,I4,2);
7791     VARIDIV(I4,2,UI2,1,I4,2);
7792     VARIDIV(I4,2,UI4,1,I4,2);
7793     if (HAVE_OLEAUT32_I8)
7794     {
7795         VARIDIV(I4,2,I8,1,I8,2);
7796         VARIDIV(I4,2,UI8,1,I4,2);
7797     }
7798     VARIDIV(I4,2,INT,1,I4,2);
7799     VARIDIV(I4,2,UINT,1,I4,2);
7800     VARIDIV(R4,2.0f,NULL,0,NULL,0);
7801     VARIDIV(R4,2.0f,I2,1,I4,2);
7802     VARIDIV(R4,2.0f,I4,1,I4,2);
7803     VARIDIV(R4,2.0f,R4,1.0f,I4,2);
7804     VARIDIV(R4,2.0f,R8,1.0,I4,2);
7805     VARIDIV(R4,2.0f,DATE,1,I4,2);
7806     VARIDIV(R4,2.0f,BSTR,num1_str,I4,2);
7807     VARIDIV(R4,2.0f,BOOL,VARIANT_TRUE,I4,-2);
7808     VARIDIV(R4,2.0f,I1,1,I4,2);
7809     VARIDIV(R4,2.0f,UI1,1,I4,2);
7810     VARIDIV(R4,2.0f,UI2,1,I4,2);
7811     VARIDIV(R4,2.0f,UI4,1,I4,2);
7812     if (HAVE_OLEAUT32_I8)
7813     {
7814         VARIDIV(R4,2.0f,I8,1,I8,2);
7815         VARIDIV(R4,2.0f,UI8,1,I4,2);
7816     }
7817     VARIDIV(R4,2.0f,INT,1,I4,2);
7818     VARIDIV(R4,2.0f,UINT,1,I4,2);
7819     VARIDIV(R8,2.0,NULL,0,NULL,0);
7820     VARIDIV(R8,2.0,I2,1,I4,2);
7821     VARIDIV(R8,2.0,I4,1,I4,2);
7822     VARIDIV(R8,2.0,R4,1,I4,2);
7823     VARIDIV(R8,2.0,R8,1,I4,2);
7824     VARIDIV(R8,2.0,DATE,1,I4,2);
7825     VARIDIV(R8,2.0,BSTR,num1_str,I4,2);
7826     VARIDIV(R8,2.0,BOOL,VARIANT_TRUE,I4,-2);
7827     VARIDIV(R8,2.0,I1,1,I4,2);
7828     VARIDIV(R8,2.0,UI1,1,I4,2);
7829     VARIDIV(R8,2.0,UI2,1,I4,2);
7830     VARIDIV(R8,2.0,UI4,1,I4,2);
7831     if (HAVE_OLEAUT32_I8)
7832     {
7833         VARIDIV(R8,2.0,I8,1,I8,2);
7834         VARIDIV(R8,2.0,UI8,1,I4,2);
7835     }
7836     VARIDIV(R8,2.0,INT,1,I4,2);
7837     VARIDIV(R8,2.0,UINT,1,I4,2);
7838     VARIDIV(DATE,2,NULL,0,NULL,0);
7839     VARIDIV(DATE,2,I2,1,I4,2);
7840     VARIDIV(DATE,2,I4,1,I4,2);
7841     VARIDIV(DATE,2,R4,1,I4,2);
7842     VARIDIV(DATE,2,R8,1,I4,2);
7843     VARIDIV(DATE,2,DATE,1,I4,2);
7844     VARIDIV(DATE,2,BSTR,num1_str,I4,2);
7845     VARIDIV(DATE,2,BOOL,VARIANT_TRUE,I4,-2);
7846     VARIDIV(DATE,2,I1,1,I4,2);
7847     VARIDIV(DATE,2,UI1,1,I4,2);
7848     VARIDIV(DATE,2,UI2,1,I4,2);
7849     VARIDIV(DATE,2,UI4,1,I4,2);
7850     if (HAVE_OLEAUT32_I8)
7851     {
7852         VARIDIV(DATE,2,I8,1,I8,2);
7853         VARIDIV(DATE,2,UI8,1,I4,2);
7854     }
7855     VARIDIV(DATE,2,INT,1,I4,2);
7856     VARIDIV(DATE,2,UINT,1,I4,2);
7857     VARIDIV(BSTR,num2_str,NULL,0,NULL,0);
7858     VARIDIV(BSTR,num2_str,I2,1,I4,2);
7859     VARIDIV(BSTR,num2_str,I4,1,I4,2);
7860     VARIDIV(BSTR,num2_str,R4,1.0f,I4,2);
7861     VARIDIV(BSTR,num2_str,R8,1.0,I4,2);
7862     VARIDIV(BSTR,num2_str,DATE,1,I4,2);
7863     VARIDIV(BSTR,num2_str,BSTR,num1_str,I4,2);
7864     VARIDIV(BSTR,num2_str,BOOL,VARIANT_TRUE,I4,-2);
7865     VARIDIV(BSTR,num2_str,I1,1,I4,2);
7866     VARIDIV(BSTR,num2_str,UI1,1,I4,2);
7867     VARIDIV(BSTR,num2_str,UI2,1,I4,2);
7868     VARIDIV(BSTR,num2_str,UI4,1,I4,2);
7869     if (HAVE_OLEAUT32_I8)
7870     {
7871         VARIDIV(BSTR,num2_str,I8,1,I8,2);
7872         VARIDIV(BSTR,num2_str,UI8,1,I4,2);
7873     }
7874     VARIDIV(BSTR,num2_str,INT,1,I4,2);
7875     VARIDIV(BSTR,num2_str,UINT,1,I4,2);
7876     VARIDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7877     VARIDIV(BOOL,VARIANT_TRUE,I2,1,I2,-1);
7878     VARIDIV(BOOL,VARIANT_TRUE,I4,1,I4,-1);
7879     VARIDIV(BOOL,VARIANT_TRUE,R4,1.0f,I4,-1);
7880     VARIDIV(BOOL,VARIANT_TRUE,R8,1.0,I4,-1);
7881     VARIDIV(BOOL,VARIANT_TRUE,DATE,1,I4,-1);
7882     VARIDIV(BOOL,VARIANT_TRUE,BSTR,num1_str,I4,-1);
7883     VARIDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,I2,1);
7884     VARIDIV(BOOL,VARIANT_TRUE,I1,1,I4,-1);
7885     VARIDIV(BOOL,VARIANT_TRUE,UI1,1,I2,-1);
7886     VARIDIV(BOOL,VARIANT_TRUE,UI2,1,I4,-1);
7887     VARIDIV(BOOL,VARIANT_TRUE,UI4,1,I4,-1);
7888     if (HAVE_OLEAUT32_I8)
7889     {
7890         VARIDIV(BOOL,VARIANT_TRUE,I8,1,I8,-1);
7891         VARIDIV(BOOL,VARIANT_TRUE,UI8,1,I4,-1);
7892     }
7893     VARIDIV(BOOL,VARIANT_TRUE,INT,1,I4,-1);
7894     VARIDIV(BOOL,VARIANT_TRUE,UINT,1,I4,-1);
7895     VARIDIV(I1,2,NULL,0,NULL,0);
7896     VARIDIV(I1,2,I2,1,I4,2);
7897     VARIDIV(I1,2,I4,1,I4,2);
7898     VARIDIV(I1,2,R4,1.0f,I4,2);
7899     VARIDIV(I1,2,R8,1.0,I4,2);
7900     VARIDIV(I1,2,DATE,1,I4,2);
7901     VARIDIV(I1,2,BSTR,num1_str,I4,2);
7902     VARIDIV(I1,2,BOOL,VARIANT_TRUE,I4,-2);
7903     VARIDIV(I1,2,I1,1,I4,2);
7904     VARIDIV(I1,2,UI1,1,I4,2);
7905     VARIDIV(I1,2,UI2,1,I4,2);
7906     VARIDIV(I1,2,UI4,1,I4,2);
7907     if (HAVE_OLEAUT32_I8)
7908     {
7909         VARIDIV(I1,2,I8,1,I8,2);
7910         VARIDIV(I1,2,UI8,1,I4,2);
7911     }
7912     VARIDIV(I1,2,INT,1,I4,2);
7913     VARIDIV(I1,2,UINT,1,I4,2);
7914     VARIDIV(UI1,2,NULL,0,NULL,0);
7915     VARIDIV(UI1,2,I2,1,I2,2);
7916     VARIDIV(UI1,2,I4,1,I4,2);
7917     VARIDIV(UI1,2,R4,1.0f,I4,2);
7918     VARIDIV(UI1,2,R8,1.0,I4,2);
7919     VARIDIV(UI1,2,DATE,1,I4,2);
7920     VARIDIV(UI1,2,BSTR,num1_str,I4,2);
7921     VARIDIV(UI1,2,BOOL,VARIANT_TRUE,I2,-2);
7922     VARIDIV(UI1,2,I1,1,I4,2);
7923     VARIDIV(UI1,2,UI1,1,UI1,2);
7924     VARIDIV(UI1,2,UI2,1,I4,2);
7925     VARIDIV(UI1,2,UI4,1,I4,2);
7926     if (HAVE_OLEAUT32_I8)
7927     {
7928         VARIDIV(UI1,2,I8,1,I8,2);
7929         VARIDIV(UI1,2,UI8,1,I4,2);
7930     }
7931     VARIDIV(UI1,2,INT,1,I4,2);
7932     VARIDIV(UI1,2,UINT,1,I4,2);
7933     VARIDIV(UI2,2,NULL,0,NULL,0);
7934     VARIDIV(UI2,2,I2,1,I4,2);
7935     VARIDIV(UI2,2,I4,1,I4,2);
7936     VARIDIV(UI2,2,R4,1.0f,I4,2);
7937     VARIDIV(UI2,2,R8,1.0,I4,2);
7938     VARIDIV(UI2,2,DATE,1,I4,2);
7939     VARIDIV(UI2,2,BSTR,num1_str,I4,2);
7940     VARIDIV(UI2,2,BOOL,VARIANT_TRUE,I4,-2);
7941     VARIDIV(UI2,2,I1,1,I4,2);
7942     VARIDIV(UI2,2,UI1,1,I4,2);
7943     VARIDIV(UI2,2,UI2,1,I4,2);
7944     VARIDIV(UI2,2,UI4,1,I4,2);
7945     if (HAVE_OLEAUT32_I8)
7946     {
7947         VARIDIV(UI2,2,I8,1,I8,2);
7948         VARIDIV(UI2,2,UI8,1,I4,2);
7949     }
7950     VARIDIV(UI2,2,INT,1,I4,2);
7951     VARIDIV(UI2,2,UINT,1,I4,2);
7952     VARIDIV(UI4,2,NULL,0,NULL,0);
7953     VARIDIV(UI4,2,I2,1,I4,2);
7954     VARIDIV(UI4,2,I4,1,I4,2);
7955     VARIDIV(UI4,2,R4,1.0f,I4,2);
7956     VARIDIV(UI4,2,R8,1.0,I4,2);
7957     VARIDIV(UI4,2,DATE,1,I4,2);
7958     VARIDIV(UI4,2,BSTR,num1_str,I4,2);
7959     VARIDIV(UI4,2,BOOL,VARIANT_TRUE,I4,-2);
7960     VARIDIV(UI4,2,I1,1,I4,2);
7961     VARIDIV(UI4,2,UI1,1,I4,2);
7962     VARIDIV(UI4,2,UI2,1,I4,2);
7963     VARIDIV(UI4,2,UI4,1,I4,2);
7964     if (HAVE_OLEAUT32_I8)
7965     {
7966         VARIDIV(UI4,2,I8,1,I8,2);
7967         VARIDIV(UI4,2,UI8,1,I4,2);
7968     }
7969     VARIDIV(UI4,2,INT,1,I4,2);
7970     VARIDIV(UI4,2,UINT,1,I4,2);
7971     if (HAVE_OLEAUT32_I8)
7972     {
7973         VARIDIV(I8,2,NULL,0,NULL,0);
7974         VARIDIV(I8,2,I2,1,I8,2);
7975         VARIDIV(I8,2,I4,1,I8,2);
7976         VARIDIV(I8,2,R4,1.0f,I8,2);
7977         VARIDIV(I8,2,R8,1.0,I8,2);
7978         VARIDIV(I8,2,DATE,1,I8,2);
7979         VARIDIV(I8,2,BSTR,num1_str,I8,2);
7980         VARIDIV(I8,2,BOOL,1,I8,2);
7981         VARIDIV(I8,2,I1,1,I8,2);
7982         VARIDIV(I8,2,UI1,1,I8,2);
7983         VARIDIV(I8,2,UI2,1,I8,2);
7984         VARIDIV(I8,2,UI4,1,I8,2);
7985         VARIDIV(I8,2,I8,1,I8,2);
7986         VARIDIV(I8,2,UI8,1,I8,2);
7987         VARIDIV(I8,2,UINT,1,I8,2);
7988         VARIDIV(UI8,2,NULL,0,NULL,0);
7989         VARIDIV(UI8,2,I2,1,I4,2);
7990         VARIDIV(UI8,2,I4,1,I4,2);
7991         VARIDIV(UI8,2,R4,1.0f,I4,2);
7992         VARIDIV(UI8,2,R8,1.0,I4,2);
7993         VARIDIV(UI8,2,DATE,1,I4,2);
7994         VARIDIV(UI8,2,BSTR,num1_str,I4,2);
7995         VARIDIV(UI8,2,BOOL,VARIANT_TRUE,I4,-2);
7996         VARIDIV(UI8,2,I1,1,I4,2);
7997         VARIDIV(UI8,2,UI1,1,I4,2);
7998         VARIDIV(UI8,2,UI2,1,I4,2);
7999         VARIDIV(UI8,2,UI4,1,I4,2);
8000         VARIDIV(UI8,2,I8,1,I8,2);
8001         VARIDIV(UI8,2,UI8,1,I4,2);
8002         VARIDIV(UI8,2,INT,1,I4,2);
8003         VARIDIV(UI8,2,UINT,1,I4,2);
8004     }
8005     VARIDIV(INT,2,NULL,0,NULL,0);
8006     VARIDIV(INT,2,I2,1,I4,2);
8007     VARIDIV(INT,2,I4,1,I4,2);
8008     VARIDIV(INT,2,R4,1.0f,I4,2);
8009     VARIDIV(INT,2,R8,1.0,I4,2);
8010     VARIDIV(INT,2,DATE,1,I4,2);
8011     VARIDIV(INT,2,BSTR,num1_str,I4,2);
8012     VARIDIV(INT,2,BOOL,VARIANT_TRUE,I4,-2);
8013     VARIDIV(INT,2,I1,1,I4,2);
8014     VARIDIV(INT,2,UI1,1,I4,2);
8015     VARIDIV(INT,2,UI2,1,I4,2);
8016     VARIDIV(INT,2,UI4,1,I4,2);
8017     if (HAVE_OLEAUT32_I8)
8018     {
8019         VARIDIV(INT,2,UI8,1,I4,2);
8020     }
8021     VARIDIV(INT,2,INT,1,I4,2);
8022     VARIDIV(INT,2,UINT,1,I4,2);
8023     VARIDIV(UINT,2,NULL,0,NULL,0);
8024     VARIDIV(UINT,2,I2,1,I4,2);
8025     VARIDIV(UINT,2,I4,1,I4,2);
8026     VARIDIV(UINT,2,R4,1.0f,I4,2);
8027     VARIDIV(UINT,2,R8,1.0,I4,2);
8028     VARIDIV(UINT,2,DATE,1,I4,2);
8029     VARIDIV(UINT,2,BSTR,num1_str,I4,2);
8030     VARIDIV(UINT,2,BOOL,VARIANT_TRUE,I4,-2);
8031     VARIDIV(UINT,2,I1,1,I4,2);
8032     VARIDIV(UINT,2,UI1,1,I4,2);
8033     VARIDIV(UINT,2,UI2,1,I4,2);
8034     VARIDIV(UINT,2,UI4,1,I4,2);
8035     if (HAVE_OLEAUT32_I8)
8036     {
8037         VARIDIV(UINT,2,I8,1,I8,2);
8038         VARIDIV(UINT,2,UI8,1,I4,2);
8039     }
8040     VARIDIV(UINT,2,INT,1,I4,2);
8041     VARIDIV(UINT,2,UINT,1,I4,2);
8042
8043     /* Manually test some VT_CY, VT_DECIMAL variants */
8044     V_VT(&cy) = VT_CY;
8045     hres = VarCyFromI4(10000, &V_CY(&cy));
8046     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8047     V_VT(&dec) = VT_DECIMAL;
8048     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8049     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8050     memset(&left, 0, sizeof(left));
8051     memset(&right, 0, sizeof(right));
8052     V_VT(&left) = VT_I4;
8053     V_I4(&left) = 100;
8054     V_VT(&right) = VT_I8;
8055     V_UI1(&right) = 2;
8056
8057     hres = pVarIdiv(&cy, &cy, &result);
8058     ok(hres == S_OK && V_VT(&result) == VT_I4,
8059         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8060         S_OK, hres, vtstr(V_VT(&result)));
8061     ok(hres == S_OK && V_I4(&result) == 1,
8062         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 1);
8063
8064     if (HAVE_OLEAUT32_I8)
8065     {
8066         hres = pVarIdiv(&cy, &right, &result);
8067         ok(hres == S_OK && V_VT(&result) == VT_I8,
8068             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8069             S_OK, hres, vtstr(V_VT(&result)));
8070         ok(hres == S_OK && V_I8(&result) == 5000,
8071             "VARIDIV: CY value 0x%x%08x, expected 0x%x\n",
8072             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), 5000);
8073     }
8074
8075     hres = pVarIdiv(&left, &cy, &result);
8076     ok(hres == S_OK && V_VT(&result) == VT_I4,
8077         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8078         S_OK, hres, vtstr(V_VT(&result)));
8079     ok(hres == S_OK && V_I4(&result) == 0,
8080         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 0);
8081
8082     hres = pVarIdiv(&left, &dec, &result);
8083     ok(hres == S_OK && V_VT(&result) == VT_I4,
8084         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8085         S_OK, hres, vtstr(V_VT(&result)));
8086     ok(hres == S_OK && V_I4(&result) == 50,
8087         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 50);
8088
8089     hres = pVarIdiv(&dec, &dec, &result);
8090     ok(hres == S_OK && V_VT(&result) == VT_I4,
8091         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8092         S_OK, hres, vtstr(V_VT(&result)));
8093     ok(hres == S_OK && V_I4(&result) == 1,
8094         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 1);
8095
8096     if (HAVE_OLEAUT32_I8)
8097     {
8098         hres = pVarIdiv(&dec, &right, &result);
8099         ok(hres == S_OK && V_VT(&result) == VT_I8,
8100             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8101             S_OK, hres, vtstr(V_VT(&result)));
8102         ok(hres == S_OK && V_I8(&result) == 1,
8103             "VARIDIV: DECIMAL value 0x%x%08x, expected %d\n",
8104             (DWORD)(V_I8(&result) >> 32), (DWORD)V_I8(&result), 1);
8105     }
8106
8107     /* Check for division by zero */
8108     V_VT(&left) = VT_INT;
8109     V_I4(&left) = 1;
8110     V_VT(&right) = VT_INT;
8111     V_I4(&right) = 0;
8112     hres = pVarIdiv(&left, &right, &result);
8113     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8114         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8115
8116     V_VT(&left) = VT_INT;
8117     V_I4(&left) = 0;
8118     V_VT(&right) = VT_INT;
8119     V_I4(&right) = 0;
8120     hres = pVarIdiv(&left, &right, &result);
8121     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8122         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8123
8124     SysFreeString(num1_str);
8125     SysFreeString(num2_str);
8126 }
8127
8128
8129 static HRESULT (WINAPI *pVarImp)(LPVARIANT,LPVARIANT,LPVARIANT);
8130
8131 #define VARIMP(vt1,val1,vt2,val2,rvt,rval)              \
8132         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
8133         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
8134         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
8135         test_var_call2( __LINE__, pVarImp, &left, &right, &exp )
8136
8137 /* Skip any type that is not defined or produces an error for every case */
8138 #define SKIPTESTIMP(a)                            \
8139     if (a == VT_ERROR || a == VT_VARIANT ||       \
8140         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
8141         a == VT_RECORD || a > VT_UINT ||          \
8142         a == 15 /*not defined*/)                  \
8143         continue
8144
8145 static void test_VarImp(void)
8146 {
8147     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
8148     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
8149     VARIANT left, right, exp, result, cy, dec;
8150     BSTR true_str, false_str;
8151     VARTYPE i;
8152     HRESULT hres;
8153
8154     CHECKPTR(VarImp);
8155
8156     true_str = SysAllocString(szTrue);
8157     false_str = SysAllocString(szFalse);
8158
8159     /* Test all possible flag/vt combinations & the resulting vt type */
8160     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
8161     {
8162         VARTYPE leftvt, rightvt, resvt;
8163
8164         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
8165         {
8166             SKIPTESTIMP(leftvt);
8167
8168             /* Check if we need/have support for I8 and/or UI8 */
8169             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8170                 continue;
8171
8172             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
8173             {
8174                 BOOL bFail = FALSE;
8175                 SKIPTESTIMP(rightvt);
8176
8177                 /* Native crashes when using the extra flag VT_BYREF
8178                  * or with the following VT combinations
8179                  */
8180                 if ((leftvt == VT_UI4 && rightvt == VT_BSTR) ||
8181                     (leftvt == VT_UI8 && rightvt == VT_BSTR) ||
8182                     ExtraFlags[i] == VT_BYREF)
8183                     continue;
8184
8185                 /* Check if we need/have support for I8 and/or UI8 */
8186                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8187                     continue;
8188
8189                 memset(&left, 0, sizeof(left));
8190                 memset(&right, 0, sizeof(right));
8191                 V_VT(&left) = leftvt | ExtraFlags[i];
8192                 V_VT(&right) = rightvt | ExtraFlags[i];
8193                 V_VT(&result) = VT_EMPTY;
8194                 resvt = VT_EMPTY;
8195
8196                 if (leftvt == VT_BSTR)
8197                     V_BSTR(&left) = true_str;
8198
8199                 /* This allows us to test return types that are not NULL
8200                  * (NULL Imp value = n, NULL Imp 0 = NULL)
8201                  */
8202                 switch(rightvt)
8203                 {
8204                 case VT_BSTR:
8205                     V_BSTR(&right) = true_str;
8206                     break;
8207                 case VT_DECIMAL:
8208                     VarDecFromR8(2.0, &V_DECIMAL(&right));
8209                     V_VT(&right) = rightvt | ExtraFlags[i];
8210                     break;
8211                 case VT_BOOL:
8212                     V_BOOL(&right) = VARIANT_TRUE;
8213                     break;
8214                 case VT_I1: V_I1(&right) = 2; break;
8215                 case VT_I2: V_I2(&right) = 2; break;
8216                 case VT_I4: V_I4(&right) = 2; break;
8217                 case VT_R4: V_R4(&right) = 2.0f; break;
8218                 case VT_R8: V_R8(&right) = 2.0; break;
8219                 case VT_CY: V_CY(&right).int64 = 10000; break;
8220                 case VT_DATE: V_DATE(&right) = 2; break;
8221                 case VT_I8: V_I8(&right) = 2; break;
8222                 case VT_INT: V_INT(&right) = 2; break;
8223                 case VT_UINT: V_UINT(&right) = 2; break;
8224                 case VT_UI1: V_UI1(&right) = 2; break;
8225                 case VT_UI2: V_UI2(&right) = 2; break;
8226                 case VT_UI4: V_UI4(&right) = 2; break;
8227                 case VT_UI8: V_UI8(&right) = 2; break;
8228                 default: break;
8229                 }
8230
8231                 /* Native VarImp always returns an error when using extra
8232                  * flags or if the variants are I8 and INT.
8233                  */
8234                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
8235                     ExtraFlags[i] != 0)
8236                     bFail = TRUE;
8237
8238                 /* Determine result type */
8239                 else if ((leftvt == VT_BSTR && rightvt == VT_NULL) ||
8240                     (leftvt == VT_NULL && rightvt == VT_NULL) ||
8241                     (leftvt == VT_NULL && rightvt == VT_EMPTY))
8242                     resvt = VT_NULL;
8243                 else if (leftvt == VT_I8 || rightvt == VT_I8)
8244                     resvt = VT_I8;
8245                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
8246                     leftvt == VT_INT || rightvt == VT_INT ||
8247                     leftvt == VT_UINT || rightvt == VT_UINT ||
8248                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
8249                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
8250                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
8251                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
8252                     leftvt == VT_DATE || rightvt == VT_DATE ||
8253                     leftvt == VT_CY || rightvt == VT_CY ||
8254                     leftvt == VT_R8 || rightvt == VT_R8 ||
8255                     leftvt == VT_R4 || rightvt == VT_R4 ||
8256                     leftvt == VT_I1 || rightvt == VT_I1)
8257                     resvt = VT_I4;
8258                 else if ((leftvt == VT_UI1 && rightvt == VT_UI1) ||
8259                     (leftvt == VT_UI1 && rightvt == VT_NULL) ||
8260                     (leftvt == VT_NULL && rightvt == VT_UI1))
8261                     resvt = VT_UI1;
8262                 else if (leftvt == VT_EMPTY || rightvt == VT_EMPTY ||
8263                     leftvt == VT_I2 || rightvt == VT_I2 ||
8264                     leftvt == VT_UI1 || rightvt == VT_UI1)
8265                     resvt = VT_I2;
8266                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
8267                     leftvt == VT_BSTR || rightvt == VT_BSTR)
8268                     resvt = VT_BOOL;
8269
8270                 hres = pVarImp(&left, &right, &result);
8271
8272                 /* Check expected HRESULT and if result variant type is correct */
8273                 if (bFail)
8274                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
8275                         "VarImp: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
8276                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
8277                         vtstr(V_VT(&result)), hres);
8278                 else
8279                     ok (hres == S_OK && resvt == V_VT(&result),
8280                         "VarImp: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
8281                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
8282                         S_OK, vtstr(V_VT(&result)), hres);
8283             }
8284         }
8285     }
8286
8287     VARIMP(EMPTY,0,EMPTY,0,I2,-1);
8288     VARIMP(EMPTY,0,NULL,0,I2,-1);
8289     VARIMP(EMPTY,0,I2,-1,I2,-1);
8290     VARIMP(EMPTY,0,I4,-1,I4,-1);
8291     VARIMP(EMPTY,0,R4,0.0f,I4,-1);
8292     VARIMP(EMPTY,0,R8,-1.0,I4,-1);
8293     VARIMP(EMPTY,0,DATE,0,I4,-1);
8294     VARIMP(EMPTY,0,BSTR,true_str,I2,-1);
8295     VARIMP(EMPTY,0,BOOL,VARIANT_FALSE,I2,-1);
8296     VARIMP(EMPTY,0,I1,0,I4,-1);
8297     VARIMP(EMPTY,0,UI1,1,I2,-1);
8298     VARIMP(EMPTY,0,UI2,1,I4,-1);
8299     VARIMP(EMPTY,0,UI4,1,I4,-1);
8300     if (HAVE_OLEAUT32_I8)
8301     {
8302         VARIMP(EMPTY,0,I8,1,I8,-1);
8303         VARIMP(EMPTY,0,UI8,1,I4,-1);
8304     }
8305     VARIMP(EMPTY,0,INT,-1,I4,-1);
8306     VARIMP(EMPTY,0,UINT,1,I4,-1);
8307     VARIMP(NULL,0,EMPTY,0,NULL,0);
8308     VARIMP(NULL,0,NULL,0,NULL,0);
8309     VARIMP(NULL,0,I2,-1,I2,-1);
8310     VARIMP(NULL,0,I4,-1,I4,-1);
8311     VARIMP(NULL,0,R4,0.0f,NULL,0);
8312     VARIMP(NULL,0,R8,-1.0,I4,-1);
8313     VARIMP(NULL,0,DATE,0,NULL,0);
8314     VARIMP(NULL,0,BSTR,true_str,BOOL,-1);
8315     VARIMP(NULL,0,BOOL,VARIANT_FALSE,NULL,0);
8316     VARIMP(NULL,0,I1,0,NULL,0);
8317     VARIMP(NULL,0,UI1,1,UI1,1);
8318     VARIMP(NULL,0,UI2,1,I4,1);
8319     VARIMP(NULL,0,UI4,1,I4,1);
8320     if (HAVE_OLEAUT32_I8)
8321     {
8322         VARIMP(NULL,0,I8,1,I8,1);
8323         VARIMP(NULL,0,UI8,1,I4,1);
8324     }
8325     VARIMP(NULL,0,INT,-1,I4,-1);
8326     VARIMP(NULL,0,UINT,1,I4,1);
8327     VARIMP(I2,-1,EMPTY,0,I2,0);
8328     VARIMP(I2,-1,I2,-1,I2,-1);
8329     VARIMP(I2,-1,I4,-1,I4,-1);
8330     VARIMP(I2,-1,R4,0.0f,I4,0);
8331     VARIMP(I2,-1,R8,-1.0,I4,-1);
8332     VARIMP(I2,-1,DATE,0,I4,0);
8333     VARIMP(I2,-1,BSTR,true_str,I2,-1);
8334     VARIMP(I2,-1,BOOL,VARIANT_FALSE,I2,0);
8335     VARIMP(I2,-1,I1,0,I4,0);
8336     VARIMP(I2,-1,UI1,1,I2,1);
8337     VARIMP(I2,-1,UI2,1,I4,1);
8338     VARIMP(I2,-1,UI4,1,I4,1);
8339     if (HAVE_OLEAUT32_I8)
8340     {
8341         VARIMP(I2,-1,I8,1,I8,1);
8342         VARIMP(I2,-1,UI8,1,I4,1);
8343     }
8344     VARIMP(I2,-1,INT,-1,I4,-1);
8345     VARIMP(I2,-1,UINT,1,I4,1);
8346     VARIMP(I4,2,EMPTY,0,I4,-3);
8347     VARIMP(I4,2,NULL,0,I4,-3);
8348     VARIMP(I4,2,I2,-1,I4,-1);
8349     VARIMP(I4,2,I4,-1,I4,-1);
8350     VARIMP(I4,2,R4,0.0f,I4,-3);
8351     VARIMP(I4,2,R8,-1.0,I4,-1);
8352     VARIMP(I4,2,DATE,0,I4,-3);
8353     VARIMP(I4,2,BSTR,true_str,I4,-1);
8354     VARIMP(I4,2,BOOL,VARIANT_FALSE,I4,-3);
8355     VARIMP(I4,2,I1,0,I4,-3);
8356     VARIMP(I4,2,UI1,1,I4,-3);
8357     VARIMP(I4,2,UI2,1,I4,-3);
8358     VARIMP(I4,2,UI4,1,I4,-3);
8359     if (HAVE_OLEAUT32_I8)
8360     {
8361         VARIMP(I4,2,I8,1,I8,-3);
8362         VARIMP(I4,2,UI8,1,I4,-3);
8363     }
8364     VARIMP(I4,2,INT,-1,I4,-1);
8365     VARIMP(I4,2,UINT,1,I4,-3);
8366     VARIMP(R4,-1.0f,EMPTY,0,I4,0);
8367     VARIMP(R4,-1.0f,NULL,0,NULL,0);
8368     VARIMP(R4,-1.0f,I2,-1,I4,-1);
8369     VARIMP(R4,-1.0f,I4,-1,I4,-1);
8370     VARIMP(R4,-1.0f,R4,0.0f,I4,0);
8371     VARIMP(R4,-1.0f,R8,-1.0,I4,-1);
8372     VARIMP(R4,-1.0f,DATE,1,I4,1);
8373     VARIMP(R4,-1.0f,BSTR,true_str,I4,-1);
8374     VARIMP(R4,-1.0f,BOOL,VARIANT_FALSE,I4,0);
8375     VARIMP(R4,-1.0f,I1,0,I4,0);
8376     VARIMP(R4,-1.0f,UI1,1,I4,1);
8377     VARIMP(R4,-1.0f,UI2,1,I4,1);
8378     VARIMP(R4,-1.0f,UI4,1,I4,1);
8379     if (HAVE_OLEAUT32_I8)
8380     {
8381         VARIMP(R4,-1.0f,I8,1,I8,1);
8382         VARIMP(R4,-1.0f,UI8,1,I4,1);
8383     }
8384     VARIMP(R4,-1.0f,INT,-1,I4,-1);
8385     VARIMP(R4,-1.0f,UINT,1,I4,1);
8386     VARIMP(R8,1.0,EMPTY,0,I4,-2);
8387     VARIMP(R8,1.0,NULL,0,I4,-2);
8388     VARIMP(R8,1.0,I2,-1,I4,-1);
8389     VARIMP(R8,1.0,I4,-1,I4,-1);
8390     VARIMP(R8,1.0,R4,0.0f,I4,-2);
8391     VARIMP(R8,1.0,R8,-1.0,I4,-1);
8392     VARIMP(R8,1.0,DATE,0,I4,-2);
8393     VARIMP(R8,1.0,BSTR,true_str,I4,-1);
8394     VARIMP(R8,1.0,BOOL,VARIANT_FALSE,I4,-2);
8395     VARIMP(R8,1.0,I1,0,I4,-2);
8396     VARIMP(R8,1.0,UI1,1,I4,-1);
8397     VARIMP(R8,1.0,UI2,1,I4,-1);
8398     VARIMP(R8,1.0,UI4,1,I4,-1);
8399     if (HAVE_OLEAUT32_I8)
8400     {
8401         VARIMP(R8,1.0,I8,1,I8,-1);
8402         VARIMP(R8,1.0,UI8,1,I4,-1);
8403     }
8404     VARIMP(R8,1.0,INT,-1,I4,-1);
8405     VARIMP(R8,1.0,UINT,1,I4,-1);
8406     VARIMP(DATE,0,EMPTY,0,I4,-1);
8407     VARIMP(DATE,0,NULL,0,I4,-1);
8408     VARIMP(DATE,0,I2,-1,I4,-1);
8409     VARIMP(DATE,0,I4,-1,I4,-1);
8410     VARIMP(DATE,0,R4,0.0f,I4,-1);
8411     VARIMP(DATE,0,R8,-1.0,I4,-1);
8412     VARIMP(DATE,0,DATE,0,I4,-1);
8413     VARIMP(DATE,0,BSTR,true_str,I4,-1);
8414     VARIMP(DATE,0,BOOL,VARIANT_FALSE,I4,-1);
8415     VARIMP(DATE,0,I1,0,I4,-1);
8416     VARIMP(DATE,0,UI1,1,I4,-1);
8417     VARIMP(DATE,0,UI2,1,I4,-1);
8418     VARIMP(DATE,0,UI4,1,I4,-1);
8419     if (HAVE_OLEAUT32_I8)
8420     {
8421         VARIMP(DATE,0,I8,1,I8,-1);
8422         VARIMP(DATE,0,UI8,1,I4,-1);
8423     }
8424     VARIMP(DATE,0,INT,-1,I4,-1);
8425     VARIMP(DATE,0,UINT,1,I4,-1);
8426     VARIMP(BSTR,false_str,EMPTY,0,I2,-1);
8427     VARIMP(BSTR,false_str,NULL,0,BOOL,-1);
8428     VARIMP(BSTR,false_str,I2,-1,I2,-1);
8429     VARIMP(BSTR,false_str,I4,-1,I4,-1);
8430     VARIMP(BSTR,false_str,R4,0.0f,I4,-1);
8431     VARIMP(BSTR,false_str,R8,-1.0,I4,-1);
8432     VARIMP(BSTR,false_str,DATE,0,I4,-1);
8433     VARIMP(BSTR,false_str,BSTR,true_str,BOOL,-1);
8434     VARIMP(BSTR,false_str,BOOL,VARIANT_FALSE,BOOL,-1);
8435     VARIMP(BSTR,false_str,I1,0,I4,-1);
8436     VARIMP(BSTR,false_str,UI1,1,I2,-1);
8437     VARIMP(BSTR,false_str,UI2,1,I4,-1);
8438     VARIMP(BSTR,false_str,UI4,1,I4,-1);
8439     if (HAVE_OLEAUT32_I8)
8440     {
8441         VARIMP(BSTR,false_str,I8,1,I8,-1);
8442         VARIMP(BSTR,false_str,UI8,1,I4,-1);
8443     }
8444     VARIMP(BSTR,false_str,INT,-1,I4,-1);
8445     VARIMP(BSTR,false_str,UINT,1,I4,-1);
8446     VARIMP(BOOL,VARIANT_TRUE,EMPTY,0,I2,0);
8447     VARIMP(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
8448     VARIMP(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
8449     VARIMP(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
8450     VARIMP(BOOL,VARIANT_TRUE,R4,0.0f,I4,0);
8451     VARIMP(BOOL,VARIANT_TRUE,R8,-1.0,I4,-1);
8452     VARIMP(BOOL,VARIANT_TRUE,DATE,0,I4,0);
8453     VARIMP(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,-1);
8454     VARIMP(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,0);
8455     VARIMP(BOOL,VARIANT_TRUE,I1,0,I4,0);
8456     VARIMP(BOOL,VARIANT_TRUE,UI1,1,I2,1);
8457     VARIMP(BOOL,VARIANT_TRUE,UI2,1,I4,1);
8458     VARIMP(BOOL,VARIANT_TRUE,UI4,1,I4,1);
8459     if (HAVE_OLEAUT32_I8)
8460     {
8461         VARIMP(BOOL,VARIANT_TRUE,I8,1,I8,1);
8462         VARIMP(BOOL,VARIANT_TRUE,UI8,1,I4,1);
8463     }
8464     VARIMP(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
8465     VARIMP(BOOL,VARIANT_TRUE,UINT,1,I4,1);
8466     VARIMP(I1,-1,EMPTY,0,I4,0);
8467     VARIMP(I1,-1,NULL,0,NULL,0);
8468     VARIMP(I1,-1,I2,-1,I4,-1);
8469     VARIMP(I1,-1,I4,-1,I4,-1);
8470     VARIMP(I1,-1,R4,0.0f,I4,0);
8471     VARIMP(I1,-1,R8,-1.0,I4,-1);
8472     VARIMP(I1,-1,DATE,0,I4,0);
8473     VARIMP(I1,-1,BSTR,true_str,I4,-1);
8474     VARIMP(I1,-1,BOOL,VARIANT_FALSE,I4,0);
8475     VARIMP(I1,-1,I1,0,I4,0);
8476     VARIMP(I1,-1,UI1,1,I4,1);
8477     VARIMP(I1,-1,UI2,1,I4,1);
8478     VARIMP(I1,-1,UI4,1,I4,1);
8479     if (HAVE_OLEAUT32_I8)
8480     {
8481         VARIMP(I1,-1,I8,1,I8,1);
8482         VARIMP(I1,-1,UI8,1,I4,1);
8483     }
8484     VARIMP(I1,-1,INT,-1,I4,-1);
8485     VARIMP(I1,-1,UINT,1,I4,1);
8486     VARIMP(UI1,0,EMPTY,0,I2,-1);
8487     VARIMP(UI1,0,NULL,0,UI1,255);
8488     VARIMP(UI1,0,I2,-1,I2,-1);
8489     VARIMP(UI1,0,I4,-1,I4,-1);
8490     VARIMP(UI1,0,R4,0.0f,I4,-1);
8491     VARIMP(UI1,0,R8,-1.0,I4,-1);
8492     VARIMP(UI1,0,DATE,0,I4,-1);
8493     VARIMP(UI1,0,BSTR,true_str,I2,-1);
8494     VARIMP(UI1,0,BOOL,VARIANT_FALSE,I2,-1);
8495     VARIMP(UI1,0,I1,0,I4,-1);
8496     VARIMP(UI1,0,UI1,1,UI1,255);
8497     VARIMP(UI1,0,UI2,1,I4,-1);
8498     VARIMP(UI1,0,UI4,1,I4,-1);
8499     if (HAVE_OLEAUT32_I8)
8500     {
8501         VARIMP(UI1,0,I8,1,I8,-1);
8502         VARIMP(UI1,0,UI8,1,I4,-1);
8503     }
8504     VARIMP(UI1,0,INT,-1,I4,-1);
8505     VARIMP(UI1,0,UINT,1,I4,-1);
8506     VARIMP(UI2,0,EMPTY,0,I4,-1);
8507     VARIMP(UI2,0,NULL,0,I4,-1);
8508     VARIMP(UI2,0,I2,-1,I4,-1);
8509     VARIMP(UI2,0,I4,-1,I4,-1);
8510     VARIMP(UI2,0,R4,0.0f,I4,-1);
8511     VARIMP(UI2,0,R8,-1.0,I4,-1);
8512     VARIMP(UI2,0,DATE,0,I4,-1);
8513     VARIMP(UI2,0,BSTR,true_str,I4,-1);
8514     VARIMP(UI2,0,BOOL,VARIANT_FALSE,I4,-1);
8515     VARIMP(UI2,0,I1,0,I4,-1);
8516     VARIMP(UI2,0,UI1,1,I4,-1);
8517     VARIMP(UI2,0,UI2,1,I4,-1);
8518     VARIMP(UI2,0,UI4,1,I4,-1);
8519     if (HAVE_OLEAUT32_I8)
8520     {
8521         VARIMP(UI2,0,I8,1,I8,-1);
8522         VARIMP(UI2,0,UI8,1,I4,-1);
8523     }
8524     VARIMP(UI2,0,INT,-1,I4,-1);
8525     VARIMP(UI2,0,UINT,1,I4,-1);
8526     VARIMP(UI4,0,EMPTY,0,I4,-1);
8527     VARIMP(UI4,0,NULL,0,I4,-1);
8528     VARIMP(UI4,0,I2,-1,I4,-1);
8529     VARIMP(UI4,0,I4,-1,I4,-1);
8530     VARIMP(UI4,0,R4,0.0f,I4,-1);
8531     VARIMP(UI4,0,R8,-1.0,I4,-1);
8532     VARIMP(UI4,0,DATE,0,I4,-1);
8533     VARIMP(UI4,0,BSTR,true_str,I4,-1);
8534     VARIMP(UI4,0,BOOL,VARIANT_FALSE,I4,-1);
8535     VARIMP(UI4,0,I1,0,I4,-1);
8536     VARIMP(UI4,0,UI1,1,I4,-1);
8537     VARIMP(UI4,0,UI2,1,I4,-1);
8538     VARIMP(UI4,0,UI4,1,I4,-1);
8539     if (HAVE_OLEAUT32_I8)
8540     {
8541         VARIMP(UI4,0,I8,1,I8,-1);
8542         VARIMP(UI4,0,UI8,1,I4,-1);
8543     }
8544     VARIMP(UI4,0,INT,-1,I4,-1);
8545     VARIMP(UI4,0,UINT,1,I4,-1);
8546     if (HAVE_OLEAUT32_I8)
8547     {
8548         VARIMP(I8,-1,EMPTY,0,I8,0);
8549         VARIMP(I8,-1,NULL,0,NULL,0);
8550         VARIMP(I8,-1,I2,-1,I8,-1);
8551         VARIMP(I8,-1,I4,-1,I8,-1);
8552         VARIMP(I8,-1,R4,0.0f,I8,0);
8553         VARIMP(I8,-1,R8,-1.0,I8,-1);
8554         VARIMP(I8,-1,DATE,0,I8,0);
8555         VARIMP(I8,-1,BSTR,true_str,I8,-1);
8556         VARIMP(I8,-1,BOOL,VARIANT_FALSE,I8,0);
8557         VARIMP(I8,-1,I1,0,I8,0);
8558         VARIMP(I8,-1,UI1,1,I8,1);
8559         VARIMP(I8,-1,UI2,1,I8,1);
8560         VARIMP(I8,-1,UI4,1,I8,1);
8561         VARIMP(I8,-1,I8,1,I8,1);
8562         VARIMP(I8,-1,UI8,1,I8,1);
8563         VARIMP(I8,-1,UINT,1,I8,1);
8564         VARIMP(UI8,0,EMPTY,0,I4,-1);
8565         VARIMP(UI8,0,NULL,0,I4,-1);
8566         VARIMP(UI8,0,I2,-1,I4,-1);
8567         VARIMP(UI8,0,I4,-1,I4,-1);
8568         VARIMP(UI8,0,R4,0.0f,I4,-1);
8569         VARIMP(UI8,0,R8,-1.0,I4,-1);
8570         VARIMP(UI8,0,DATE,0,I4,-1);
8571         VARIMP(UI8,0,BSTR,true_str,I4,-1);
8572         VARIMP(UI8,0,BOOL,VARIANT_FALSE,I4,-1);
8573         VARIMP(UI8,0,I1,0,I4,-1);
8574         VARIMP(UI8,0,UI1,1,I4,-1);
8575         VARIMP(UI8,0,UI2,1,I4,-1);
8576         VARIMP(UI8,0,UI4,1,I4,-1);
8577         VARIMP(UI8,0,I8,1,I8,-1);
8578         VARIMP(UI8,0,UI8,1,I4,-1);
8579         VARIMP(UI8,0,INT,-1,I4,-1);
8580         VARIMP(UI8,0,UINT,1,I4,-1);
8581     }
8582     VARIMP(INT,-1,EMPTY,0,I4,0);
8583     VARIMP(INT,-1,NULL,0,NULL,0);
8584     VARIMP(INT,-1,I2,-1,I4,-1);
8585     VARIMP(INT,-1,I4,-1,I4,-1);
8586     VARIMP(INT,-1,R4,0.0f,I4,0);
8587     VARIMP(INT,-1,R8,-1.0,I4,-1);
8588     VARIMP(INT,-1,DATE,0,I4,0);
8589     VARIMP(INT,-1,BSTR,true_str,I4,-1);
8590     VARIMP(INT,-1,BOOL,VARIANT_FALSE,I4,0);
8591     VARIMP(INT,-1,I1,0,I4,0);
8592     VARIMP(INT,-1,UI1,1,I4,1);
8593     VARIMP(INT,-1,UI2,1,I4,1);
8594     VARIMP(INT,-1,UI4,1,I4,1);
8595     if (HAVE_OLEAUT32_I8)
8596     {
8597         VARIMP(INT,-1,I8,1,I8,1);
8598         VARIMP(INT,-1,UI8,1,I4,1);
8599     }
8600     VARIMP(INT,-1,INT,-1,I4,-1);
8601     VARIMP(INT,-1,UINT,1,I4,1);
8602     VARIMP(UINT,1,EMPTY,0,I4,-2);
8603     VARIMP(UINT,1,NULL,0,I4,-2);
8604     VARIMP(UINT,1,I2,-1,I4,-1);
8605     VARIMP(UINT,1,I4,-1,I4,-1);
8606     VARIMP(UINT,1,R4,0.0f,I4,-2);
8607     VARIMP(UINT,1,R8,-1.0,I4,-1);
8608     VARIMP(UINT,1,DATE,0,I4,-2);
8609     VARIMP(UINT,1,BSTR,true_str,I4,-1);
8610     VARIMP(UINT,1,BOOL,VARIANT_FALSE,I4,-2);
8611     VARIMP(UINT,1,I1,0,I4,-2);
8612     VARIMP(UINT,1,UI1,1,I4,-1);
8613     VARIMP(UINT,1,UI2,1,I4,-1);
8614     VARIMP(UINT,1,UI4,1,I4,-1);
8615     if (HAVE_OLEAUT32_I8)
8616     {
8617         VARIMP(UINT,1,I8,1,I8,-1);
8618         VARIMP(UINT,1,UI8,1,I4,-1);
8619     }
8620     VARIMP(UINT,1,INT,-1,I4,-1);
8621     VARIMP(UINT,1,UINT,1,I4,-1);
8622
8623     /* Manually test some VT_CY, VT_DECIMAL variants */
8624     V_VT(&cy) = VT_CY;
8625     hres = VarCyFromI4(1, &V_CY(&cy));
8626     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8627     V_VT(&dec) = VT_DECIMAL;
8628     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8629     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8630     memset(&left, 0, sizeof(left));
8631     memset(&right, 0, sizeof(right));
8632     V_VT(&left) = VT_I4;
8633     V_I4(&left) = 0;
8634     V_VT(&right) = VT_I8;
8635     V_UI1(&right) = 0;
8636
8637     hres = pVarImp(&cy, &cy, &result);
8638     ok(hres == S_OK && V_VT(&result) == VT_I4,
8639         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8640         S_OK, hres, vtstr(V_VT(&result)));
8641     ok(hres == S_OK && V_I4(&result) == -1,
8642         "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8643
8644     if (HAVE_OLEAUT32_I8)
8645     {
8646         hres = pVarImp(&cy, &right, &result);
8647         ok(hres == S_OK && V_VT(&result) == VT_I8,
8648             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8649             S_OK, hres, vtstr(V_VT(&result)));
8650         ok(hres == S_OK && V_I8(&result) == -2,
8651             "VARIMP: CY value %x%08x, expected %d\n",
8652             (DWORD)((V_I8(&result)) >> 32), (DWORD)(V_I8(&result)), -2);
8653     }
8654
8655     hres = pVarImp(&left, &cy, &result);
8656     ok(hres == S_OK && V_VT(&result) == VT_I4,
8657         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8658         S_OK, hres, vtstr(V_VT(&result)));
8659     ok(hres == S_OK && V_I4(&result) == -1,
8660         "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8661
8662     hres = pVarImp(&left, &dec, &result);
8663     ok(hres == S_OK && V_VT(&result) == VT_I4,
8664         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8665         S_OK, hres, vtstr(V_VT(&result)));
8666     ok(hres == S_OK && V_I4(&result) == -1,
8667         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8668
8669     hres = pVarImp(&dec, &dec, &result);
8670     ok(hres == S_OK && V_VT(&result) == VT_I4,
8671         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8672         S_OK, hres, vtstr(V_VT(&result)));
8673     ok(hres == S_OK && V_I4(&result) == -1,
8674         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8675
8676     if (HAVE_OLEAUT32_I8)
8677     {
8678         hres = pVarImp(&dec, &right, &result);
8679         ok(hres == S_OK && V_VT(&result) == VT_I8,
8680             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8681             S_OK, hres, vtstr(V_VT(&result)));
8682         ok(hres == S_OK && V_I8(&result) == -3,
8683             "VARIMP: DECIMAL value 0x%x%08x, expected %d\n",
8684             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), -3);
8685     }
8686
8687     SysFreeString(false_str);
8688     SysFreeString(true_str);
8689 }
8690
8691 START_TEST(vartest)
8692 {
8693   init();
8694
8695   test_VariantInit();
8696   test_VariantClear();
8697   test_VariantCopy();
8698   test_VariantCopyInd();
8699   test_VarParseNumFromStr();
8700   test_VarNumFromParseNum();
8701   test_VarUdateFromDate();
8702   test_VarDateFromUdate();
8703   test_SystemTimeToVariantTime();
8704   test_VariantTimeToSystemTime();
8705   test_DosDateTimeToVariantTime();
8706   test_VariantTimeToDosDateTime();
8707   test_VarAbs();
8708   test_VarNot();
8709   test_VarSub();
8710   test_VarMod();
8711   test_VarFix();
8712   test_VarInt();
8713   test_VarNeg();
8714   test_VarRound();
8715   test_VarXor();
8716   test_VarOr();
8717   test_VarPow();
8718   test_VarEqv();
8719   test_VarMul();
8720   test_VarAdd();
8721   test_VarCmp(); /* Before test_VarCat() which needs VarCmp() */
8722   test_VarCat();
8723   test_VarAnd();
8724   test_VarDiv();
8725   test_VarIdiv();
8726   test_VarImp();
8727 }